Brute-Force-Angriff auf SSH mit Hydra

Einführung

In diesem Lab lernen Sie, wie Sie Brute-Force-Angriffe gegen SSH-Dienste mit Hydra durchführen, einem beliebten Tool zum Knacken von Passwörtern im Bereich der Cybersicherheit. Die Übung umfasst die Hydra-Installation, die Einrichtung eines Zielservers mit schwachen Anmeldedaten und die Ausführung von Angriffen mit vorbereiteten Wortlisten (Wordlists).

Sie sammeln praktische Erfahrungen bei der Konfiguration einer SSH-Testumgebung und der Analyse der Brute-Force-Fähigkeiten von Hydra. Dieses Lab demonstriert reale Angriffsszenarien und stärkt gleichzeitig die ethischen Hacking-Prinzipien in einer kontrollierten Umgebung.

Hydra installieren

In diesem Schritt installieren wir Hydra, ein leistungsstarkes Tool zum Knacken von Passwörtern, das für Brute-Force-Angriffe gegen verschiedene Netzwerkdienste verwendet wird. Hydra ist besonders nützlich für Penetrationstests, da es systematisch verschiedene Kombinationen aus Benutzernamen und Passwörtern ausprobieren kann, um Zugriff auf gesicherte Systeme zu erhalten. Es unterstützt mehrere Protokolle, darunter SSH (das wir in diesem Lab verwenden werden), FTP, HTTP und mehr.

Öffnen Sie zunächst das Terminal in Ihrer LabEx VM-Umgebung. Das Terminal ist Ihre primäre Schnittstelle zum Ausführen von Befehlen in Linux. Stellen Sie sicher, dass Sie sich im Standardarbeitsverzeichnis befinden, in dem wir alle unsere Laborarbeiten durchführen werden:
```
cd ~/project
```
Bevor Sie neue Software installieren, ist es ratsam, Ihre Paketliste zu aktualisieren. Dadurch wird sichergestellt, dass Sie die neueste verfügbare Version von Hydra und alle seine Abhängigkeiten erhalten:
```
sudo apt update
```
Jetzt installieren wir Hydra mit dem apt Paketmanager, der die Softwareinstallation auf Debian-basierten Systemen wie Ubuntu verwaltet. Das Flag -y bestätigt die Installation automatisch:
```
sudo apt install -y hydra
```
Überprüfen wir nach der Installation, ob Hydra ordnungsgemäß installiert wurde, indem wir seine Version überprüfen. Der Befehl head -n 1 zeigt nur die erste Zeile der Ausgabe an, die die Versionsinformationen enthält:
```
hydra -h | head -n 1
```
Sie sollten eine ähnliche Ausgabe sehen wie:
```
Hydra v9.2 (c) 2022 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes.
```
Hydra bietet auch eine grafische Benutzeroberfläche (GUI) für diejenigen, die GUI-Tools bevorzugen. Während wir in diesem Lab die Befehlszeilenversion verwenden werden, können Sie optional die GTK+ GUI-Version installieren mit:
```
sudo apt install -y hydra-gtk
```

Einen Ziel-SSH-Server einrichten

In diesem Schritt konfigurieren wir einen lokalen SSH-Server, der in den folgenden Schritten als unser Ziel für das Knacken von Passwörtern dienen wird. Dies ermöglicht es uns, Penetrationstest-Techniken in einer kontrollierten Umgebung zu üben. SSH (Secure Shell) ist ein Protokoll, das für die sichere Remote-Anmeldung zwischen Computern verwendet wird, und wir werden eine anfällige Version zu Lernzwecken einrichten.

Stellen Sie zunächst sicher, dass Sie sich im Standardarbeitsverzeichnis befinden. Dies ist wichtig, da wir alle unsere Labordateien an einem Ort organisiert haben möchten:
```
cd ~/project
```
Installieren Sie das OpenSSH-Serverpaket. Diese Software verwandelt Ihren Rechner in einen SSH-Server, der Remote-Verbindungen akzeptieren kann:
```
sudo apt install -y openssh-server
```
Erstellen Sie ein dediziertes Testbenutzerkonto mit einem schwachen Passwort (nur zu Demonstrationszwecken). In realen Szenarien sind schwache Passwörter wie dieses genau das, wonach Angreifer suchen:
```
sudo useradd -m testuser
echo "testuser:password123" | sudo chpasswd
```
Konfigurieren Sie SSH so, dass die Passwortauthentifizierung zugelassen wird (vorübergehend für dieses Lab). Standardmäßig deaktivieren viele Systeme die Passwortauthentifizierung aus Sicherheitsgründen, aber wir aktivieren sie hier, um zu demonstrieren, wie Brute-Force-Angriffe funktionieren:
```
sudo sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/' /etc/ssh/sshd_config
```
Starten Sie den SSH-Dienst neu, um die Änderungen zu übernehmen. Dienste müssen oft neu gestartet werden, nachdem Konfigurationsänderungen wirksam werden:
```
sudo service ssh restart
```
Überprüfen Sie, ob der SSH-Server ausgeführt wird. Dieser Befehl prüft, ob unser SSH-Server ordnungsgemäß aktiv ist und auf Verbindungen wartet:
```
sudo service ssh status
```
Sie sollten eine Ausgabe sehen, die anzeigt, dass der Dienst aktiv ist (wird ausgeführt). Wenn nicht, ist möglicherweise ein Fehler in den vorherigen Schritten aufgetreten, der behoben werden muss.
Testen Sie die SSH-Verbindung lokal. Diese abschließende Überprüfung bestätigt, dass alles funktioniert, bevor wir mit der Angriffsphase fortfahren:
```
ssh testuser@localhost -o StrictHostKeyChecking=no
```
Geben Sie bei Aufforderung das Passwort password123 ein. Geben Sie nach erfolgreicher Anmeldung exit ein, um zu Ihrer Hauptsitzung zurückzukehren. Die Option -o StrictHostKeyChecking=no verhindert, dass SSH Sie auffordert, den Fingerabdruck (Fingerprint) des Servers zu überprüfen, was für diese Laborumgebung akzeptabel ist.

Eine Liste von Benutzernamen und Passwörtern vorbereiten

In diesem Schritt erstellen wir Textdateien, die potenzielle Benutzernamen und Passwörter enthalten, die Hydra verwenden wird, um die SSH-Authentifizierung zu versuchen. Diese Dateien sind für wörterbuchbasierte Brute-Force-Angriffe unerlässlich. Ein Wörterbuchangriff funktioniert, indem systematisch alle möglichen Kombinationen von Benutzernamen und Passwörtern aus vordefinierten Listen ausprobiert werden. Deshalb ist die Vorbereitung guter Listen entscheidend.

Stellen Sie zunächst sicher, dass Sie sich im Standardarbeitsverzeichnis befinden. Dies hilft, Ihre Projektdateien organisiert zu halten und erleichtert das spätere Referenzieren:
```
cd ~/project
```
Erstellen Sie eine Benutzernamenliste mit dem Texteditor nano. Häufige Benutzernamen werden bei Brute-Force-Angriffen oft zuerst ausprobiert, da viele Systeme Standard- oder vorhersehbare Benutzernamen verwenden:
```
nano usernames.txt
```
Fügen Sie diese gängigen Benutzernamen hinzu (drücken Sie Strg+O zum Speichern und dann Strg+X zum Beenden):
```
admin
root
testuser
user
guest
```
Erstellen Sie eine Passwortliste. Schwache Passwörter wie diese werden häufig verwendet und sind oft die ersten Ziele bei Sicherheitstests:
```
nano passwords.txt
```
Fügen Sie diese gängigen Passwörter hinzu:
```
password
password123
123456
qwerty
letmein
```
Überprüfen Sie, ob die Dateien korrekt erstellt wurden, indem Sie ihren Inhalt anzeigen. Dieser Bestätigungsschritt stellt sicher, dass sich keine Tippfehler oder Formatierungsprobleme in Ihren Listen befinden:
```
cat usernames.txt
cat passwords.txt
```
Sie sollten die von Ihnen erstellten Listen im Terminal angezeigt sehen.
(Optional) Generieren Sie zusätzliche Passwortvariationen mit crunch. Dieses Tool hilft bei der Erstellung umfassenderer Passwortlisten, indem es automatisch Kombinationen basierend auf angegebenen Mustern generiert:
```
sudo apt install -y crunch
crunch 4 6 0123456789 -o num_passwords.txt
```
Dies erstellt numerische Passwörter zwischen 4 und 6 Zeichen Länge. Der Befehl gibt die Mindestlänge (4), die maximale Länge (6) und den Zeichensatz (Ziffern 0-9) an.

Hydra gegen SSH ausführen

In diesem Schritt verwenden wir Hydra, um einen Brute-Force-Angriff gegen unseren lokalen SSH-Server durchzuführen. Brute-Forcing (Brute-Force-Methode) ist eine Methode, bei der viele Benutzername/Passwort-Kombinationen ausprobiert werden, bis die richtige gefunden wird. Wir verwenden die zuvor erstellten Wortlisten, um diesen Prozess zu automatisieren.

Navigieren Sie zunächst zum Projektverzeichnis, das Ihre Wortlisten enthält. Dies stellt sicher, dass Hydra die von uns erstellten Dateien finden kann:
```
cd ~/project
```
Jetzt führen wir Hydra mit bestimmten Parametern aus. Die Befehlsstruktur teilt Hydra mit, was angegriffen werden soll und wie. Lassen Sie uns dies aufschlüsseln:
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -vV
```
Erläuterung der Parameter:
- -L usernames.txt: Verweist auf unsere Liste möglicher Benutzernamen
- -P passwords.txt: Gibt unsere Passwort-Wörterbuchdatei an
- ssh://localhost: Zielt auf den SSH-Dienst auf diesem Rechner ab
- -t 4: Steuert die Geschwindigkeit, indem auf 4 gleichzeitige Versuche begrenzt wird
- -vV: Zeigt detaillierten Fortschritt im Terminal an
Während Hydra ausgeführt wird, zeigt es jeden Versuch in Echtzeit an. Wenn es gültige Anmeldeinformationen findet, werden diese deutlich in der Ausgabe angezeigt, wie hier:
```
[22][ssh] host: localhost   login: testuser   password: password123
```
(Optional) Um eine dauerhafte Aufzeichnung der Ergebnisse zu erhalten, können wir diese in einer Datei speichern. Dies ist nützlich für die Dokumentation oder weitere Analysen:
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -o results.txt
```
Nach Abschluss des Scans können Sie die gespeicherten Ergebnisse mit folgendem Befehl anzeigen:
```
cat results.txt
```

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie mit Hydra, einem leistungsstarken Tool zum Knacken von Passwörtern, einen Brute-Force-Angriff auf SSH durchführen. Die Übung umfasste die Installation von Hydra, die Konfiguration eines SSH-Servers zum Testen und die Erstellung gezielter Benutzername-/Passwortlisten.

Sie haben das Ausführen von wörterbuchbasierten Angriffen und das Analysieren von Ergebnissen geübt und demonstriert, wie schwache Anmeldeinformationen ausgenutzt werden können. Diese praktische Erfahrung unterstreicht die entscheidende Notwendigkeit starker Passwörter und sicherer Authentifizierungsmethoden in der Cybersicherheit (Cybersecurity).