So installierst und konfigurierst du Suricata IDS zusammen mit Elastic Stack auf Rocky Linux 9

Suricata ist ein Netzwerküberwachungsprogramm, das jedes Paket des Internetverkehrs, das durch deinen Server fließt, untersucht und verarbeitet. Es kann Ereignisse protokollieren, Warnungen auslösen und den Datenverkehr unterbrechen, wenn es verdächtige Aktivitäten entdeckt.

Du kannst Suricata 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 Lernprogramm wirst du Suricata IDS und ElasticStack auf einem Rocky Linux 9 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 unterteilt: Der erste Teil befasst sich mit der Installation und Konfiguration von Suricata, der zweite Teil mit der 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 zu kommunizieren.
• Auf den Servern sollte Rocky Linux 9 mit einem nicht-root sudo Benutzer laufen.
• Die Server sollten auf dem neuesten Stand sein.

  $ sudo dnf update
  

• 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 wget policycoreutils-python-utils -y
  

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-7.0

Mit dem ersten Befehl aktivierst du die Gemeinschaftsprojekte (copr) für den dnf Paketinstaller. Mit dem zweiten Befehl fügst du das OISF-Repository zu deinem System hinzu. suricata-7.0 Aktiviert das Repository, um auf die neueste stabile Version der Software zuzugreifen. 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 -y epel-release dnf-plugins-core

Installiere Suricata.

$ sudo dnf install -y 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 (Intrusion Prevention System) Modus einschalten.

Community ID einschalten

Das Feld Community ID erleichtert die Korrelation von Daten zwischen Datensätzen, die von verschiedenen Monitoring-Tools erstellt wurden. Da wir Suricata mit Elasticsearch verwenden werden, kann die Aktivierung der Community ID hilfreich sein.

Ö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
. . .

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

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": "172.31.1.1",
        "dev": "eth0",
        "protocol": "dhcp",
        "prefsrc": "65.108.61.177",
        "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. Bei jeder Schnittstelle, die du hinzufügst, musst du eine eindeutige Cluster-ID angeben.

Suche die Zeile pcap: und setze den Wert der Variable interface auf den Gerätenamen deines Systems.

# Cross platform libpcap capture support
pcap:
  - interface: eth0
    # On Linux, pcap will try to use mmap'ed capture and will use "buffer-size"
    # as total memory used by the ring. So set this to something bigger
    # than 1% of your bandwidth.

Um eine neue Schnittstelle hinzuzufügen, fügst du sie wie unten gezeigt direkt über dem Abschnitt - interface: default ein.

- interface: enp0s1
# Put default values here
  - interface: default
    #checksum-checks: auto

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Live Rule Reload

Du musst Suricata jedes Mal neu starten, wenn du Regeln hinzufügst, entfernst oder bearbeitest. Du musst nichts tun, um dies zu aktivieren, denn es ist standardmäßig aktiviert.

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 $(pidof suricata) Flag 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.

Verzeichnisberechtigungen konfigurieren

Suricata hat während der Installation automatisch einen Systembenutzer und eine Gruppe mit dem Namen 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
$ 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
$ sudo chmod -R g+rw /var/log/suricata

Aktuellen Benutzer zur Suricata-Gruppe hinzufügen

Suricata hat während der Installation automatisch einen Systembenutzer und eine Gruppe namens suricata erstellt. Füge deinen aktuellen Benutzernamen zur Suricata-Gruppe 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, melde dich vom Server ab und wieder an 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 wheel 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
14/4/2024 -- 01:32:58 - <Info> -- Using data-directory /var/lib/suricata.
14/4/2024 -- 01:32:58 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
14/4/2024 -- 01:32:58 - <Info> -- Using /usr/share/suricata/rules for Suricata provided rules.
14/4/2024 -- 01:32:58 - <Info> -- Found Suricata version 7.0.4 at /usr/sbin/suricata.
.....
14/4/2024 -- 01:32:58 - <Info> -- No sources configured, will use Emerging Threats Open
14/4/2024 -- 01:32:58 - <Info> -- Fetching https://rules.emergingthreats.net/open/suricata-7.0.4/emerging.rules.tar.gz.
 100% - 4243799/4243799               
14/4/2024 -- 01:33:00 - <Info> -- Done.
14/4/2024 -- 01:33:00 - <Info> -- Loading distribution rule file /usr/share/suricata/rules/app-layer-events.rules
.....
14/4/2024 -- 01:33:04 - <Info> -- Writing rules to /var/lib/suricata/rules/suricata.rules: total: 48646; enabled: 37144; added: 48646; removed 0; modified: 0
14/4/2024 -- 01:33:04 - <Info> -- Writing /var/lib/suricata/rules/classification.config
14/4/2024 -- 01:33:04 - <Info> -- Testing with suricata -T.
14/4/2024 -- 01:33:41 - <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
14/4/2024 -- 01:37:07 - <Info> -- Using data-directory /var/lib/suricata.
14/4/2024 -- 01:37:07 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
14/4/2024 -- 01:37:07 - <Info> -- Using /usr/share/suricata/rules for Suricata provided rules.
14/4/2024 -- 01:37:07 - <Info> -- Found Suricata version 7.0.4 at /usr/sbin/suricata.
14/4/2024 -- 01:37:07 - <Warning> -- Source index does not exist, will use bundled one.
14/4/2024 -- 01:37:07 - <Warning> -- Please run suricata-update update-sources.
14/4/2024 -- 01:37:07 - <Info> -- Creating directory /var/lib/suricata/update/sources
14/4/2024 -- 01:37:07 - <Info> -- Enabling default source et/open
14/4/2024 -- 01:37:07 - <Info> -- Source tgreen/hunting enabled

Führe den Befehl suricata-update erneut aus, um die neuen Regeln herunterzuladen und zu aktualisieren. Suricata kann standardmäßig alle Regeländerungen verarbeiten, ohne neu zu starten.

Schritt 4 – Validierung der Suricata-Konfiguration

Suricata wird mit einem Validierungstool geliefert, das die Konfigurationsdatei und die Regeln auf Fehler überprüft. Führe den folgenden Befehl aus, um das Validierungstool zu starten.

$ suricata -T -c /etc/suricata/suricata.yaml -v
Notice: suricata: This is Suricata version 7.0.4 RELEASE running in SYSTEM mode
Info: cpu: CPUs/cores online: 2
Info: suricata: Running suricata under test mode
Info: suricata: Setting engine mode to IDS mode by default
Info: exception-policy: master exception-policy set to: auto
Info: logopenfile: fast output device (regular) initialized: fast.log
Info: logopenfile: eve-log output device (regular) initialized: eve.json
Info: logopenfile: stats output device (regular) initialized: stats.log
Info: detect: 1 rule files processed. 37144 rules successfully loaded, 0 rules failed, 0
Info: threshold-config: Threshold config parsed: 0 rule(s) found
Info: detect: 37147 signatures processed. 1194 are IP-only rules, 4892 are inspecting packet payload, 30849 inspect application layer, 108 are decoder event only
Notice: suricata: Configuration provided was successfully loaded. Exiting.

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; preset: disabled)
     Active: active (running) since Sun 2024-04-14 01:45:43 UTC; 4s ago
       Docs: man:suricata(1)
    Process: 6081 ExecStartPre=/bin/rm -f /var/run/suricata.pid (code=exited, status=0/SUCCESS)
   Main PID: 6082 (Suricata-Main)
      Tasks: 1 (limit: 22569)
     Memory: 111.8M
        CPU: 4.318s
     CGroup: /system.slice/suricata.service
             ??6082 /sbin/suricata -c /etc/suricata/suricata.yaml --pidfile /var/run/suricata.pid -i eth0 --user suricata

Apr 14 01:45:43 suricata systemd[1]: Starting Suricata Intrusion Detection Service...
Apr 14 01:45:43 suricata systemd[1]: Started Suricata Intrusion Detection Service.
Apr 14 01:45:43 suricata suricata[6082]: i: suricata: This is Suricata version 7.0.4 RELEASE running in SYSTEM mode

Möglicherweise siehst du die folgenden Fehler im Dienststatus.

Apr 15 02:20:13 suricata suricata[5554]: E: logopenfile: Error opening file: "/var/log/suricata//fast.log": Permission denied
Apr 15 02:20:13 suricata suricata[5554]: W: runmodes: output module "fast": setup failed
Apr 15 02:20:13 suricata suricata[5554]: E: logopenfile: Error opening file: "/var/log/suricata//eve.json": Permission denied
Apr 15 02:20:13 suricata suricata[5554]: W: runmodes: output module "eve-log": setup failed
Apr 15 02:20:13 suricata suricata[5554]: E: logopenfile: Error opening file: "/var/log/suricata//stats.log": Permission denied
Apr 15 02:20:13 suricata suricata[5554]: W: runmodes: output module "stats": setup failed

Dann musst du die Berechtigungen erneut festlegen.

$ sudo chown -R suricata:suricata /var/log/suricata

Starte den Suricata-Dienst neu.

$ sudo systemctl restart suricata

Der Prozess kann einige Minuten dauern, bis alle Regeln analysiert sind. Daher ist die obige Statusprüfung kein vollständiger Hinweis darauf, ob Suricata betriebsbereit ist. Du kannst die Logdatei mit dem folgenden Befehl überwachen.

$ sudo tail -f /var/log/suricata/suricata.log

Wenn du die folgenden Zeilen siehst, bedeutet das, dass Suricata läuft und bereit ist, den Netzwerkverkehr zu überwachen.

[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: exception-policy: master exception-policy set to: auto
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: ioctl: eth0: MTU 1500
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: privs: dropped the caps for main thread
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: conf: Running in live mode, activating unix socket
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: logopenfile: fast output device (regular) initialized: fast.log
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: logopenfile: eve-log output device (regular) initialized: eve.json
[5577 - Suricata-Main] 2024-04-15 02:22:52 Info: logopenfile: stats output device (regular) initialized: stats.log
[5577 - Suricata-Main] 2024-04-15 02:23:03 Info: detect: 1 rule files processed. 37144 rules successfully loaded, 0 rules failed, 0
[5577 - Suricata-Main] 2024-04-15 02:23:03 Info: threshold-config: Threshold config parsed: 0 rule(s) found
[5577 - Suricata-Main] 2024-04-15 02:23:04 Info: detect: 37147 signatures processed. 1194 are IP-only rules, 4892 are inspecting packet payload, 30849 inspect application layer, 108 are decoder event only
[5577 - Suricata-Main] 2024-04-15 02:23:32 Info: runmodes: eth0: creating 2 threads
[5577 - Suricata-Main] 2024-04-15 02:23:32 Info: unix-manager: unix socket '/var/run/suricata/suricata-command.socket'
[5577 - Suricata-Main] 2024-04-15 02:23:32 Notice: threads: Threads created -> W: 2 FM: 1 FR: 1   Engine started.

Drücke Strg + C, um die Ausgabe zu beenden.

Schritt 6 – Suricata-Regeln testen

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 des id 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.

TEIL 2

Wir sind fertig mit Teil eins 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. Der zweite Teil des Tutorials sollte auf dem zweiten Server durchgeführt werden, sofern nicht anders angegeben.

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 8.x packages
baseurl=https://artifacts.elastic.co/packages/8.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 gelassen haben. Dies verhindert ein versehentliches Upgrade dieser Pakete.

Bei der Installation von Elasticsearch erhältst du die folgende Ausgabe.

--------------------------- Security autoconfiguration information ------------------------------

Authentication and authorization are enabled.
TLS for the transport and HTTP layers is enabled and configured.

The generated password for the elastic built-in superuser is : ilc+Gju=gZTxQHI4cSkF

If this node should join an existing cluster, you can reconfigure this with
'/usr/share/elasticsearch/bin/elasticsearch-reconfigure-node --enrollment-token <token-here>'
after creating an enrollment token on your existing cluster.

You can complete the following actions at any time:

Reset the password of the elastic built-in superuser with 
'/usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic'.

Generate an enrollment token for Kibana instances with 
 '/usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana'.

Generate an enrollment token for Elasticsearch nodes with 
'/usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s node'.

-------------------------------------------------------------------------------------------------

Finde die private IP-Adresse deines Servers mit folgendem Befehl heraus.

$ ip -brief address show
lo               UNKNOWN        127.0.0.1/8 ::1/128 
eth0             UP             37.27.84.123/32 2a01:4f9:c012:db02::1/64 fe80::9400:3ff:fe34:d589/64 
eth1             UP             10.0.0.2/32 fe80::8400:ff:fe84:5baf/64

Notiere dir die private IP deines Servers (in diesem Fall 10.0.0.2). Wir werden sie als your_private_IP bezeichnen. Die öffentliche IP-Adresse des Servers (37.27.84.123) 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

Wenn du mehrere Elastic-Suchknoten verwenden willst, kannst du sie weglassen.

Kommentiere außerdem die folgende Zeile aus, indem du ihr eine Raute (#) voranstellst.

#cluster.initial_master_nodes: ["elastic"]

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

JVM Heap-Größe konfigurieren

Bevor wir Elasticsearch starten, müssen wir den von Elasticsearch verwendeten Speicher konfigurieren. Erstelle und öffne die Datei /etc/elasticsearch/jvm.options.d/jvm-heap.options zum Bearbeiten.

$ sudo nano /etc/elasticsearch/jvm.options.d/jvm-heap.options

Füge die folgenden Zeilen in die Datei ein.

-Xms3g
-Xmx3g

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Hier geben wir Elasticsearch 3 GB Speicherplatz. Wähle den Wert entsprechend der Größe deines Servers.

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 --permanent --add-port=5601/tcp
$ 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.

Lade den System Daemon neu.

$ sudo systemctl daemon-reload

Aktiviere und starte den Elasticsearch-Server.

$ sudo systemctl enable elasticsearch --now

Überprüfe den Status des Dienstes.

$ sudo systemctl status elasticsearch
? elasticsearch.service - Elasticsearch
     Loaded: loaded (/usr/lib/systemd/system/elasticsearch.service; enabled; preset: disabled)
     Active: active (running) since Sun 2024-04-14 03:51:12 UTC; 1min 20s ago
       Docs: https://www.elastic.co
   Main PID: 5987 (java)
      Tasks: 74 (limit: 22569)
     Memory: 3.4G
        CPU: 50.532s
     CGroup: /system.slice/elasticsearch.service

Elasticsearch-Passwörter erstellen

Nachdem du die Sicherheitseinstellungen von Elasticsearch aktiviert hast, musst du im nächsten Schritt das Passwort für den Superuser von Elasticsearch erstellen. Das Standardpasswort wurde bei der Installation angegeben und kann verwendet werden, aber es wird empfohlen, es zu ändern.

Führe den folgenden Befehl aus, um das Elasticsearch-Passwort zurückzusetzen. Wähle ein sicheres Passwort.

$ sudo /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic -i
This tool will reset the password of the [elastic] user.
You will be prompted to enter the password.
Please confirm that you would like to continue [y/N]y


Enter password for [elastic]: <ENTER-PASSWORD>
Re-enter password for [elastic]: <CONFIRM-PASSWORD>
Password for the [elastic] user successfully reset.

Testen wir nun, ob Elasticsearch auf Abfragen antwortet.

$ sudo curl --cacert /etc/elasticsearch/certs/http_ca.crt -u elastic https://localhost:9200
Enter host password for user 'elastic':
{
  "name" : "elastic",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "VSP7LEZURF6SR8I1BPF9RQ",
  "version" : {
    "number" : "8.13.2",
    "build_flavor" : "default",
    "build_type" : "rpm",
    "build_hash" : "16cc90cd2d08a3147ce02b07e50894bc060a4cbf",
    "build_date" : "2024-04-05T14:45:26.420424304Z",
    "build_snapshot" : false,
    "lucene_version" : "9.10.0",
    "minimum_wire_compatibility_version" : "7.17.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "You Know, for Search"
}

Dies bestätigt, dass Elasticsearch voll funktionsfähig ist und reibungslos läuft.

Schritt 9 – Kibana konfigurieren

Der erste Schritt bei der Konfiguration von Kibana besteht darin, das Elasticsearch-Zertifikat in das Kibana-Verzeichnis zu kopieren.

$ sudo cp /etc/elasticsearch/certs/http_ca.crt /etc/kibana/

Als nächstes aktivierst du die Sicherheitsfunktion xpack, indem du geheime Schlüssel generierst. Kibana verwendet diese geheimen Schlüssel, um Daten in Elasticsearch zu speichern. Das Dienstprogramm zur Erzeugung geheimer Schlüssel ist im Verzeichnis /usr/share/kibana/bin zu finden.

$ sudo /usr/share/kibana/bin/kibana-encryption-keys generate -q

Das Flag -q unterdrückt die Befehlsanweisungen. Du erhältst dann eine Ausgabe wie die folgende.

xpack.encryptedSavedObjects.encryptionKey: fdce3576894a0a7b12a639a40f643acd
xpack.reporting.encryptionKey: 92f426be0f487b7d8dd191b86443f2a6
xpack.security.encryptionKey: 34bf00781dbe85d1dcd99dc94ef1c9b7

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.

. . .

# Maximum number of documents loaded by each shard to generate autocomplete suggestions.
# This value must be a whole number greater than zero. Defaults to 100_000
#unifiedSearch.autocomplete.valueSuggestions.terminateAfter: 100000

xpack.encryptedSavedObjects.encryptionKey: fdce3576894a0a7b12a639a40f643acd
xpack.reporting.encryptionKey: 92f426be0f487b7d8dd191b86443f2a6
xpack.security.encryptionKey: 34bf00781dbe85d1dcd99dc94ef1c9b7

Kibana-Host 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"

Telemetrie ausschalten

Kibana sendet standardmäßig Daten an seine Server zurück. Das kann die Leistung beeinträchtigen und stellt außerdem ein Datenschutzrisiko dar. Deshalb solltest du die Telemetrie ausschalten. Füge den folgenden Code am Ende der Datei ein, um die Telemetrie zu deaktivieren. Die erste Einstellung schaltet die Telemetrie aus und die zweite Einstellung verbietet das Überschreiben der ersten Einstellung im Abschnitt Erweiterte Einstellungen in Kibana.

telemetry.optIn: false
telemetry.allowChangingOptInStatus: false

SSL konfigurieren

Suche die Variable elasticsearch.ssl.certificateAuthorities, entkommentiere sie und ändere ihren Wert wie unten gezeigt.

elasticsearch.ssl.certificateAuthorities: [ "/etc/kibana/http_ca.crt" ]

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Kibana-Zugang konfigurieren

Der nächste Schritt ist die Erstellung eines Anmeldetokens, mit dem wir uns später bei der Kibana-Weboberfläche anmelden werden.

$ sudo /usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana
eyJ2ZXIiOiI4LjEzLjIiLCJhZHIiOlsiMzcuMjcuODQuMTIzOjkyMDAiXSwiZmdyIjoiMmI2ZjhhOWRiOWJjMDU5NDk0NGE0OGFkMjMxODg2NzYxNTViZGViN2U5YjY4MmY3N2MzYmI3ZDk2Nzc3YjY0NyIsImtleSI6InppVU0zSTRCOE5lSHBLU3k2T0owOnBLNHJiWjBZVHYybWNTbmxrTXlqbncifQ==

Kibana starten

Nachdem du nun den sicheren Zugang und das Netzwerk für Kibana konfiguriert hast, starte den Prozess und aktiviere ihn.

$ sudo systemctl enable kibana --now

Überprüfe den Status, um zu sehen, ob der Prozess läuft.

$ sudo systemctl status kibana
? kibana.service - Kibana
     Loaded: loaded (/usr/lib/systemd/system/kibana.service; enabled; preset: disabled)
     Active: active (running) since Sun 2024-04-14 04:25:54 UTC; 963ms ago
       Docs: https://www.elastic.co
   Main PID: 6464 (node)
      Tasks: 7 (limit: 22569)
     Memory: 48.2M
        CPU: 1.238s
     CGroup: /system.slice/kibana.service
             ??6464 /usr/share/kibana/bin/../node/bin/node /usr/share/kibana/bin/../src/cli/dist

Apr 14 04:25:54 elastic systemd[1]: Started Kibana.
.....

Schritt 10 – 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. Du musst wahrscheinlich den SSH-Zugang konfigurieren, falls du das noch nicht 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 -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.

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 willst. Alle diese Befehle müssen auf dem Elasticsearch-Server ausgeführt werden.

Nginx installieren

Rocky Linux 9 wird mit einer älteren Version von Nginx ausgeliefert. Du musst das offizielle Nginx-Repository verwenden, um die neueste Version zu installieren.

Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.

$ sudo nano /etc/yum.repos.d/nginx.repo

Füge den folgenden Code in die Datei ein.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Wir werden die Mainline-Version von Nginx verwenden und haben daher in der obigen Datei das Mainline-Repositorium aktiviert, indem wir enabled=1 unter dem Mainline-Abschnitt statt dem Stable-Abschnitt verwenden. Du kannst eine der beiden Versionen wählen.

Installiere Nginx.

$ sudo dnf install -y nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.25.4

Aktiviere und starte den Nginx-Serverdienst.

$ sudo systemctl enable nginx --now

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. Dazu müssen wir zuerst das EPEL-Repository installieren.

$ sudo dnf install -y epel-release

Installiere Certbot und das entsprechende Nginx-Plugin.

$ sudo dnf install -y certbot python3-certbot-nginx

Erstelle das SSL-Zertifikat für die Domain kibana.example.com.

$ sudo certbot certonly --nginx --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 -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Aktiviere und starte den Certbot Timer für die automatische Erneuerung.

$ sudo systemctl enable certbot-renew.timer
$ sudo systemctl start certbot-renew.timer

Sieh dir die Liste der Timer an.

$ sudo systemctl list-timers
NEXT                        LEFT         LAST                        PASSED    UNIT                         ACTIVATES
---------------------------------------------------------------------------------------------------------------------------------
Mon 2024-04-15 00:00:00 UTC 19min left   Sun 2024-04-14 08:20:34 UTC 15h ago   logrotate.timer              logrotate.service
Mon 2024-04-15 00:43:16 UTC 1h 2min left Sun 2024-04-14 09:01:33 UTC 14h ago   fstrim.timer                 fstrim.service
Mon 2024-04-15 00:44:47 UTC 1h 4min left Sun 2024-04-14 23:30:19 UTC 10min ago dnf-makecache.timer          dnf-makecache.service
Mon 2024-04-15 06:52:31 UTC 7h left      -                           -         certbot-renew.timer          certbot-renew.service

Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.

Nginx konfigurieren

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;
  listen [::]:443 ssl;
  http2 on;
  http3 on;
  quic_retry on;


  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;
  ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
  ssl_prefer_server_ciphers off;

  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

Als Nächstes musst du das Basis-URL-Feld in der Konfiguration von Kibana 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

Konfiguriere SELinux, um Nginx zu aktivieren

Wende die Richtlinie an, um Verbindungen zu externen Hosts zuzulassen.

$ sudo setsebool -P httpd_can_network_connect 1

Beende die Konfiguration von ElasticSearch mit Kibana

Warte ein paar Minuten und lade die URL https://kibana.example.com in deinem Browser.

Du erhältst das Feld für das Anmelde-Token. Gib das in Schritt 9 erstellte Enrollment-Token ein.

Klicke auf die Schaltfläche Configure Elastic, um fortzufahren. Als nächstes wirst du nach dem Verifizierungscode gefragt.

Wechsle zurück zum Elasticsearch-Terminal und führe den folgenden Befehl aus, um den Code zu generieren. Gib diesen Code auf der Seite ein und klicke auf die Schaltfläche Verifizieren, um fortzufahren.

$ sudo /usr/share/kibana/bin/kibana-verification-code
Your verification code is:  232 001

Warte nun, bis die Elastic-Einrichtung abgeschlossen ist. Das kann einige Minuten dauern.

Danach wirst du zum Anmeldebildschirm weitergeleitet.

Schritt 11 – 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 8.x packages
baseurl=https://artifacts.elastic.co/packages/8.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

Bevor wir Filebeat konfigurieren, müssen wir die Datei http_ca.crt vom Elasticsearch-Server auf den Filebeat-Server kopieren. Führe den folgenden Befehl auf dem Filebeat-Server aus.

$ scp username@your_public_ip:/etc/elasticsearch/certs/http_ca.crt /etc/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 sie 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"
  protocol: "http"
  ssl.enabled: true
  ssl.certificate_authorities: ["/etc/filebeat/http_ca.crt"]

. . .

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. Setze außerdem protocol auf HTTPS.

output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["your_private_IP:9200"]
  
  # Performance preset - one of "balanced", "throughput", "scale",
  # "latency", or "custom".
  preset: balanced

  # Protocol - either `http` (default) or `https`.
  protocol: "https"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elastic"
  password: "<yourelasticpassword>"
  ssl.certificate_authorities: ["/etc/filebeat/http_ca.crt"]
  ssl.verification_mode: full

. . .

Füge die folgende Zeile am Ende der Datei ein.

setup.ilm.overwrite: true

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Es gibt noch einen weiteren Schritt, um sicherzustellen, dass Filebeat eine Verbindung zu Elasticsearch herstellt. Wir müssen die SSL-Informationen von Elasticsearch an Filebeat weitergeben, damit die Verbindung hergestellt werden kann.

Teste die Verbindung zwischen Filebeat und dem Elasticsearch-Server. Du wirst nach deinem Elasticsearch-Passwort gefragt.

$ sudo curl -v --cacert /etc/filebeat/http_ca.crt https://your_private_ip:9200 -u elastic

Du wirst die folgende Ausgabe erhalten.

Enter host password for user 'elastic':
*   Trying 10.0.0.2:9200...
* Connected to 10.0.0.2 (10.0.0.2) port 9200 (#0)
* ALPN, offering h2
* ALPN, offering http/1.1
*  CAfile: /etc/filebeat/http_ca.crt
* TLSv1.0 (OUT), TLS header, Certificate Status (22):
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.2 (IN), TLS header, Certificate Status (22):
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.2 (IN), TLS header, Finished (20):
* TLSv1.2 (IN), TLS header, Unknown (23):
* TLSv1.3 (IN), TLS handshake, Encrypted Extensions (8):
* TLSv1.3 (IN), TLS handshake, Certificate (11):
* TLSv1.3 (IN), TLS handshake, CERT verify (15):
* TLSv1.3 (IN), TLS handshake, Finished (20):
* TLSv1.2 (OUT), TLS header, Finished (20):
* TLSv1.3 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.2 (OUT), TLS header, Unknown (23):
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN, server did not agree to a protocol
* Server certificate:
*  subject: CN=elastic
*  start date: Apr 14 08:37:21 2024 GMT
*  expire date: Apr 14 08:37:21 2026 GMT
*  subjectAltName: host "10.0.0.2" matched cert's IP address!
*  issuer: CN=Elasticsearch security auto-configuration HTTP CA
*  SSL certificate verify ok.
* Server auth using Basic with user 'elastic'
* TLSv1.2 (OUT), TLS header, Unknown (23):
> GET / HTTP/1.1
> Host: 10.0.0.2:9200
> Authorization: Basic ZWxhc3RpYzpsaWZlc3Vja3M2NjIwMDI=
> User-Agent: curl/7.76.1
> Accept: */*
> 
* TLSv1.2 (IN), TLS header, Unknown (23):
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* TLSv1.2 (IN), TLS header, Unknown (23):
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< X-elastic-product: Elasticsearch
< content-type: application/json
< content-length: 532
< 
{
  "name" : "elastic",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "vnUn8l1bQ1qkF-VjCoiWmQ",
  "version" : {
    "number" : "8.13.2",
    "build_flavor" : "default",
    "build_type" : "rpm",
    "build_hash" : "16cc90cd2d08a3147ce02b07e50894bc060a4cbf",
    "build_date" : "2024-04-05T14:45:26.420424304Z",
    "build_snapshot" : false,
    "lucene_version" : "9.10.0",
    "minimum_wire_compatibility_version" : "7.17.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "You Know, for Search"
}
* Connection #0 to host 10.0.0.2 left intact

Als Nächstes aktivierst du das in Filebeat integrierte Suricata-Modul.

$ sudo filebeat modules enable suricata
Enabled suricata

Öffne die Datei /etc/filebeat/modules.d/suricata.yml zum Bearbeiten.

$ sudo nano /etc/filebeat/modules.d/suricata.yml

Bearbeite die Datei wie unten gezeigt. Du musst den Wert der Variable enabled in true ändern. Entferne außerdem die Kommentierung der Variable var.paths und setze ihren Wert wie gezeigt.

# Module: suricata
# Docs: https://www.elastic.co/guide/en/beats/filebeat/8.10/filebeat-module-suricata.html

- module: suricata
  # All logs
  eve:
    enabled: true

    # Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    var.paths: ["/var/log/suricata/eve.json"]

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

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.

Index setup finished.
Loading dashboards (Kibana must be running and reachable)
Loaded dashboards
Loaded Ingest pipelines

Starte und aktiviere den Filebeat-Dienst.

$ sudo systemctl enable filebeat --now

Überprüfe den Status des Dienstes.

$ sudo systemctl status filebeat
? filebeat.service - Filebeat sends log files to Logstash or directly to Elasticsearch.
     Loaded: loaded (/usr/lib/systemd/system/filebeat.service; enabled; preset: disabled)
     Active: active (running) since Sun 2024-04-14 10:12:51 UTC; 31s ago
       Docs: https://www.elastic.co/beats/filebeat
   Main PID: 7299 (filebeat)
      Tasks: 8 (limit: 22569)
     Memory: 407.2M
        CPU: 7.640s
     CGroup: /system.slice/filebeat.service
             ??7299 /usr/share/filebeat/bin/filebeat --environment systemd -c /etc/filebeat/filebeat.yml --path.home /usr/share/filebeat --path.config /etc/filebeat..........

Schritt 12 – Kibana Dashboards verwalten

Öffne https://kibana.example.com und du gelangst erneut zum Anmeldebildschirm.

Melde dich mit dem Benutzernamen elastic und dem Kennwort an, das du zuvor erstellt hast, und du erhältst den folgenden Bildschirm.

Klicke auf den Link Erkunden auf eigene Faust, um zum Dashboard zu gelangen.

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 ähnlichen Bildschirm. Standardmäßig werden nur die Einträge der letzten 15 Minuten angezeigt, aber wir zeigen sie über 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 im linken Hamburger-Menü auf das Security Dashboard, wähle Explore und dann auf der rechten Seite Network Dashboard.

Du siehst dann die folgende Seite.

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 9 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.