Hydra-Angriffsresultate speichern

Einführung

In diesem Labor lernen Sie, die Ergebnisse von Hydra-Angriffen zu speichern. Hydra, ein leistungsstarkes Passwort-knackendes Werkzeug, wird verwendet, um die Sicherheit eines simulierten HTTP-Anmeldeformulars zu testen. Sie beginnen mit einem grundlegenden HTTP-Angriff auf einen Zielwebserver unter Verwendung von Benutzernamen- und Passwortlisten.

Dieses Labor führt Sie dann durch die Speicherung der Angriffsresultate mithilfe der Option -o und die Ausgabe im JSON-Format mit der Option -b. Abschließend vergleichen Sie die Text- und JSON-Ausgaben, um die verschiedenen Möglichkeiten von Hydra zur Darstellung seiner Ergebnisse zu verstehen.

Einrichtung des Zieldienstes und der Benutzer-/Passwortlisten

In diesem Schritt richten Sie einen simulierten HTTP-Anmeldeservice ein und erstellen die notwendigen Benutzer- und Passwortlisten für Hydra. Dies bietet eine kontrollierte Umgebung, um die Ausgabe von Hydra zu speichern.

Navigieren Sie zunächst in Ihr Projektverzeichnis:

cd ~/project

Als Nächstes erstellen Sie ein einfaches Python-Skript, das einen HTTP-Anmeldeservice simuliert. Dieses Skript hört auf Port 80 und antwortet auf POST-Anforderungen an /login.php. Es betrachtet admin als korrekten Benutzernamen und password als korrektes Passwort.

Erstellen Sie die Datei login.py mit nano:

nano login.py

Fügen Sie den folgenden Python-Code in den nano-Editor ein:

from http.server import BaseHTTPRequestHandler, HTTPServer
import urllib.parse
import os

class LoginHandler(BaseHTTPRequestHandler):
    def do_POST(self):
        if self.path == '/login.php':
            content_length = int(self.headers['Content-Length'])
            post_data = self.rfile.read(content_length).decode('utf-8')
            parsed_data = urllib.parse.parse_qs(post_data)

            username = parsed_data.get('username', [''])[0]
            password = parsed_data.get('password', [''])[0]

            if username == 'admin' and password == 'password':
                self.send_response(200)
                self.send_header('Content-type', 'text/html')
                self.end_headers()
                self.wfile.write(b"Login erfolgreich!")
            else:
                self.send_response(401)
                self.send_header('Content-type', 'text/html')
                self.end_headers()
                self.wfile.write(b"Ungültiger Benutzername oder Passwort")
        else:
            self.send_response(404)
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            self.wfile.write(b"Nicht gefunden")

def run(server_class=HTTPServer, handler_class=LoginHandler, port=80):
    server_address = ('', port)
    httpd = server_class(server_address, handler_class)
    print(f"httpd-Server auf Port {port} starten")
    httpd.serve_forever()

if __name__ == "__main__":
    run()

Speichern Sie die Datei, indem Sie Strg+X, dann Y und anschließend Eingabe drücken.

Führen Sie nun den Python-HTTP-Server im Hintergrund aus. Dies simuliert den Zieldienst für Hydra.

nohup python3 login.py > /dev/null 2>&1 &

Der Befehl nohup ermöglicht es dem Prozess, auch nach dem Schließen des Terminals weiterzulaufen, und > /dev/null 2>&1 & leitet alle Ausgaben an /dev/null weiter und führt den Prozess im Hintergrund aus.

Als Nächstes erstellen Sie die Benutzer- und Passwortlisten, die Hydra für seinen Angriff verwenden wird.

Erstellen Sie eine Datei namens users.txt im Verzeichnis ~/project:

nano users.txt

Fügen Sie die folgenden Benutzernamen in die Datei ein:

admin
user
test

Speichern Sie die Datei, indem Sie Strg+X, dann Y und anschließend Eingabe drücken.

Erstellen Sie schließlich eine Datei namens passwords.txt im Verzeichnis ~/project:

nano passwords.txt

Fügen Sie die folgenden Passwörter in die Datei ein:

password
123456
test

Speichern Sie die Datei, indem Sie Strg+X, dann Y und anschließend Eingabe drücken.

Sie haben nun den Ziel-HTTP-Dienst erfolgreich eingerichtet und die Benutzer- und Passwortlisten vorbereitet.

Durchführung eines grundlegenden HTTP-Angriffs

In diesem Schritt führen Sie einen grundlegenden HTTP-Angriff mit Hydra auf den von Ihnen eingerichteten simulierten Anmeldeservice aus. Dies demonstriert, wie Hydra versucht, Anmeldeinformationen zu knacken, ohne die Ausgabe in eine Datei zu speichern.

Hydra ist ein leistungsstarkes Werkzeug zum Knacken von Passwörtern und kann verwendet werden, um die Sicherheit verschiedener Dienste, einschließlich HTTP, zu testen. In diesem Szenario zielen Sie auf ein einfaches HTTP-Anmeldeformular ab.

Sie verwenden das Modul http-post-form von Hydra, das für den Angriff auf Webformulare entwickelt wurde, die die HTTP-POST-Methode für die Übermittlung verwenden. Der Zieldienst läuft auf 127.0.0.1 auf Port 80, und das Anmeldeformular befindet sich unter /login.php.

Führen Sie den folgenden Hydra-Befehl in Ihrem Terminal aus:

hydra -L ~/project/users.txt -P ~/project/passwords.txt 127.0.0.1 http-post-form "/login.php:username=^USER^&password=^PASS^:Invalid username or password"

Lassen Sie uns diesen Befehl aufschlüsseln:

• hydra: Der Befehl zum Aufrufen des Hydra-Tools.
• -L ~/project/users.txt: Gibt den Pfad zur Datei mit der Benutzernamenliste an. Hydra iteriert durch jeden Benutzernamen in dieser Datei.
• -P ~/project/passwords.txt: Gibt den Pfad zur Datei mit der Passwortliste an. Hydra versucht jedes Passwort aus dieser Datei für jeden Benutzernamen.
• 127.0.0.1: Die Ziel-IP-Adresse des simulierten HTTP-Servers.
• http-post-form: Dies ist das Modul, das Hydra verwendet, um HTTP-POST-Formulare anzugreifen.
• "/login.php:username=^USER^&password=^PASS^:Invalid username or password": Dies ist der entscheidende Teil, der definiert, wie Hydra mit dem Formular interagiert:
  • /login.php: Der Pfad zur Anmeldeseite auf dem Zielserver.
  • username=^USER^&password=^PASS^: Definiert die Parameter, die im POST-Request gesendet werden. ^USER^ und ^PASS^ sind Platzhalter, die Hydra durch Werte aus Ihren Benutzernamen- und Passwortlisten ersetzt.
  • Invalid username or password: Dies ist die Fehlermeldung, nach der Hydra in der Serverantwort sucht, um festzustellen, ob ein Anmeldeversuch fehlgeschlagen ist. Wenn diese Zeichenkette nicht gefunden wird, betrachtet Hydra den Anmeldeversuch als erfolgreich.

Nach Ausführung des Befehls zeigt Hydra seinen Fortschritt und alle erfolgreichen Anmeldeversuche direkt in Ihrem Terminal an.

Beispielausgabe (falls erfolgreich):

Hydra vX.X (c) XXXX by van Hauser/THC - Use freely but only for legal purposes.

Hydra starts...

[DATA] X task, X servers, X login tries (l:X/p:X), ~X try per server
[DATA] attacking service http-post-form on port 80
[ATTACK] attacking 127.0.0.1:80/login.php
[80][http-post-form] host: 127.0.0.1   login: admin   password: password

Diese Ausgabe zeigt an, dass Hydra die Kombination aus Benutzername admin und Passwort password erfolgreich gefunden hat. Wenn keine erfolgreiche Anmeldung gefunden wird, wird Hydra ohne Anzeige erfolgreicher Anmeldeinformationen abgeschlossen.

Speichern von Ergebnissen mit der Option -o

In diesem Schritt erfahren Sie, wie Sie die Ergebnisse eines Hydra-Angriffs mithilfe der Option -o in eine Datei speichern. Dies ist nützlich, um die Ergebnisse später zu analysieren oder zu Berichtszwecken, da es geknackte Anmeldeinformationen in einer persistenten Datei speichert.

Die Option -o ermöglicht es Ihnen, eine Ausgabedatei anzugeben, in der Hydra die geknackten Anmeldeinformationen speichert. Wenn Hydra eine gültige Kombination aus Benutzername und Passwort findet, wird diese in einem einfachen, menschenlesbaren Format in die angegebene Datei geschrieben.

Sie setzen das gleiche Szenario fort: der simulierte Webserver läuft auf 127.0.0.1 auf Port 80 mit einem Anmeldeformular unter /login.php, und die Dateien users.txt und passwords.txt, die Sie zuvor erstellt haben.

Um die Ergebnisse in eine Datei namens hydra.log im Verzeichnis ~/project zu speichern, führen Sie den folgenden Befehl aus:

hydra -L ~/project/users.txt -P ~/project/passwords.txt -o ~/project/hydra.log 127.0.0.1 http-post-form "/login.php:username=^USER^&password=^PASS^:Invalid username or password"

Der einzige Unterschied zu dem vorherigen Befehl ist die Hinzufügung der Option -o ~/project/hydra.log. Dadurch wird Hydra angewiesen, die Ergebnisse in die Datei hydra.log zu speichern, anstatt sie nur im Terminal anzuzeigen.

Nach Ausführung des Befehls versucht Hydra, sich mit jeder Kombination aus Benutzername und Passwort anzumelden. Wenn eine erfolgreiche Anmeldung gefunden wird, werden der Benutzername und das Passwort in die Datei hydra.log geschrieben.

Um den Inhalt der Datei hydra.log anzuzeigen, verwenden Sie den Befehl cat:

cat ~/project/hydra.log

Beispielausgabe (falls erfolgreich):

Wenn Hydra die Kombination admin:password findet, enthält die Datei hydra.log eine Zeile ähnlich dieser:

127.0.0.1 http-post-form: admin:password

Wenn keine erfolgreiche Anmeldung gefunden wird, ist die Datei hydra.log leer.

Es ist wichtig zu beachten, dass die Option -o die Ausgabedatei überschreibt, falls sie bereits existiert. Wenn Sie die Ergebnisse an eine vorhandene Datei anhängen möchten, verwenden Sie stattdessen die Option -O (großes O). Für dieses Labor reicht die Option -o jedoch aus.

Ausgabe als JSON mit der Option -b

In diesem Schritt untersuchen Sie, wie Sie die Ergebnisse eines Hydra-Angriffs im JSON-Format mithilfe der Option -b ausgeben. JSON (JavaScript Object Notation) ist ein leichtgewichtiges Daten-Austauschformat, das sowohl für Menschen als auch für Maschinen leicht les- und schreibbar sowie parsier- und generierbar ist. Dieses Format ist besonders nützlich, wenn Sie die Ergebnisse programmatisch verarbeiten müssen, beispielsweise beim Integrieren der Hydra-Ausgabe in andere Tools oder Skripte.

Die Option -b, kombiniert mit der Option -o, weist Hydra an, die Ausgabe im angegebenen Format in die Datei zu speichern. Die Option -b erfordert einen Formatparameter: text (Standard), json oder jsonv1.

Sie setzen das gleiche Szenario fort: der simulierte Webserver läuft auf 127.0.0.1 auf Port 80 mit einem Anmeldeformular unter /login.php, und die Dateien users.txt und passwords.txt liegen vor.

Um die Ergebnisse im JSON-Format in eine Datei namens hydra.json im Verzeichnis ~/project zu speichern, führen Sie den folgenden Befehl aus:

hydra -L ~/project/users.txt -P ~/project/passwords.txt -o ~/project/hydra.json -b json 127.0.0.1 http-post-form "/login.php:username=^USER^&password=^PASS^:Invalid username or password"

In diesem Befehl haben Sie die Option -b json zusammen mit der Option -o ~/project/hydra.json hinzugefügt. Dadurch wird Hydra angewiesen, die Ausgabe im JSON-Format in die Datei hydra.json zu speichern.

Nach Ausführung des Befehls versucht Hydra, sich mit jeder Kombination aus Benutzername und Passwort anzumelden. Wenn eine erfolgreiche Anmeldung gefunden wird, werden der Benutzername und das Passwort im JSON-Format in die Datei hydra.json geschrieben.

Um den Inhalt der Datei hydra.json anzuzeigen, verwenden Sie den Befehl cat:

cat ~/project/hydra.json

Beispielausgabe (falls erfolgreich):

Wenn Hydra die Kombination admin:password findet, enthält die Datei hydra.json ein JSON-Objekt ähnlich diesem:

{
  "generator": {
    "software": "Hydra",
    "version": "v9.2",
    "built": "2025-05-30 08:10:07",
    "server": "127.0.0.1",
    "service": "http-post-form",
    "jsonoutputversion": "1.00",
    "commandline": "hydra -L users.txt -P passwords.txt -o hydra.json -b json 127.0.0.1 http-post-form /login.php:username=^USER^&password=^PASS^:Invalid username or password"
  },
  "results": [
    {
      "port": 80,
      "service": "http-post-form",
      "host": "127.0.0.1",
      "login": "admin",
      "password": "password"
    }
  ],
  "success": true,
  "errormessages": [],
  "quantityfound": 1
}

Wenn keine erfolgreiche Anmeldung gefunden wird, enthält die Datei hydra.json ein leeres JSON-Array:

[]

Dieses JSON-Format ermöglicht es Ihnen, die Ergebnisse mithilfe von Skriptsprachen wie Python oder JavaScript für weitere Analysen oder Automatisierungen leicht zu parsen.

Zusammenfassung

In diesem Labor haben Sie gelernt, wie man einen grundlegenden HTTP-Angriff mit Hydra, einem leistungsfähigen Passwort-Knackwerkzeug, durchführt. Sie haben einen simulierten HTTP-Anmeldeservice eingerichtet und Listen mit Benutzernamen und Passwörtern erstellt. Anschließend haben Sie Hydra verwendet, um zu versuchen, das simulierte HTTP-Anmeldeformular unter 127.0.0.1 zu knacken.

Sie haben erforscht, wie Sie die Hydra-Ausgabe mit der Option -o in eine Datei speichern können, um eine menschenlesbare hydra.log-Datei zu erstellen. Darüber hinaus haben Sie gelernt, die Ergebnisse im JSON-Format mit der Option -b auszugeben, um eine maschinenlesbare hydra.json-Datei zu generieren. Dieses Labor demonstrierte die Flexibilität von Hydra bei der Darstellung seiner Ergebnisse, was sowohl eine schnelle Überprüfung als auch eine programmatische Verarbeitung der Angriffsresultate ermöglicht.