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.json Logdatei 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 [email protected]_public_IP -N
  • Das -L Flag bezieht sich auf den lokalen SSH-Tunnel, der den Datenverkehr vom Port deines PCs zum Server weiterleitet.
  • private_IP:5601 ist 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_IP ist die öffentliche IP-Adresse des Elasticsearch-Servers, die zum Öffnen einer SSH-Verbindung verwendet wird.
  • Das -N Flag 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.

Kibana Dashboard Anmeldung

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 [email protected] -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.

Kibana Dashboard

Gib oben in das Suchfeld type:data suricata ein, um die Informationen von Suricata zu finden.

Suricata Suche in Kibana

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.

Filebeat Suricata Alerts

Klicke auf die Schaltfläche Ereignisse, um alle protokollierten Ereignisse anzuzeigen.

Filebeat Suricata Ereignisse

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.

Kibana Security Dashboard

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.

Das könnte dich auch interessieren …