Cybersicherheit

Einen SOC-Analyst-Home-Lab mit Wazuh, Suricata und dem ELK-Stack aufbauen

Geschrieben von Adam Muiz 17 Aug 2026 Aktualisiert: 17 Aug 2026 8 Min. gelesen

Wenn du jemals Threat Hunting, Incident Response oder Security Monitoring üben wolltest, ohne dein Produktionsnetzwerk zu gefährden, ist ein SOC-Analyst-Home-Lab genau das Richtige. Stell es dir wie einen Flugsimulator für Cybersicherheit vor — du erlebst echte Angriffe, echte Warnungen und echte Untersuchungen in einer sandgeboxten Umgebung, die weder deinen Job noch deine Freiheit gefährdet.

In diesem Guide zeige ich dir, wie du ein voll funktionsfähiges SOC (Security Operations Center) Home-Lab mit drei leistungsstarken Open-Source-Tools aufbaust: Wazuh für Intrusion Detection und Compliance-Monitoring, Suricata für Netzwerkverkehrs-Analyse und den ELK-Stack (Elasticsearch, Logstash, Kibana) für Log-Management und Visualisierung. Am Ende hast du ein Setup, das widerspiegelt, was echte SOC-Teams täglich nutzen.

Warum ein SOC Home-Lab bauen?

Die meisten Cybersicherheits-Zertifizierungen — von CompTIA Security+ über CEH bis BTL1 — erwarten, dass du verstehst, wie Sicherheitstools in der Praxis funktionieren, nicht nur in der Theorie. Ein Home-Lab ermöglicht es dir:

Echten Angriffsverkehr zu erzeugen und zu analysieren (Metasploit, Nmap usw.)
Custom Detection Rules zu schreiben und in Echtzeit zu sehen, wie sie auslösen
Alarme zu triagieren und Untersuchungs-Workflows aufzubauen
Ein Portfolio-Projekt zu erstellen, das in Bewerbungen heraussticht

Die Investition ist minimal — ein alter Laptop oder ein kleiner VPS mit 8GB+ RAM reicht völlig. Aber die Rendite ist enorm: Praxiserfahrung, die dich von Kandidaten unterscheidet, die nur Buchwissen haben.

Architektur-Überblick

Hier ist das Layout, das wir aufbauen. Stell dir dein Heimnetzwerk als kleine Stadt vor: Der ELK-Stack ist das zentrale Polizeirevier, das Berichte sammelt, Wazuh ist der Sicherheitswachtler, der Türen und Fenster in jedem Gebäude beobachtet, und Suricata ist das Überwachungskamerasystem, das den gesamten Verkehr auf den Straßen überwacht.

┌─────────────────────────────────────────────────┐
│                 SOC HOME LAB                    │
│                                                 │
│  ┌───────────┐   ┌────────────┐   ┌──────────┐ │
│  │  Wazuh    │──▶│  Logstash  │──▶│  Elastic │ │
│  │  Agent(s) │   │  Pipeline  │   │  search  │ │
│  └───────────┘   └────────────┘   └────┬─────┘ │
│                                        │       │
│  ┌───────────┐   ┌────────────┐        │       │
│  │ Suricata  │──▶│   Filebeat │────────┘       │
│  │  (IDS/IPS)│   └────────────┘                │
│  └───────────┘                  ┌──────────┐   │
│                                 │  Kibana  │   │
│  ┌───────────┐                  │Dashboard │   │
│  │  Target   │                  └──────────┘   │
│  │  Machine  │                                 │
│  └───────────┘                                 │
└─────────────────────────────────────────────────┘

Die Kernidee ist, dass Wazuh und Suricata Datenquellen sind, während der ELK-Stack die Analysplattform ist. Warnungen fließen von den Sensoren an einen zentralen Ort, an dem du sie durchsuchen, korrelieren und visualisieren kannst.

Schritt 1: Den ELK-Stack einrichten

Der ELK-Stack ist das Rückgrat unseres Labs. Wir lassen ihn in Docker laufen, um es sauber und reproduzierbar zu halten. Erstelle ein Verzeichnis und eine Docker-Compose-Datei:

mkdir -p ~/soc-lab && cd ~/soc-lab

Erstelle eine docker-compose.yml mit Elasticsearch, Logstash und Kibana. Für ein Home-Lab reicht ein Einzelknoten-Elasticsearch-Cluster aus. Weise Elasticsearch mindestens 4GB Heap-Speicher zu, wenn dein Gerät insgesamt 8GB RAM hat:

version: '3.8'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.14.0
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - "ES_JAVA_OPTS=-Xms4g -Xmx4g"
    ports:
      - "9200:9200"
    volumes:
      - es-data:/usr/share/elasticsearch/data

  logstash:
    image: docker.elastic.co/logstash/logstash:8.14.0
    volumes:
      - ./logstash/pipeline:/usr/share/logstash/pipeline
    ports:
      - "5044:5044"
    depends_on:
      - elasticsearch

  kibana:
    image: docker.elastic.co/kibana/kibana:8.14.0
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch

volumes:
  es-data:

Starte den Stack mit docker compose up -d und warte einige Minuten, bis Elasticsearch initialisiert ist. Überprüfen kannst du es mit:

curl -s http://localhost:9200/_cluster/health?pretty

Wenn du "status": "green" oder "status": "yellow" siehst, läuft alles. Yellow ist normal bei einem Einzelknoten-Cluster — es bedeutet nur, dass Replikate nicht über mehrere Knoten verteilt werden können.

Schritt 2: Wazuh installieren

Wazuh ist eine kostenlose, Open-Source-Sicherheitsplattform, die Intrusion Detection, Log-Analyse, File-Integrity-Monitoring und Compliance-Prüfung kombiniert. Stell es dir wie einen Sicherheitswachtler vor, der nie schläft, jede Sprache spricht und sich an jede Regel erinnert, die du ihm jemals gegeben hast.

Der einfachste Weg, Wazuh zu betreiben, ist über die Docker-basierte Installation. Auf deinem Lab-Server:

git clone https://github.com/wazuh/wazuh-docker.git -b 4.9.0
cd wazuh-docker/single-node
docker compose up -d

Dies startet den Wazuh-Manager, den Indexer und das Dashboard. Erreichen kannst du das Dashboard unter https://localhost:443 (Standardanmeldedaten: admin/admin — sofort ändern!).

Jetzt installiere den Wazuh-Agent auf deiner Zielmaschine (der „Opfer"-Maschine in deinem Lab). Auf einem Debian/Ubuntu-Ziel:

curl -sO https://packages.wazuh.com/4.9/wazuh-agent_4.9.0-1_amd64.deb
sudo WAZUH_MANAGER='ip-deines-lab-servers' dpkg -i ./wazuh-agent_4.9.0-1_amd64.deb
sudo systemctl enable wazuh-agent
sudo systemctl start wazuh-agent

Innerhalb weniger Minuten erscheint der Agent im Wazuh-Dashboard. Er beginnt automatisch mit der Überwachung von Rootkits, der Prüfung von Logdateien, der Datei-Integritätsprüfung und der Anomalieerkennung. Das Schönste an Wazuh ist, dass er mit Hunderten von Out-of-the-Box-Regeln kommt — kein Bedarf, Erkennungslogik von Grund auf zu schreiben.

Schritt 3: Suricata bereitstellen

Suricata ist eine leistungsstarke Network IDS, IPS und Network Security Monitoring Engine. Während Wazuh einzelne Hosts überwacht, sitzt Suricata auf Netzwerkebene und untersucht jedes Paket, das durch dein Lab-Netzwerk fließt.

Installiere Suricata auf einem Gerät mit Zugriff auf den Netzwerkverkehr deines Labs (idealerweise an einem Span-Port oder in Inline-Position):

sudo add-apt-repository ppa:oisf/suricata-stable
sudo apt update && sudo apt install suricata -y
sudo suricata-update
sudo suricata-update update-sources

Bearbeite /etc/suricata/suricata.yaml und setze das af-packet-Interface auf dein Lab-Netzwerkinterface (z.B. eth0). Suricata nutzt standardmäßig das ET-Open-Ruleset — über 30.000 Regeln, die alles von Malware-Callbacks bis zu SQL-Injection-Versuchen abdecken:

sudo systemctl enable suricata
sudo systemctl start suricata

Suricata gibt Logs im EVE-JSON-Format aus, was ideal für die Aufnahme durch den ELK-Stack ist. Richte Filebeat auf /var/log/suricata/eve.json und erstelle eine Logstash-Pipeline zum Parsen und Indizieren der Ereignisse.

Schritt 4: Alles mit Logstash und Filebeat verbinden

Hier passiert die Magie. Logstash fungiert als zentrales Nervensystem, sammelt Logs von Wazuh und Suricata, parst sie in strukturierte Daten und leitet sie an Elasticsearch weiter.

Erstelle eine Logstash-Pipeline-Konfiguration unter logstash/pipeline/soc-pipeline.conf:

input {
  beats {
    port => 5044
  }
}

filter {
  if [agent][name] == "suricata" {
    json {
      source => "message"
      target => "suricata"
    }
    if [suricata][event_type] == "alert" {
      mutate {
        add_tag => ["alert", "suricata"]
      }
    }
  }
}

output {
  elasticsearch {
    hosts => ["http://elasticsearch:9200"]
    index => "soc-lab-%{+YYYY.MM.dd}"
  }
}

Auf deiner Suricata-Maschine installierst du Filebeat und konfigurierst es so, dass es die EVE-Logs an Logstash sendet. Auf deinem Wazuh-Manager behandelt der Wazuh-Indexer bereits die Log-Speicherung, aber du kannst Warnungen an ELK weiterleiten, um ein einheitliches Dashboard zu erhalten.

Schritt 5: Dashboards in Kibana aufbauen

Kibana ist der Ort, an dem all deine Daten visuell und handlungsrelevant werden. Sobald die Logs fließen, erstelle Index-Muster für soc-lab-* und beginne mit dem Aufbau von Dashboards. Das sind die wichtigsten:

Warnungsübersicht — Gesamte Warnungen über die Zeit, aufgeschlüsselt nach Schweregrad und Quelle (Wazuh vs Suricata)
Netzwerkverkehr — Top-Talker, Protokollverteilung, geografische Karte der Ziel-IPs
Threat-Feed — Warnungen, die mit bekannten bösartigen IPs aus Threat-Intelligence-Feeds korreliert sind
Agent-Gesundheit — Status aller Wazuh-Agenten, Datei-Integritätsänderungen, Compliance-Scores

Der Lens-Editor in Kibana macht den Aufbau dieser Visualisierungen einfach — Drag-and-Drop-Felder, Diagrammtypen wählen und speichern. Das Ziel ist eine einzige Oberfläche, auf der du dein gesamtes Sicherheitsstatus auf einen Blick siehst.

Schritt 6: Angriffsverkehr für die Übung erzeugen

Ein SOC-Lab ohne Angriffe ist wie ein Fitnessstudio ohne Gewichte. Du musst bösartigen Verkehr erzeugen, damit deine Tools etwas zum Erkennen haben. Hier sind einige sichere Möglichkeiten:

# Nmap-Service-Scan gegen dein Ziel (löst Suricata-Regeln aus)
nmap -sV -sC target-ip

# DNS-Tunneling-Verkehr erzeugen (löst DNS-basierte Erkennung aus)
# Verwende iodine oder dnscat2 in deinem Lab-Netzwerk

# SSH-Brute-Force simulieren (löst Wazuh Auth-FAILURE-Regeln aus)
hydra -l admin -P /usr/share/wordlists/rockyou.txt ssh://target-ip

# Eine verwundbare Web-App wie DVWA für Web-Angriffserkennung starten
docker run --rm -it -p 80:80 vulnerables/web-dvwa

Nach jedem Angriff überprüfe deine Kibana-Dashboards. Du solltest innerhalb von Sekunden neue Warnungen sehen. Diese Feedback-Schleife — Angreifen, Erkennen, Untersuchen, Regeln verfeinern — ist genau das, was echte SOC-Analysten täglich tun.

Tipps, um das Beste aus deinem Lab herauszuholen

Fang klein an und iteriere. Versuche nicht, am ersten Tag alles bereitzustellen. Richte zuerst ELK ein, dann füge Wazuh hinzu, dann Suricata. Jedes Tool hat eine Lernkurve, und drei neue Systeme gleichzeitig stapeln ist ein Rezept für Frust.

Nutze Snapshots. Wenn du das auf einem VPS oder einer virtuellen Maschine laufen lässt, mache vor jeder größeren Änderung einen Snapshot. Dinge kaputt machen gehört zum Lernen dazu — Snapshots lassen dich Dinge kaputt machen, ohne Konsequenzen.

Dokumentiere deine Ergebnisse. Erstelle ein GitHub-Repository und beschreibe deinen Untersuchungsprozess für jedes Angriffsszenario. Das wird bei Vorstellungsgesprächen unbezahlbar — du kannst einer Personalverantwortlichen buchstäblich deinen Denkprozess mit echten Beweisen durchgehen lassen.

Tritt der Community bei. Der Wazuh-Slack, die Elastic-Diskussionsforen und der Suricata-Issue-Tracker sind alle aktiv mit Fachleuten, die Probleme gelöst haben, auf die du stoßen wirst. Leide nicht im Stillen, wenn die Antwort nur eine Nachricht entfernt ist.

Fazit

Der Aufbau eines SOC-Analyst-Home-Labs ist eine der lohnendsten Investitionen, die du in einer Cybersicherheitskarriere machen kannst. Du bekommst Praxiserfahrung mit unternehmensklassigen Tools, Übung, die direkt auf Zertifizierungsziele zugeschnitten ist, und ein Portfolio-Projekt, das beweist, dass du die Arbeit kannst — nicht nur darüber reden.

Die Kombination aus Wazuh, Suricata und ELK-Stack deckt host-basierte Erkennung, Netzwerküberwachung und zentralisierte Log-Analyse ab — die drei Säulen eines echten SOC. Fang mit dem an, was du hast, wachse mit dem Lernen und denke daran: Jeder Experte war einmal ein Anfänger, der beschlossen hat, ein Lab aufzubauen, anstatt nur über Tools zu lesen.

Hast du Fragen oder dein eigenes Lab gebaut? Schreib einen Kommentar unten — ich freue mich, von deinem Projekt zu hören.