Dein Heim als KI-Wächter: Anomalien im Netzwerk erkennen

Servus, liebe Admins und Heimlaboranten! Als jemand, der schon seit Jahren meine eigenen vier Wände und mein Heimnetzwerk mit allen möglichen Sensoren und Automatisierungen überwacht, war ich sofort fasziniert, als ich von Projekten wie "KI-Wächter Kirmes" hörte. Klar, die jagen Saboteure auf der Ostsee – ein bisschen anders als mein Heimlabor. Aber die Grundidee, ein mobiles Sensornetzwerk aufzubauen, das hybride Bedrohungen in Echtzeit erkennt, ist doch Gold wert, oder? Warum sollten wir das nicht für unsere eigenen Zwecke adaptieren?

Stell dir vor, dein Heimnetzwerk ist nicht nur eine Ansammlung von Geräten, sondern ein wachsamer Wächter, der ungewöhnliche Aktivitäten nicht nur meldet, sondern vielleicht sogar antizipiert. Keine Saboteure, die dein WLAN infiltrieren wollen (hoffentlich!), aber vielleicht ein unbekanntes Gerät, das sich plötzlich in deinem Netz meldet, ein Sensor, der völlig unerwartete Werte liefert, oder eine ungewöhnliche Funkaktivität. Das ist der Kern dessen, was wir hier aufbauen wollen: Ein dezentrales Sensornetzwerk zur Anomalieerkennung in deinem Heim. Und das alles mit Tools, die wir lieben: Raspberry Pis, Docker, Home Assistant und n8n.

In meiner Erfahrung ist Proaktivität im Heimnetzwerk Gold wert. Es geht nicht nur darum, Probleme zu beheben, wenn sie auftreten, sondern sie möglichst früh zu erkennen – oder noch besser, ungewöhnliche Muster zu identifizieren, bevor sie zu echten Problemen werden. Lass uns gemeinsam so einen "KI-Wächter" für dein Zuhause basteln!

Voraussetzungen: Was du mitbringen solltest

Bevor wir loslegen, lass uns kurz checken, ob du alles am Start hast. Keine Sorge, das Meiste davon ist Standard in jedem guten Heimlabor:

• Hardware:
  • Proxmox-Server: Optional, aber sehr empfehlenswert für zentrale Dienste wie MQTT und n8n. Eine VM oder ein LXC reicht völlig aus.
  • Mindestens zwei Raspberry Pis: Idealerweise ein RPi 3B+ oder 4 für die Sensor-Nodes. ESP32/ESP8266 sind auch super für spezifische Aufgaben wie WLAN-Monitoring.
  • Diverse Sensoren: Hier sind deiner Fantasie keine Grenzen gesetzt. Ich nutze gerne:
    • DHT22 (Temperatur/Luftfeuchte)
    • PIR-Sensoren (Bewegung)
    • Reed-Kontakte (Tür-/Fensterstatus)
    • ESP32s mit WiFi/Bluetooth-Scanning-Fähigkeiten (zur Erkennung unbekannter Geräte)
    • Ein SDR (Software Defined Radio) wie ein RTL-SDR-Dongle für fortgeschrittenes RF-Monitoring (optional, aber cool für "Drohnen-Spionage"-Simulation im Miniformat).
• Software & Tools:
  • Docker und Docker Compose: Für die einfache Bereitstellung unserer zentralen Dienste.
  • Home Assistant: Dein zentrales Dashboard und deine Automatisierungszentrale.
  • Mosquitto (MQTT-Broker): Der Kommunikationsknotenpunkt für alle Sensoren.
  • n8n: Unsere "KI"-Logik-Engine für komplexere Anomalieerkennung und Benachrichtigungen.
  • Raspberry Pi OS Lite: Auf den Sensor-Nodes.
• Kenntnisse:
  • Linux-Grundlagen: SSH, Dateisystem, Systemd.
  • Netzwerkgrundlagen: IP-Adressen, Subnetze, Port-Weiterleitung (falls du Sensoren außerhalb deines lokalen Netzes hast), idealerweise VLANs für die Sensor-Nodes.
  • Grundverständnis von YAML und Python: Keine Angst, wir gehen die Beispiele durch.

Wichtig zu wissen: Wir bauen hier kein militärisches Überwachungssystem, sondern adaptieren die Prinzipien der "hybriden Bedrohungserkennung" auf unseren Heimkontext. Das bedeutet, wir suchen nach Anomalien im normalen Betriebsablauf unseres Zuhauses und Netzwerks.

Das Konzept: Dein Heim als "Kirmes"-Sensorfeld

Die Idee hinter unserem Heim-Wächter ist eine dezentrale Datenerfassung mit zentraler Auswertung. Stell dir vor, jeder Raspberry Pi ist ein kleiner "Wächter", der seine Umgebung im Blick hat und seine Beobachtungen an eine zentrale Stelle meldet. Diese zentrale Stelle (Home Assistant & n8n) analysiert die Daten und schlägt Alarm, wenn etwas nicht stimmt.

Was wollen wir erreichen?

Unser Ziel ist die frühzeitige Erkennung von ungewöhnlichem Verhalten oder unbekannten Elementen. Hier ein paar Beispiele, was unser System entdecken könnte:

• Unbekannte Geräte im Netzwerk: Ein neuer Laptop, ein Smartphone, das sich ohne dein Wissen verbindet – oder sogar ein potenzieller Eindringling.
• Unerwartete Bewegung/Zugriff: Bewegung in einem Raum, der eigentlich leer sein sollte, oder eine Tür/Fenster, das sich zu ungewöhnlichen Zeiten öffnet.
• Umgebungsanomalien: Plötzlicher Temperaturanstieg in einem Serverraum, ungewöhnlich hohe Luftfeuchtigkeit.
• Funkstörungen/Unbekannte WLANs: Ein ESP32, der plötzlich ein neues, starkes WLAN-Signal in deiner Umgebung entdeckt, könnte auf eine neue Quelle hinweisen – im schlimmsten Fall eine getarnte Drohne oder ein unbekanntes Gerät.

Die Architektur: Dezentral und doch verbunden

Wir nutzen eine bewährte Architektur:

1. Dezentrale Sensoren (Raspberry Pis, ESPs): Sammeln Daten aus ihrer Umgebung.
2. MQTT-Broker (Mosquitto): Der zentrale Nachrichtenverteiler. Alle Sensoren senden ihre Daten hierher, und alle Konsumenten (Home Assistant, n8n) abonnieren die relevanten Topics.
3. Home Assistant: Sammelt, visualisiert und speichert die Sensordaten. Kann einfache Automatisierungen auslösen.
4. n8n: Die eigentliche "KI"-Logik. Hier definieren wir komplexere Regeln und Schwellenwerte, um Anomalien zu erkennen und dann Benachrichtigungen zu versenden.

Schritt-für-Schritt-Anleitung: Dein Heim-Wächter aufbauen

1. Basis-Setup: MQTT-Broker auf Proxmox/Docker

Wir starten mit dem Herzstück der Kommunikation: Dem MQTT-Broker. Ich persönlich betreibe Mosquitto am liebsten in einem Docker-Container auf einer Proxmox-VM oder direkt auf meinem Proxmox-Host in einem LXC. Das ist robust und einfach zu managen.

Zuerst erstellen wir ein Verzeichnis für unsere Docker Compose-Konfiguration:

mkdir -p /opt/mosquitto
cd /opt/mosquitto

Dann erstellen wir unsere `docker-compose.yml`. Ich empfehle dringend, Authentifizierung zu verwenden, auch im Heimnetzwerk!

version: '3'
services:
  mosquitto:
    image: eclipse-mosquitto:latest
    container_name: mosquitto
    restart: unless-stopped
    ports:
      - "1883:1883" # Standard MQTT-Port
      - "9001:9001" # Websockets (optional)
    volumes:
      - ./config:/mosquitto/config
      - ./data:/mosquitto/data
      - ./log:/mosquitto/log
    environment:
      - TZ=Europe/Berlin

Jetzt brauchen wir noch eine minimale `mosquitto.conf` im `config`-Verzeichnis. Erstelle `config/mosquitto.conf`:

# Standard Listener für MQTT
listener 1883
allow_anonymous false # WICHTIG: Keine anonymen Verbindungen!
password_file /mosquitto/config/passwd

# Optional: Listener für Websockets
# listener 9001
# protocol websockets

Und jetzt erstellen wir den Benutzer und das Passwort. Ersetze `dein_user` und `dein_passwort` durch sichere Zugangsdaten:

docker run --rm -it -v /opt/mosquitto/config:/mosquitto/config eclipse-mosquitto mosquitto_passwd -c /mosquitto/config/passwd dein_user

Du wirst aufgefordert, das Passwort einzugeben. Danach kannst du den Container starten:

docker compose up -d

Mein Tipp: Überprüfe immer die Firewall deines Hosts! Standardmäßig blockiert Proxmox oft Ports. Stelle sicher, dass Port 1883 (und 9001, falls genutzt) von deinen Sensor-Nodes aus erreichbar ist.

2. Sensor-Nodes (Raspberry Pi) vorbereiten

Jetzt wird's spannend! Wir nehmen einen Raspberry Pi und machen ihn zu einem unserer "Wächter".

Basis-Setup des Raspberry Pi

1. Installier Raspberry Pi OS Lite (64-bit ist meine Empfehlung) auf einer SD-Karte.
2. Aktiviere SSH und konfiguriere eine statische IP-Adresse. Das ist absolut entscheidend für ein stabiles Sensornetzwerk.
3. Melde dich per SSH an und aktualisiere das System:

   sudo apt update && sudo apt upgrade -y

4. Installier Python und die MQTT-Bibliothek:

   sudo apt install python3-pip -y
   pip3 install paho-mqtt

Beispiel: DHT22 Temperatur-/Feuchtigkeitssensor

Wir schließen einen DHT22-Sensor an den GPIO-Pin 4 des Raspberry Pi an (Datenleitung). Dann erstellen wir ein Python-Skript, das die Daten ausliest und per MQTT sendet.

Erstelle die Datei `/home/pi/dht22_sensor.py`:

import Adafruit_DHT
import paho.mqtt.client as mqtt
import time
import json

# Sensor-Typ und GPIO-Pin
SENSOR_TYPE = Adafruit_DHT.DHT22
GPIO_PIN = 4

# MQTT-Konfiguration
MQTT_BROKER = "192.168.1.10" # IP-Adresse deines Mosquitto-Servers
MQTT_PORT = 1883
MQTT_USER = "dein_user"
MQTT_PASSWORD = "dein_passwort"
MQTT_TOPIC_BASE = "home/sensor/rpi_wohnzimmer" # Eindeutiger Topic-Pfad

client = mqtt.Client()
client.username_pw_set(MQTT_USER, MQTT_PASSWORD)

def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("Verbunden mit MQTT-Broker!")
    else:
        print(f"Verbindung fehlgeschlagen, Fehlercode {rc}")

client.on_connect = on_connect
client.connect(MQTT_BROKER, MQTT_PORT, 60)
client.loop_start()

try:
    while True:
        humidity, temperature = Adafruit_DHT.read_retry(SENSOR_TYPE, GPIO_PIN)

        if humidity is not None and temperature is not None:
            payload = {
                "temperature": round(temperature, 2),
                "humidity": round(humidity, 2),
                "timestamp": int(time.time())
            }
            client.publish(f"{MQTT_TOPIC_BASE}/data", json.dumps(payload))
            print(f"Gesendet: Temperatur={temperature:.2f}°C, Luftfeuchtigkeit={humidity:.2f}%")
        else:
            print("Fehler beim Auslesen des Sensors.")

        time.sleep(30) # Alle 30 Sekunden messen
except KeyboardInterrupt:
    print("Beendet.")
finally:
    client.loop_stop()
    client.disconnect()

Wichtig: Für `Adafruit_DHT` musst du die Bibliothek installieren. Das geht so:

sudo apt install build-essential python3-dev python3-smbus git -y
git clone https://github.com/adafruit/Adafruit_Python_DHT.git
cd Adafruit_Python_DHT
sudo python3 setup.py install
cd ..

Um das Skript automatisch beim Systemstart auszuführen und zu überwachen, erstellen wir einen Systemd Service (`/etc/systemd/system/dht22_sensor.service`):

[Unit]
Description=DHT22 Sensor MQTT Publisher
After=network.target

[Service]
ExecStart=/usr/bin/python3 /home/pi/dht22_sensor.py
WorkingDirectory=/home/pi
StandardOutput=inherit
StandardError=inherit
Restart=always
User=pi

[Install]
WantedBy=multi-user.target

Aktiviere und starte den Dienst:

sudo systemctl daemon-reload
sudo systemctl enable dht22_sensor.service
sudo systemctl start dht22_sensor.service
sudo systemctl status dht22_sensor.service

3. Home Assistant Integration

Jetzt bringen wir die Daten in Home Assistant. Öffne deine `configuration.yaml` oder die `mqtt.yaml` (wenn du eine separate Datei verwendest) und füge den Sensor hinzu. Achte auf den korrekten Topic!

mqtt:
  sensor:
    - name: "Wohnzimmer Temperatur"
      state_topic: "home/sensor/rpi_wohnzimmer/data"
      value_template: "{{ value_json.temperature }}"
      unit_of_measurement: "°C"
      device_class: temperature
      state_class: measurement
    - name: "Wohnzimmer Luftfeuchtigkeit"
      state_topic: "home/sensor/rpi_wohnzimmer/data"
      value_template: "{{ value_json.humidity }}"
      unit_of_measurement: "%"
      device_class: humidity
      state_class: measurement

Nach einem Neustart von Home Assistant solltest du die Sensoren sehen. Du kannst jetzt Dashboards erstellen, um die Daten zu visualisieren.

Einfache Anomalieerkennung in Home Assistant:

Für einfache Schwellenwerte kannst du Home Assistant-Automatisierungen nutzen. Beispiel: Benachrichtigung, wenn die Temperatur über 28°C steigt.

automation:
  - alias: 'Wohnzimmer Temperatur zu hoch'
    trigger:
      - platform: numeric_state
        entity_id: sensor.wohnzimmer_temperatur
        above: 28
    action:
      - service: notify.mobile_app_dein_handy # Oder ein anderer Benachrichtigungsdienst
        data:
          message: "Achtung! Temperatur im Wohnzimmer über 28°C!"
          title: "Anomalie erkannt!"

4. n8n für erweiterte Anomalieerkennung

Hier kommt die Magie für komplexere "KI"-Logik ins Spiel. n8n ist ein geniales Tool für Workflow-Automatisierung und kann deutlich mehr als Home Assistant bei der Verarbeitung von Datenströmen.

n8n Installation (via Docker Compose)

Ich installiere n8n ebenfalls auf meinem Proxmox-Host in einem Docker-Container. Erstelle ein Verzeichnis `/opt/n8n` und eine `docker-compose.yml`:

version: '3.8'
services:
  n8n:
    image: n8nio/n8n
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678" # n8n Webinterface
    environment:
      - N8N_HOST=deine_n8n_ip_oder_domain
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
      - WEBHOOK_URL=http://deine_n8n_ip_oder_domain:5678/
      - TZ=Europe/Berlin
    volumes:
      - ./data:/home/node/.n8n

Starte n8n:

docker compose up -d

Greif über `http://deine_n8n_ip:5678` auf das Webinterface zu.

Workflow: Temperatur-Anomalieerkennung mit n8n

Erstelle einen neuen Workflow in n8n:

1. MQTT Trigger Node:
   • Füge einen "MQTT Trigger" Node hinzu.
   • Konfiguriere deine MQTT-Broker-Verbindung (Host, Port, User, Passwort).
   • Setze den Topic auf `home/sensor/rpi_wohnzimmer/data`.
   • Der Node wartet nun auf Nachrichten.
2. Function Node (für einfache Anomalieerkennung):
   • Füge einen "Function" Node hinzu. Hier können wir JavaScript nutzen, um komplexere Logik zu implementieren.
   • Wir können hier zum Beispiel einen gleitenden Durchschnitt berechnen und prüfen, ob der aktuelle Wert stark davon abweicht. Für eine erste Version können wir aber auch einfach die Werte aus Home Assistant übernehmen und hier weiterverarbeiten.
   • Beispiel für eine einfache Anomalieprüfung (wenn Wert > Schwellenwert ODER < unterer Schwellenwert):

     const temp = $json.temperature;
     const minTemp = 18;
     const maxTemp = 28;
     
     if (temp < minTemp || temp > maxTemp) {
       return [{json: {
         alert: true,
         message: `Temperatur-Anomalie im Wohnzimmer: ${temp}°C`,
         currentTemperature: temp
       }}];
     } else {
       return [{json: {
         alert: false,
         message: `Temperatur im Normalbereich: ${temp}°C`,
         currentTemperature: temp
       }}];
     }

3. If Node:
   • Verbinde den Function Node mit einem "If" Node.
   • Setze die Bedingung auf `{{ $json.alert === true }}`.
4. Benachrichtigungs-Node (z.B. Telegram):
   • Verbinde den "True"-Pfad des If-Nodes mit einem "Telegram" oder "Pushbullet" Node.
   • Konfiguriere deine Benachrichtigung: `{{ $json.message }}`.

Aktiviere den Workflow. Jedes Mal, wenn der DHT22-Sensor eine Anomalie meldet, erhältst du eine Benachrichtigung. Du kannst diese Logik beliebig erweitern, z.B. mit historischen Daten aus einer Datenbank (PostgreSQL-Node), um komplexere Muster zu erkennen.

5. Netzwerk-Monitoring für "hybride Bedrohungen"

Um wirklich hybride Bedrohungen zu erkennen, brauchen wir auch Netzwerkdaten. Ein Raspberry Pi kann hier auch als kleiner Netzwerk-Sniffer oder Scanner dienen.

Unbekannte MAC-Adressen im Netzwerk erkennen

Auf einem weiteren Raspberry Pi (oder einem der bestehenden) installieren wir `arp-scan`:

sudo apt install arp-scan -y

Erstelle ein Skript `/home/pi/network_scanner.py`:

import subprocess
import paho.mqtt.client as mqtt
import time
import json

MQTT_BROKER = "192.168.1.10"
MQTT_PORT = 1883
MQTT_USER = "dein_user"
MQTT_PASSWORD = "dein_passwort"
MQTT_TOPIC = "home/network/devices"

client = mqtt.Client()
client.username_pw_set(MQTT_USER, MQTT_PASSWORD)
client.connect(MQTT_BROKER, MQTT_PORT, 60)
client.loop_start()

known_macs = ["AA:BB:CC:DD:EE:FF", "11:22:33:44:55:66"] # FÜGE HIER DEINE BEKANNTEN MAC-ADRESSEN EIN!

def scan_network():
    try:
        # arp-scan auf dem Interface, z.B. eth0 oder wlan0
        # -l scannt das lokale Subnetz
        result = subprocess.run(['sudo', 'arp-scan', '-l', '-I', 'eth0'], capture_output=True, text=True, check=True)
        lines = result.stdout.splitlines()
        
        current_devices = []
        for line in lines:
            if "bytes" in line and "mac address" in line: # Filtert relevante Zeilen
                parts = line.split('\t')
                ip = parts[0]
                mac = parts[1].upper() # MAC-Adresse in Großbuchstaben
                vendor = parts[2].strip() if len(parts) > 2 else "Unknown"
                
                if mac not in known_macs:
                    print(f"Unbekanntes Gerät gefunden: IP={ip}, MAC={mac}, Vendor={vendor}")
                    payload = {
                        "ip": ip,
                        "mac": mac,
                        "vendor": vendor,
                        "status": "unbekannt",
                        "timestamp": int(time.time())
                    }
                    client.publish(f"{MQTT_TOPIC}/unknown", json.dumps(payload))
                current_devices.append(mac)
        
        # Optional: Sende alle gefundenen Geräte (bekannt & unbekannt)
        client.publish(f"{MQTT_TOPIC}/all", json.dumps({"devices": current_devices, "timestamp": int(time.time())}))

    except subprocess.CalledProcessError as e:
        print(f"Fehler beim arp-scan: {e}")
    except Exception as e:
        print(f"Ein Fehler ist aufgetreten: {e}")

while True:
    scan_network()
    time.sleep(300) # Alle 5 Minuten scannen

Auch hierfür einen Systemd Service erstellen und starten. Wichtig: `arp-scan` benötigt Root-Rechte. Entweder du lässt das Skript als Root laufen (nicht ideal, aber einfach) oder du konfigurierst `sudoers` für den `pi`-Benutzer, damit `arp-scan` ohne Passwort ausgeführt werden kann.

In n8n kannst du dann einen weiteren MQTT-Trigger auf `home/network/devices/unknown` abonnieren und eine Benachrichtigung auslösen, wenn eine Nachricht empfangen wird. Das ist eine effektive Methode, um unerwünschte Gäste frühzeitig zu erkennen!

Häufige Fehler und Lösungen

Wer das zum ersten Mal einrichtet, stolpert oft über ein paar Klassiker. Hier meine Top 3 der häufigsten Probleme:

1. MQTT-Verbindungsprobleme:
   • Symptom: Deine Sensoren senden keine Daten, Home Assistant zeigt keine Werte.
   • Ursache: Oft sind es Firewall-Regeln auf dem Host des Mosquitto-Containers, falsche IP-Adresse oder Port im Sensor-Skript, oder falsche Zugangsdaten.
   • Lösung:
     • Prüfe die IP-Adresse des MQTT-Brokers. Ist sie korrekt und erreichbar? (`ping deine_mqtt_ip`)
     • Überprüfe die Firewall (z.B. `ufw status` oder Proxmox-Firewall-Regeln). Port 1883 muss offen sein.
     • Kontrolliere `username_pw_set` im Python-Skript und in der `mosquitto.conf` bzw. `passwd`-Datei.