Einen Honeypot in Cowrie deployen

Einführung

In diesem Lab lernen Sie, wie Sie Cowrie einrichten, ein SSH-Honeypot (Einhöpperschrank) mit mittlerer Interaktionsebene, der das Verhalten von Angreifern aufzeichnet und analysiert. Sie werden Cowrie in einer Python-Virtual Environment (virtuellen Python-Umgebung) einrichten und so konfigurieren, dass es einem echten SSH-Service gleicht, während es umfassende Protokollierung ermöglicht.

Durch diese praktische Übung werden Sie den Honeypot testen, indem Sie Angriffe simulieren und die generierten Protokolle analysieren. Diese praktische Erfahrung wird Ihnen helfen zu verstehen, wie Honeypots als Cybersicherheitstools für die Bedrohungserkennung und -analyse funktionieren.

Cowrie installieren

In diesem Schritt werden Sie Cowrie installieren, ein SSH-Honeypot (Einhöpperschrank) mit mittlerer Interaktionsebene, der darauf ausgelegt ist, Brute-Force-Angriffe und die Shell-Interaktion von Angreifern zu protokollieren. Cowrie ist in Python implementiert und kann einfach mit pip installiert werden. Ein Honeypot ist ein Sicherheitsmechanismus, der reale Systeme nachahmt, um bösartige Aktivitäten anzuziehen und zu untersuchen, und hilft Sicherheitsexperten, Angriffsmuster zu verstehen.

Stellen Sie zunächst sicher, dass Sie sich im Standardarbeitsverzeichnis befinden. Hier werden wir alle Projektdateien organisiert aufbewahren:
```
cd ~/project
```
Installieren Sie die erforderlichen Systemabhängigkeiten für Cowrie. Diese Pakete stellen die wesentlichen Komponenten bereit, die für das ordnungsgemäße Funktionieren von Cowrie erforderlich sind, einschließlich Python-Entwicklungstools und kryptographischen Bibliotheken:
```
sudo apt-get update && sudo apt-get install -y python3-venv python3-dev libssl-dev libffi-dev build-essential
```
Erstellen Sie eine Python-Virtual Environment (virtuelle Python-Umgebung) für Cowrie. Virtuelle Umgebungen isolieren die Projektabhängigkeiten von Ihrer System-Python-Installation und verhindern potenzielle Konflikte:
```
python3 -m venv cowrie-env
```
Aktivieren Sie die virtuelle Umgebung. Wenn die Umgebung aktiviert ist, werden alle Python-Pakete, die Sie installieren, in diese isolierte Umgebung statt in Ihre systemweite Python-Installation gehen:
```
source cowrie-env/bin/activate
```
Installieren Sie Cowrie mit pip. Pip ist der Paketmanager von Python, der Cowrie zusammen mit seinen Abhängigkeiten herunterlädt und installiert:
```
pip install cowrie
```
Überprüfen Sie die Installation, indem Sie die Cowrie-Version prüfen. Dies bestätigt, dass das Paket korrekt installiert wurde und zeigt, welche Version Sie ausführen:
```
cowrie --version
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
cowrie 2.1.0
```
Deaktivieren Sie die virtuelle Umgebung, wenn Sie fertig sind. Dadurch kehren Sie zur Standard-Python-Umgebung Ihres Systems zurück:
```
deactivate
```

Honeypot-Einstellungen konfigurieren

In diesem Schritt werden Sie die Einstellungen des Cowrie-Honeypots konfigurieren, um sein Verhalten und seine Protokollierungsfähigkeiten anzupassen. Die Konfigurationsdateien fungieren als das "Gehirn" Ihres Honeypots und bestimmen, wie er mit potenziellen Angreifern interagiert und welche Daten zur Analyse aufgezeichnet werden.

Aktivieren Sie zunächst die Python-Virtual Environment (virtuelle Python-Umgebung), die im vorherigen Schritt erstellt wurde. Dies isoliert die Abhängigkeiten von Cowrie von Ihrer System-Python-Installation:
```
cd ~/project
source cowrie-env/bin/activate
```
Generieren Sie die Standard-Konfigurationsdateien. Diese Vorlagen enthalten alle verfügbaren Einstellungen mit ihren Standardwerten:
```
cowrie-gen-config
```
Dadurch werden Konfigurationsdateien in ~/project/cowrie-env/etc/cowrie/ erstellt.
Bearbeiten Sie die Hauptkonfigurationsdatei mit nano, einem für Anfänger geeigneten Texteditor:
```
nano cowrie-env/etc/cowrie/cowrie.cfg
```
Ändern Sie diese wichtigen Einstellungen (verwenden Sie die Pfeiltasten zum Navigieren, Ctrl+O zum Speichern und Ctrl+X zum Beenden):
- Ändern Sie listen_port = 2222 in listen_port = 22 – dadurch erscheint der Honeypot als Standard-SSH-Server.
- Setzen Sie enabled = true im Abschnitt [output_json] – dies aktiviert die strukturierte Protokollierung für eine einfachere Analyse.
- Setzen Sie enabled = true im Abschnitt [output_textlog] – dies liefert menschenlesbare Protokolle.
Erstellen Sie ein separates Verzeichnis für die Protokolldateien. Die getrennte Aufbewahrung der Protokolle erleichtert die Organisation und Analyse:
```
mkdir -p ~/project/cowrie-logs
```
Aktualisieren Sie den Protokollierungspfad in der Konfiguration, um auf Ihr neues Verzeichnis zu verweisen:
```
nano cowrie-env/etc/cowrie/cowrie.cfg
```
Suchen Sie die Einstellung log_path und ändern Sie sie in:
```
log_path = /home/labex/project/cowrie-logs
```
Überprüfen Sie Ihre Konfigurationsänderungen, indem Sie die geänderten Einstellungen prüfen:
```
grep -E 'listen_port|enabled|log_path' cowrie-env/etc/cowrie/cowrie.cfg
```
Sie sollten eine Ausgabe sehen, die Ihre Änderungen widerspiegelt und bestätigt, dass die Konfiguration korrekt gespeichert wurde.

Den SSH-Service starten

In diesem Schritt werden Sie den Cowrie-Honeypot-SSH-Service starten, der auf eingehende Verbindungen lauscht. Da wir in einem Docker-Container ohne systemd laufen, werden wir die direkte Prozessausführung verwenden. Dieser Ansatz ist einfacher als die traditionelle Servicemanagement und besser für containerisierte Umgebungen geeignet.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Verzeichnis befinden und aktivieren Sie die virtuelle Umgebung. Die virtuelle Umgebung enthält alle erforderlichen Python-Abhängigkeiten, die von Ihrem System isoliert sind:
```
cd ~/project
source cowrie-env/bin/activate
```
Starten Sie den Cowrie-Service im Hintergrund. Der -n-Schalter lässt ihn im Nicht-Daemon-Modus laufen (die Ausgabe wird direkt im Terminal angezeigt), während das &-Zeichen den Prozess im Hintergrund ausführt, sodass Sie weiterhin das Terminal verwenden können:
```
cowrie start -n &
```
Überprüfen Sie, ob der Service läuft, indem Sie die Prozessliste prüfen. Dieser Befehl filtert alle laufenden Prozesse, um nur diejenigen anzuzeigen, die "cowrie" enthalten:
```
ps aux | grep cowrie
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
labex   12345  0.0  0.5  12345  6789 ?        S    12:34   0:00 python cowrie start -n
```
Prüfen Sie, ob der Service auf Port 22 lauscht. Dies ist wichtig, da SSH-Verbindungen über diesen Port eingehen. Der Befehl zeigt alle Netzwerkservices und ihre Lauschports an:
```
sudo netstat -tulnp | grep 22
```
Sie sollten eine Ausgabe sehen, die darauf hinweist, dass Python auf Port 22 lauscht.
Um den Service über Terminal-Sitzungen hinweg persistent zu machen, erstellen Sie ein einfaches Keep-Alive-Skript. Dies stellt sicher, dass der Honeypot auch dann weiterläuft, wenn Sie Ihr Terminal schließen:
```
nano cowrie-keepalive.sh
```
Fügen Sie den folgenden Inhalt hinzu:
```
#!/bin/bash
source ~/project/cowrie-env/bin/activate
cowrie start -n
```
Machen Sie das Skript ausführbar, damit es direkt ausgeführt werden kann:
```
chmod +x cowrie-keepalive.sh
```
Sie können nun den Honeypot starten, indem Sie dieses Skript ausführen. Es aktiviert die Umgebung und startet Cowrie in einem Schritt:
```
./cowrie-keepalive.sh
```

Einen Angriff simulieren

In diesem Schritt werden Sie einen SSH-Brute-Force-Angriff auf Ihren Cowrie-Honeypot simulieren, um seine Protokollierungsfähigkeiten zu überprüfen. Diese Simulation zeigt, wie Angreifer in der realen Welt versuchen könnten, unbefugten Zugang zu erhalten, und wie der Honeypot diese Versuche zur Analyse protokolliert.

Stellen Sie zunächst sicher, dass Ihr Cowrie-Honeypot läuft (aus dem vorherigen Schritt):
```
ps aux | grep cowrie
```
Dieser Befehl prüft, ob der Cowrie-Prozess aktiv ist. Sie sollten 'cowrie' in der Ausgabeliste sehen.
Installieren Sie den SSH-Client, falls er noch nicht verfügbar ist:
```
sudo apt-get install -y openssh-client
```
Das openssh-client-Paket stellt den ssh-Befehl bereit, den wir verwenden werden, um uns mit unserem Honeypot zu verbinden. Der '-y'-Schalter bestätigt automatisch alle Abfragen.
Simulieren Sie einen Brute-Force-Angriff, indem Sie mehrere SSH-Verbindungen mit gängigen Benutzername/Passwort-Kombinationen versuchen:
```
for i in {1..5}; do
  sshpass -p 'password' ssh -o StrictHostKeyChecking=no -p 22 labex@localhost
  sshpass -p 'admin' ssh -o StrictHostKeyChecking=no -p 22 admin@localhost
  sshpass -p 'root' ssh -o StrictHostKeyChecking=no -p 22 root@localhost
done
```
Dieses Skript versucht gängige Benutzername/Passwort-Paare (wie root/password) jeweils fünfmal. Der '-o StrictHostKeyChecking=no'-Schalter verhindert, dass SSH nach unbekannten Hosts fragt, was die Automatisierung erleichtert.
Simulieren Sie einen ausgefeilteren Angriff mit Hydra (vorinstalliert in der LabEx-VM):
```
hydra -L /usr/share/wordlists/metasploit/unix_users.txt -P /usr/share/wordlists/metasploit/unix_passwords.txt -t 4 -vV localhost ssh
```
Hydra ist ein leistungsstarkes Brute-Force-Tool. Hier versucht es Kombinationen aus den angegebenen Wortlisten (-L für Benutzernamen, -P für Passwörter). Der '-t 4'-Schalter begrenzt die Anzahl der parallelen Versuche auf 4, und '-vV' zeigt eine detaillierte Ausgabe an.
Überprüfen Sie, ob die Angriffe protokolliert wurden, indem Sie die Cowrie-Protokolle prüfen:
```
ls -l ~/project/cowrie-logs/
```
Nach dem Ausführen der Angriffe zeigt dieser Befehl neue Protokolldateien an, die Details aller Verbindungsversuche enthalten. Diese Protokolle würden Sicherheitsanalysten in einer realen Umgebung untersuchen.

Angriffslogs überprüfen

In diesem Schritt werden Sie die von Cowrie generierten Angriffsprotokolle analysieren, um die im vorherigen Schritt simulierten Angriffe zu verstehen. Die Protokolle enthalten wertvolle Sicherheitsinformationen über die Angriffsversuche. Cowrie protokolliert automatisch alle Interaktionsversuche in zwei Formaten: einem einfachen Textprotokoll für schnelles Lesen und einem strukturierten JSON-Protokoll für detaillierte Analysen.

Navigieren Sie zunächst in das Verzeichnis, in dem Cowrie alle seine Protokolldateien speichert:
```
cd ~/project/cowrie-logs
```
Sehen Sie sich die textbasierte Protokolldatei an (neueste zuerst). Der Befehl ls -lt zeigt die Dateien sortiert nach Änderungszeit an, während tail die letzten 20 Zeilen des neuesten Protokolls anzeigt:
```
ls -lt cowrie.log*
tail -n 20 cowrie.log
```
Sie sollten Einträge sehen, die fehlgeschlagene Anmeldeversuche mit Zeitstempeln, Benutzernamen und IP-Adressen anzeigen.
Untersuchen Sie die JSON-Protokolldatei auf strukturierte Daten. Das jq-Tool hilft bei der Analyse von JSON, und less ermöglicht das Scrollen durch lange Ausgaben:
```
jq '.' cowrie.json | less
```
Suchen Sie nach Einträgen mit "eventid": "cowrie.login.failed", die fehlgeschlagene Authentifizierungsversuche anzeigen.
Suchen Sie nach bestimmten Angriffsmustern, die auf gängige Admin-Konten abzielen. Der grep-Befehl sucht nach Textmustern in Dateien:
```
grep -a "root" cowrie.log
grep -a "admin" cowrie.log
```

Generieren Sie eine Zusammenfassung der Angriffsversuche. Diese Befehle extrahieren und zählen die am häufigsten versucht Benutzernamen und Passwörter aus den JSON-Protokollen:

echo "Top usernames attempted:"
jq -r 'select(.eventid=="cowrie.login.failed") | .username' cowrie.json | sort | uniq -c | sort -nr

echo -e "\nTop passwords attempted:"
jq -r 'select(.eventid=="cowrie.login.failed") | .password' cowrie.json | sort | uniq -c | sort -nr

Sehen Sie sich die Informationen zur Quell-IP an (in dieser Simulation wird localhost angezeigt). Dies extrahiert die IP-Adressen der sich verbindenden Clients:
```
jq -r 'select(.eventid=="cowrie.session.connect") | .src_ip' cowrie.json
```

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie einen Cowrie SSH-Honeypot (Einhöppfalle) bereitstellen können, um Cyberangriffe zu überwachen und zu analysieren. Der Prozess umfasste die Einrichtung einer Python-Virtual Environment (virtuellen Python-Umgebung), die Konfiguration von SSH-Ports und die Aktivierung der JSON-Protokollierung für die detaillierte Erfassung von Angriffsdaten.

Sie haben auch praktische Erfahrungen beim Starten des Honeypot-Services, der Simulation von Angriffen und der Analyse der protokollierten Daten gesammelt. Diese praktische Übung hat gezeigt, wie Sicherheitswerkzeuge reale Systeme imitieren können, um schädliche Aktivitäten effektiv zu erkennen und zu untersuchen.