HoneyAegis: Bauen Sie Ihr eigenes KI-gestütztes Honeypot-Netzwerk

The Hacker's Path: Begleitanleitung

Dieser Artikel gehört zu Teil 1: Einführung und Teil 2: Flipper-Meisterklasse. Du hast den Angriff gelernt. Jetzt baust du deine Verteidigung.

Ich habe mir letzten Monat die Preise kommerzieller Honeypot-Plattformen angeschaut. Thinkst Canary will 5.000 Dollar pro Jahr für fünf Geräte. Andere Anbieter berechnen pro Sensor und Monat, wobei deine Bedrohungsdaten zuerst durch deren Infrastruktur fließen. Die sehen deine Angreifer, bevor du es tust.

Das ist absurd.

Ein Honeypot ist ein Köder-System, das dafür gebaut wurde, angegriffen zu werden. Du stellst Fake-Dienste bereit (SSH, SMB, FTP) und schaust, was passiert. Angreifer denken, sie brechen in einen echten Server ein, aber in Wirklichkeit liefern sie dir Informationen über ihre Werkzeuge, Techniken und Ziele. Das ist offensive Verteidigung.

Das Konzept ist simpel. Die Umsetzung sollte keine Hypothekenzahlung kosten.

Also haben wir HoneyAegis gebaut: eine selbstgehostete, Docker-native Honeypot-Plattform mit lokaler KI-Analyse. Ein Raspberry Pi 5 betreibt die Sensoren. Ein alter Alienware-Laptop übernimmt das Denken. Alles bleibt in deinem Netzwerk. Keine Cloud. Keine Abonnements. Kein Anbieter, der deine Bedrohungsdaten vor dir sieht.

Aufbau an einem Nachmittag. Alles gehört dir. Für immer.

Was ist ein Honeypot?

Bevor wir bauen, klären wir, was wir bauen.

Ein Honeypot ist ein absichtlich verwundbares System, das eingesetzt wird, um Angreifer anzulocken. Es sieht echt genug aus, um automatisierte Scanner und neugierige Hacker zu täuschen, ist aber komplett gefälscht. Keine echten Daten, keine echten Benutzer, keine echten Dienste, nur emulierte, die alles protokollieren.

Warum sollte man so etwas wollen?

• Frühwarnung: Angreifer treffen zuerst auf deinen Honeypot, bevor sie deine echten Systeme erreichen. Du siehst sie kommen.
• Threat Intelligence: Erfahre, welche Tools sie verwenden, welche Zugangsdaten sie ausprobieren, worauf sie es abgesehen haben.
• Angriffsmuster: Baue eine Datenbank mit Techniken auf, die speziell auf die Exposition deines Netzwerks zugeschnitten sind.
• Training: Beobachte echte Angriffe in Echtzeit. Besser als jede Simulation.
• Penetrationstests: Ein sicheres Ziel für deine eigenen offensiven Übungen.

Was HoneyAegis emuliert

Cowrie: SSH- und Telnet-Honeypot. Zeichnet komplette Sitzungsprotokolle auf, erfasst Zugangsdaten, protokolliert Befehle.

Dionaea: Fängt Malware ab. Emuliert SMB, FTP, HTTP und andere Dienste. Speichert Payloads zur Analyse.

OpenCanary: Multi-Service-Honeypot. Emuliert Windows-Freigaben, MySQL, SSH und mehr. Hochgradig konfigurierbar.

Die Zwei-Knoten-Architektur

HoneyAegis nutzt eine bewusste Aufteilung: Der Sensor ist dem Internet zugewandt, das Gehirn bleibt geschützt.

Internet ──► Router (Port-Weiterleitung) ──► Pi 5 SENSOR
                                           │
                                           │ Vector (Logs)
                                           ▼
Internes Netzwerk ◄──────► Alienware GEHIRN
                              │
                              ├── PostgreSQL + TimescaleDB
                              ├── FastAPI Backend
                              ├── Ollama (lokale KI)
                              ├── Next.js Dashboard
                              └── Redis + Celery

Warum die Trennung?

Der Sensor ist absichtlich exponiert. Er wird angegriffen werden. Das ist der ganze Sinn. Falls etwas katastrophal schiefgeht, falls ein Angreifer aus den Honeypot-Containern ausbricht, ist der Pi ein 60-Dollar-Gerät mit nichts drauf außer Ködern. Löschen. Neu aufsetzen. Dreißig Minuten.

Das Gehirn enthält alles Wertvolle: deine Datenbank, dein Dashboard, deine KI-Analyse, deine historischen Angriffsdaten. Es berührt niemals das Internet. Es sitzt in deinem internen Netzwerk und empfängt Logs vom Sensor über einen sicheren Kanal.

⚠️ Das Gehirn darf niemals dem Internet ausgesetzt sein

Port-Weiterleitung zum Gehirn bedeutet sofortige Kompromittierung. Das Gehirn hat deine PostgreSQL-Datenbank, deine API, dein Dashboard. Exponierst du es, lädst du Angreifer in deine tatsächliche Infrastruktur ein. Nur der Sensor bekommt Port-Weiterleitungen. Nur Honeypot-Ports. Nichts anderes.

Hardware-Konfiguration

Hier ist, was wir betreiben. Das ist nicht die einzig gültige Konfiguration, sondern unser optimales Setup mit Hardware, die wir bereits hatten.

KNOTEN 1 — SENSOR (Raspberry Pi 5 4GB)

KNOTEN 2 — GEHIRN (Alienware 15 R3)

Warum die GTX 1070?

Lokale KI braucht GPU-Beschleunigung, um nützlich zu sein. Die GTX 1070 hat 8 GB VRAM, genug, um Ollama mit llama3.1:8b komfortabel auszuführen. Das gibt dir KI-generierte Bedrohungszusammenfassungen, ohne Daten an OpenAI oder Anthropic zu senden. Die KI erklärt, was Angreifer tun, in verständlichem Deutsch, komplett auf deiner eigenen Hardware.

Schritt-für-Schritt-Anleitung: Pi 5 Sensor

Lass uns das von Grund auf bauen. Wir beginnen mit dem Sensor, dem Pi 5, der dem Internet zugewandt ist.

Phase 1: Raspberry Pi 5 Sensor-Setup

Zeit: 45 Minuten

Voraussetzungen: Raspberry Pi 5 (4GB), microSD-Karte oder NVMe-HAT, Netzteil, Ethernet-Kabel, ein anderer Computer mit SSH

1.1 Raspberry Pi OS flashen

Lade den Raspberry Pi Imager auf deinem Computer herunter. Lege deine microSD-Karte ein.

# Im Raspberry Pi Imager:
# 1. Choose Device: Raspberry Pi 5
# 2. Choose OS: Raspberry Pi OS Lite (64-bit)
# 3. Choose Storage: Your microSD card
# 4. Click the gear icon for advanced options:
#    - Set hostname: honeypot-sensor
#    - Enable SSH with password authentication
#    - Set username/password (not pi/raspberry)
#    - Configure WiFi if needed (but use Ethernet)
# 5. Write the image

Stecke die Karte in deinen Pi 5, verbinde Ethernet und schalte ihn ein.

1.2 Ersteinrichtung

Verbinde dich per SSH mit deinem Pi:

bash# Von deinem Computer
ssh [email protected]

# Alles aktualisieren
sudo apt update && sudo apt upgrade -y

# Grundlegende Tools installieren
sudo apt install -y git curl vim htop

1.3 Statische IP festlegen

Dein Pi braucht eine vorhersehbare IP für die Port-Weiterleitung. Ersetze die IP-Adressen durch dein Netzwerk-Schema:

bash# Aktuellen Verbindungsnamen prüfen
nmcli con show

# Statische IP setzen (an dein Netzwerk anpassen)
sudo nmcli con mod "Wired connection 1" ipv4.addresses 192.168.1.50/24
sudo nmcli con mod "Wired connection 1" ipv4.gateway 192.168.1.1
sudo nmcli con mod "Wired connection 1" ipv4.dns "8.8.8.8,8.8.4.4"
sudo nmcli con mod "Wired connection 1" ipv4.method manual
sudo nmcli con up "Wired connection 1"

# Überprüfen
ip addr show eth0

1.4 Docker installieren

bash# Docker mit dem Convenience-Script installieren
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Benutzer zur Docker-Gruppe hinzufügen
sudo usermod -aG docker $USER

# Docker Compose Plugin installieren
sudo apt install -y docker-compose-plugin

# Abmelden und wieder anmelden für Gruppenänderungen
exit

# Erneut per SSH verbinden, dann überprüfen
docker --version
docker compose version

1.5 HoneyAegis Sensor bereitstellen

bash# Repository klonen
git clone https://github.com/thesecretchief/HoneyAegis.git
cd HoneyAegis

# Umgebungsvorlage kopieren
cp .env.example .env

# Konfiguration bearbeiten
nano .env

Setze in der .env-Datei folgende Werte:

bash# Sensor-Konfiguration
HONEYAEGIS_MODE=sensor
BRAIN_HOST=192.168.1.100  # IP deines Alienware
SENSOR_NAME=pi5-sensor-01

Sensor-Stack bereitstellen:

bash# Sensor-Dienste starten
docker compose --profile sensor up -d

# Container beim Hochfahren beobachten
docker ps
# Erwartete Container:
# - honeyaegis-cowrie (SSH/Telnet-Honeypot)
# - honeyaegis-dionaea (Malware-Erfassung)
# - honeyaegis-opencanary (Multi-Service)
# - honeyaegis-vector (Log-Versand)

# Logs prüfen, ob alles funktioniert
docker compose logs -f

Schritt-für-Schritt-Anleitung: Alienware-Gehirn

Jetzt das Gehirn, der geschützte Knoten, der alles verarbeitet.

Phase 2: Alienware-Gehirn-Setup

Zeit: 30 Minuten

Voraussetzungen: Kali Linux installiert, NVIDIA-Treiber konfiguriert, im selben Netzwerk wie der Pi

2.1 Kali und NVIDIA überprüfen

bash# Kali-Version prüfen
cat /etc/os-release

# NVIDIA-Treiber überprüfen
nvidia-smi
# Du solltest sehen:
# - Treiberversion (535+ empfohlen)
# - GTX 1070 mit ~8GB VRAM
# - CUDA-Version

2.2 Docker auf Kali installieren

bash# Aktualisieren und Docker installieren
sudo apt update
sudo apt install -y docker.io docker-compose-v2

# Docker aktivieren und starten
sudo systemctl enable docker
sudo systemctl start docker

# Benutzer zur Docker-Gruppe hinzufügen
sudo usermod -aG docker $USER

# Abmelden und wieder anmelden, dann überprüfen
docker --version
docker compose version

2.3 NVIDIA Container Toolkit installieren

Damit können Docker-Container auf deine GPU zugreifen, was für Ollama erforderlich ist:

bash# NVIDIA Container Toolkit Repository hinzufügen
distribution=$(. /etc/os-release; echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-docker.list

# Toolkit installieren
sudo apt update
sudo apt install -y nvidia-container-toolkit

# Docker für NVIDIA Runtime konfigurieren
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# GPU-Zugriff in einem Container testen
docker run --rm --gpus all nvidia/cuda:12.0-base nvidia-smi

2.4 HoneyAegis-Gehirn bereitstellen

bash# Repository klonen
git clone https://github.com/thesecretchief/HoneyAegis.git
cd HoneyAegis

# Umgebungsvorlage kopieren
cp .env.example .env

# Konfiguration bearbeiten
nano .env

Das Gehirn konfigurieren:

bash# Gehirn-Konfiguration
HONEYAEGIS_MODE=brain
OLLAMA_GPU=true
POSTGRES_PASSWORD=your-strong-password-here
JWT_SECRET=another-strong-secret
ADMIN_PASSWORD=dashboard-admin-password

Bereitstellen:

bash# Kompletten Gehirn-Stack starten
docker compose --profile brain up -d

# Beim ersten Start dauert es ein paar Minuten
# Fortschritt beobachten:
docker compose logs -f

# Sobald die Container laufen, KI-Modell herunterladen
docker exec -it honeyaegis-ollama ollama pull llama3.1:8b
# Das lädt ~4,7GB herunter - dauert ein paar Minuten

# Alle Container überprüfen
docker ps
# Erwartete Container:
# - honeyaegis-fastapi (API-Backend)
# - honeyaegis-postgres (Datenbank)
# - honeyaegis-redis (Cache/Queue)
# - honeyaegis-celery (Hintergrund-Worker)
# - honeyaegis-ollama (lokale KI)
# - honeyaegis-nextjs (Dashboard)
# - honeyaegis-traefik (Reverse Proxy)

Netzwerk-Konfiguration

Hier machen Leute Fehler. Lies sorgfältig.

⚠️ Port-Weiterleitungsregeln

Leite NUR diese Ports an den Pi-Sensor weiter:

Leite NIEMALS diese weiter:

• Port 3000 (Dashboard)
• Port 8000 (API)
• Port 5432 (PostgreSQL)
• Port 6379 (Redis)
• Irgendeinen Port zum Alienware

Melde dich in deinem Router an und konfiguriere die Port-Weiterleitung zur statischen IP des Pi (192.168.1.50 in unserem Beispiel). Die Honeypot-Dienste laufen intern auf hohen Ports, aber Angreifer sehen sie extern auf Standard-Ports.

Zugriff auf das Dashboard

Von jedem Computer in deinem internen Netzwerk:

bash# Im Browser öffnen:
http://192.168.1.100:3000

# Standard-Zugangsdaten (sofort ändern!):
# Benutzername: admin
# Passwort: (was du in ADMIN_PASSWORD gesetzt hast)

Was du siehst:

• Echtzeit-Angriffsfeed: Live-Stream eingehender Angriffe, während sie passieren
• GeoIP-Karte: Visuelle Darstellung, woher die Angriffe kommen
• Sitzungsaufzeichnungen: Komplette Transkripte von SSH/Telnet-Sitzungen, exportierbar als MP4/GIF
• KI-Zusammenfassungen: Von Ollama generierte Erklärungen der Angriffsmuster in verständlicher Sprache
• Statistiken: Angriffshäufigkeit, häufige Zugangsdaten, angegriffene Dienste
• Alarmkonfiguration: Slack-, Discord-, E-Mail-Benachrichtigungen via Apprise einrichten

HoneyAegis für Penetrationstests nutzen

Hier wird es richtig spaßig. Dein Honeypot ist ein sicheres Ziel zum Üben offensiver Techniken.

Übung: Greif deinen eigenen Honeypot an

Von Kali (auf die interne IP des Pi zielend):

1. Führe nmap gegen den Pi aus, um exponierte Dienste zu sehen
2. Versuche SSH-Brute-Force mit Hydra
3. Probiere SMB-Enumeration
4. Beobachte, wie das Dashboard in Echtzeit aufleuchtet
5. Lies die KI-Analyse deines Angriffs

bash# Deinen Honeypot scannen
nmap -sV -p 22,23,445,21 192.168.1.50

# SSH per Brute-Force angreifen (Cowrie akzeptiert alles und protokolliert es)
hydra -l root -P /usr/share/wordlists/rockyou.txt ssh://192.168.1.50:2222

# Manuell verbinden und herumstöbern
ssh [email protected] -p 2222
# Probiere gängige Passwörter - Cowrie akzeptiert sie

# Schau ins Dashboard - deine Sitzung erscheint sofort
# Sieh zu, wie die KI erklärt, was du getan hast

Integration mit The Hacker's Path:

• Teil 3 (Kali-Grundlagen): Nutze deinen Honeypot als Aufklärungs-Ziel
• Teil 4 (Exploitation): Übe Metasploit gegen deine kontrollierte Umgebung
• Teil 5 (Vollständiges Audit): Integriere Honeypot-Deployment als defensive Komponente

Was ist mit Home Assistant auf dem gleichen Pi?

Kurze Antwort: Lass es bleiben.

⚠️ Halte deinen Honeypot isoliert

Dein Honeypot-Sensor ist absichtlich dem Internet ausgesetzt. Er wird angegriffen werden, das ist der ganze Sinn. Home Assistant auf dem gleichen Gerät zu betreiben, bringt deine Smart-Home-Steuerung nur einen Container-Ausbruch von Angreifern entfernt. Falls etwas schiefgeht, willst du den Schadensradius auf Fake-Dienste beschränkt haben, nicht auf deine echten Türschlösser und deinen Thermostat. Verwende einen separaten Pi für Home Assistant.

Die gute Nachricht? Die ~1,5 GB Reservekapazität sind nicht verschwendet. HoneyAegis hat Raum zum Wachsen.

Bessere Verwendung für die Kapazität deines Pi

Statt nicht zusammengehörige Dienste auf ein exponiertes Gerät zu quetschen, nutze den Spielraum für tiefere Honeypot-Fähigkeiten:

Pi 5 4GB RAM-Budget (Dedizierter Sensor)

Roadmap: Kommt zu HoneyAegis

Wir entwickeln aktiv zusätzliche Sensormodule für das HoneyAegis GitHub-Projekt. Geplante Ergänzungen umfassen:

• Conpot (~200 MB) — Honeypot für industrielle Steuerungssysteme. Emuliert PLCs und SCADA-Systeme.
• Mailoney (~100 MB) — SMTP-Honeypot. Fängt Spam-Bots und Zugangsdaten-Harvester ab.
• Elasticpot (~150 MB) — Elasticsearch-Honeypot. Fängt Bots, die nach exponierten Clustern suchen.
• ADBHoney (~100 MB) — Android Debug Bridge-Honeypot. Erkennt Angreifer, die auf Mobilgeräte zielen.
• Honey-Tokens — Gefälschte AWS-Zugangsdaten und API-Schlüssel, die bei Verwendung Alarm auslösen.

Die Architektur ist dafür gebaut. HoneyAegis verwendet eine modulare Docker-Compose-Struktur: Jeder neue Honeypot wird als Container eingefügt, wobei Vector seine Logs ans Gehirn sendet. Gib dem Repo einen Stern, um die Entwicklung zu verfolgen, oder trage eigene Module bei.

Das Prinzip: Halte deinen Honeypot-Sensor bei einer Sache, und mach die richtig: ein attraktives, isoliertes Ziel sein, das Informationen an dein Gehirn liefert. Betreibe Home Assistant auf einem separaten Gerät, wo es hingehört.

Weiterführende Lektüre: Operation Smart Home behandelt dedizierte Home-Assistant-Setups, und Dein WLAN kann dich sich bewegen sehen erklärt WiFi-Sensing auf eigener Hardware.

Fehlerbehebung & Wartung

bash# Logs ansehen (beide Knoten)
docker compose logs -f
docker compose logs -f service-name

# Dienst neustarten
docker compose restart cowrie

# Container-Ressourcenverbrauch prüfen
docker stats

# Datenbank-Backup (auf dem Gehirn)
docker exec honeyaegis-postgres pg_dump -U honeyaegis honeyaegis > backup.sql

# HoneyAegis aktualisieren
git pull
docker compose pull
docker compose up -d

# Alte Angriffsdaten löschen (Vorsicht!)
docker exec honeyaegis-postgres psql -U honeyaegis -c \
  "DELETE FROM sessions WHERE created_at < NOW() - INTERVAL '30 days';"

Häufige Probleme:

• Port-Konflikte: Ein anderer Dienst belegt die Honeypot-Ports. Prüfe mit netstat -tlnp
• NVIDIA-Treiber-Inkompatibilität: Container-Toolkit-Version muss zum Treiber passen. Toolkit nach Treiberupdates neu installieren.
• Vector sendet keine Logs: Prüfe docker compose logs vector. Meist ein Netzwerk-/Firewall-Problem zwischen den Knoten.
• Ollama langsam: Überprüfe GPU-Zugriff mit docker exec honeyaegis-ollama nvidia-smi

Was kommt als Nächstes

Du hast jetzt ein produktives Honeypot-Netzwerk, das echte Threat Intelligence generiert. So entwickelst du es weiter:

• Lass es eine Woche laufen. Du wirst überrascht sein, wie schnell Angriffe auftauchen, normalerweise innerhalb von Stunden.
• Stelle die Honeypot-Haftfähigkeit ein. Konfiguriere Cowrie so, dass es ein realistischeres Dateisystem emuliert, um Angreifer länger zu beschäftigen.
• Füge Honey-Tokens hinzu. Setze gefälschte Zugangsdaten ein, die bei Verwendung sofort Alarm auslösen.
• Integriere Threat-Feeds. Verbinde dich mit MISP oder AbuseIPDB für angereicherten Angreifer-Kontext.
• Erweitere deine Sensor-Flotte. Setze zusätzliche Pi-Sensoren an verschiedenen Netzwerk-Ausgangspunkten ein.

Kommerzielle Plattformen verlangen 5.000 Dollar pro Jahr, um dir zu zeigen, was dein Netzwerk angreift. Du hast gerade die gleiche Fähigkeit für den Preis eines Pi und etwas Strom gebaut. Die Angreifer kommen, ob du hinschaust oder nicht. Jetzt schaust du hin.

Deployment-Checkliste

☐ Pi 5: Statische IP zugewiesen, Docker installiert, Sensor-Stack läuft

☐ Alienware: NVIDIA-Toolkit installiert, Docker läuft, Gehirn-Stack bereitgestellt

☐ Ollama: llama3.1:8b-Modell heruntergeladen, GPU-Beschleunigung überprüft

☐ Netzwerk: Port-Weiterleitung konfiguriert (nur Honeypot-Ports!)

☐ Gehirn-Isolation: Überprüft, dass Gehirn KEINE Internet-Exposition hat

☐ Dashboard: Über interne IP erreichbar, Admin-Passwort geändert

☐ Vector: Logs fließen vom Sensor zum Gehirn

☐ Erster Angriff: Test durch Angriff auf den eigenen Honeypot

☐ KI-Analyse: Überprüft, dass Ollama Bedrohungszusammenfassungen generiert

The Hacker's Path

Dieser Leitfaden gehört zur Security-Serie.

Teil 1: Einführung Teil 2: Flipper-Meisterklasse HoneyAegis-Leitfaden ✓ Teil 3: Kali-Grundlagen Teil 4: Exploitation