Logs in Graylog analysieren | Log-Management & Cybersicherheit

Einführung

In diesem Lab lernen Sie, wie Sie Graylog, eine leistungsstarke Open-Source-Log-Management-Plattform, zum Sammeln und Analysieren von Log-Daten verwenden. Zentralisiertes Logging ist eine kritische Komponente der Cybersicherheit, die es Ihnen ermöglicht, Systemereignisse zu überwachen, Anomalien zu erkennen und Sicherheitsvorfälle von einer einzigen Schnittstelle aus zu untersuchen.

Sie beginnen mit dem Deployment des gesamten Graylog-Stacks, der MongoDB und OpenSearch (der moderne Ersatz für Elasticsearch) umfasst, mithilfe von Docker Compose. Anschließend konfigurieren Sie Graylog zum Empfangen von Log-Daten, senden Beispiellogs an Graylog, führen Suchanfragen zum Filtern von Informationen durch und erstellen schließlich ein visuelles Dashboard zur Überwachung wichtiger Metriken. Am Ende dieses Labs haben Sie praktische Erfahrung mit dem grundlegenden Workflow der Log-Analyse in Graylog gesammelt.

Graylog mit Docker Compose bereitstellen

In diesem ersten Schritt stellen Sie die Graylog-Logging-Plattform bereit. Wir verwenden Docker Compose v2, ein Werkzeug zur Definition und Ausführung von Multi-Container-Docker-Anwendungen. Dieser Ansatz vereinfacht den Einrichtungsprozess, indem alle notwendigen Komponenten – Graylog, OpenSearch und MongoDB – mit einer einzigen Konfigurationsdatei verwaltet werden.

Zuerst bereiten wir die Umgebung vor und starten die Dienste.

Das Setup-Skript hat Docker Compose v2 bereits für Sie installiert. Sie können die Installation überprüfen, indem Sie die Version abfragen.
```
docker compose version
```
Sie sollten eine Ausgabe sehen, die die Docker Compose-Version anzeigt, ähnlich dieser:
```
Docker Compose version v2.29.7
```
Navigieren Sie in das dafür vorgesehene Verzeichnis für Ihre Graylog-Konfiguration. Dies hilft, Ihr Projekt organisiert zu halten.
```
cd /home/labex/project/graylog
```
Erstellen Sie als Nächstes die Konfigurationsdatei docker-compose.yml mit dem Texteditor nano. Diese Datei teilt Docker Compose mit, welche Container ausgeführt und wie sie konfiguriert werden sollen.
```
nano docker-compose.yml
```

Kopieren Sie die folgende YAML-Konfiguration und fügen Sie sie in den nano-Editor ein. Diese Konfiguration definiert drei Dienste:

mongodb: Speichert die Konfigurationsdaten von Graylog.
opensearch: Indiziert und speichert die Log-Nachrichten für schnelle Suchen. Beachten Sie, dass OpenSearch 2.12+ ein initiales Admin-Passwort benötigt.
graylog: Die Hauptanwendung, die die Weboberfläche und die Log-Verarbeitungs-Engine bereitstellt.

services:
  mongodb:
    image: mongo:6.0
    container_name: graylog_mongodb
    volumes:
      - mongo_data:/data/db
    networks:
      - graylog_network
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.runCommand('ping').ok"]
      interval: 30s
      timeout: 10s
      retries: 3
  opensearch:
    image: opensearchproject/opensearch:2.13.0
    container_name: graylog_opensearch
    environment:
      - discovery.type=single-node
      - plugins.security.disabled=true
      - bootstrap.memory_lock=true
      - "OPENSEARCH_JAVA_OPTS=-Xms512m -Xmx512m"
      - "OPENSEARCH_INITIAL_ADMIN_PASSWORD=StrongPassword123!"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - opensearch_data:/usr/share/opensearch/data
    networks:
      - graylog_network
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl -f http://localhost:9200/_cluster/health || exit 1"
        ]
      interval: 30s
      timeout: 10s
      retries: 3
  graylog:
    image: graylog/graylog:6.1
    container_name: graylog_server
    volumes:
      - graylog_data:/usr/share/graylog/data
    environment:
      - GRAYLOG_PASSWORD_SECRET=somepasswordpepper
      - GRAYLOG_ROOT_PASSWORD_SHA2=8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918
      - GRAYLOG_HTTP_EXTERNAL_URI=http://127.0.0.1:9000/
      - GRAYLOG_ELASTICSEARCH_HOSTS=http://opensearch:9200
      - GRAYLOG_MONGODB_URI=mongodb://mongodb:27017/graylog
    depends_on:
      mongodb:
        condition: service_healthy
      opensearch:
        condition: service_healthy
    ports:
      - "9000:9000"
      - "1514:1514"
      - "1514:1514/udp"
      - "12201:12201"
      - "12201:12201/udp"
    networks:
      - graylog_network
volumes:
  mongo_data:
  opensearch_data:
  graylog_data:
networks:
  graylog_network:
    driver: bridge

Drücken Sie Ctrl+O, dann Enter, um die Datei zu speichern, und Ctrl+X, um nano zu beenden.

Starten Sie nun alle Dienste im Hintergrund mit dem Flag -d (detached).
```
docker compose up -d
```

Es kann ein bis zwei Minuten dauern, bis alle Dienste initialisiert sind. Sie können den Status Ihrer Container überprüfen, um sicherzustellen, dass sie korrekt ausgeführt werden.

docker compose ps

Sie sollten alle drei Dienste (graylog_server, graylog_opensearch, graylog_mongodb) mit dem State Up sehen.

NAME                 IMAGE                                 COMMAND                  SERVICE      CREATED              STATUS                        PORTS
graylog_mongodb      mongo:6.0                             "docker-entrypoint.s…"   mongodb      About a minute ago   Up About a minute (healthy)   27017/tcp
graylog_opensearch   opensearchproject/opensearch:2.13.0   "./opensearch-docker…"   opensearch   About a minute ago   Up About a minute (healthy)   9200/tcp, 9300/tcp, 9600/tcp, 9650/tcp
graylog_server       graylog/graylog:6.1                   "tini -- /docker-ent…"   graylog      About a minute ago   Up 34 seconds (healthy)       0.0.0.0:1514->1514/tcp, :::1514->1514/tcp, 0.0.0.0:9000->9000/tcp, 0.0.0.0:1514->1514/udp, :::9000->9000/tcp, :::1514->1514/udp, 0.0.0.0:12201->12201/tcp, 0.0.0.0:12201->12201/udp, :::12201->12201/tcp, :::12201->12201/udp

Die Graylog-Weboberfläche ist nun zugänglich. Sie haben den Graylog-Stack erfolgreich bereitgestellt und können ihn nun konfigurieren.

Einen Syslog-Input konfigurieren

Nachdem Graylog läuft, besteht der nächste Schritt darin, einen "Input" zu konfigurieren. Ein Input ist eine Komponente, die Graylog mitteilt, wie Log-Nachrichten empfangen werden sollen. Für dieses Lab erstellen Sie einen Syslog UDP Input, der ein gängiger Standard für das Sammeln von Logs von Netzwerkgeräten und Linux/Unix-Servern ist.

Öffnen Sie die Graylog-Weboberfläche in Ihrem Browser. Sie können dies tun, indem Sie auf den Tab "Web Terminal" klicken und "Desktop" auswählen, um den Browser zu öffnen, oder indem Sie das dedizierte Browser-Symbol in der Lab-Umgebung verwenden. Navigieren Sie zur folgenden URL:

http://127.0.0.1:9000
Melden Sie sich mit den Standardanmeldeinformationen an:
- Benutzername: admin
- Passwort: admin
Nach der Anmeldung erstellen Sie den neuen Input. Klicken Sie in der oberen Navigationsleiste auf System und wählen Sie dann im Dropdown-Menü Inputs aus.
Suchen Sie auf der Inputs-Seite im Dropdown-Menü "Select input" den Input-Typ "Syslog UDP" und klicken Sie daneben auf die Schaltfläche Launch new input.
Ein Modal-Fenster wird angezeigt. Füllen Sie das Formular mit den folgenden Details aus, um den Input zu konfigurieren:
- Node: Wählen Sie den einzigen verfügbaren Node aus dem Dropdown-Menü (dies wird Ihr Graylog-Server sein).
- Title: Syslog UDP Input (Dies ist ein beschreibender Name für Ihren Input).
- Bind address: 0.0.0.0 (Dies weist Graylog an, auf allen Netzwerkschnittstellen des Containers auf Logs zu lauschen).
- Port: 1514 (Dies ist der Port, an dem Graylog auf eingehende Syslog-Nachrichten wartet).
Lassen Sie alle anderen Einstellungen auf ihren Standardwerten und klicken Sie auf Save.
Nach dem Speichern werden Sie zur Inputs-Seite zurückgeleitet. Ihr neuer "Syslog UDP Input" sollte in der Liste mit dem grünen Status "Running" erscheinen, was bedeutet, dass er aktiv und bereit ist, Daten zu empfangen.
Um den Input zu testen, kehren Sie zu Ihrem Terminal zurück und senden Sie eine Beispiel-Log-Nachricht mit dem netcat (nc) Utility. Dieser Befehl erstellt eine grundlegende Syslog-Nachricht und sendet sie an den UDP-Port 1514 auf Ihrem lokalen Rechner.
```
echo "<14>$(date +'%b %d %H:%M:%S') localhost labex: Test syslog message" | nc -w1 -u 127.0.0.1 1514
```

Sie haben nun Graylog erfolgreich für den Empfang von Logs konfiguriert. Im nächsten Schritt senden Sie strukturiertere Logs und lernen, wie Sie diese in der Graylog-Oberfläche anzeigen.

Beispiel-Logs senden und anzeigen

Nachdem Ihr Syslog-Input bereit ist, ist es an der Zeit, eine Reihe von Beispiel-Logs zu generieren und zu senden. Dies wird Graylog mit Daten füllen, sodass Sie mit der Suche und Analyse üben können. Sie erstellen ein einfaches Shell-Skript, um Log-Nachrichten von einer Anwendung zu simulieren.

Navigieren Sie zuerst im Terminal zurück in das Stammverzeichnis Ihres Projekts.
```
cd /home/labex/project
```
Erstellen Sie ein neues Shell-Skript namens generate_logs.sh mit dem nano-Editor.
```
nano generate_logs.sh
```
Kopieren Sie das folgende Skript und fügen Sie es in den Editor ein. Dieses Skript generiert in einer Schleife 10 Log-Nachrichten. Jede Nachricht hat eine zufällige Schweregradstufe (severity), einen Zeitstempel und einen einfachen Nachrichtentext. Anschließend verwendet es nc, um jedes Log an den von Ihnen konfigurierten Graylog-Input zu senden.
```
#!/bin/bash
for i in {1..10}; do
  severity=$(((RANDOM % 8)))
  timestamp=$(date +'%b %d %H:%M:%S')
  echo "<$((severity + 8))>$timestamp localhost sample_app[$i]: Sample log message $i with severity $severity" | nc -w1 -u 127.0.0.1 1514
  echo "Sent log message $i"
  sleep 1
done
```
Drücken Sie Ctrl+O, Enter und Ctrl+X, um zu speichern und zu beenden.
Machen Sie das Skript mit dem Befehl chmod ausführbar.
```
chmod +x generate_logs.sh
```
Führen Sie das Skript aus, um die Logs an Graylog zu senden.
```
./generate_logs.sh
```
Sie sehen im Terminal Ausgaben, während jedes Log gesendet wird.
```
Sent log message 1
Sent log message 2
...
Sent log message 10
```
Betrachten wir nun diese Logs in Graylog. Kehren Sie zur Graylog-Weboberfläche in Ihrem Browser zurück (http://127.0.0.1:9000).
Klicken Sie in der oberen Navigationsleiste auf den Tab Search. Sie sollten die gerade gesendeten Log-Nachrichten in der Liste "Messages" sehen. Es kann einige Sekunden dauern, bis sie indiziert und angezeigt werden.

Sie können sehen, wie Graylog die Nachrichten automatisch parst und sie in Felder wie timestamp, source, application_name und severity aufteilt. Diese strukturierten Daten sind entscheidend für eine effektive Log-Analyse.

Protokolldaten abfragen und analysieren

Nachdem die Logs in Graylog eingegangen sind, können Sie nun lernen, wie Sie sie suchen und filtern. Die Suchfunktionalität von Graylog ist leistungsstark und ermöglicht es Ihnen, bestimmte Ereignisse schnell zu identifizieren. Dies ist unerlässlich für die Fehlerbehebung oder die Untersuchung von Sicherheitsvorfällen.

Gehen Sie auf der Graylog-Weboberfläche zur Seite Search. Die Suchleiste befindet sich am oberen Rand der Seite.
Beginnen wir mit einer einfachen Abfrage. Um alle Logs Ihrer simulierten Anwendung zu finden, geben Sie Folgendes in die Suchleiste ein und drücken Sie Enter:

application_name:sample_app

Dies filtert die Ergebnisse, sodass nur die Logs angezeigt werden, bei denen das Feld application_name exakt sample_app lautet.
Versuchen Sie nun einige andere Abfragen, um verschiedene Filterfunktionen zu erkunden:
- Logs mit einem bestimmten Schweregrad (z. B. Level 4) finden: severity:4
- Logs mit einem Schweregrad größer als 5 finden (Warnungen, Fehler usw.): severity:>5
- Nach einer Phrase in der Log-Nachricht suchen: message:"log message 5"
- Filter mit AND kombinieren: application_name:sample_app AND severity:<3
Sie können auch den Zeitrahmen Ihrer Suche steuern. Standardmäßig zeigt Graylog Logs der "Letzten 5 Minuten" an. Klicken Sie auf den Zeitbereichsauswähler links neben der Suchleiste und ändern Sie ihn auf Letzte 30 Minuten, um sicherzustellen, dass alle Ihre generierten Logs in den Suchergebnissen enthalten sind.
Um eine häufig verwendete Abfrage leicht zugänglich zu machen, können Sie sie speichern. Speichern wir eine Suche nach Ereignissen mit hohem Schweregrad.
- Führen Sie die Abfrage aus: severity:>4
- Klicken Sie rechts neben der Suchleiste auf das Diskettensymbol (Save Search).
- Geben Sie im Dialogfeld "Save Search" einen Title ein, z. B. High Severity Events.
- Klicken Sie auf Save.
Sie können nun jederzeit von der Liste "Saved Searches" in der linken Seitenleiste auf diese gespeicherte Suche zugreifen, sodass Sie kritische Ereignisse schnell überprüfen können.

Überwachungs-Dashboard erstellen

Während die Suchseite hervorragend für aktive Untersuchungen geeignet ist, bieten Dashboards einen Überblick über Ihre Log-Daten auf einen Blick. In diesem letzten Schritt erstellen Sie ein Dashboard mit mehreren Widgets, um wichtige Metriken aus Ihren Logs zu visualisieren.

Navigieren Sie in der Graylog-Weboberfläche im oberen Menü zum Abschnitt Dashboards.
Klicken Sie auf die Schaltfläche Create dashboard.
- Geben Sie einen Title ein: Application Health Dashboard
- Geben Sie eine Description ein: Monitors the health and activity of sample_app.
- Klicken Sie auf Create.
Sie haben nun ein leeres Dashboard. Fügen wir ihm einige Widgets hinzu. Klicken Sie auf die Schaltfläche Unlock / Edit, um in den Bearbeitungsmodus zu wechseln.
Ein "Log Count"-Widget hinzufügen: Dieses Widget zeigt die Gesamtzahl der Log-Nachrichten im Zeitverlauf an.
- Klicken Sie auf Create Widget for Dashboard.
- Wählen Sie Aggregation als Widget-Typ.
- Im Konfigurationsfenster:
  - Title: Total Log Volume
  - Wählen Sie unter "Rows" das Feld timestamp.
  - Wählen Sie Bar Chart als Visualisierungstyp.
- Klicken Sie auf Create.
Ein "Severity Distribution"-Widget hinzufügen: Dieses Widget zeigt die Aufschlüsselung der Logs nach Schweregrad an.
- Klicken Sie erneut auf Create Widget for Dashboard.
- Wählen Sie Aggregation als Widget-Typ.
- Im Konfigurationsfenster:
  - Title: Log Severity Distribution
  - Wählen Sie unter "Rows" das Feld severity.
  - Wählen Sie Pie Chart als Visualisierungstyp.
- Klicken Sie auf Create.
Ein "Recent Messages"-Widget hinzufügen: Dieses Widget zeigt eine Liste der neuesten Log-Nachrichten an.
- Klicken Sie auf Create Widget for Dashboard.
- Wählen Sie Messages als Widget-Typ.
- Im Konfigurationsfenster:
  - Title: Recent Log Messages
  - Stellen Sie im Feld "Streams" sicher, dass All messages ausgewählt ist.
- Klicken Sie auf Create.
Sobald Sie die Widgets hinzugefügt haben, können Sie sie per Drag & Drop anordnen. Sie können sie auch durch Ziehen an den Ecken in der Größe ändern. Ordnen Sie sie so an, dass sie leicht lesbar sind.
Wenn Sie mit dem Layout zufrieden sind, klicken Sie in der oberen rechten Ecke auf die Schaltfläche Lock / Save, um Ihr Dashboard zu speichern.

Sie haben nun ein grundlegendes Monitoring-Dashboard erstellt. In einem realen Szenario sind Dashboards wie dieses von unschätzbarem Wert, um die Systemgesundheit und die Sicherheitslage im Auge zu behalten.

Zusammenfassung

In diesem Lab haben Sie praktische Erfahrungen mit den Kernfunktionalitäten von Graylog für die Protokollverwaltung und -analyse gesammelt. Sie haben mit der Bereitstellung einer vollständigen Graylog-Umgebung mithilfe von Docker Compose begonnen, die den Graylog-Server, OpenSearch und MongoDB umfasste.

Anschließend haben Sie eine Syslog-Eingabe konfiguriert, um die Protokollsammlung zu ermöglichen, und ein Skript verwendet, um Beispieldaten zu senden, die reale Anwendungsprotokolle simulieren. Sie haben gelernt, wie Sie die leistungsstarke Such- und Abfragesprache von Graylog verwenden, um spezifische Informationen in Ihren Protokollen zu filtern und zu finden. Schließlich haben Sie alles zusammengebracht, indem Sie ein benutzerdefiniertes Dashboard mit verschiedenen Widgets erstellt haben, um Protokollmetriken zu visualisieren und einen schnellen Überblick über die Systemaktivität zu erhalten. Diese Fähigkeiten bilden eine solide Grundlage für die Verwendung von Graylog in der Cybersicherheitsüberwachung und im operativen Intelligence-Bereich.