Anomalien in Suricata erkennen

Einführung

In diesem Lab lernen Sie, Netzwerk-Anomalien mit Suricata zu erkennen, einem leistungsstarken Open-Source-Gefahren-Erkennungs-Engine (Bedrohungs-Erkennungs-Engine). Sie werden die wichtigsten Funktionen wie Regelkonguration, Verkehrsüberwachung und Alarmanalyse erkunden, um potenzielle Sicherheitsbedrohungen zu identifizieren.

Die praktischen Übungen führen Sie durch die Einrichtung von Suricata, die Erstellung grundlegender Regeln und die Echtzeit-Inspektion des Netzwerkverkehrs. Sie werden praktische Erfahrungen in der Erkennung verdächtiger Aktivitäten wie ICMP-Ping-Anfragen sammeln und lernen, Regeln für bestimmte Gefährungsszenarien (Bedrohungsszenarien) anzupassen.

Suricata installieren

In diesem Schritt werden Sie Suricata installieren, ein Open-Source-Netzwerk-Bedrohungs-Erkennungs-Engine (Netzwerk-Gefahren-Erkennungs-Engine). Suricata fungiert wie eine Sicherheitskamera für Ihr Netzwerk und analysiert ständig den Netzwerkverkehr, um potenzielle Bedrohungen zu identifizieren. Es kann drei Schlüsselfunktionen ausführen: Echtzeit-Einbruchs-Erkennung (Intrusion Detection System - IDS) zur Überwachung auf Angriffe, Inline-Einbruchs-Verhinderung (Intrusion Prevention System - IPS) zum Blockieren von schädlichem Verkehr und Netzwerksicherheitsüberwachung zur Protokollierung aller Aktivitäten.

Beginnen wir den Installationsprozess Schritt für Schritt:

Zunächst müssen wir die Paketliste aktualisieren. Dies stellt sicher, dass Ihr System über die neuesten verfügbaren Softwareversionen informiert ist, bevor wir etwas installieren:
```
sudo apt update
```
Der Befehl sudo gibt Ihnen Administratorrechte, während apt update die Liste der verfügbaren Pakete auf Ihrem System aktualisiert.
Jetzt installieren wir Suricata zusammen mit allen erforderlichen Komponenten (Abhängigkeiten). Das -y-Flag bestätigt die Installation automatisch:
```
sudo apt install -y suricata
```
Dieser Befehl lädt das Suricata-Softwarepaket aus den offiziellen Ubuntu-Repositories herunter und installiert es.
Nach der Installation überprüfen wir, ob alles korrekt funktioniert hat, indem wir die installierte Version überprüfen:
```
suricata -V
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
This is Suricata version 6.0.3 RELEASE
```
Das -V-Flag veranlasst Suricata, seine Versionsinformationen anzuzeigen. Wenn Sie diese Ausgabe sehen, bestätigt dies, dass die Installation erfolgreich war.
Das Verhalten von Suricata wird durch eine Konfigurationsdatei gesteuert. Überprüfen wir, ob diese wichtige Datei an ihrem Standardort vorhanden ist:
```
ls /etc/suricata/suricata.yaml
```
Das Verzeichnis /etc/suricata/ ist der Ort, an dem Linux normalerweise Konfigurationsdateien für systemweite Anwendungen speichert.
Schließlich benötigt Suricata Regeln, um zu wissen, wonach es im Netzwerkverkehr suchen soll. Diese Regeln sind wie eine Anweisungsliste, die Suricata sagt, was als verdächtige Aktivität gilt. Die Standardregeln werden gespeichert in:
```
ls /var/lib/suricata/rules
```
Das Verzeichnis /var/lib/suricata/rules enthält die Regeldateien, die mit der Suricata-Installation kommen. Wir werden später in diesem Lab mit diesen Regeln arbeiten.

Grundlegende Regeln konfigurieren

In diesem Schritt werden Sie grundlegende Erkennungsregeln für Suricata konfigurieren. Regeln sind die Kernkomponente, die Suricata sagt, wonach es im Netzwerkverkehr suchen soll. Stellen Sie sich sie wie eine Anweisungsliste vor, die verdächtige Muster oder bekannte Bedrohungen definiert.

Navigieren Sie zunächst zum Suricata-Regelverzeichnis, in dem alle Regeldateien gespeichert sind:
```
cd /var/lib/suricata/rules
```
Hier werden die Standard- und benutzerdefinierten Regeldateien von Suricata gespeichert. Der Verzeichnispfad ist in der Suricata-Konfiguration angegeben.
Listen Sie die vorhandenen Regeldateien auf, um zu sehen, was bereits verfügbar ist:
```
ls
```
Sie sollten mehrere .rules-Dateien wie suricata.rules sehen. Diese Dateien enthalten verschiedene Kategorien von Regeln, die Suricata zur Erkennung verwendet.
Untersuchen wir die Struktur einer grundlegenden Regel. Öffnen Sie die Hauptregeldatei mit dem nano-Editor:
```
sudo nano suricata.rules
```
Der nano-Editor ist ein einfacher Texteditor, den wir zur Modifikation von Regeln verwenden werden. Sie werden viele vorhandene Regeln mit ähnlichen Strukturen sehen.
Fügen Sie eine einfache Regel hinzu, um ICMP-Ping-Anfragen zu erkennen (fügen Sie dies am Ende der Datei hinzu):
```
alert icmp any any -> any any (msg:"ICMP Ping Detected"; itype:8; sid:1000001; rev:1;)
```
Lassen Sie uns analysieren, was diese Regel tut:
- alert: Teilt Suricata mit, einen Alarm zu generieren, wenn die Regel übereinstimmt
- icmp: Bezieht sich auf ICMP-Protokollverkehr
- any any -> any any: Passt auf jeden Quell-IP/Port zu jedem Ziel-IP/Port
- msg: Die Alarmmeldung, die in den Protokollen angezeigt wird
- itype:8: Passt speziell auf ICMP-Typ 8 (Ping-Anfragen)
- sid: Eindeutiger Regelbezeichner (1000001+ für benutzerdefinierte Regeln)
- rev: Regelversionsnummer
Speichern Sie die Datei (Ctrl+O, Enter, Ctrl+X in nano). Dadurch wird Ihre neue Regel dauerhaft gespeichert.
Überprüfen Sie die Syntax der Regel, bevor Sie sie anwenden:
```
sudo suricata -T -c /etc/suricata/suricata.yaml -v
```
Das -T-Flag testet die Konfiguration. Sie sollten eine Ausgabe sehen, die mit folgendem endet:
```
Configuration provided was successfully loaded. Exiting.
```
Dies bestätigt, dass Ihre Regel korrekt formatiert ist.
Starten Sie Suricata neu, um die neuen Regeln zu laden und die Überwachung zu beginnen:
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
Der erste Befehl stoppt alle laufenden Suricata-Instanzen, während der zweite es neu startet mit Ihren neuen Regeln und überwacht die eth0-Schnittstelle.

Live-Traffic überwachen

In diesem Schritt werden wir beobachten, wie Suricata Echtzeit-Netzwerkverkehr überwacht und auf der Grundlage der zuvor konfigurierten Regeln Alarme auslöst. Dies ist die Kernfunktion eines jeden IDS (Intrusion Detection System) – das Beobachten von Netzwerkpaketen und das Kennzeichnen verdächtiger Aktivitäten.

Zunächst müssen wir Suricata im Live-Aufnahmemodus starten. Die folgenden Befehle stoppen zunächst alle laufenden Suricata-Instanzen (falls vorhanden) und starten dann eine neue, die die eth0-Schnittstelle überwacht:
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
Das -c-Flag gibt unsere Konfigurationsdatei an, während -i Suricata mitteilt, welche Netzwerkschnittstelle überwacht werden soll.
Jetzt erzeugen wir etwas Testverkehr, der unsere ICMP-Regel aus dem vorherigen Schritt auslösen sollte. Öffnen Sie ein neues Terminal und führen Sie aus:
```
ping -c 3 8.8.8.8
```
Dies sendet 3 ICMP-Ping-Pakete an Google's DNS-Server (8.8.8.8). Da wir eine Regel zum Erkennen von ICMP-Verkehr erstellt haben, sollte Suricata diese Aktivität protokollieren.
Suricata schreibt Alarme in die Datei /var/log/suricata/fast.log. Um diese Alarme in Echtzeit zu beobachten, verwenden Sie:
```
sudo tail -f /var/log/suricata/fast.log
```
Der Befehl tail -f zeigt kontinuierlich neue Zeilen an, die zur Datei hinzugefügt werden. Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
01/01/2023-12:34:56.123456  [**] [1:1000001:1] ICMP Ping Detected [**] [Classification: (null)] [Priority: 3] {ICMP} 192.168.1.1 -> 8.8.8.8
```
Dies zeigt den Zeitstempel, die Regel-ID (1:1000001:1), die Alarmmeldung sowie die Quell- und Ziel-IP-Adressen an.
Für detailliertere Protokollierung im JSON-Format können wir die Datei eve.json untersuchen. Der folgende Befehl filtert und gibt nur Alarmereignisse schön formatiert aus:
```
sudo tail -f /var/log/suricata/eve.json | jq '. | select(.event_type == "alert")'
```
Das jq-Tool hilft dabei, die JSON-Ausgabe zu analysieren und zu formatieren, was das Lesen erleichtert.
Um Statistiken über den Verkehr anzuzeigen, den Suricata verarbeitet, einschließlich der Anzahl der ausgelösten Alarme:
```
sudo suricatasc -c stats
```
Suchen Sie im Output nach Zählern wie detect.alert – dies zeigt, wie oft unsere Regeln Alarme ausgelöst haben.
Wenn Sie mit der Beobachtung des Verkehrs fertig sind, drücken Sie in allen Terminalfenstern, in denen Sie die Protokolle überwachen, Ctrl+C, um die kontinuierliche Ausgabe zu stoppen.

Generierte Alarme überprüfen

In diesem Schritt werden Sie die von Suricata während der vorherigen Überwachungssitzung generierten Alarme analysieren. Dies hilft Ihnen zu verstehen, welche Verkehrsmuster Ihre Regeln ausgelöst haben. Bei der Arbeit mit Intrusion Detection Systemen (Eindringlingserkennungssystemen) ist die Überprüfung von Alarmen entscheidend, um potenzielle Sicherheitsbedrohungen zu identifizieren und Ihre Erkennungsregeln zu optimieren.

Zunächst überprüfen Sie das grundlegende Alarmprotokoll:
```
sudo cat /var/log/suricata/fast.log
```
Dieser Befehl zeigt zeitgestempelte Alarme in einem einfachen, menschenlesbaren Format an. Die Datei fast.log ist die Standard-Ausgabedatei für Alarme in Suricata. Suchen Sie nach Einträgen, die "ICMP Ping Detected" enthalten – diese weisen auf Ping-Anfragen hin, die Ihrer Erkennungsregel entsprachen.
Für eine detailliertere Analyse untersuchen Sie das strukturierte JSON-Protokoll:
```
sudo cat /var/log/suricata/eve.json | jq '. | select(.event_type == "alert")'
```
Die Datei eve.json enthält umfassende maschinenlesbare Protokolle im JSON-Format. Wir verwenden jq, um nur Alarmereignisse zu filtern. Dies liefert detaillierte Informationen, darunter:
- Quell- und Ziel-IP-Adressen
- Genaue Zeitstempel
- Vollständige Regelinformationen
- Informationen zur Paketnutzlast (wenn konfiguriert)
Um zu zählen, wie oft jeder Alarm ausgelöst wurde:
```
sudo grep -o "ICMP Ping Detected" /var/log/suricata/fast.log | wc -l
```
Diese Befehlskette extrahiert zunächst alle Vorkommen von "ICMP Ping Detected" mit grep -o und zählt sie anschließend mit wc -l. Dies hilft, die Häufigkeit dieses Ereignisses zu quantifizieren.
Für eine Zusammenfassung der Alarmtypen:
```
sudo jq -r '.alert.signature' /var/log/suricata/eve.json | sort | uniq -c
```
Dieser Befehl extrahiert alle Alarmsignaturen (Regelnamen), sortiert sie alphabetisch und zählt dann die eindeutigen Vorkommen. Er gibt Ihnen einen Überblick darüber, welche Regeln am häufigsten ausgelöst werden.
Um Alarme mit Quell-IP-Informationen anzuzeigen:
```
sudo jq -r 'select(.event_type == "alert") | [.timestamp, .src_ip, .alert.signature] | @tsv' /var/log/suricata/eve.json
```
Diese erweiterte jq-Abfrage erzeugt eine tabulatorgetrennte Ausgabe, die den Zeitstempel, die Quell-IP und die Alarmsignatur für jedes Ereignis anzeigt. Das @tsv-Format erleichtert das Importieren in Tabellenkalkulationen.
Um die letzten 5 Alarme zu überprüfen:
```
sudo tail -n 5 /var/log/suricata/fast.log
```
Der Befehl tail zeigt die letzten Zeilen einer Datei an. Dies ist nützlich für schnelle Überprüfungen der jüngsten Aktivitäten, ohne das gesamte Protokoll durchscrollen zu müssen.

Eigene Regel hinzufügen

In diesem Schritt lernen Sie, wie Sie Ihre eigene Suricata-Regel erstellen und testen, um bestimmte Muster im Netzwerkverkehr zu erkennen. Wir konzentrieren uns auf die Erkennung von HTTP-Anfragen an eine Testdomäne (example.com) als praktisches Beispiel. Benutzerdefinierte Regeln ermöglichen es Ihnen, die Erkennungsfähigkeiten von Suricata über die Standard-Regelsätze hinaus zu erweitern.

Navigieren Sie zunächst zum Verzeichnis, in dem Suricata seine Erkennungsregeln speichert:
```
cd /var/lib/suricata/rules
```
Hier werden normalerweise alle Suricata-Regeldateien gespeichert. Wir werden unsere benutzerdefinierten Regeln hier hinzufügen, um sie mit den vorhandenen Regeln zu organisieren.
Erstellen Sie eine neue Regeldatei speziell für Ihre benutzerdefinierten Regeln:
```
sudo nano custom.rules
```
Die Verwendung von sudo ist erforderlich, da das Regelnverzeichnis administrative Berechtigungen zur Änderung erfordert. Wir benennen die Datei custom.rules, um sie deutlich von Suricata's Standard-Regeldateien zu unterscheiden.
Fügen Sie die folgende Regel hinzu, um HTTP-Anfragen an example.com zu erkennen:
```
alert http any any -> any any (msg:"HTTP Request to example.com"; flow:to_server; http.host; content:"example.com"; nocase; sid:1000002; rev:1;)
```
Lassen Sie uns analysieren, was diese Regel tut:
- alert http: Löst einen Alarm für HTTP-Verkehr aus
- any any -> any any: Wird auf Verkehr von jedem Quellport zu jedem Zielport angewendet
- msg: Liefert eine menschenlesbare Alarmmeldung
- flow:to_server: Passt nur auf Verkehr zu Servern
- http.host: Untersucht den HTTP-Host-Header
- content:"example.com": Sucht nach dieser bestimmten Domäne
- nocase: Macht die Übereinstimmung unabhängig von Groß- und Kleinschreibung
- sid:1000002: Gibt der Regel eine eindeutige ID (über 1.000.000 für benutzerdefinierte Regeln)
- rev:1: Gibt an, dass dies die erste Version der Regel ist
Speichern Sie die Datei im Nano-Editor, indem Sie Strg+O drücken (ausschreiben), dann Enter zum Bestätigen und Strg+X zum Beenden.
Jetzt müssen wir Suricata mitteilen, dass es unsere neue Regeldatei laden soll. Bearbeiten Sie die Hauptkonfiguration:
```
sudo nano /etc/suricata/suricata.yaml
```
Suchen Sie den Abschnitt rule-files: (normalerweise um Zeile 50 - 60) und fügen Sie hinzu:
```
- custom.rules
```
Diese Ergänzung stellt sicher, dass Suricata unsere benutzerdefinierten Regeln beim Starten lädt.
Überprüfen Sie vor der Anwendung der Änderungen, ob die Regelsyntax korrekt ist:
```
sudo suricata -T -c /etc/suricata/suricata.yaml -v
```
Das -T-Flag teilt Suricata mit, die Konfiguration zu testen, ohne tatsächlich zu starten. Dies hilft, Syntaxfehler in Ihren Regeln zu finden, bevor sie verwendet werden.
Starten Sie Suricata neu, um die neue Regel zu laden:
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
Der erste Befehl stoppt alle laufenden Suricata-Instanzen, während der zweite es frisch mit unserer aktualisierten Konfiguration startet.
Um zu testen, ob unsere Regel funktioniert, generieren Sie etwas HTTP-Verkehr zu example.com:
```
curl http://example.com
```
Dieser Befehl macht eine einfache HTTP-Anfrage, die unsere neue Regel auslösen sollte.
Überprüfen Sie schließlich, ob Suricata den Verkehr erkannt hat, indem Sie die neuesten Alarme anzeigen:
```
sudo tail -n 5 /var/log/suricata/fast.log
```
Sie sollten einen Alarm sehen, der der Meldung unserer benutzerdefinierten Regel über HTTP-Anfragen an example.com entspricht. Wenn nicht, überprüfen Sie jeden Schritt noch einmal und vergewissern Sie sich, dass die Regelsyntax korrekt ist.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Suricata, einen quelloffenen Netzwerkbedrohungs-Erkennungs-Engine (Netzwerkbedrohungs-Erkennungsmotor), installieren und konfigurieren. Der Prozess umfasste das Aktualisieren von Paketen, das Installieren von Abhängigkeiten und die Überprüfung der Installation durch Prüfen der Konfigurationsdatei und des Regelnverzeichnisses.

Sie haben auch das Erstellen benutzerdefinierter Erkennungsregeln erkundet, indem Sie eine Regel für ICMP-Ping-Anfragen hinzugefügt, deren Struktur und Komponenten verstanden haben. Schließlich haben Sie die Regelsyntax überprüft, um sicherzustellen, dass Suricata effektiv den Netzwerkverkehr überwachen und Alarme für Anomalien auslösen kann.