Demonstration von Eingabevalidierung und Code-Integrität

Einführung

In diesem Lab werden Sie zwei grundlegende Sicherheitskonzepte untersuchen: Eingabevalidierung und Code-Integrität. Eingabevalidierung ist die Praxis, sicherzustellen, dass jede Eingabe, die ein Programm erhält, sicher und wohlgeformt ist, bevor sie verarbeitet wird. Dies ist eine kritische Verteidigung gegen eine Vielzahl von Angriffen, einschließlich Command Injection. Code-Integrität beinhaltet die Überprüfung, ob Ihr Anwendungscode nicht von einer unbefugten Partei verändert oder beschädigt wurde.

Sie werden diese Konzepte durch einen praktischen Ansatz erlernen. Zuerst erstellen Sie ein einfaches Shell-Skript, das absichtlich anfällig für Command Injection ist. Als Nächstes werden Sie diese Schwachstelle ausnutzen, um das Risiko zu verstehen. Dann sichern Sie das Skript, indem Sie eine ordnungsgemäße Eingabe-Sanitisierung implementieren. Schließlich lernen Sie, wie Sie kryptografische Hashes verwenden, um die Integrität Ihres Skripts zu überprüfen und sicherzustellen, dass es nicht manipuliert wurde.

Erstellen eines einfachen Skripts mit Benutzereingabe

In diesem Schritt erstellen Sie ein einfaches Bash-Skript, das den Benutzer nach einem Dateinamen fragt und dann detaillierte Informationen über diese Datei mithilfe des Befehls ls -l anzeigt. Diese anfängliche Version des Skripts wird keine Sicherheitsprüfungen enthalten.

Verwenden Sie zuerst den nano-Editor, um eine neue Datei namens check_file.sh im Verzeichnis ~/project zu erstellen.

nano ~/project/check_file.sh

Fügen Sie nun den folgenden Code in die Datei ein. Dieses Skript fragt nach einem Dateinamen, liest die Eingabe in eine Variable namens filename und führt dann ls -l für diesen Dateinamen mithilfe des eval-Befehls aus. Beachten Sie, dass die Verwendung von eval mit Benutzereingaben eine ernsthafte Sicherheitslücke darstellt.

#!/bin/bash

echo "Bitte geben Sie einen Dateinamen zur Überprüfung ein:"
read filename
echo "Überprüfe Details für: $filename"
eval "ls -l $filename"

Drücken Sie Strg+X, dann Y und Enter, um die Datei zu speichern und nano zu beenden.

Als Nächstes müssen Sie das Skript ausführbar machen, damit Sie es ausführen können. Verwenden Sie den chmod-Befehl, um Ausführungsberechtigungen hinzuzufügen.

chmod +x ~/project/check_file.sh

Lassen Sie uns das Skript nun ausführen, um es in Aktion zu sehen. Wir verwenden testfile.txt, das für Sie in der Laborumgebung erstellt wurde.

./check_file.sh

Das Skript wird Sie zur Eingabe auffordern. Geben Sie testfile.txt ein und drücken Sie Enter.

Bitte geben Sie einen Dateinamen zur Überprüfung ein:
testfile.txt
Überprüfe Details für: testfile.txt
-rw-rw-r-- 1 labex labex 0 Aug  4 15:19 testfile.txt

Sie haben erfolgreich ein einfaches Skript erstellt und ausgeführt, das Benutzereingaben entgegennimmt. Im nächsten Schritt sehen Sie, wie dieses Skript ausgenutzt werden kann.

Simulation eines grundlegenden Command Injection-Angriffs

In diesem Schritt sehen Sie, wie das im vorherigen Schritt erstellte Skript anfällig für einen Command Injection-Angriff ist. Command Injection tritt auf, wenn ein Angreifer über eine anfällige Anwendung beliebige Befehle auf dem Host-Betriebssystem ausführen kann.

Unser Skript ist anfällig, da es eval verwendet, um einen Befehl auszuführen, der Benutzereingaben ($filename) enthält, ohne vorher zu prüfen, ob die Eingabe sicher ist. Der eval-Befehl behandelt die gesamte Zeichenkette als auszuführenden Befehl, was ihn besonders gefährlich macht. Ein Angreifer kann dies ausnutzen, indem er Eingaben bereitstellt, die zusätzliche Shell-Befehle enthalten.

Führen wir das Skript erneut aus.

./check_file.sh

Geben Sie dieses Mal, wenn Sie nach einem Dateinamen gefragt werden, die folgende Zeichenkette ein. Das Semikolon (;) ist ein Sonderzeichen in der Shell, das Befehle trennt.

testfile.txt; whoami

Nachdem Sie Enter gedrückt haben, sehen Sie die folgende Ausgabe:

Bitte geben Sie einen Dateinamen zur Überprüfung ein:
testfile.txt; whoami
Überprüfe Details für: testfile.txt; whoami
-rw-rw-r-- 1 labex labex 0 Aug  4 15:19 testfile.txt
labex

Beachten Sie, was passiert ist. Das Skript führte zuerst wie erwartet ls -l testfile.txt aus. Aufgrund des Semikolons und der Verwendung von eval führte die Shell dann den zweiten Befehl, whoami, aus, der den aktuellen Benutzernamen (labex) ausgab. Dies demonstriert eine erfolgreiche Command Injection. Der eval-Befehl ermöglichte dies, indem er die gesamte Eingabe als ausführbaren Code behandelte. Ein Angreifer könnte diese Schwachstelle nutzen, um weitaus gefährlichere Befehle auszuführen.

Hinweis: Wenn Sie ls -l $filename ohne eval (wie in der ursprünglichen Version) verwendet hätten, wäre der Angriff nicht erfolgreich gewesen, da die Shell testfile.txt; whoami als separate Argumente für ls behandelt hätte, was zu Fehlermeldungen wie "cannot access 'testfile.txt;'" und "cannot access 'whoami'" geführt hätte. Der eval-Befehl ist es, der die Command Injection in diesem Beispiel ermöglicht.

Implementierung der Eingabe-Sanitisierung zur Verhinderung von Injection

In diesem Schritt modifizieren Sie das Skript, um Command Injection-Angriffe zu verhindern, indem Sie die Benutzereingabe bereinigen und den gefährlichen eval-Befehl entfernen. Input Sanitization ist der Prozess der Bereinigung oder Filterung von Eingaben, um potenziell bösartige Zeichen zu entfernen oder zu neutralisieren.

Unsere Strategie wird sein:

1. Entfernen des gefährlichen eval-Befehls und Verwendung der direkten Befehlsausführung mit ordnungsgemäßer Quoting.
2. Überprüfen, ob der eingegebene Dateiname nur erlaubte Zeichen enthält. Für einen typischen Dateinamen können wir eine Whitelist von Zeichen erstellen, wie z. B. Buchstaben, Zahlen, Unterstriche, Bindestriche und Punkte. Wir lehnen jede Eingabe ab, die andere Zeichen wie das Semikolon enthält.

Öffnen Sie das Skript check_file.sh erneut mit nano.

nano ~/project/check_file.sh

Modifizieren Sie das Skript, um eine Validierungsprüfung mithilfe eines regulären Ausdrucks einzufügen. Ersetzen Sie den vorhandenen Inhalt durch den folgenden Code:

#!/bin/bash

echo "Bitte geben Sie einen Dateinamen zur Überprüfung ein:"
read filename

## Input sanitization: nur alphanumerische Zeichen, Unterstriche, Bindestriche und Punkte erlauben.
if [[ "$filename" =~ ^[a-zA-Z0-9_.-]+$ ]]; then
  echo "Überprüfe Details für: $filename"
  ls -l "$filename"
else
  echo "Fehler: Ungültiger Dateiname. Bösartige Eingabe erkannt."
fi

Die wichtigsten Änderungen sind:

1. Entfernung des gefährlichen eval-Befehls.
2. Hinzufügen von ordnungsgemäßer Quoting um "$filename" im ls-Befehl.
3. Die if-Anweisung mit Eingabevalidierung. Der Ausdruck [[ "$filename" =~ ^[a-zA-Z0-9_.-]+$ ]] prüft, ob die Variable filename nur die Zeichen des angegebenen Satzes vom Anfang (^) bis zum Ende ($) enthält.

Drücken Sie Strg+X, Y und Enter, um die Änderungen zu speichern.

Versuchen wir nun denselben Angriff erneut. Führen Sie das Skript aus:

./check_file.sh

Geben Sie die bösartige Eingabe testfile.txt; whoami ein und drücken Sie Enter.

Bitte geben Sie einen Dateinamen zur Überprüfung ein:
testfile.txt; whoami
Fehler: Ungültiger Dateiname. Bösartige Eingabe erkannt.

Wie Sie sehen können, erkennt das Skript nun die ungültigen Zeichen und gibt eine Fehlermeldung aus, anstatt den bösartigen whoami-Befehl auszuführen. Der Angriff wird erfolgreich verhindert.

Skriptintegrität mit Hashing überprüfen

In diesem Schritt lernen Sie, wie Sie die Integrität Ihres Skripts mithilfe eines kryptografischen Hashs überprüfen können. Dies stellt sicher, dass das Skript nach der Sicherung nicht von einem Angreifer modifiziert oder manipuliert wurde. Wir werden das Dienstprogramm sha256sum verwenden, das einen SHA-256-Hash berechnet.

Zuerst generieren wir einen Hash für unser sicheres Skript check_file.sh und speichern ihn in einer Datei. Diese Datei dient als unsere "bekannte gute" Signatur.

sha256sum ~/project/check_file.sh > ~/project/check_file.sha256

Dieser Befehl berechnet den SHA-256-Hash von check_file.sh und leitet die Ausgabe in eine neue Datei namens check_file.sha256 um. Sehen wir uns den Inhalt dieser Datei an.

cat ~/project/check_file.sha256

Sie sehen eine lange Zeichenkette, gefolgt vom Dateinamen. Diese Zeichenkette ist der eindeutige Hash Ihres Skripts.

e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  /home/labex/project/check_file.sh

(Hinweis: Ihr Hash-Wert wird anders sein.)

Nun simulieren wir eine unbefugte Änderung. Wir fügen einen einfachen Kommentar am Ende des Skripts hinzu. Selbst eine kleine Änderung wie diese sollte den Hash vollständig verändern.

echo "## Ein harmloser Kommentar" >> ~/project/check_file.sh

Das Skript wurde nun modifiziert. Um seine Integrität zu überprüfen, können wir sha256sum mit der Option -c (check) verwenden, die den Hash aus unserer Signaturdatei liest und ihn mit dem aktuellen Hash des Skripts vergleicht.

sha256sum -c ~/project/check_file.sha256

Der Befehl meldet einen Fehler, da die Datei geändert wurde.

/home/labex/project/check_file.sh: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

Dies bestätigt, dass die Integrität des Skripts kompromittiert wurde. Diese Technik ist unerlässlich, um sicherzustellen, dass der Code, den Sie ausführen, der Code ist, dem Sie vertrauen.

Zusammenfassung

Herzlichen Glückwunsch zum Abschluss dieses Labs! Sie haben praktische Erfahrungen mit zwei kritischen Sicherheitsprinzipien gesammelt.

Sie haben gelernt, wie man Command Injection-Schwachstellen identifiziert und verhindert, indem man Input Sanitization implementiert. Durch die Validierung von Benutzereingaben gegen eine Whitelist erlaubter Zeichen haben Sie ein anfälliges Shell-Skript erfolgreich gesichert.

Sie haben auch gelernt, wie man die Code-Integrität mithilfe kryptografischer Hashes sicherstellt. Durch die Generierung einer SHA-256-Prüfsumme für Ihr Skript konnten Sie eine überprüfbare Signatur erstellen, die jede unbefugte Änderung erkennen kann.

Diese Fähigkeiten sind grundlegend für das Schreiben von sicherem Code und die Aufrechterhaltung der Sicherheit jedes Systems.