So installierst und konfigurierst du Suricata IDS zusammen mit Elastic Stack unter Ubuntu 22.04

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 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 Tutorium wirst du Suricata IDS zusammen mit ElasticStack auf einem Ubuntu 22.04 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, um den Netzwerkverkehr nach verdächtigen Ereignissen zu durchsuchen und die ungültigen Pakete zu verwerfen.

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 Ubuntu 22.04 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 Elasticsearch installiert wird.
• Installiere die wichtigsten Pakete auf beiden Servern. Einige von ihnen sind vielleicht schon installiert.

  $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
  

• Vergewissere dich, dass auf beiden Servern alles auf dem neuesten Stand ist.

  $ sudo apt update
  

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 add-apt-repository ppa:oisf/suricata-stable

Installiere Suricata.

$ sudo apt install suricata

Aktiviere den Suricata-Dienst.

$ sudo systemctl enable suricata

Bevor du fortfährst, stoppe den Suricata-Dienst, da wir ihn zuerst konfigurieren müssen.

$ sudo systemctl stop 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 Ü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": "95.179.184.1",
        "dev": "enp1s0",
        "protocol": "dhcp",
        "prefsrc": "95.179.185.42",
        "metric": 100,
        "flags": [ ]
    } ]

Die Variable dev bezieht sich auf das Netzwerkgerät. In unserer Ausgabe wird enp1s0 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: enp1s0
    # 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: enp1s0
    # 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.

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.

$ sudo suricata-update
25/2/2023 -- 06:48:14 - <Info> -- Using data-directory /var/lib/suricata.
25/2/2023 -- 06:48:14 - <Info> -- Using Suricata configuration /etc/suricata/suricata.yaml
25/2/2023 -- 06:48:14 - <Info> -- Using /etc/suricata/rules for Suricata provided rules.
.....
25/2/2023 -- 06:48:14 - <Info> -- No sources configured, will use Emerging Threats Open
25/2/2023 -- 06:48:14 - <Info> -- Fetching https://rules.emergingthreats.net/open/suricata-6.0.10/emerging.rules.tar.gz.
 100% - 3744681/3744681
.....
25/2/2023 -- 06:48:19 - <Info> -- Writing rules to /var/lib/suricata/rules/suricata.rules: total: 41022; enabled: 33278; added: 41022; removed 0; modified: 0
25/2/2023 -- 06:48:19 - <Info> -- Writing /var/lib/suricata/rules/classification.config
25/2/2023 -- 06:48:19 - <Info> -- Testing with suricata -T.
25/2/2023 -- 06:48: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.

$ sudo suricata-update list-sources

Wenn du zum Beispiel den Regelsatz tgreen/hunting einbeziehen möchtest, kannst du ihn mit dem folgenden Befehl aktivieren.

$ sudo suricata-update enable-source tgreen/hunting

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 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
25/2/2023 -- 06:51:11 - <Info> - Running suricata under test mode
25/2/2023 -- 06:51:11 - <Notice> - This is Suricata version 6.0.10 RELEASE running in SYSTEM mode
25/2/2023 -- 06:51:11 - <Info> - CPUs/cores online: 2
25/2/2023 -- 06:51:11 - <Info> - fast output device (regular) initialized: fast.log
25/2/2023 -- 06:51:11 - <Info> - eve-log output device (regular) initialized: eve.json
25/2/2023 -- 06:51:11 - <Info> - stats output device (regular) initialized: stats.log
25/2/2023 -- 06:51:22 - <Info> - 1 rule files processed. 33519 rules successfully loaded, 0 rules failed
25/2/2023 -- 06:51:22 - <Info> - Threshold config parsed: 0 rule(s) found
25/2/2023 -- 06:51:22 - <Info> - 33522 signatures processed. 1189 are IP-only rules, 5315 are inspecting packet payload, 26814 inspect application layer, 108 are decoder event only
25/2/2023 -- 06:51:34 - <Notice> - Configuration provided was successfully loaded. Exiting.
25/2/2023 -- 06:51:34 - <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 - LSB: Next Generation IDS/IPS
     Loaded: loaded (/etc/init.d/suricata; generated)
     Active: active (running) since Sat 2023-02-25 07:04:23 UTC; 5s ago
       Docs: man:systemd-sysv-generator(8)
    Process: 2701 ExecStart=/etc/init.d/suricata start (code=exited, status=0/SUCCESS)
      Tasks: 1 (limit: 4575)
     Memory: 190.6M
        CPU: 5.528s
     CGroup: /system.slice/suricata.service
             ??2710 /usr/bin/suricata -c /etc/suricata/suricata.yaml --pidfile /var/run/suricata.pid --af-packet -D -vvv

Feb 25 07:04:23 kibana systemd[1]: Starting LSB: Next Generation IDS/IPS...
Feb 25 07:04:23 kibana suricata[2701]: Starting suricata in IDS (af-packet) mode... done.
Feb 25 07:04:23 kibana systemd[1]: Started LSB: Next Generation IDS/IPS.

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.

25/2/2023 -- 07:04:44 - <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 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/25/2023-07:06:09.513208  [**] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 2600:9000:2250:3200:0018:30b3:e400:93a1:80 -> 2001:19f0:5001:225f:5400:04ff:fe52:2ca2:36770

Wenn deine Anfrage IPv4 verwendet hat, würdest du die folgende Ausgabe sehen.

02/19/2023-10:13:17.872335  [**] [1:2100498:7] GPL ATTACK_RESPONSE id check returned root [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 108.158.221.5:80 -> 95.179.185.42: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 visualisiert. 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.

$ wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

Erstelle ein Repository für das Elasticsearch-Paket, indem du die Datei /etc/apt/sources.list.d/elastic-7.x.list erstellst.

$ echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-7.x.list

Aktualisiere die Repository-Liste deines Systems.

$ sudo apt update

Installiere Elasticsearch und Kibana.

$ sudo apt install elasticsearch kibana

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

$ ip -brief address show
lo               UNKNOWN        127.0.0.1/8 ::1/128 
enp1s0           UP             78.141.220.30/23 metric 100 2001:19f0:5001:b35:5400:4ff:fe52:2ca3/64 fe80::5400:4ff:fe52:2ca3/64 
enp6s0           UP             10.7.96.4/20 fe80::5800:4ff:fe52:2ca3/64

Notiere dir die private IP deines Servers (in diesem Fall10.7.96.4 ). Wir werden sie als your_private_IP bezeichnen. Die öffentliche IP-Adresse des Servers (78.141.220.30) wird im weiteren Verlauf des Lehrgangs als your_public_IP bezeichnet. Notiere dir auch den Netzwerknamen deines Servers, enp6s0.

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 ufw allow in on enp6s0
$ sudo ufw allow out on enp6s0

Achte darauf, dass du im ersten Befehl den Namen der Schnittstelle auswählst, wie du ihn in Schritt 7 erhalten hast.

Starte Elasticsearch

Lade den Service Daemon neu.

$ sudo systemctl daemon-reload

Aktiviere den Elasticsearch-Dienst.

$ sudo systemctl enable elasticsearch

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 = y5uilzBu8akwRChvXFEq

Changed password for user kibana_system
PASSWORD kibana_system = nEeGIo9YJysUITU0ywLO

Changed password for user kibana
PASSWORD kibana = nEeGIo9YJysUITU0ywLO

Changed password for user logstash_system
PASSWORD logstash_system = VmumYBdNAwjsjwql6F5j

Changed password for user beats_system
PASSWORD beats_system = NZJxIPySwsNwPwCD2rsy

Changed password for user remote_monitoring_user
PASSWORD remote_monitoring_user = c2GafzJIueAxZEAAC6tZ

Changed password for user elastic
PASSWORD elastic = l4r7CyCHPw5p4c43RfA1

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: 20cabb5381ad09aeb6cccd1136c8138f
xpack.reporting.encryptionKey: d5293c386d14479f72bb2f6f6f984ad9
xpack.security.encryptionKey: 9cda918cc718fb58f022423b97e3171a

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 und aktiviere den Prozess.

$ 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 (/etc/systemd/system/kibana.service; enabled; vendor preset: enabled)
     Active: active (running) since Sat 2023-02-25 07:24:37 UTC; 6s ago
       Docs: https://www.elastic.co
   Main PID: 3884 (node)
      Tasks: 11 (limit: 4575)
     Memory: 181.8M
        CPU: 6.700s
     CGroup: /system.slice/kibana.service
             ??3884 /usr/share/kibana/bin/../node/bin/node /usr/share/kibana/bin/../src/cli/dist --logging.dest=/var/log/kibana/kibana.log --pid.file=/run/kibana/kibana.pid "--deprecation.skip_de>
Feb 25 07:24:37 elasticsearch systemd[1]: Started 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.

$ wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

Erstelle das Elastic Repository.

$ echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-7.x.list

Aktualisiere die Liste der System-Repositorys.

$ sudo apt update

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

Installiere Filebeat.

$ sudo apt install 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 andere Möglichkeit 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.

Firewall konfigurieren

Bevor du weitermachst, musst du HTTP- und HTTPS-Ports in der Firewall öffnen.

$ sudo ufw allow http
$ sudo ufw allow https

Nginx installieren

Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.

Importiere den Signierschlüssel von Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Füge das Repository für die stabile Version von Nginx hinzu.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx.

$ sudo apt install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.22.1

Starte den Nginx-Server.

$ sudo systemctl start nginx

SSL installieren und konfigurieren

Der erste Schritt ist die Installation des Let’s Encrypt SSL-Zertifikats. Wir müssen Certbot installieren, um das SSL-Zertifikat zu erzeugen. Du kannst Certbot entweder über das Ubuntu-Repository installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core && sudo snap refresh core

Installiere Certbot.

$ sudo snap install --classic certbot

Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

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

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf des Prozesses durch.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, ist alles in Ordnung. 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 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 neu.

$ sudo systemctl restart 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 Ubuntu 22.04 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.