SSH-Brute-Force mit Hydra

Einführung

In diesem Lab lernen Sie, wie Sie Brute-Force-Angriffe gegen SSH-Dienste mit Hydra durchführen, einem in der Cybersecurity weit verbreiteten Tool zum Knacken von Passwörtern. Die Übung umfasst die Installation von Hydra, die Einrichtung eines Zielservers mit schwachen Zugangsdaten sowie die Durchführung von Angriffen unter Verwendung vorbereiteter Wortlisten.

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 Prinzipien des Ethical Hacking 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 eingesetzt wird. Hydra ist besonders nützlich für Penetrationstests, da es systematisch verschiedene Kombinationen von Benutzernamen und Passwörtern ausprobieren kann, um Zugang zu gesicherten Systemen zu erhalten. Es unterstützt zahlreiche Protokolle, darunter SSH (das wir in diesem Lab verwenden), FTP, HTTP und viele weitere.

Öffnen Sie zunächst das Terminal in Ihrer LabEx-VM-Umgebung. Das Terminal ist Ihre primäre Schnittstelle zum Ausführen von Befehlen unter Linux. Stellen Sie sicher, dass Sie sich im Standard-Arbeitsverzeichnis befinden, in dem wir alle Lab-Arbeiten durchführen werden:
```
cd ~/project
```
Bevor Sie neue Software installieren, ist es ratsam, die Paketliste zu aktualisieren. Dies stellt sicher, dass Sie die neueste verfügbare Version von Hydra und alle zugehörigen Abhängigkeiten erhalten:
```
sudo apt update
```
Nun installieren wir Hydra über den Paketmanager apt, 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 die Version abfragen. Der Befehl head -n 1 zeigt nur die erste Zeile der Ausgabe an, welche die Versionsinformationen enthält:
```
hydra -h | head -n 1
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
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 für diejenigen an, die GUI-Tools bevorzugen. Obwohl wir in diesem Lab die Kommandozeilenversion verwenden, können Sie optional die GTK+-Version mit folgendem Befehl installieren:
```
sudo apt install -y hydra-gtk
```

Einen Ziel-SSH-Server einrichten

In diesem Schritt konfigurieren wir einen lokalen SSH-Server, der uns in den folgenden Schritten als Ziel für das Passwort-Cracking dient. Dies ermöglicht es uns, Penetrationstest-Techniken in einer kontrollierten Umgebung zu üben. SSH (Secure Shell) ist ein Protokoll für die sichere Fernanmeldung zwischen Computern. Zu Lernzwecken richten wir hier eine verwundbare Konfiguration ein.

Stellen Sie zunächst sicher, dass Sie sich im Standard-Arbeitsverzeichnis befinden. Dies ist wichtig, damit alle Lab-Dateien an einem Ort organisiert sind:
```
cd ~/project
```
Installieren Sie das OpenSSH-Server-Paket. Diese Software verwandelt Ihren Rechner in einen SSH-Server, der Remote-Verbindungen entgegennehmen kann:
```
sudo apt install -y openssh-server
```
Erstellen Sie ein dediziertes Test-Benutzerkonto mit einem schwachen Passwort (nur zu Demonstrationszwecken). In realen Szenarien sind genau solche schwachen Passwörter das Ziel von Angreifern:
```
sudo useradd -m testuser
echo "testuser:password123" | sudo chpasswd
```
Konfigurieren Sie SSH so, dass die Passwort-Authentifizierung erlaubt ist (vorübergehend für dieses Lab). Standardmäßig deaktivieren viele Systeme die Passwort-Authentifizierung aus Sicherheitsgründen, aber wir aktivieren sie hier, um die Funktionsweise von Brute-Force-Angriffen zu demonstrieren:
```
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, damit Konfigurationsänderungen wirksam werden:
```
sudo service ssh restart
```
Überprüfen Sie, ob der SSH-Server läuft. 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 besagt, dass der Dienst aktiv (running) ist. Falls nicht, gab es möglicherweise einen Fehler in den vorherigen Schritten, der behoben werden muss.
Testen Sie die SSH-Verbindung lokal. Diese abschließende Prüfung bestätigt, dass alles funktioniert, bevor wir zur Angriffsphase übergehen:
```
ssh testuser@localhost -o StrictHostKeyChecking=no
```
Geben Sie nach Aufforderung das Passwort password123 ein. Nach erfolgreichem Login tippen Sie exit, um zu Ihrer Hauptsitzung zurückzukehren. Die Option -o StrictHostKeyChecking=no verhindert, dass SSH Sie zur Verifizierung des Server-Fingerabdrucks auffordert, was in dieser Lab-Umgebung akzeptabel ist.

Benutzernamen- und Passwortlisten vorbereiten

In diesem Schritt erstellen wir Textdateien mit potenziellen Benutzernamen und Passwörtern, die Hydra für die SSH-Authentifizierungsversuche verwenden wird. Diese Dateien sind essenziell für wörterbuchbasierte Brute-Force-Angriffe. Ein Wörterbuchangriff funktioniert durch systematisches Ausprobieren aller möglichen Kombinationen von Benutzernamen und Passwörtern aus vordefinierten Listen. Daher ist die Vorbereitung guter Listen entscheidend.

Stellen Sie sicher, dass Sie sich im Standard-Arbeitsverzeichnis befinden. Dies hilft dabei, Ihre Projektdateien organisiert zu halten und erleichtert die spätere Referenzierung:
```
cd ~/project
```
Erstellen Sie eine Liste mit Benutzernamen mit dem Texteditor nano. Häufige Benutzernamen werden bei Brute-Force-Angriffen oft zuerst ausprobiert, da viele Systeme Standardnamen oder vorhersehbare Namen verwenden:
```
nano usernames.txt
```
Fügen Sie diese gängigen Benutzernamen hinzu (drücken Sie Strg+O zum Speichern, 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 deren Inhalt anzeigen. Dieser Bestätigungsschritt stellt sicher, dass keine Tippfehler oder Formatierungsprobleme in Ihren Listen vorliegen:
```
cat usernames.txt
cat passwords.txt
```
Die von Ihnen erstellten Listen sollten nun im Terminal angezeigt werden.
(Optional) Generieren Sie zusätzliche Passwortvariationen mit crunch. Dieses Tool hilft dabei, umfassendere Passwortlisten zu erstellen, indem es automatisch Kombinationen basierend auf bestimmten Mustern generiert:
```
sudo apt install -y crunch
crunch 4 6 0123456789 -o num_passwords.txt
```
Dies erstellt numerische Passwörter mit einer Länge zwischen 4 und 6 Zeichen. Der Befehl spezifiziert die Mindestlänge (4), die Maximallänge (6) und den Zeichensatz (Ziffern 0-9).

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 ist eine Methode, bei der so lange viele Kombinationen von Benutzernamen und Passwörtern ausprobiert werden, bis die richtigen gefunden sind. Wir nutzen die zuvor vorbereiteten Wortlisten, um diesen Prozess zu automatisieren.

Navigieren Sie zunächst in das Projektverzeichnis, das Ihre Wortlisten enthält. So stellen wir sicher, dass Hydra die von uns erstellten Dateien finden kann:
```
cd ~/project
```
Nun führen wir Hydra mit spezifischen Parametern aus. Die Befehlsstruktur teilt Hydra mit, was wie angegriffen werden soll. Hier ist die Aufschlüsselung:
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -vV
```
Erklärung der Parameter:
- -L usernames.txt: Verweist auf unsere Liste möglicher Benutzernamen.
- -P passwords.txt: Gibt unser Passwort-Wörterbuch an.
- ssh://localhost: Zielt auf den SSH-Dienst auf diesem Rechner ab.
- -t 4: Steuert die Geschwindigkeit, indem die Anzahl gleichzeitiger Versuche auf 4 begrenzt wird.
- -vV: Zeigt den detaillierten Fortschritt im Terminal an.
Während Hydra läuft, wird jeder Versuch in Echtzeit angezeigt. Wenn gültige Zugangsdaten gefunden werden, erscheinen diese deutlich hervorgehoben in der Ausgabe:
```
[22][ssh] host: localhost   login: testuser   password: password123
```
(Optional) Um die Ergebnisse dauerhaft festzuhalten, können wir sie 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 einsehen mit:
```
cat results.txt
```

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man einen Brute-Force-Angriff auf SSH mit Hydra durchführt, einem leistungsstarken Tool zum Knacken von Passwörtern. Die Übung umfasste die Installation von Hydra, die Konfiguration eines SSH-Servers zu Testzwecken und das Erstellen gezielter Listen für Benutzernamen und Passwörter.

Sie haben die Durchführung von Wörterbuchangriffen und die Analyse der Ergebnisse geübt und dabei gesehen, wie schwache Zugangsdaten ausgenutzt werden können. Diese praktische Erfahrung unterstreicht die dringende Notwendigkeit starker Passwörter und sicherer Authentifizierungsmethoden in der Cybersecurity.