KI-Net-Sicherheitssystem

Die Einrichtung eines umfassenden KI-gestützten Überwachungssystems auf einem Debian-Server, das ein gesamtes Netzwerk nach Ransomware und schädlichen Einbrüchen überwacht und bei der Erkennung von Bedrohungen automatisch Maßnahmen wie Isolierung und Benachrichtigung durchführt, war schon immer ein Projekt, daß mich ständig fasziniert und fordert.

Bei meiner Lösung werden sowohl Netzwerk- als auch Host-basierte Intrusion Detection Systeme (IDS), Dateiintegritätsprüfungen und Firewall-Regeln sowie auch ein hostbasiertes Sicherheitsmanagement integriert, um eine ganzheitliche Sicherheitslösung für ein vorhandenes Netzwerk zu schaffen. Viele Diensteanbieter bieten solche Systeme auch aktuell als Komplettlösung inklusive Hardware an. Leider sind die Kosten bisher einfach exorbitant hoch dafür. Bei meiner letzten Recherche habe ich einen jährlichen Lizenzpreis von 12.000 Euro zu erfahren bekommen. Da diese Unternehmen jedoch alle auch nur mit Wasser kochen wollte ich mich mit dieser Technik einmal etwas näher beschäftigen.

Hier ist nun meine Anleitung, wie ich ein solches System eingerichtet habe:

Systemvorbereitung

Debian Server Installation und Vorbereitung

  • Debian aktualisieren:
    sudo apt update && sudo apt upgrade -y
  • Erforderliche Pakete installieren:
    sudo apt install curl wget gnupg2 software-properties-common build-essential zlib1g-dev libpcre2-dev libssl-dev -y

KI-gestütztes Intrusion Detection und Prevention System (IDS/IPS)

Wazuh – Integriertes HIDS, SIEM und Log-Management

Wazuh ist eine Open-Source-Plattform, die eine zentrale Sicherheitsüberwachung durch IDS/IPS, HIDS, Log-Management und SIEM ermöglicht. Wazuh integriert Kibana für die Visualisierung und Elasticsearch für die Datenanalyse.

Installation von Elasticsearch

Elasticsearch dient als Such- und Analysemaschine für Logs und Sicherheitsdaten.

  • Elasticsearch installieren:
    wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
    sudo apt-add-repository "deb https://artifacts.elastic.co/packages/7.x/apt stable main"
    sudo apt update && sudo apt install elasticsearch -y
  • Elasticsearch konfigurieren: Bearbeite die Datei /etc/elasticsearch/elasticsearch.yml und setze die Einstellung für den Cluster-Namen und die Netzwerkschnittstelle:
    cluster.name: wazuh-cluster
    network.host: localhost
  • Elasticsearch starten:
    sudo systemctl enable elasticsearch
    sudo systemctl start elasticsearch

Installation von Kibana

Kibana ist das Visualisierungstool, das auf Elasticsearch aufbaut. Kibana wird in der Regel zusammen mit Elasticsearch installiert. Elasticsearch bietet eine schnelle Suchmaschine für strukturierte und unstrukturierte Daten, während Kibana das Frontend für die Datenvisualisierung bereitstellt.

  • Kibana installieren:
    sudo apt install kibana -y
  • Kibana konfigurieren:

Die Konfigurationsdatei von Kibana befindet sich unter /etc/kibana/kibana.yml. Diese Datei enthält die Einstellungen für Kibana, wie z.B. den Host, auf dem es läuft, und die Verbindung zu Elasticsearch.

Wir öffnen die Konfigurationsdatei:

sudo nano /etc/kibana/kibana.yml

Ändere die folgenden Parameter nach deinen Anforderungen:

  • Server-Host: Definiere den Host, auf dem Kibana laufen soll. Standardmäßig ist Kibana nur lokal erreichbar (localhost).
    server.host: "0.0.0.0"

    Diese Einstellung erlaubt es, dass Kibana von allen IP-Adressen aus zugänglich ist. Wenn Kibana nur lokal zugänglich sein soll, lasse die Einstellung auf localhost.

  • Elasticsearch-URL: Definiere die Adresse, unter der Elasticsearch erreichbar ist.
    elasticsearch.hosts: ["http://localhost:9200"]

    Stelle sicher, dass diese Adresse korrekt ist, basierend auf deinem Elasticsearch-Setup.

  • Optional: Kibana-Index-Management: Konfiguriere den Index, den Kibana zur Speicherung seiner Daten verwendet.
    kibana.index: ".kibana"
  • Optional: Authentifizierung (bei aktiviertem X-Pack): Wenn Elasticsearch und Kibana mit X-Pack installiert sind (das ist in den meisten Versionen standardmäßig enthalten), kannst du eine Authentifizierung einrichten.
    elasticsearch.username: "kibana_system"
    elasticsearch.password: "your_password"

Die Installation und Konfiguration von Kibana auf einem Debian-Server ist ein wichtiger Schritt, um eine visuelle Schnittstelle für die Datenanalyse und Überwachung bereitzustellen. Kibana arbeitet häufig mit Elasticsearch zusammen, um Echtzeitdaten darzustellen und zu analysieren. Hier ist eine Schritt-für-Schritt-Anleitung für die Installation und Konfiguration von Kibana auf einem Debian-System.

Kibana starten und aktivieren

Starte Kibana und aktiviere es, damit es beim Systemstart automatisch gestartet wird:

sudo systemctl enable kibana
sudo systemctl start kibana

Überprüfen, ob Kibana läuft

Überprüfe den Status des Kibana-Dienstes:

sudo systemctl status kibana

Wenn Kibana erfolgreich gestartet wurde, sollte es über den Webbrowser zugänglich sein.

Zugriff auf Kibana

Öffne deinen Webbrowser und navigiere zur IP-Adresse deines Servers, gefolgt vom Port 5601, um auf die Kibana-Weboberfläche zuzugreifen:

http://your_server_ip:5601
Kibana Security Netzwerk Übersicht

Wenn Kibana ordnungsgemäß läuft, sollte man die Kibana-Benutzeroberfläche sehen. Kibana bietet eine leistungsstarke Plattform zur Visualisierung und Analyse der Daten. Die Konfiguration kann weiter verfeinert werden, um den spezifischen Anforderungen des Systems gerecht zu werden. Hier sollte man aber für den Realeinsatz TLS/SSL Verschlüsselung zusätzlich einrichten.

Installation von Wazuh Server

Wazuh überwacht Hosts, analysiert Logs und bietet eine umfassende SIEM-Funktionalität.

  • Wazuh Repository hinzufügen und installieren:
    curl -s https://packages.wazuh.com/key/GPG-KEY-WAZUH | sudo apt-key add -
    echo "deb https://packages.wazuh.com/4.x/apt/ stable main" | sudo tee /etc/apt/sources.list.d/wazuh.list
    sudo apt update && sudo apt install wazuh-manager -y
  • Wazuh-Konfiguration anpassen: Bearbeite /var/ossec/etc/ossec.conf, um das System entsprechend den spezifischen Sicherheitsanforderungen zu konfigurieren. Beispiele hierfür sind Regeln zur Logüberwachung, Benutzeraktivitätsüberwachung und Dateiänderungserkennung.
  • Wazuh starten:
    sudo systemctl enable wazuh-manager
    sudo systemctl start wazuh-manager

Integration von Wazuh mit Elasticsearch und Kibana

  • Installiere Wazuh Plugin für Kibana:
    sudo apt install wazuh-kibana-app -y
  • Konfiguriere Wazuh zur Kommunikation mit Elasticsearch: Füge in /etc/elasticsearch/elasticsearch.yml die Wazuh-Integration hinzu:
    wazuh.enabled: true
    wazuh.cluster_host: localhost
    wazuh.cluster_port: 1514
  • Kibana neu starten:
    sudo systemctl restart kibana

Netzwerkbasierte Intrusion Detection mit Suricata

Suricata installieren und konfigurieren

Suricata ist ein leistungsstarkes IDS/IPS-System zur Überwachung und Analyse des Netzwerkverkehrs.

  • Suricata installieren:
    sudo apt install suricata -y
  • Suricata konfigurieren: In der Datei /etc/suricata/suricata.yaml wird die Netzwerkschnittstelle für die Überwachung festgelegt:
    af-packet:
      - interface: eth0
        threads: 4
        cluster-id: 99
        cluster-type: cluster_flow
        defrag: yes
        checksum-checks: auto
  • Regeln für Suricata aktualisieren:
    sudo suricata-update
    sudo systemctl restart suricata
  • Suricata in den IPS-Modus versetzen: Bearbeite die Datei /etc/suricata/suricata.yaml, um Suricata so zu konfigurieren, dass es verdächtigen Traffic blockiert.

Integration mit Wazuh

Suricata-Logs können an Wazuh gesendet werden, um Netzwerkereignisse zentral zu analysieren.

  • Suricata-Logs an Wazuh senden: Bearbeite die Datei /etc/suricata/suricata.yaml, um das Logging an Wazuh zu aktivieren:
    outputs:
      - eve-log:
          enabled: yes
          filetype: unix_stream
          filename: /var/ossec/logs/suricata/eve.json

Host-basierte Intrusion Detection mit OSSEC

OSSEC installieren und konfigurieren

OSSEC ist ein leistungsstarkes HIDS, das Dateiintegrität, Benutzeraktivitäten und Logs auf den Hosts überwacht.

  • OSSEC installieren:
    wget https://github.com/ossec/ossec-hids/archive/refs/tags/3.7.0.tar.gz
    tar -zxvf 3.7.0.tar.gz
    cd ossec-hids-3.7.0
    sudo ./install.sh
  • OSSEC als lokal installieren (Standalone-Modus): Während der Installation wähle local aus, um OSSEC als eigenständige Lösung zu betreiben.
  • Konfiguration anpassen: Passe /var/ossec/etc/ossec.conf an, um Verzeichnisse wie /etc und /var/log zu überwachen:
    <directories check_all="yes" realtime="yes">/etc,/var/log</directories>
  • OSSEC starten und aktivieren:
    sudo systemctl start ossec
    sudo systemctl enable ossec

Dateiintegritätsprüfung mit AIDE

AIDE installieren und konfigurieren

AIDE (Advanced Intrusion Detection Environment) überwacht die Integrität kritischer Systemdateien.

  • AIDE installieren:
    sudo apt install aide -y
  • Initiale AIDE-Datenbank erstellen:
    sudo aideinit
    sudo cp /var/lib/aide/aide.db.new /var/lib/aide/aide.db
  • Konfiguration anpassen: Bearbeite die Datei /etc/aide/aide.conf, um spezifische Dateien und Verzeichnisse zur Überwachung hinzuzufügen:
    /bin    NORMAL
    /sbin   NORMAL
    /etc    DIR
    /var/log   LOG
  • Tägliche Integritätsprüfungen einrichten: Erstelle einen Cron-Job, um AIDE regelmäßig auszuführen:
    echo "0 3 * * * root /usr/bin/aide --check" | sudo tee /etc/cron.d/aide-check

Firewall und zusätzliche Sicherheitsmaßnahmen

Firewall-Konfiguration mit UFW

Uncomplicated Firewall (UFW) ist ein einfaches Firewall-Frontend für iptables, das die Sicherheitsrichtlinien des Systems verwaltet.

  • UFW installieren:
    sudo apt install ufw -y
  • Basis-Regeln festlegen:
    • Erlaube SSH-Zugriff:
      sudo ufw allow ssh
    • Standardmäßig eingehenden Traffic blockieren und ausgehenden Traffic erlauben:
      sudo ufw default deny incoming
      sudo ufw default allow outgoing
  • UFW aktivieren:
    sudo ufw enable

Fail2ban für Schutz vor Brute-Force-Angriffen

Fail2ban überwacht Logs und blockiert IP-Adressen, die verdächtige Aktivitäten zeigen.

  • Fail2ban installieren:
    sudo apt install fail2ban -y
  • Fail2ban-Konfiguration: Bearbeite die Datei /etc/fail2ban/jail.local, um spezifische Dienste wie SSH zu schützen:
    [sshd]
    enabled  = true
    port     = ssh
    filter   = sshd
    logpath  = /var/log/auth.log
    maxretry = 5
    bantime  = 3600
  • Fail2ban starten und aktivieren:
    sudo systemctl enable fail2ban
    sudo systemctl start fail2ban

KI-gestützte Bedrohungserkennung

Machine Learning-Modelle integrieren

Man kann Wazuh nutzen, um KI-Modelle in die Überwachung einzubeziehen. Diese Modelle können auf Anomalien und Bedrohungen in Echtzeit hinweisen.

Die Integration einer KI-gestützten Bedrohungserkennung in dein Sicherheitssystem kann mithilfe von Machine Learning (ML)-Modellen durchgeführt werden, die speziell für die Erkennung von Anomalien in Netzwerk- und Systemlogs entwickelt wurden. Hier ist ein detailliertes Beispiel für die Konfiguration einer KI-gestützten Bedrohungserkennung, basierend auf der Kombination von Wazuh, Python und einem ML-Modell.

Grundlegende Vorbereitung

Python-Umgebung einrichten

Installiere Python und die erforderlichen Pakete auf deinem Debian-Server.

  • Python und Pip installieren:
    sudo apt update
    sudo apt install python3 python3-pip -y
  • Erforderliche Python-Bibliotheken installieren:
    pip3 install numpy pandas scikit-learn joblib

Verzeichnisstruktur einrichten

Erstelle ein Verzeichnis für die KI-Modelle und Scripts.

  • Verzeichnis erstellen:
    sudo mkdir -p /opt/ml_security/models
    sudo mkdir -p /opt/ml_security/scripts

Erstellung eines ML-Modells zur Anomalieerkennung

In diesem Beispiel verwenden wir das Scikit-Learn-Paket, um ein einfaches ML-Modell zur Erkennung von Anomalien zu erstellen.

Daten vorbereiten

Das Modell benötigt Trainingsdaten, um normal und anormal gekennzeichnete Beispiele zu lernen. Diese Daten können aus Systemlogs stammen, die bereits Angriffe enthalten.

  • Beispiel für die Vorbereitung von Trainingsdaten (CSV-Format):
    import pandas as pd
    from sklearn.model_selection import train_test_split
    from sklearn.ensemble import IsolationForest
    from joblib import dump
    # Beispiel für das Laden der Log-Daten
    data = pd.read_csv('/path/to/your/logdata.csv')
    # Features und Zielvariable definieren
    X = data[['feature1', 'feature2', 'feature3']]  # Beispielhafte Features
    y = data['label']  # 0 für normal, 1 für anormal
    # Trainings- und Testdaten splitten
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
    # Isolation Forest Modell erstellen
    model = IsolationForest(n_estimators=100, contamination=0.1, random_state=42)
    model.fit(X_train, y_train)
    # Modell speichern
    dump(model, '/opt/ml_security/models/anomaly_detection_model.joblib')

Modelltraining

Trainiere das Modell auf den vorbereiteten Daten.

  • Training ausführen:
    python3 /opt/ml_security/scripts/train_model.py

Integration des Modells in die Echtzeitüberwachung

Script zur Vorhersage und Integration in Wazuh

Erstelle ein Python-Skript, das neue Daten durch das Modell laufen lässt, um Anomalien zu erkennen, und bei Erkennung eines verdächtigen Musters eine Aktion auslöst.

  • Vorhersage-Skript (/opt/ml_security/scripts/predict.py):
    import pandas as pd
    from joblib import load
    import json
    import os
    # Modell laden
    model = load('/opt/ml_security/models/anomaly_detection_model.joblib')
    # Neue Daten laden (Beispielhaft von einer JSON Datei, diese könnte von Wazuh kommen)
    with open('/var/ossec/logs/alerts/alerts.json', 'r') as f:
        logs = json.load(f)
    # Daten vorbereiten (an dein Modell anpassen)
    df = pd.DataFrame(logs['data'])
    # Vorhersage durchführen
    predictions = model.predict(df[['feature1', 'feature2', 'feature3']])
    # Prüfen, ob Anomalien erkannt wurden
    if -1 in predictions:
        # Aktion bei Erkennung, z.B. einen Alarm auslösen
        os.system('sudo ufw deny from {}'.format(df['source_ip'][predictions == -1]))

Installation von ML-Modulen in Wazuh:

Um das ML-Modell in die Überwachung von Wazuh einzubinden, kann das Vorhersage-Skript als benutzerdefinierte Aktion konfiguriert werden, die ausgelöst wird, wenn bestimmte Log-Ereignisse erkannt werden. So findet die Integration in die Wazuh-Pipeline statt. Wazuh soll die Daten durch das KI-Modell analysieren, bevor Alarme ausgelöst werden.

  • Konfiguration in Wazuh (/var/ossec/etc/ossec.conf):
    <ossec_config>
      <rules>
        <rule id="100001" level="10">
          <decoded_as>json</decoded_as>
          <description>Suspicious activity detected by ML model</description>
          <options>no_full_log</options>
          <command>ml-predict</command>
        </rule>
      </rules>
      <commands>
        <command>
          <name>ml-predict</name>
          <executable>python3</executable>
          <expect>any</expect>
          <timeout_allowed>yes</timeout_allowed>
          <run_on>any</run_on>
          <args>/opt/ml_security/scripts/predict.py</args>
        </command>
      </commands>
    </ossec_config>

Wazuh neu starten

Starte den Wazuh-Manager neu, um die Änderungen zu übernehmen:

sudo systemctl restart wazuh-manager

Testen und Validieren

Nutze Python und spezialisierte Bibliotheken wie scikit-learn oder TensorFlow, um Bedrohungserkennungsmodelle zu erstellen.

System auf verdächtige Aktivitäten überwachen

Wazuh überwacht die Logs und führt das Vorhersage-Skript aus, wenn entsprechende Regeln ausgelöst werden.

Überprüfung der Reaktionen

Simuliere Angriffe oder Manipulationen im Netzwerk, um zu prüfen, ob das System Anomalien korrekt erkennt und die vordefinierten Maßnahmen wie das Blockieren verdächtiger IP-Adressen durchführt.

Optimierung des Modells

Je nach den Testergebnissen kann das ML-Modell weiter optimiert werden, indem es mit mehr Daten oder fortgeschritteneren Techniken neu trainiert wird. Dieses Skript nimmt Logs als Eingabe, führt eine Vorhersage durch und ergreift entsprechende Maßnahmen. In diesem Beispiel gehen wir davon aus, dass das Skript wie folgt aussieht:

  • Pfad zum Skript: /opt/ml_security/scripts/predict.py
  • Modellpfad: /opt/ml_security/models/anomaly_detection_model.joblib

Das Skript liest Log-Daten ein, führt eine Vorhersage durch und blockiert verdächtige IP-Adressen.

Erklärung einer Wazuh-Benutzerdefinierten Regel

Zuerst muss eine benutzerdefinierte Regel erstellt werden, die spezifische Muster in den Logs erkennt. Wenn diese Regel ausgelöst wird, wird das ML-Skript ausgeführt. Bearbeite oder erstelle eine benutzerdefinierte Regel in der Datei /var/ossec/etc/rules/local_rules.xml.

Beispiel:

<group name="ml-rules">
  <rule id="100001" level="10">
    <decoded_as>json</decoded_as>
    <description>Suspicious activity detected, invoking ML model</description>
    <options>no_full_log</options>
    <command>ml-predict</command>
    <group>json,ml</group>
  </rule>
</group>

Diese Regel identifiziert ein bestimmtes Muster in den Logs, das in JSON codiert ist, und wenn sie ausgelöst wird, führt sie den Befehl ml-predict aus.

Integration in Wazuh Commands

Nun muss man Wazuh anweisen, das ML-Skript auszuführen, wenn die Regel ausgelöst wird. Bearbeite die Datei /var/ossec/etc/ossec.conf und füge den folgenden Abschnitt unter <commands> hinzu:

<ossec_config>
  <commands>
    <command>
      <name>ml-predict</name>
      <executable>python3</executable>
      <expect>any</expect>
      <timeout_allowed>yes</timeout_allowed>
      <run_on>any</run_on>
      <args>/opt/ml_security/scripts/predict.py</args>
    </command>
  </commands>
</ossec_config>

Dieser Abschnitt definiert den Befehl ml-predict, der das Python-Skript predict.py ausführt. Wenn die oben definierte Regel ausgelöst wird, wird das ML-Skript automatisch durch Wazuh ausgeführt. Das Skript kann dann die entsprechenden Aktionen basierend auf den Vorhersagen des Modells durchführen, z.B. IP-Adressen blockieren, Warnungen ausgeben, etc.

Zusätzliche Überwachung und Integration

Dashboard für KI-gestützte Bedrohungen

Erstelle ein Dashboard in Kibana, das die Ergebnisse des ML-Modells anzeigt, einschließlich der Anzahl der Anomalien und der betroffenen IP-Adressen. Nachdem man Kibana erfolgreich installiert und konfiguriert hat wie oben angegeben, kann man mit der Erstellung von Dashboards beginnen:

Datenquelle konfigurieren In Kibana kann man Elasticsearch-Indizes als Datenquellen konfigurieren:

Navigiere zu:
    Management -> Stack Management -> Index Patterns
    Klicke auf "Create index pattern" und folge den Anweisungen, um einen neuen Index für deine Daten zu erstellen.

Dashboards erstellen Erstelle Dashboards, um die Daten zu visualisieren:

Navigiere zu: Dashboard -> Create new dashboard Füge Visualisierungen hinzu, indem du auf „Add“ klickst und die entsprechenden Datenquellen und Visualisierungstypen auswählst.

Alarmierungssystem

Integriere Benachrichtigungen (z.B. per E-Mail oder Slack) in Wazuh, um sofort informiert zu werden, wenn eine Anomalie erkannt wird.

Regelmäßige Modellaktualisierung

Erstelle ein Skript oder einen Cron-Job, der das ML-Modell regelmäßig mit neuen Daten neu trainiert, um es auf dem neuesten Stand zu halten.

Regelmäßige Wartung und Überwachung

  • Logs überwachen: Überwache regelmäßig die Logs in Kibana und Wazuh auf verdächtige Aktivitäten.
  • Sicherheitsregeln aktualisieren: Halte alle Sicherheitsregeln und Signaturen in Wazuh, Suricata, OSSEC und AIDE auf dem neuesten Stand.
  • Schulung und Awareness: Sorge dafür, dass das IT-Team kontinuierlich geschult wird, um neue Bedrohungen und Techniken zu erkennen.

Durch dieses Sicherheitssetup mit KI-Unterstützung kann man ein Netzwerk effektiv und anschaulich überwachen, Bedrohungen erkennen, automatisch darauf reagieren und Sicherheitsberichte erstellen. Die Integration von HIDS, SIEM, KI und Dateiintegritätsprüfung stellt sicher, dass das System einen ganzheitlichen Schutz vor einer Vielzahl von Bedrohungen bietet. Meine nächste Planung ist ein solches System als Docker Container zur einfacheren Verfügung zu bauen.