Suricata Installation · 25 min read · Nov 26, 2025
So installieren und konfigurieren Sie Suricata IDS zusammen mit dem Elastic Stack auf Rocky Linux 8
Suricata ist ein Netzwerküberwachungstool, das jedes Paket des Internetverkehrs, das durch Ihren Server fließt, untersucht und verarbeitet. Es kann Protokollereignisse generieren, Alarme auslösen und den Verkehr stoppen, wenn verdächtige Aktivitäten erkannt werden.
Sie können Suricata entweder auf einer einzelnen Maschine installieren, um deren Verkehr zu überwachen, oder auf einem Gateway-Host bereitstellen, um den gesamten ein- und ausgehenden Verkehr von anderen damit verbundenen Servern zu scannen. Sie können Suricata mit Elasticsearch, Kibana und Filebeat kombinieren, um ein Security Information and Event Management (SIEM)-Tool zu erstellen.
In diesem Tutorial installieren Sie Suricata IDS zusammen mit dem Elastic Stack auf einem Rocky Linux 8-Server. Die verschiedenen Komponenten des Stacks sind:
- Elasticsearch, um die Sicherheitsereignisse vom Server zu speichern, zu indizieren, zu korrelieren und zu durchsuchen.
- Kibana, um die in Elasticsearch gespeicherten Protokolle anzuzeigen.
- Filebeat, um die
eve.json-Protokolldatei von Suricata zu analysieren und jedes Ereignis zur Verarbeitung an Elasticsearch zu senden. - Suricata, um den Netzwerkverkehr auf verdächtige Ereignisse zu scannen und ungültige Pakete zu verwerfen.
Das Tutorial ist in zwei Teile unterteilt. Der erste Teil befasst sich mit der Installation und Konfiguration von Suricata, und der zweite Teil befasst sich mit der Installation und Konfiguration des Elastic Stack.
Wir werden Suricata und den Elastic Stack auf verschiedenen Servern für unser Tutorial installieren.
Voraussetzungen
- Die Server, die den Elastic Stack und Suricata hosten, sollten mindestens 4 GB RAM und 2 CPU-Kerne haben.
- Die Server sollten in der Lage sein, über private IP-Adressen miteinander zu kommunizieren.
- Die Server sollten Rocky Linux 8 mit einem nicht-root sudo-Benutzer ausführen.
- Wenn Sie von überall auf die Kibana-Dashboards zugreifen möchten, richten Sie eine Domain (
kibana.example.com) ein, die auf den Server verweist, auf dem Suricata installiert wird. - Installieren Sie die erforderlichen Pakete auf beiden Servern.
$ sudo dnf install yum-utils nano curl
Firewall konfigurieren
TEIL 1
Schritt 1 - Suricata installieren
Um Suricata zu installieren, müssen Sie das Paket-Repository der Open Information Security Foundation (OISF) zu Ihrem Server hinzufügen.
$ sudo dnf install 'dnf-command(copr)'
$ sudo dnf copr enable @oisf/suricata-6.0
Der erste Befehl aktiviert die Community-Projekte (copr) für den dnf-Paketinstaller. Der zweite Befehl aktiviert und fügt das OISF-Repository zu Ihrem System hinzu. suricata-6.0 aktiviert das Repository für die neueste stabile Version der Software. Drücken Sie bei jeder Aufforderung y und ENTER.
Fügen Sie als Nächstes das EPEL-Repository hinzu.
$ sudo dnf install epel-release
Installieren Sie Suricata.
$ sudo dnf install suricata
Aktivieren Sie den Suricata-Dienst.
$ sudo systemctl enable suricata
Schritt 2 - Suricata konfigurieren
Suricata speichert seine Konfiguration in der Datei /etc/suricata/suricata.yaml. Der Standardmodus für Suricata ist der IDS (Intrusion Detection System)-Modus, in dem der Verkehr nur protokolliert und nicht gestoppt wird. Wenn Sie neu bei Suricata sind, sollten Sie den Modus unverändert lassen. Sobald Sie es konfiguriert haben und mehr gelernt haben, können Sie den IPS (Intrusion Prevention System)-Modus aktivieren.
Community-ID aktivieren
Das Community-ID-Feld erleichtert die Korrelation von Daten zwischen Datensätzen, die von verschiedenen Überwachungstools generiert werden. Da wir Suricata mit Elasticsearch verwenden werden, kann die Aktivierung der Community-ID nützlich sein.
Öffnen Sie die Datei /etc/suricata/suricata.yaml zur Bearbeitung.
$ sudo nano /etc/suricata/suricata.yaml
Suchen Sie die Zeile # Community Flow ID und setzen Sie den Wert der Variablen community-id auf true.
. . .
# Community Flow ID
# Fügt ein 'community_id'-Feld zu EVE-Datensätzen hinzu. Diese sollen dazu dienen,
# Datensätze mit einer vorhersehbaren Flow-ID zu versehen, die verwendet werden kann, um
# Datensätze mit Ausgaben anderer Tools wie Zeek (Bro) abzugleichen.
#
# Nimmt einen 'Seed', der über Sensoren und Tools hinweg gleich sein muss,
# um die ID weniger vorhersehbar zu machen.
# Aktivieren/Deaktivieren der Community-ID-Funktion.
community-id: true
. . .
Jetzt tragen Ihre Ereignisse eine ID wie 1:S+3BA2UmrHK0Pk+u3XH78GAFTtQ=, die Sie verwenden können, um Datensätze über verschiedene Überwachungstools hinweg abzugleichen.
Netzwerkinterface auswählen
Die Standardkonfigurationsdatei von Suricata untersucht den Verkehr auf dem eth0-Gerät/netzwerkinterface. Wenn Ihr Server ein anderes Netzwerkinterface verwendet, müssen Sie dies in der Konfiguration aktualisieren.
Überprüfen Sie den Gerätenamen Ihres Netzwerkinterfaces mit dem folgenden Befehl.
$ ip -p -j route show default
Sie erhalten eine Ausgabe wie die folgende.
[ {
"dst": "default",
"gateway": "164.90.192.1",
"dev": "eth0",
"protocol": "static",
"metric": 100,
"flags": [ ]
} ]
Die Variable dev bezieht sich auf das Netzwerkgerät. In unserer Ausgabe zeigt es eth0 als das Netzwerkgerät an. Ihre Ausgabe kann je nach System unterschiedlich sein.
Jetzt, da Sie den Gerätenamen kennen, öffnen Sie die Konfigurationsdatei.
$ sudo nano /etc/suricata/suricata.yaml
Suchen Sie die Zeile af-packet: um die Zeilennummer 580. Setzen Sie darunter den Wert der Variablen interface auf den Gerätenamen Ihres Systems.
# Linux High-Speed-Capture-Unterstützung
af-packet:
- interface: eth0
# Anzahl der Empfangsthreads. "auto" verwendet die Anzahl der Kerne
#threads: auto
# Standard-Cluster-ID. AF_PACKET wird Pakete basierend auf dem Fluss ausbalancieren.
cluster-id: 99
. . .
Wenn Sie zusätzliche Interfaces hinzufügen möchten, können Sie dies tun, indem Sie sie am Ende des af-packet-Abschnitts um die Zeile 650 hinzufügen.
Um ein neues Interface hinzuzufügen, fügen Sie es direkt über dem Abschnitt - interface: default wie unten gezeigt ein.
# Für eBPF- und XDP-Setup einschließlich Bypass, Filter und Lastenausgleich, bitte
# siehe doc/userguide/capture-hardware/ebpf-xdp.rst für weitere Informationen.
- interface: enp0s1
cluster-id: 98
...
- interface: default
#threads: auto
#use-mmap: no
#tpacket-v3: yes
Wir haben ein neues Interface enp0s1 und einen einzigartigen Wert für die Variable cluster-id in unserem Beispiel hinzugefügt. Sie müssen für jedes hinzugefügte Interface eine eindeutige Cluster-ID angeben.
Live-Regel-Neuladen
Sie müssen Suricata jedes Mal neu starten, wenn Sie seine Regeln hinzufügen, entfernen oder bearbeiten. Durch die Aktivierung des Live-Regel-Neuladens kann Suricata Regeländerungen ohne Neustart verarbeiten.
Um das Live-Neuladen zu aktivieren, fügen Sie die folgenden Zeilen am Ende der Konfigurationsdatei hinzu.
. . .
detect-engine:
- rule-reload: true
Mit aktiviertem Live-Neuladen können Sie den folgenden Befehl verwenden, um Regeln ohne Neustart des Suricata-Prozesses neu zu laden.
$ sudo kill -usr2 $(pidof suricata)
Das Flag $(pidof suricata) findet die Prozess-ID des Suricata-Prozesses. Der Teil -usr2 des kill-Befehls sendet ein SIGUSR2-Signal an den Suricata-Prozess. Das SIGUSR2-Signal ist mit Suricata konfiguriert, um die Regeln neu zu laden.
Sobald Sie fertig sind, speichern Sie die Datei, indem Sie Strg + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Verzeichnisberechtigungen konfigurieren
Suricata hat während des Installationsprozesses automatisch einen Systembenutzer und eine Gruppe namens suricata erstellt. Sie müssen die richtigen Verzeichnisberechtigungen festlegen, damit die Installation ordnungsgemäß funktioniert.
Führen Sie den folgenden Befehl aus, um suricata als Gruppe für die Verzeichnisse von Suricata festzulegen.
$ sudo chgrp -R suricata /etc/suricata
$ sudo chgrp -R suricata /var/lib/suricata/rules
$ sudo chgrp -R suricata /var/lib/suricata/update
$ sudo chgrp -R suricata /var/log/suricata
Setzen Sie die Gruppenberechtigungen für Lesen und Schreiben.
$ sudo chmod -R g+r /etc/suricata/
$ sudo chmod -R g+rw /var/lib/suricata/rules
$ sudo chmod -R g+rw /var/lib/suricata/update
$ sudo chmod -R g+rw /var/log/suricata
Fügen Sie Ihren aktuellen Benutzernamen zur suricata-Gruppe hinzu, damit Sie Operationen direkt ohne sudo durchführen können.
$ sudo usermod -a -G suricata $USER
Um die neue Gruppenmitgliedschaft anzuwenden, melden Sie sich vom Server ab und wieder an oder geben Sie Folgendes ein:
$ su - ${USER}
Sie werden aufgefordert, das Passwort Ihres Benutzers einzugeben, um fortzufahren.
Bestätigen Sie, dass Ihr Benutzer jetzt zur suricata-Gruppe hinzugefügt wurde, indem Sie eingeben:
$ id -nG
username sudo suricata
Schritt 3 - Suricata-Regeln konfigurieren
Suricata verwendet standardmäßig nur eine begrenzte Anzahl von Regeln zur Erkennung des Netzwerkverkehrs. Sie können weitere Regelsets von externen Anbietern mit einem Tool namens suricata-update hinzufügen. Führen Sie den folgenden Befehl aus, um zusätzliche Regeln einzuschließen.
$ suricata-update
16/2/2022 -- 07:00:16 - -- Verwende Datenverzeichnis /var/lib/suricata.
16/2/2022 -- 07:00:16 - -- Verwende Suricata-Konfiguration /etc/suricata/suricata.yaml
16/2/2022 -- 07:00:16 - -- Verwende /usr/share/suricata/rules für von Suricata bereitgestellte Regeln.
.....
16/2/2022 -- 07:00:16 - -- Keine konfigurierten Quellen, werde Emerging Threats Open verwenden
('https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz', None, True)
16/2/2022 -- 07:00:16 - -- Überprüfe https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz.md5.
16/2/2022 -- 07:00:16 - -- Hole https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz.
100% - 3162050/3162050
.....
16/2/2022 -- 07:00:23 - -- Schreibe Regeln nach /var/lib/suricata/rules/suricata.rules: insgesamt: 32004; aktiviert: 24611; hinzugefügt: 8; entfernt: 1; geändert: 1218
16/2/2022 -- 07:00:23 - -- Schreibe /var/lib/suricata/rules/classification.config
16/2/2022 -- 07:00:23 - -- Teste mit suricata -T.
16/2/2022 -- 07:01:16 - -- Fertig.
Regelanbieter hinzufügen
Sie können die Regeln von Suricata erweitern, indem Sie weitere Anbieter hinzufügen. Es kann Regeln von einer Vielzahl von kostenlosen und kommerziellen Anbietern abrufen.
Sie können die Standardanbieter-Liste mit dem folgenden Befehl auflisten.
$ suricata-update list-sources
Wenn Sie beispielsweise das Regelset tgreen/hunting einfügen möchten, können Sie es mit dem folgenden Befehl aktivieren.
$ suricata-update enable-source tgreen/hunting
Führen Sie den Befehl suricata-update erneut aus, um die neuen Regeln herunterzuladen und zu aktualisieren.
Schritt 4 - Suricata-Konfiguration validieren
Suricata wird mit einem Validierungstool geliefert, um die Konfigurationsdatei und die Regeln auf Fehler zu überprüfen. Führen Sie den folgenden Befehl aus, um das Validierungstool auszuführen.
$ sudo suricata -T -c /etc/suricata/suricata.yaml -v
22/2/2022 -- 23:20:10 - - Führe Suricata im Testmodus aus
22/2/2022 -- 23:20:10 - - Dies ist Suricata Version 6.0.4 RELEASE, die im SYSTEM-Modus läuft
22/2/2022 -- 23:20:10 - - CPUs/Kerne online: 2
22/2/2022 -- 23:20:10 - - hat die Berechtigungen für den Hauptthread entfernt
22/2/2022 -- 23:20:10 - - schnelles Ausgabegerät (regulär) initialisiert: fast.log
22/2/2022 -- 23:20:10 - - eve-log Ausgabegerät (regulär) initialisiert: eve.json
22/2/2022 -- 23:20:10 - - stats Ausgabegerät (regulär) initialisiert: stats.log
22/2/2022 -- 23:20:21 - - 1 Regeldatei verarbeitet. 24611 Regeln erfolgreich geladen, 0 Regeln fehlgeschlagen
22/2/2022 -- 23:20:21 - - Schwellenwertkonfiguration analysiert: 0 Regel(n) gefunden
22/2/2022 -- 23:20:21 - - 24614 Signaturen verarbeitet. 1216 sind IP-only Regeln, 4120 untersuchen Paketnutzlast, 19074 untersuchen Anwendungsschicht, 108 sind nur Decoder-Ereignisse
22/2/2022 -- 23:21:02 - - Die bereitgestellte Konfiguration wurde erfolgreich geladen. Beende.
22/2/2022 -- 23:21:03 - - Bereinige die Struktur der Signaturgruppen... abgeschlossen
Das -T-Flag weist Suricata an, im Testmodus zu laufen, das -c-Flag konfiguriert den Speicherort der Konfigurationsdatei, und das -v-Flag gibt die ausführliche Ausgabe des Befehls aus. Je nach Ihrer Systemkonfiguration und der Anzahl der hinzugefügten Regeln kann der Befehl einige Minuten dauern.
Schritt 5 - Suricata ausführen
Jetzt, da Suricata konfiguriert und eingerichtet ist, ist es an der Zeit, die Anwendung auszuführen.
$ sudo systemctl start suricata
Überprüfen Sie den Status des Prozesses.
$ sudo systemctl status suricata
Sie sollten die folgende Ausgabe sehen, wenn alles korrekt funktioniert.
? suricata.service - Suricata Intrusion Detection Service
Loaded: loaded (/usr/lib/systemd/system/suricata.service; enabled; vendor preset: disabled)
Active: active (running) since Wed 2022-02-16 07:14:22 UTC; 32min ago
Docs: man:suricata(1)
Process: 1494 ExecStartPre=/bin/rm -f /var/run/suricata.pid (code=exited, status=0/SUCCESS)
Main PID: 1496 (Suricata-Main)
Tasks: 8 (limit: 23479)
Memory: 367.5M
CGroup: /system.slice/suricata.service
??1496 /sbin/suricata -c /etc/suricata/suricata.yaml --pidfile /var/run/suricata.pid -i eth0 --user suricata
Feb 16 07:14:22 suricata systemd[1]: Starting Suricata Intrusion Detection Service...
Feb 16 07:14:22 suricata systemd[1]: Started Suricata Intrusion Detection Service.
Der Prozess kann einige Minuten dauern, um alle Regeln zu parsen. Daher ist die obige Statusüberprüfung kein vollständiger Hinweis darauf, ob Suricata aktiv und bereit ist. Sie können die Protokolldatei dafür mit dem folgenden Befehl überwachen.
$ sudo tail -f /var/log/suricata/suricata.log
Wenn Sie die folgende Zeile in der Protokolldatei sehen, bedeutet dies, dass Suricata läuft und bereit ist, den Netzwerkverkehr zu überwachen.
16/02/2022 -- 07:18:39 - - Alle AFP-Capture-Threads laufen.
Schritt 6 - Suricata-Regeln testen
Wir werden überprüfen, ob Suricata verdächtigen Verkehr erkennt. Der Suricata-Leitfaden empfiehlt, die ET Open-Regelnummer 2100498 mit dem folgenden Befehl zu testen.
$ curl http://testmynids.org/uid/index.html
Sie erhalten die folgende Antwort.
uid=0(root) gid=0(root) groups=0(root)
Der obige Befehl gibt vor, die Ausgabe des id-Befehls zurückzugeben, der auf einem kompromittierten System ausgeführt werden kann. Um zu testen, ob Suricata den Verkehr erkannt hat, müssen Sie die Protokolldatei mit der angegebenen Regelnummer überprüfen.
$ grep 2100498 /var/log/suricata/fast.log
Wenn Ihre Anfrage IPv6 verwendet hat, sollten Sie die folgende Ausgabe sehen.
02/22/2022-23:24:33.997371 [] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 2600:9000:2204:5c00:0018:30b3:e400:93a1:80 -> 2a03:b0c0:0002:00d0:0000:0000:0fc2:b001:41468
Wenn Ihre Anfrage IPv4 verwendet hat, würden Sie die folgende Ausgabe sehen.
02/22/2022-23:21:46.783476 [] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 204.246.178.81:80 -> 164.90.192.1:36364
Suricata protokolliert auch Ereignisse in der Datei /var/log/suricata/eve.log im JSON-Format. Um diese Regeln zu lesen und zu interpretieren, müssen Sie jq installieren, was außerhalb des Rahmens dieses Tutorials liegt.
Wir sind mit Teil eins des Tutorials fertig, in dem wir Suricata installiert und getestet haben. Der nächste Teil umfasst die Installation des ELK-Stacks und dessen Einrichtung zur Visualisierung von Suricata und seinen Protokollen. Dieser Teil des Tutorials sollte auf dem zweiten Server durchgeführt werden, sofern nicht anders angegeben.
Schritt 7 - Elasticsearch und Kibana installieren
Der erste Schritt bei der Installation von Elasticsearch besteht darin, den Elastic GPG-Schlüssel zu Ihrem Server hinzuzufügen.
$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
Erstellen Sie ein Repository für das Elasticsearch-Paket, indem Sie die Datei /etc/yum/yum.repos.d/elasticsearch.repo zur Bearbeitung erstellen und öffnen.
$ sudo nano /etc/yum.repos.d/elasticsearch.repo
Fügen Sie den folgenden Code ein.
[elasticsearch]
name=Elasticsearch-Repository für 7.x-Pakete
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=0
autorefresh=1
type=rpm-md
Speichern Sie die Datei, indem Sie Strg + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Installieren Sie Elasticsearch und Kibana.
$ sudo dnf install --enablerepo=elasticsearch elasticsearch kibana
Sie müssen das Flag --enablerepo=elasticsearch jedes Mal verwenden, da wir das Repository standardmäßig deaktiviert haben. Dies verhindert eine versehentliche Aktualisierung dieser Pakete.
Bestimmen Sie die private IP-Adresse Ihres Servers mit dem folgenden Befehl.
$ ip -brief address show
lo UNKNOWN 127.0.0.1/8 ::1/128
eth0 UP 164.90.205.77/20 10.18.0.7/16 2a03:b0c0:2:d0::fef:b001/64 fe80::340a:6eff:fe5c:76ed/64
eth1 UP 10.133.0.3/16 fe80::906f:b5ff:fec4:c7b8/64
Notieren Sie sich die private IP Ihres Servers (in diesem Fall 10.133.0.3). Wir werden sie im weiteren Verlauf des Tutorials als your_private_IP bezeichnen. Die öffentliche IP-Adresse des Servers (164.90.205.77) wird im verbleibenden Tutorial als your_public_IP bezeichnet. Notieren Sie sich auch den Netzwerknamen Ihres Servers, eth1.
Schritt 8 - Elasticsearch konfigurieren
Elasticsearch speichert seine Konfiguration in der Datei /etc/elasticsearch/elasticsearch.yml. Öffnen Sie die Datei zur Bearbeitung.
$ sudo nano /etc/elasticsearch/elasticsearch.yml
Elasticsearch akzeptiert standardmäßig nur lokale Verbindungen. Wir müssen es ändern, damit Kibana über die private IP-Adresse darauf zugreifen kann.
Suchen Sie die Zeile #network.host: 192.168.0.1 und fügen Sie die folgende Zeile direkt darunter hinzu, wie unten gezeigt.
# Standardmäßig ist Elasticsearch nur auf localhost zugänglich. Setzen Sie hier eine andere
# Adresse, um diesen Knoten im Netzwerk verfügbar zu machen:
#
#network.host: 192.168.0.1
network.bind_host: ["127.0.0.1", "your_private_IP"]
#
# Standardmäßig hört Elasticsearch auf HTTP-Verkehr am ersten freien Port, den es
# findet, beginnend bei 9200. Setzen Sie hier einen bestimmten HTTP-Port:
Dies stellt sicher, dass Elastic weiterhin lokale Verbindungen akzeptiert, während es über die private IP-Adresse für Kibana verfügbar ist.
Der nächste Schritt besteht darin, einige Sicherheitsfunktionen zu aktivieren und sicherzustellen, dass Elastic so konfiguriert ist, dass es auf einem einzelnen Knoten ausgeführt wird. Fügen Sie dazu die folgenden Zeilen am Ende der Datei hinzu.
. . .
discovery.type: single-node
xpack.security.enabled: true
Wenn Sie mehrere Elasticsearch-Knoten verwenden möchten, können Sie die erste Zeile weglassen.
Sobald Sie fertig sind, speichern Sie die Datei, indem Sie Strg + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Firewall konfigurieren
Fügen Sie die richtigen Firewall-Regeln für Elasticsearch hinzu, damit es über das private Netzwerk zugänglich ist.
$ sudo firewall-cmd --permanent --zone=internal --change-interface=eth1
$ sudo firewall-cmd --permanent --zone=internal --add-service=elasticsearch
$ sudo firewall-cmd --permanent --zone=internal --add-service=kibana
$ sudo firewall-cmd --reload
Stellen Sie sicher, dass Sie im ersten Befehl den Schnittstellennamen wie den verwenden, den Sie in Schritt 7 erhalten haben. Die obigen Befehle ändern die Standardzone der Firewall auf intern und öffnen die Ports 9200, 9300 für Elasticsearch und Port 5601 für Kibana.
Elasticsearch starten
Jetzt, da Sie Elasticsearch konfiguriert haben, ist es an der Zeit, den Dienst zu starten.
$ sudo systemctl start elasticsearch
Elasticsearch-Passwörter erstellen
Nachdem Sie die Sicherheitseinstellung von Elasticsearch aktiviert haben, besteht der nächste Schritt darin, einige Passwörter für den Standardbenutzer zu generieren. Elasticsearch wird mit einem Passworterstellungstool unter /usr/share/elasticsearch/bin/elasticsearch-setup-passwords geliefert, das zufällige Passwörter generieren kann.
Erstellen Sie die Passwörter.
$ cd /usr/share/elasticsearch/bin
$ sudo ./elasticsearch-setup-passwords auto
Sie erhalten eine Ausgabe wie die folgende. Drücken Sie y, um fortzufahren, wenn Sie dazu aufgefordert werden.
Initiating the setup of passwords for reserved users elastic,apm_system,kibana,kibana_system,logstash_system,beats_system,remote_monitoring_user.
The passwords will be randomly generated and printed to the console.
Please confirm that you would like to continue [y/N]y
Changed password for user apm_system
PASSWORD apm_system = EtwMg8maU67o5tvD5rse
Changed password for user kibana_system
PASSWORD kibana_system = dTanR7Q2HtgDtATRvuJv
Changed password for user kibana
PASSWORD kibana = dTanR7Q2HtgDtATRvuJv
Changed password for user logstash_system
PASSWORD logstash_system = XGSjxNktuNMWVfGYibox
Changed password for user beats_system
PASSWORD beats_system = JXTr7CeHkMue608qVTQa
Changed password for user remote_monitoring_user
PASSWORD remote_monitoring_user = Q6JTJNl3lPy0fhy6QuMP
Changed password for user elastic
PASSWORD elastic = bd1YJfhSa8RC8SMvTIwg
Sie können das Dienstprogramm nur einmal ausführen, also speichern Sie alle Passwörter an einem sicheren Ort.
Schritt 9 - Kibana konfigurieren
Der erste Schritt bei der Konfiguration von Kibana besteht darin, die xpack-Sicherheitsfunktion zu aktivieren, indem Sie geheime Schlüssel generieren. Kibana verwendet diese geheimen Schlüssel, um Daten in Elasticsearch zu speichern. Das Dienstprogramm zum Generieren geheimer Schlüssel kann aus dem Verzeichnis /usr/share/kibana/bin aufgerufen werden.
$ cd /usr/share/kibana/bin/
$ sudo ./kibana-encryption-keys generate -q --force
Das -q-Flag unterdrückt die Befehlsanweisungen, und das --force-Flag stellt sicher, dass frische Geheimnisse generiert werden. Sie erhalten eine Ausgabe wie die folgende.
xpack.encryptedSavedObjects.encryptionKey: 0f4e5e1cf8fad1874ffed0faac6be0da
xpack.reporting.encryptionKey: d435c78a4e37521e539c0e905420c9f5
xpack.security.encryptionKey: 7ba0e2a02747bb90fb0f9a3c267b99ed
Kopieren Sie die Ausgabe. Öffnen Sie die Konfigurationsdatei von Kibana unter /etc/kibana/kibana.yml zur Bearbeitung.
$ sudo nano /etc/kibana/kibana.yml
Fügen Sie den Code aus dem vorherigen Befehl am Ende der Datei ein.
. . .
# Gibt die Sprache an, die für alle lokalisierbaren Zeichenfolgen, Daten und Zahlenformate verwendet werden soll.
# Unterstützte Sprachen sind die folgenden: Englisch - en, standardmäßig, Chinesisch - zh-CN.
#i18n.locale: "en"
xpack.encryptedSavedObjects.encryptionKey: 0f4e5e1cf8fad1874ffed0faac6be0da
xpack.reporting.encryptionKey: d435c78a4e37521e539c0e905420c9f5
xpack.security.encryptionKey: 7ba0e2a02747bb90fb0f9a3c267b99ed
Kibana-Port konfigurieren
Kibana muss so konfiguriert werden, dass es über die private IP-Adresse des Servers zugänglich ist. Suchen Sie die Zeile #server.host: "localhost" in der Datei und fügen Sie die folgende Zeile direkt darunter hinzu, wie gezeigt.
# Kibana wird von einem Backend-Server bereitgestellt. Diese Einstellung gibt den zu verwendenden Port an.
#server.port: 5601
# Gibt die Adresse an, an die der Kibana-Server gebunden wird. IP-Adressen und Hostnamen sind beide gültige Werte.
# Der Standardwert ist 'localhost', was normalerweise bedeutet, dass entfernte Maschinen keine Verbindung herstellen können.
# Um Verbindungen von entfernten Benutzern zuzulassen, setzen Sie diesen Parameter auf eine nicht-loopback-Adresse.
#server.host: "localhost"
server.host: "your_private_IP"
Sobald Sie fertig sind, speichern Sie die Datei, indem Sie Strg + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Zugriff auf Kibana konfigurieren
Der nächste Schritt besteht darin, einen Benutzernamen und ein Passwort zu erstellen, die Kibana zur Authentifizierung verwenden kann. Sie können dies tun, indem Sie direkt die Konfigurationsdatei von Kibana bearbeiten, aber das kann ein Sicherheitsproblem verursachen. Die sichere Methode besteht darin, die Anwendung kibana-keystore zu verwenden.
Führen Sie die folgenden Befehle aus, um einen Benutzernamen festzulegen. Geben Sie kibana_system als Benutzernamen ein.
$ cd /usr/share/kibana/bin
$ sudo ./kibana-keystore add elasticsearch.username
Geben Sie den Wert für elasticsearch.username ein: ***********
Führen Sie den Befehl erneut aus, um das Passwort festzulegen. Stellen Sie sicher, dass Sie das Passwort verwenden, das Sie in Schritt 8 für Kibana erstellt haben. Für unser Tutorial ist das Passwort dTanR7Q2HtgDtATRvuJv.
$ sudo ./kibana-keystore add elasticsearch.password Geben Sie den Wert für elasticsearch.password ein:******************
Kibana starten
Jetzt, da Sie den sicheren Zugriff und das Networking für Kibana konfiguriert haben, starten Sie den Prozess.
$ sudo systemctl start kibana
Überprüfen Sie den Status, um zu sehen, ob es läuft.
$ sudo systemctl status kibana
Schritt 10 - Filebeat installieren und konfigurieren
Es ist wichtig zu beachten, dass wir Filebeat auf dem Suricata-Server installieren werden. Wechseln Sie also zurück zu ihm und fügen Sie den Elastic GPG-Schlüssel hinzu, um zu beginnen.
$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
Erstellen und öffnen Sie das Elastic-Repository.
$ sudo nano /etc/yum.repos.d/elasticsearch.repo
Fügen Sie den folgenden Code ein.
[elasticsearch]
name=Elasticsearch-Repository für 7.x-Pakete
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=0
autorefresh=1
type=rpm-md
Speichern Sie die Datei, indem Sie Strg + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Installieren Sie Filebeat.
$ sudo dnf install --enablerepo=elasticsearch filebeat
Filebeat speichert seine Konfiguration in der Datei /etc/filebeat/filebeat.yml. Öffnen Sie sie zur Bearbeitung.
$ sudo nano /etc/filebeat/filebeat.yml
Das erste, was Sie tun müssen, ist, es mit dem Kibana-Dashboard zu verbinden. Suchen Sie die Zeile #host: "localhost:5601" im Kibana-Abschnitt und fügen Sie die folgende Zeile direkt darunter hinzu, wie gezeigt.
. . .
# Ab Beats-Version 6.0.0 werden die Dashboards über die Kibana-API geladen.
# Dies erfordert eine Kibana-Endpunktkonfiguration.
setup.kibana:
# Kibana-Host
# Schema und Port können weggelassen werden und werden auf den Standardwert (http und 5601) gesetzt.
# Falls Sie einen zusätzlichen Pfad angeben, ist das Schema erforderlich: http://localhost:5601/path
# IPv6-Adressen sollten immer als: https://[2001:db8::1]:5601 definiert werden
#host: "localhost:5601"
host: "your_private_IP:5601"
. . .
Suchen Sie als Nächstes den Abschnitt Elasticsearch-Ausgabe der Datei und bearbeiten Sie die Werte von hosts, username und password wie unten gezeigt. Verwenden Sie für den Benutzernamen den Wert elastic und für das Passwort den Wert, der in Schritt 8 dieses Tutorials generiert wurde.
output.elasticsearch:
# Array von Hosts, zu denen eine Verbindung hergestellt werden soll.
hosts: ["your_private_IP:9200"]
# Protokoll - entweder `http` (Standard) oder `https`.
#protocol: "https"
# Authentifizierungsanmeldeinformationen - entweder API-Schlüssel oder Benutzername/Passwort.
#api_key: "id:api_key"
username: "elastic"
password: "bd1YJfhSa8RC8SMvTIwg"
. . .
Sobald Sie fertig sind, speichern Sie die Datei, indem Sie Strg + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Aktivieren Sie als Nächstes das integrierte Suricata-Modul von Filebeat.
$ sudo filebeat modules enable suricata
Der letzte Schritt bei der Konfiguration von Filebeat besteht darin, die SIEM-Dashboards und -Pipelines in Elasticsearch mit dem Befehl filebeat setup zu laden.
$ sudo filebeat setup
Es kann einige Minuten dauern, bis der Befehl abgeschlossen ist. Sobald er abgeschlossen ist, sollten Sie die folgende Ausgabe erhalten.
Das Überschreiben der ILM-Richtlinie ist deaktiviert. Setzen Sie `setup.ilm.overwrite: true`, um dies zu aktivieren.
Indexeinrichtung abgeschlossen.
Lade Dashboards (Kibana muss laufen und erreichbar sein)
Geladene Dashboards
Einrichten von ML mit setup --machine-learning wird in 8.0.0 entfernt. Bitte verwenden Sie stattdessen die ML-App.
Siehe mehr: https://www.elastic.co/guide/en/machine-learning/current/index.html
Es ist nicht möglich, ML-Jobs in eine Elasticsearch 8.0.0 oder neuere Version mit dem Beat zu laden.
Geladene Konfigurationen für maschinelles Lernen
Geladene Ingest-Pipelines
Starten Sie den Filebeat-Dienst.
$ sudo systemctl start filebeat
Überprüfen Sie den Status des Dienstes.
$ sudo systemctl status filebeat
Schritt 11 - Zugriff auf das Kibana-Dashboard
Da Kibana so konfiguriert ist, dass es Elasticsearch nur über seine private IP-Adresse zugreift, haben Sie zwei Optionen, um darauf zuzugreifen. Die erste Methode besteht darin, einen SSH-Tunnel zum Elasticsearch-Server von Ihrem PC aus zu verwenden. Dies leitet Port 5601 von Ihrem PC zur privaten IP-Adresse des Servers weiter, und Sie können auf Kibana von Ihrem PC unter http://localhost:5601 zugreifen. Aber diese Methode bedeutet, dass Sie von überall sonst nicht darauf zugreifen können.
Die Option besteht darin, Nginx auf Ihrem Suricata-Server zu installieren und es als Reverse-Proxy zu verwenden, um auf den Elasticsearch-Server über seine private IP-Adresse zuzugreifen. Wir werden beide Methoden besprechen. Sie können je nach Ihren Anforderungen entweder wählen.
Verwendung des SSH-Local-Tunnels
Wenn Sie Windows 10 oder Windows 11 verwenden, können Sie den SSH-LocalTunnel von Ihrem Windows-Powershell ausführen. Unter Linux oder macOS können Sie das Terminal verwenden. Sie müssen wahrscheinlich den SSH-Zugriff konfigurieren, wenn Sie dies noch nicht getan haben.
Führen Sie den folgenden Befehl im Terminal Ihres Computers aus, um den SSH-Tunnel zu erstellen.
$ ssh -L 5601:your_private_IP:5601 navjot@your_public_IP -N
- Das
-L-Flag bezieht sich auf den lokalen SSH-Tunnel, der den Verkehr vom Port Ihres PCs an den Server weiterleitet. - Die
private_IP:5601ist die IP-Adresse, an die Ihr Verkehr auf dem Server weitergeleitet wird. In diesem Fall ersetzen Sie sie durch die private IP-Adresse Ihres Elasticsearch-Servers. - Die
your_public_IPist die öffentliche IP-Adresse des Elasticsearch-Servers, die verwendet wird, um eine SSH-Verbindung herzustellen. - Das
-N-Flag weist OpenSSH an, keinen Befehl auszuführen, sondern die Verbindung so lange aufrechtzuerhalten, wie der Tunnel läuft.
Jetzt, da der Tunnel geöffnet ist, können Sie auf Kibana zugreifen, indem Sie die URL http://localhost:5601 im Browser Ihres PCs öffnen. Sie erhalten den folgenden Bildschirm.
Sie müssen den Befehl so lange laufen lassen, wie Sie auf Kibana zugreifen müssen. Drücken Sie Strg + C in Ihrem Terminal, um den Tunnel zu schließen.
Verwendung des Nginx-Reverse-Proxys
Diese Methode eignet sich am besten, wenn Sie von überall auf der Welt auf das Dashboard zugreifen möchten.
Firewall konfigurieren
Bevor Sie fortfahren, müssen Sie die HTTP- und HTTPS-Ports in der Firewall öffnen.
$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
Laden Sie die Firewall neu, um die Änderungen zu aktivieren.
$ sudo firewall-cmd --reload
SSL installieren und konfigurieren
Der erste Schritt besteht darin, das Let’s Encrypt-SSL-Zertifikat zu installieren. Da wir bereits das EPEL-Repository eingerichtet haben, installieren Sie das Certbot-Tool.
$ sudo dnf install certbot
Generieren Sie das SSL-Zertifikat für die Domain kibana.example.com.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d kibana.example.com
Der obige Befehl lädt ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/kibana.example.com auf Ihrem Server herunter.
Generieren Sie ein Diffie-Hellman-Gruppe-Zertifikat.
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
Erstellen Sie ein Challenge-Web-Root-Verzeichnis für die automatische Erneuerung von Let’s Encrypt.
$ sudo mkdir -p /var/lib/letsencrypt
Erstellen Sie einen Cron-Job zur Erneuerung des SSL. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstellen Sie dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffnen Sie sie zur Bearbeitung.
$ sudo nano /etc/cron.daily/certbot-renew
Fügen Sie den folgenden Code ein.
#!/bin/sh
certbot renew --cert-name kibana.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
Speichern Sie die Datei, indem Sie Strg + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Ändern Sie die Berechtigungen der Aufgaben-Datei, um sie ausführbar zu machen.
$ sudo chmod +x /etc/cron.daily/certbot-renew
Nginx installieren und konfigurieren
Rocky Linux 8.5 wird mit der neuesten stabilen Version von Nginx als Modul ausgeliefert. Installieren Sie es mit dem folgenden Befehl.
$ sudo dnf module install nginx:1.20
Sie können die Version, die Sie installieren möchten, mit dem folgenden Befehl überprüfen.
$ dnf module list nginx
Rocky Linux 8 - AppStream
Name Stream Profiles Summary
nginx 1.14 [d] common [d] nginx webserver
nginx 1.16 common [d] nginx webserver
nginx 1.18 common [d] nginx webserver
nginx 1.20 [e] common [d] [i] nginx webserver
Extra Packages for Enterprise Linux Modular 8 - x86_64
Name Stream Profiles Summary
nginx mainline common nginx webserver
nginx 1.20 [e] common [d] [i] nginx webserver
Bestätigen Sie die Nginx-Installation.
$ nginx -v
nginx version 1.20.1
Aktivieren Sie den Nginx-Dienst.
$ sudo systemctl enable nginx
Erstellen und öffnen Sie die Nginx-Konfigurationsdatei für Kibana.
$ sudo nano /etc/nginx/conf.d/kibana.conf
Fügen Sie den folgenden Code ein. Ersetzen Sie die IP-Adresse durch die private IP-Adresse Ihres Elasticsearch-Servers.
server {
listen 80; listen [::]:80;
server_name kibana.example.com;
return 301 https://$host$request_uri;
}
server {
server_name kibana.example.com;
charset utf-8;
listen 443 ssl http2;
listen [::]:443 ssl http2;
access_log /var/log/nginx/kibana.access.log;
error_log /var/log/nginx/kibana.error.log;
ssl_certificate /etc/letsencrypt/live/kibana.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/kibana.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/kibana.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
resolver 8.8.8.8;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
location / {
proxy_pass http://your_private_IP:5601;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
Speichern Sie die Datei, indem Sie Strg + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Öffnen Sie die Datei /etc/nginx/nginx.conf zur Bearbeitung.
$ sudo nano /etc/nginx/nginx.conf
Fügen Sie die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; hinzu.
server_names_hash_bucket_size 64;
Speichern Sie die Datei, indem Sie Strg + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Überprüfen Sie die Konfiguration.
$ sudo nginx -t
nginx: die Konfigurationsdatei /etc/nginx/nginx.conf-Syntax ist ok
nginx: Konfigurationsdatei /etc/nginx/nginx.conf-Test war erfolgreich
Starten Sie den Nginx-Dienst.
$ sudo systemctl start nginx
Ihr Kibana-Dashboard sollte über die URL https://kibana.example.com von überall aus zugänglich sein.
Schritt 12 - Verwalten von Kibana-Dashboards
Bevor Sie mit der Verwaltung der Dashboards fortfahren, müssen Sie das Basis-URL-Feld in der Konfiguration von Kibana hinzufügen.
Öffnen Sie die Konfigurationsdatei von Kibana.
$ sudo nano /etc/kibana/kibana.yml
Suchen Sie die kommentierte Zeile #server.publicBaseUrl: "" und ändern Sie sie wie folgt, indem Sie das Hashzeichen davor entfernen.
server.publicBaseUrl: "https://kibana.example.com"
Speichern Sie die Datei, indem Sie Strg + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.
Starten Sie den Kibana-Dienst neu.
$ sudo systemctl restart kibana
Warten Sie einige Minuten und laden Sie die URL https://kibana.example.com in Ihrem Browser. Melden Sie sich mit dem Benutzernamen elastic und dem Passwort an, das Sie zuvor generiert haben (bd1YJfhSa8RC8SMvTIwg), und Sie erhalten den folgenden Bildschirm.
Geben Sie type:data suricata in das Suchfeld oben ein, um die Informationen von Suricata zu finden.
Klicken Sie auf das erste Ergebnis ([Filebeat Suricata] Alert Overview), und Sie erhalten einen Bildschirm, der dem folgenden ähnelt. Standardmäßig zeigt es die Einträge nur für die letzten 15 Minuten an, aber wir zeigen es über einen größeren Zeitraum an, um mehr Daten für das Tutorial anzuzeigen.
Klicken Sie auf die Schaltfläche Ereignisse, um alle protokollierten Ereignisse anzuzeigen.
Wenn Sie auf den Ereignis- und Alarmseiten nach unten scrollen, können Sie jedes Ereignis und jeden Alarm anhand des Protokolltyps, der Quell- und Zielports sowie der IP-Adresse der Quelle identifizieren. Sie können auch die Länder sehen, aus denen der Verkehr stammt.
Sie können Kibana und Filebeat verwenden, um auf andere Arten von Dashboards zuzugreifen und diese zu generieren. Eines der nützlichen integrierten Dashboards, das Sie sofort verwenden können, ist das Sicherheitsdashboard. Klicken Sie im linken Hamburger-Menü auf das Netzwerk-Dashboard, und Sie erhalten den folgenden Bildschirm.
Sie können weitere Dashboards wie Nginx hinzufügen, indem Sie integrierte Filebeat-Module aktivieren und konfigurieren.
Fazit
Damit endet das Tutorial zur Installation und Konfiguration von Suricata IDS mit dem Elastic Stack auf einem Rocky Linux 8-basierten Server. Sie haben auch Nginx als Reverse-Proxy konfiguriert, um extern auf die Kibana-Dashboards zuzugreifen. Wenn Sie Fragen haben, posten Sie diese in den Kommentaren unten.
Erhalte neue Beiträge in deinem Posteingang.
Kein Spam. Jederzeit abmelden.