So installierst und konfigurierst du Suricata IDS zusammen mit Elastic Stack auf Rocky Linux 8
Suricata ist ein Netzwerküberwachungsprogramm, das jedes Paket des Internetverkehrs, das durch deinen Server fließt, untersucht und verarbeitet. Es kann Log-Ereignisse erzeugen, Warnungen auslösen und den Datenverkehr bei verdächtigen Aktivitäten unterbrechen.
Du kannst Suricata entweder auf einem einzelnen Rechner installieren, um dessen Datenverkehr zu überwachen, oder es auf einem Gateway-Host einsetzen, um den gesamten ein- und ausgehenden Datenverkehr von anderen Servern, die mit ihm verbunden sind, zu überprüfen. Du kannst Suricata mit Elasticsearch, Kibana und Filebeat kombinieren, um ein Security Information and Event Management (SIEM) Tool zu erstellen.
In diesem Tutorial wirst du Suricata IDS zusammen mit ElasticStack auf einem Rocky Linux 8 Server installieren. Die verschiedenen Komponenten des Stacks sind:
- Elasticsearch zum Speichern, Indizieren, Korrelieren und Durchsuchen der Sicherheitsereignisse auf dem Server.
- Kibana, um die in Elasticsearch gespeicherten Logs anzuzeigen.
- Filebeat, um Suricatas
eve.jsonLogdatei zu analysieren und jedes Ereignis zur Verarbeitung an Elasticsearch zu senden. - Suricata scannt den Netzwerkverkehr auf verdächtige Ereignisse und verwirft die ungültigen Pakete.
Das Tutorial ist in zwei Teile gegliedert: Im ersten Teil geht es um die Installation und Konfiguration von Suricata, im zweiten Teil um die Installation und Konfiguration von Elastic Stack.
Für unser Tutorial werden wir Suricata und den Elastic Stack auf verschiedenen Servern 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.
- Auf den Servern sollte Rocky Linux 8 mit einem nicht-root sudo Benutzer laufen.
- Wenn du von überall auf die Kibana-Dashboards zugreifen willst, richte eine Domain (
kibana.example.com) ein, die auf den Server zeigt, auf dem Suricata installiert wird. - Installiere die wichtigsten Pakete auf beiden Servern.
$ sudo dnf install yum-utils nano curl
Firewall konfigurieren
TEIL 1
Schritt 1 – Suricata installieren
Um Suricata zu installieren, musst du das Paket-Repository der Open Information Security Foundation (OISF) zu deinem Server hinzufügen.
$ sudo dnf install 'dnf-command(copr)' $ sudo dnf copr enable @oisf/suricata-6.0
Mit dem ersten Befehl aktivierst du die Gemeinschaftsprojekte (copr) für den dnf Paketinstaller. Der zweite Befehl aktiviert das OISF-Repository und fügt es zu deinem System hinzu. suricata-6.0 aktiviert das Repository für die neueste stabile Version der Software. Drücke y und ENTER jedes Mal, wenn du dazu aufgefordert wirst.
Als nächstes fügst du das EPEL-Repository hinzu.
$ sudo dnf install epel-release
Installiere Suricata.
$ sudo dnf install suricata
Aktiviere 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 Datenverkehr nur protokolliert und nicht gestoppt wird. Wenn du neu in Suricata bist, solltest du den Modus unverändert lassen. Sobald du ihn konfiguriert und mehr gelernt hast, kannst du den IPS-Modus (Intrusion Prevention System) einschalten.
Community ID einschalten
Das Feld Community ID erleichtert die Korrelation von Daten zwischen Datensätzen, die von verschiedenen Überwachungstools erstellt wurden. Da wir Suricata mit Elasticsearch verwenden werden, kann es nützlich sein, die Community ID zu aktivieren.
Öffne die Datei /etc/suricata/suricata.yaml zum Bearbeiten.
$ sudo nano /etc/suricata/suricata.yaml
Finde die Zeile # Community Flow ID und setze den Wert der Variable community-id auf true.
. . .
# Community Flow ID
# Adds a 'community_id' field to EVE records. These are meant to give
# records a predictable flow ID that can be used to match records to
# output of other tools such as Zeek (Bro).
#
# Takes a 'seed' that needs to be same across sensors and tools
# to make the id less predictable.
# enable/disable the community id feature.
community-id: true
. . .
Jetzt tragen deine Ereignisse eine ID wie 1:S+3BA2UmrHK0Pk+u3XH78GAFTtQ=, die du verwenden kannst, um Datensätze zwischen verschiedenen Monitoring-Tools abzugleichen.
Netzwerkschnittstelle auswählen
Die Standardkonfigurationsdatei von Suricata untersucht den Datenverkehr auf dem eth0 Gerät/der Netzwerkschnittstelle. Wenn dein Server eine andere Netzwerkschnittstelle verwendet, musst du diese in der Konfiguration aktualisieren.
Überprüfe den Gerätenamen deiner Netzwerkschnittstelle mit dem folgenden Befehl.
$ ip -p -j route show default
Du wirst eine Ausgabe wie die folgende erhalten.
[ {
"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 wird eth0 als Netzwerkgerät angezeigt. Je nach System kann deine Ausgabe anders aussehen.
Da du nun den Gerätenamen kennst, öffne die Konfigurationsdatei.
$ sudo nano /etc/suricata/suricata.yaml
Suche die Zeile af-packet: um die Zeilennummer 580 herum. Setze darunter den Wert der Variable interface auf den Gerätenamen deines Systems.
# Linux high speed capture support
af-packet:
- interface: eth0
# Number of receive threads. "auto" uses the number of cores
#threads: auto
# Default clusterid. AF_PACKET will load balance packets based on flow.
cluster-id: 99
. . .
Wenn du weitere Schnittstellen hinzufügen möchtest, kannst du dies am Ende des Abschnitts af-packet um die Zeile 650 herum tun.
Um eine neue Schnittstelle hinzuzufügen, füge sie direkt über dem Abschnitt - interface: default ein, wie unten gezeigt.
# For eBPF and XDP setup including bypass, filter and load balancing, please
# see doc/userguide/capture-hardware/ebpf-xdp.rst for more info.
- interface: enp0s1
cluster-id: 98
...
- interface: default
#threads: auto
#use-mmap: no
#tpacket-v3: yes
In unserem Beispiel haben wir eine neue Schnittstelle enp0s1 und einen eindeutigen Wert für die Variable cluster-id hinzugefügt. Du musst bei jeder Schnittstelle, die du hinzufügst, eine eindeutige Cluster-ID angeben.
Live Rule Reload
Du musst Suricata jedes Mal neu starten, wenn du Regeln hinzufügst, entfernst oder bearbeitest. Wenn du Live Rule aktivierst, kann Suricata alle Regeländerungen ohne Neustart verarbeiten.
Um das Live-Reloading zu aktivieren, füge die folgenden Zeilen am Ende der Konfigurationsdatei hinzu.
. . . detect-engine: - rule-reload: true
Wenn das Live-Reloading aktiviert ist, kannst du den folgenden Befehl verwenden, um Regeln neu zu laden, ohne den Suricata-Prozess neu zu starten.
$ sudo kill -usr2 $(pidof suricata)
Das Flag $(pidof suricata) gibt die Prozess-ID des Suricata-Prozesses an. Der -usr2 Teil des kill Befehls sendet ein SIGUSR2 Signal an den Suricata Prozess. Das SIGUSR2 Signal wird mit Suricata konfiguriert, um die Regeln neu zu laden.
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Verzeichnisberechtigungen konfigurieren
Suricata hat während der Installation automatisch einen Systembenutzer und eine Gruppe namens suricata erstellt. Damit die Installation ordnungsgemäß funktioniert, musst du die richtigen Verzeichnisberechtigungen vergeben.
Führe 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
Lege die Gruppenberechtigungen für Lesen und Schreiben fest.
$ 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üge deinen aktuellen Benutzernamen zur Gruppe suricata hinzu, damit du direkt Operationen durchführen kannst, ohne sudo zu benötigen.
$ sudo usermod -a -G suricata $USER
Um die neue Gruppenzugehörigkeit zu übernehmen, logge dich vom Server aus und wieder ein oder gib Folgendes ein:
$ su - ${USER}
Du wirst aufgefordert, das Passwort deines Benutzers einzugeben, um fortzufahren.
Bestätige, dass dein Benutzer nun der Gruppe suricata angehört, indem du Folgendes eingibst:
$ id -nG username sudo suricata
Schritt 3 – Suricata-Regeln konfigurieren
Suricata verwendet standardmäßig nur einen begrenzten Satz von Regeln, um Netzwerkverkehr zu erkennen. Mit einem Tool namens suricata-update kannst du weitere Regelsätze von externen Anbietern hinzufügen. Führe den folgenden Befehl aus, um zusätzliche Regeln hinzuzufügen.
$ suricata-update
16/2/2022 -- 07:00:16 - <Info> -- Using data-directory /var/lib/suricata.
16/2/2022 -- 07:00:16 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
16/2/2022 -- 07:00:16 - <Info> -- Using /usr/share/suricata/rules for Suricata provided rules.
.....
16/2/2022 -- 07:00:16 - <Info> -- No sources configured, will use Emerging Threats Open
('https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz', None, True)
16/2/2022 -- 07:00:16 - <Info> -- Checking https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz.md5.
16/2/2022 -- 07:00:16 - <Info> -- Fetching https://rules.emergingthreats.net/open/suricata-6.0.4/emerging.rules.tar.gz.
100% - 3162050/3162050
.....
16/2/2022 -- 07:00:23 - <Info> -- Writing rules to /var/lib/suricata/rules/suricata.rules: total: 32004; enabled: 24611; added: 8; removed 1; modified: 1218
16/2/2022 -- 07:00:23 - <Info> -- Writing /var/lib/suricata/rules/classification.config
16/2/2022 -- 07:00:23 - <Info> -- Testing with suricata -T.
16/2/2022 -- 07:01:16 - <Info> -- Done.
Regelsatz-Anbieter hinzufügen
Du kannst die Regeln von Suricata erweitern, indem du weitere Anbieter hinzufügst. Suricata kann Regeln von einer Vielzahl von kostenlosen und kommerziellen Anbietern beziehen.
Mit dem folgenden Befehl kannst du die Standardanbieterliste auflisten.
$ suricata-update list-sources
Wenn du zum Beispiel den Regelsatz tgreen/hunting einbeziehen möchtest, kannst du ihn mit dem folgenden Befehl aktivieren.
$ suricata-update enable-source tgreen/hunting
Führe den Befehl suricata-update erneut aus, um die neuen Regeln herunterzuladen und zu aktualisieren.
Schritt 4 – Validierung der Suricata-Konfiguration
Suricata wird mit einem Validierungstool ausgeliefert, das die Konfigurationsdatei und die Regeln auf Fehler überprüft. Führe den folgenden Befehl aus, um das Validierungstool zu starten.
$ sudo suricata -T -c /etc/suricata/suricata.yaml -v 22/2/2022 -- 23:20:10 - <Info> - Running suricata under test mode 22/2/2022 -- 23:20:10 - <Notice> - This is Suricata version 6.0.4 RELEASE running in SYSTEM mode 22/2/2022 -- 23:20:10 - <Info> - CPUs/cores online: 2 22/2/2022 -- 23:20:10 - <Info> - dropped the caps for main thread 22/2/2022 -- 23:20:10 - <Info> - fast output device (regular) initialized: fast.log 22/2/2022 -- 23:20:10 - <Info> - eve-log output device (regular) initialized: eve.json 22/2/2022 -- 23:20:10 - <Info> - stats output device (regular) initialized: stats.log 22/2/2022 -- 23:20:21 - <Info> - 1 rule files processed. 24611 rules successfully loaded, 0 rules failed 22/2/2022 -- 23:20:21 - <Info> - Threshold config parsed: 0 rule(s) found 22/2/2022 -- 23:20:21 - <Info> - 24614 signatures processed. 1216 are IP-only rules, 4120 are inspecting packet payload, 19074 inspect application layer, 108 are decoder event only 22/2/2022 -- 23:21:02 - <Notice> - Configuration provided was successfully loaded. Exiting. 22/2/2022 -- 23:21:03 - <Info> - cleaning up signature grouping structure... complete
Das Flag -T weist Suricata an, im Testmodus zu laufen, das Flag -c konfiguriert den Speicherort der Konfigurationsdatei und das Flag -v gibt die ausführliche Ausgabe des Befehls aus. Je nach Systemkonfiguration und der Anzahl der hinzugefügten Regeln kann die Ausführung des Befehls einige Minuten dauern.
Schritt 5 – Suricata ausführen
Jetzt, wo Suricata konfiguriert und eingerichtet ist, ist es an der Zeit, die Anwendung zu starten.
$ sudo systemctl start suricata
Überprüfe den Status des Prozesses.
$ sudo systemctl status suricata
Wenn alles richtig funktioniert, solltest du die folgende Ausgabe sehen.
? 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.
Es kann ein paar Minuten dauern, bis der Prozess alle Regeln analysiert hat. Daher ist die obige Statusüberprüfung kein vollständiger Hinweis darauf, ob Suricata läuft und bereit ist. Du kannst die Logdatei mit dem folgenden Befehl überwachen.
$ sudo tail -f /var/log/suricata/suricata.log
Wenn du die folgende Zeile in der Logdatei siehst, bedeutet das, dass Suricata läuft und bereit ist, den Netzwerkverkehr zu überwachen.
16/02/2022 -- 07:18:39 - <Info> - All AFP capture threads are running.
Schritt 6 – Testen der Suricata-Regeln
Wir werden überprüfen, ob Suricata verdächtigen Datenverkehr erkennt. Der Suricata-Leitfaden empfiehlt, die ET-Open-Regel Nummer 2100498 mit dem folgenden Befehl zu testen.
$ curl http://testmynids.org/uid/index.html
Du wirst die folgende Antwort erhalten.
uid=0(root) gid=0(root) groups=0(root)
Der obige Befehl gibt vor, die Ausgabe desid Befehls zurückzugeben, der auf einem kompromittierten System ausgeführt werden kann. Um zu prüfen, ob Suricata den Datenverkehr erkannt hat, musst du die Protokolldatei mit der angegebenen Regelnummer überprüfen.
$ grep 2100498 /var/log/suricata/fast.log
Wenn deine Anfrage IPv6 verwendet hat, solltest du 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 deine Anfrage IPv4 verwendet hat, würdest du 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 Ereignisse auch in der Datei /var/log/suricata/eve.log im JSON-Format. Um diese Regeln lesen und interpretieren zu können, musst du jq installieren, was aber nicht Gegenstand dieses Lehrgangs ist.
Wir sind fertig mit dem ersten Teil des Tutorials, in dem wir Suricata installiert und getestet haben. Im nächsten Teil geht es darum, den ELK-Stack zu installieren und ihn so einzurichten, dass er Suricata und seine Logs visualisieren kann. Dieser zweite Teil des Tutorials sollte, wenn nicht anders angegeben, auf dem zweiten Server durchgeführt werden.
Schritt 7 – Installiere Elasticsearch und Kibana
Der erste Schritt bei der Installation von Elasticsearch ist das Hinzufügen des Elastic GPG-Schlüssels zu deinem Server.
$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
Erstelle ein Repository für das Elasticsearch-Paket, indem du die Datei /etc/yum/yum.repos.d/elasticsearch.repo erstellst und zur Bearbeitung öffnest.
$ sudo nano /etc/yum.repos.d/elasticsearch.repo
Füge den folgenden Code in die Datei ein.
[elasticsearch] name=Elasticsearch repository for 7.x packages 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
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere Elasticsearch und Kibana.
$ sudo dnf install --enablerepo=elasticsearch elasticsearch kibana
Du musst jedes Mal das Flag --enablerepo=elasticsearch verwenden, da wir das Repository standardmäßig deaktiviert haben. Dies verhindert ein versehentliches Upgrade dieser Pakete.
Finde die private IP-Adresse deines 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
Notiere dir die private IP deines Servers (in diesem Fall 10.133.0.3). Wir werden sie als your_private_IP bezeichnen. Die öffentliche IP-Adresse des Servers (164.90.205.77) wird im weiteren Verlauf des Lehrgangs als your_public_IP bezeichnet. Notiere dir auch den Netzwerknamen deines Servers: eth1.
Schritt 8 – Elasticsearch konfigurieren
Elasticsearch speichert seine Konfiguration in der Datei /etc/elasticsearch/elasticsearch.yml. Öffne die Datei zur Bearbeitung.
$ sudo nano /etc/elasticsearch/elasticsearch.yml
Elasticsearch akzeptiert standardmäßig nur lokale Verbindungen. Wir müssen dies ändern, damit Kibana über die private IP-Adresse darauf zugreifen kann.
Suche die Zeile #network.host: 192.168.0.1 und füge die folgende Zeile direkt darunter ein, wie unten gezeigt.
# By default Elasticsearch is only accessible on localhost. Set a different # address here to expose this node on the network: # #network.host: 192.168.0.1 network.bind_host: ["127.0.0.1", "your_private_IP"] # # By default Elasticsearch listens for HTTP traffic on the first free port it # finds starting at 9200. Set a specific HTTP port here:
Damit wird sichergestellt, dass Elastic weiterhin lokale Verbindungen akzeptiert, während Kibana über die private IP-Adresse erreichbar ist.
Im nächsten Schritt musst du einige Sicherheitsfunktionen aktivieren und sicherstellen, dass Elastic so konfiguriert ist, dass es auf einem einzelnen Knoten läuft. Dazu fügst du die folgenden Zeilen am Ende der Datei hinzu.
. . . discovery.type: single-node xpack.security.enabled: true
Wenn du mehrere Elastic-Suchknoten verwenden willst, kannst du die erste Zeile weglassen.
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Firewall konfigurieren
Füge die richtigen Firewall-Regeln für Elasticsearch hinzu, damit es über das private Netzwerk erreichbar 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
Achte darauf, dass du im ersten Befehl den Schnittstellennamen auswählst, den du aus Schritt 7 kennst. Mit den obigen Befehlen änderst du die Standardzone der Firewall auf intern und öffnest die Ports 9200 und 9300 für Elasticsearch und Port 5601 für Kibana.
Elasticsearch starten
Jetzt, wo du Elasticsearch konfiguriert hast, ist es an der Zeit, den Dienst zu starten.
$ sudo systemctl start elasticsearch
Elasticsearch-Passwörter erstellen
Nachdem du die Sicherheitseinstellungen von Elasticsearch aktiviert hast, musst du im nächsten Schritt einige Passwörter für den Standardbenutzer erstellen. Elasticsearch wird mit einem Dienstprogramm zur Erstellung von Passwörtern auf /usr/share/elasticsearch/bin/elasticsearch-setup-passwords ausgeliefert, das zufällige Passwörter erzeugen kann.
Erstelle die Passwörter.
$ cd /usr/share/elasticsearch/bin $ sudo ./elasticsearch-setup-passwords auto
Du wirst eine Ausgabe wie die folgende erhalten. Drücke y, um fortzufahren, wenn du dazu aufgefordert wirst.
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
Du kannst das Dienstprogramm nur einmal ausführen, also speichere alle Passwörter an einem sicheren Ort.
Schritt 9 – Kibana konfigurieren
Der erste Schritt bei der Konfiguration von Kibana besteht darin, die Sicherheitsfunktion xpack zu aktivieren, indem du geheime Schlüssel generierst. Kibana verwendet diese geheimen Schlüssel, um Daten in Elasticsearch zu speichern. Das Dienstprogramm zur Erzeugung von geheimen Schlüsseln kann über das Verzeichnis /usr/share/kibana/bin aufgerufen werden.
$ cd /usr/share/kibana/bin/ $ sudo ./kibana-encryption-keys generate -q --force
Das Flag -q unterdrückt die Befehlsanweisungen, und das Flag --force sorgt dafür, dass neue Geheimnisse erzeugt werden. Du erhältst eine Ausgabe wie die folgende.
xpack.encryptedSavedObjects.encryptionKey: 0f4e5e1cf8fad1874ffed0faac6be0da xpack.reporting.encryptionKey: d435c78a4e37521e539c0e905420c9f5 xpack.security.encryptionKey: 7ba0e2a02747bb90fb0f9a3c267b99ed
Kopiere die Ausgabe. Öffne die Konfigurationsdatei von Kibana unter /etc/kibana/kibana.yml, um sie zu bearbeiten.
$ sudo nano /etc/kibana/kibana.yml
Füge den Code aus dem vorherigen Befehl am Ende der Datei ein.
. . . # Specifies locale to be used for all localizable strings, dates and number formats. # Supported languages are the following: English - en , by default , Chinese - 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 erreichbar ist. Suche die Zeile #server.host: "localhost" in der Datei und füge die folgende Zeile wie gezeigt direkt darunter ein.
# Kibana is served by a back end server. This setting specifies the port to use. #server.port: 5601 # Specifies the address to which the Kibana server will bind. IP addresses and host names are both valid values. # The default is 'localhost', which usually means remote machines will not be able to connect. # To allow connections from remote users, set this parameter to a non-loopback address. #server.host: "localhost" server.host: "your_private_IP"
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Den Kibana-Zugang konfigurieren
Im nächsten Schritt musst du einen Benutzernamen und ein Passwort erstellen, die Kibana für die Authentifizierung verwenden kann. Du kannst dies tun, indem du die Konfigurationsdatei von Kibana direkt bearbeitest, aber das kann ein Sicherheitsproblem verursachen. Die sichere Methode ist die Verwendung der Anwendung kibana-keystore.
Führe die folgenden Befehle aus, um einen Benutzernamen festzulegen. Gib kibana_system als Benutzernamen ein.
$ cd /usr/share/kibana/bin $ sudo ./kibana-keystore add elasticsearch.username Enter value for elasticsearch.username: *************
Führe den Befehl erneut aus, um das Passwort festzulegen. Achte darauf, dass du das Passwort verwendest, das du in Schritt 8 für Kibana erstellt hast. Für unser Lernprogramm lautet das Passwort dTanR7Q2HtgDtATRvuJv.
$ sudo ./kibana-keystore add elasticsearch.password Enter value for elasticsearch.password: ********************
Kibana starten
Nachdem du nun den sicheren Zugang und das Netzwerk für Kibana konfiguriert hast, starte den Prozess.
$ sudo systemctl start kibana
Überprüfe den Status, um zu sehen, ob der Prozess läuft.
$ sudo systemctl status kibana
Schritt 10 – Filebeat installieren und konfigurieren
Es ist wichtig zu wissen, dass wir Filebeat auf dem Suricata-Server installieren werden. Wechsle also dorthin zurück und füge den Elastic GPG-Schlüssel hinzu, um loszulegen.
$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
Erstelle und öffne das Elastic-Repository.
$ sudo nano /etc/yum.repos.d/elasticsearch.repo
Füge den folgenden Code ein.
[elasticsearch] name=Elasticsearch repository for 7.x packages 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
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere Filebeat.
$ sudo dnf install --enablerepo=elasticsearch filebeat
Filebeat speichert seine Konfiguration in der Datei /etc/filebeat/filebeat.yml. Öffne sie zur Bearbeitung.
$ sudo nano /etc/filebeat/filebeat.yml
Als Erstes musst du es mit dem Dashboard von Kibana verbinden. Suche die Zeile #host: "localhost:5601" im Abschnitt Kibana und füge die folgende Zeile direkt darunter ein, wie gezeigt.
. . . # Starting with Beats version 6.0.0, the dashboards are loaded via the Kibana API. # This requires a Kibana endpoint configuration. setup.kibana: # Kibana Host # Scheme and port can be left out and will be set to the default (http and 5601) # In case you specify and additional path, the scheme is required: http://localhost:5601/path # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601 #host: "localhost:5601" host: "your_private_IP:5601" . . .
Als Nächstes suchst du den Abschnitt Elasticsearch Output in der Datei und bearbeitest die Werte von hosts, username und password wie unten gezeigt. Für den Benutzernamen wählst du den Wert elastic und für das Passwort den Wert, den du in Schritt 8 dieses Lernprogramms erstellt hast.
output.elasticsearch: # Array of hosts to connect to. hosts: ["your_private_IP:9200"] # Protocol - either `http` (default) or `https`. #protocol: "https" # Authentication credentials - either API key or username/password. #api_key: "id:api_key" username: "elastic" password: "bd1YJfhSa8RC8SMvTIwg" . . .
Wenn du fertig bist, speicherst du die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Als Nächstes aktivierst du das in Filebeat integrierte Suricata-Modul.
$ sudo filebeat modules enable suricata
Der letzte Schritt bei der Konfiguration von Filebeat besteht darin, die SIEM-Dashboards und -Pipelines mit dem Befehl filebeat setup in Elasticsearch zu laden.
$ sudo filebeat setup
Es kann ein paar Minuten dauern, bis der Befehl ausgeführt wird. Sobald er fertig ist, solltest du die folgende Ausgabe erhalten.
Overwriting ILM policy is disabled. Set `setup.ilm.overwrite: true` for enabling. Index setup finished. Loading dashboards (Kibana must be running and reachable) Loaded dashboards Setting up ML using setup --machine-learning is going to be removed in 8.0.0. Please use the ML app instead. See more: https://www.elastic.co/guide/en/machine-learning/current/index.html It is not possble to load ML jobs into an Elasticsearch 8.0.0 or newer using the Beat. Loaded machine learning job configurations Loaded Ingest pipelines
Starten Sie den Filebeat-Dienst.
$ sudo systemctl start filebeat
Überprüfe den Status des Dienstes.
$ sudo systemctl status filebeat
Schritt 11 – Zugriff auf das Kibana Dashboard
Da KIbana so konfiguriert ist, dass es nur über seine private IP-Adresse auf Elasticsearch zugreift, hast du zwei Möglichkeiten, darauf zuzugreifen. Die erste Methode ist, von deinem PC aus einen SSH-Tunnel zum Elasticsearch-Server zu benutzen. Dadurch wird Port 5601 von deinem PC an die private IP-Adresse des Servers weitergeleitet und du kannst von deinem PC aus über http://localhost:5601 auf Kibana zugreifen. Diese Methode bedeutet jedoch, dass du von keinem anderen Ort aus darauf zugreifen kannst.
Die Alternative ist, Nginx auf deinem Suricata-Server zu installieren und ihn als Reverse Proxy zu benutzen, um über die private IP-Adresse auf den Elasticsearch-Server zuzugreifen. Wir werden beide Möglichkeiten besprechen. Du kannst dich je nach deinen Anforderungen für einen der beiden Wege entscheiden.
Lokalen SSH-Tunnel verwenden
Wenn du Windows 10 oder Windows 11 verwendest, kannst du den SSH LocalTunnel über deine Windows Powershell ausführen. Unter Linux oder macOS kannst du das Terminal verwenden. Wahrscheinlich musst du den SSH-Zugang konfigurieren, falls du das nicht schon getan hast.
Führe den folgenden Befehl im Terminal deines Computers aus, um den SSH-Tunnel zu erstellen.
$ ssh -L 5601:your_private_IP:5601 navjot@your_public_IP -N
- Das
-LFlag bezieht sich auf den lokalen SSH-Tunnel, der den Datenverkehr vom Port deines PCs zum Server weiterleitet. private_IP:5601ist die IP-Adresse, an die dein Datenverkehr auf dem Server weitergeleitet wird. In diesem Fall ersetzt du sie durch die private IP-Adresse deines Elasticsearch-Servers.your_public_IPist die öffentliche IP-Adresse des Elasticsearch-Servers, die zum Öffnen einer SSH-Verbindung verwendet wird.- Das
-NFlag weist OpenSSH an, keinen Befehl auszuführen, sondern die Verbindung aufrecht zu erhalten, solange der Tunnel läuft.
Jetzt, da der Tunnel geöffnet ist, kannst du auf Kibana zugreifen, indem du die URL http://localhost:5601 im Browser deines PCs öffnest. Du erhältst den folgenden Bildschirm.
Du musst den Befehl so lange laufen lassen, wie du auf Kibana zugreifen willst. Drücke Strg + C in deinem Terminal, um den Tunnel zu schließen.
Nginx Reverse-Proxy verwenden
Diese Methode ist am besten geeignet, wenn du von überall auf der Welt auf das Dashboard zugreifen möchtest.
Firewall konfigurieren
Bevor du weitermachst, musst du die HTTP- und HTTPS-Ports in der Firewall öffnen.
$ sudo firewall-cmd --permanent --add-service=http $ sudo firewall-cmd --permanent --add-service=https
Lade die Firewall neu, um die Änderungen zu aktivieren.
$ sudo firewall-cmd --reload
SSL installieren und konfigurieren
Der erste Schritt ist die Installation des Let’s Encrypt SSL-Zertifikats. Da wir das EPEL-Repository bereits eingerichtet haben, installiere das Certbot-Tool.
$ sudo dnf install certbot
Erstelle 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 name@example.com -d kibana.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/kibana.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
Erstelle ein Challenge-Web-Root-Verzeichnis für die automatische Erneuerung von Let’s Encrypt.
$ sudo mkdir -p /var/lib/letsencrypt
Erstelle einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffne sie zur Bearbeitung.
$ sudo nano /etc/cron.daily/certbot-renew
Füge den folgenden Code ein.
#!/bin/sh certbot renew --cert-name kibana.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.
$ sudo chmod +x /etc/cron.daily/certbot-renew
Nginx installieren und konfigurieren
Rocket Linux 8.5 wird mit der neuesten stabilen Version von Nginx als Modul ausgeliefert. Installiere sie mit dem folgenden Befehl.
$ sudo dnf module install nginx:1.20
Du kannst die Version, die du installieren möchtest, 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ätige die Nginx-Installation.
$ nginx -v nginx version 1.20.1
Aktiviere den Nginx-Dienst.
$ sudo systemctl enable nginx
Erstelle und öffne die Nginx-Konfigurationsdatei für Kibana.
$ sudo nano /etc/nginx/conf.d/kibana.conf
Füge den folgenden Code in die Datei ein. Ersetze die IP-Adresse durch die private IP-Adresse deines 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;
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe die Konfiguration.
$ sudo nginx -t nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte den Nginx-Dienst.
$ sudo systemctl start nginx
Dein Kibana-Dashboard sollte über die URL https://kibana.example.com von jedem beliebigen Ort aus zugänglich sein.
Schritt 12 – Kibana Dashboards verwalten
Bevor du mit der Verwaltung der Dashboards fortfährst, musst du das Basis-URL-Feld in der Kibana-Konfiguration hinzufügen.
Öffne die Konfigurationsdatei von Kibana.
$ sudo nano /etc/kibana/kibana.yml
Suche die auskommentierte Zeile #server.publicBaseUrl: "" und ändere sie wie folgt, indem du die Raute davor entfernst.
server.publicBaseUrl: "https://kibana.example.com"
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den Kibana-Dienst neu.
$ sudo systemctl restart kibana
Warte ein paar Minuten und lade die URL https://kibana.example.com in deinem Browser. Melde dich mit dem Benutzernamen elastic und dem zuvor erstellten Passwort (bd1YJfhSa8RC8SMvTIwg) an und du erhältst den folgenden Bildschirm.
Gib oben in das Suchfeld type:data suricata ein, um die Informationen von Suricata zu finden.
Klicke auf das erste Ergebnis ([Filebeat Suricata] Alert Overview) und du erhältst einen Bildschirm ähnlich dem folgenden. Standardmäßig werden hier nur die Einträge der letzten 15 Minuten angezeigt, aber wir zeigen einen größeren Zeitraum an, um mehr Daten für den Lehrgang zu zeigen.
Klicke auf die Schaltfläche Ereignisse, um alle protokollierten Ereignisse anzuzeigen.
Wenn du auf den Ereignis- und Warnungsseiten nach unten scrollst, kannst du jedes Ereignis und jede Warnung anhand der Art des Protokolls, des Quell- und Zielports und der IP-Adresse der Quelle identifizieren. Du kannst dir auch die Länder ansehen, aus denen der Datenverkehr stammt.
Du kannst Kibana und Filebeat nutzen, um auf andere Arten von Dashboards zuzugreifen und diese zu erstellen. Eines der nützlichen eingebauten Dashboards, das du sofort nutzen kannst, ist das Sicherheits-Dashboard. Klicke auf das Netzwerk-Dashboard im linken Hamburger-Menü und du erhältst den folgenden Bildschirm.
Du kannst weitere Dashboards wie Nginx hinzufügen, indem du die eingebauten Filebeat-Module aktivierst und konfigurierst.
Fazit
Damit ist die Anleitung zur Installation und Konfiguration von Suricata IDS mit Elastic Stack auf einem Rocky Linux 8 basierten Server abgeschlossen. Außerdem hast du Nginx als Reverse Proxy konfiguriert, um von außen auf Kibana Dashboards zuzugreifen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.