SIEM

Nutzen Sie unser SIEM, um Informationen über die Sicherheitslage Ihres IT-Netzwerks zu sammeln und zu analysieren

Sichern Sie Ihre Daten mit unserem leistungsstarken SIEM: Kontaktieren Sie unsere Experten über [email protected], um schnellstmöglich durchzustarten und erhalten Sie Unterstützung bei Ihrer Installation!

Aufbau

Vorbereitung

Bitte nutzen Sie für die Installation das bereitgestellte ISO mit Auswahl der Component Server Option. Damit sind alle für den SIEM-Betrieb benötigten Komponenten berücksichtigt.

Für die Installation des SIEMs benötigen Sie folgende Komponenten

Komponente

Anforderung

1x SIEM Management Server

4CPU, 8GB RAM, 200GB Disk (SSD empfohlen)

1X SIEM Index Server

4CPU, 8GB RAM, 200GB Disk (SSD empfohlen)

Dieses Setup ist ausschließlich für einen Workload von 10 GB Pro Tag ausgelegt! Falls Sie höhere Anforderungen haben, lassen Sie sich gern von uns individuell beraten.

Weiterhin müssen folgende Firewall Regeln freigegeben werden:
1. NGS APP Server -> SIEM Management Server - TCP/Port 443
2. SIEM Management Server - TCP/Port 8983 ->SIEM Index Server
3. INDEX-Server -> SIEM-Management TCP/2181

Erstellen Sie auf allen VMs einen Swap, sollten Sie diesen bisher nicht haben.

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
sudo cp /etc/fstab /etc/fstab.bak
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf
echo 'vm.vfs_cache_pressure=10' | sudo tee -a /etc/sysctl.conf

Erstellen Sie eine URL für Ihren SIEM Server z.B.: ngs-siem.ihre-domain.de. Für diese muss ein Zertifikat im PEM Format vorliegen. Nutzen Sie ein selbst signiertes Zertifikat beachten Sie bitte diese Anleitung.
Bitte verändern Sie nicht die unten bereitgestellten Docker Konfigurationen, da diese aufeinander abgestimmt sind.

Installation SIEM Management Server

Der SIEM Management Server empfängt die Logs über die API und sendet diese an den SIEM Index Server weiter, wo sie vearbeitet werden.

Hierfür werden folgende Komponenten installiert:

nginx
docker-ce
docker-ce-cli
containerd.io
docker-buildx-plugin
docker-compose-plugin
Enginsight Loggernaut

Docker installieren

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
    "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
    "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Regulieren Sie den Speicherbedarf der Docker Logs, in dem Sie diese wie folgt auf 100 Mb beschränken:
```
sudo nano /etc/docker/daemon.json
```
Fügen Sie folgendes ein:
```
{  
  "log-driver": "json-file",  
  "log-opts": {
    "max-size": "100m",
    "max-file": "30"  
  }
}
```
Starten Sie anschließend Ihren Docker Dienst neu:
```
sudo systemctl restart docker
```
Erstellen Sie einen Ordner für Docker und navigieren Sie in diesen
```
sudo mkdir /opt/enginsight/enterprise -p
cd /opt/enginsight/enterprise
```
Passen Sie die docker-compose.yml an
```
sudo nano docker-compose.yml
```

Ergänzen Sie folgende Konfiguration:

version: '3'
services:
  zoo:
    image: zookeeper:<AKTUELLE_ZOOKEEPER_VERSION>
    container_name: zookeeper
    restart: always
    volumes:
      - /var/zookeeper_data:/data
      - /var/zookeeper_logs:/logs
      - /var/zookeeper_datalog:/datalog
    ports:
      - <IP_VOM_SIEM_MANAGEMENTSERVER>:2181:2181
    environment:
      ZOO_AUTOPURGE_PURGEINTERVAL: 24
      ZOO_SERVERS: server.1=<IP_VOM_SIEM_MANAGEMENTSERVER>:2888:3888;2181
      ZOO_4LW_COMMANDS_WHITELIST: mntr,conf,ruok

Die <IPvomSIEMManagementServer> entspricht der internen IP Adresse des SIEM-Management Servers. Diese muss sowohl von dem Management Server, als auch von den anderen SIEM Index Server(n) erreichbar sein.

Legen Sie die Verzeichnisse an, die in der docker-compose definiert sind:

sudo mkdir /var/zookeeper_data
sudo mkdir /var/zookeeper_datalog
sudo mkdir /var/zookeeper_logs

Starten Sie den Docker Container.
```
sudo docker compose up -d
```
Prüfen Sie, ob Ihr Docker Container läuft.
```
sudo docker ps
```

nginx installieren

Installieren Sie nginx
```
sudo apt install nginx -y
```
Erstellen Sie Benutzername und Passwort für die Authentifizierung am SIEM Management Server.
```
curl -sSL https://get.enginsight.com/siem/scripts/basicauth.sh | sudo -E bash -s 
```
Hierbei werden Benutzername und Passwort automatisch generiert. (BasicAuth)
Sie erhalten folgenden Output:
```
{
  "siem": {
    "basicAuth": {
      "username":"<IHR_BENUTZERNAME>",
      "password":"<IHR_PASSWORT>"
    },
    ...
  }
}
```
Speichern Sie den Code ab, da Sie diesen später für die Anpassung des App Servers benötigen.

Passen Sie die nginx Konfiguration an.

Hierfür öffnen Sie die Konfiguration:

sudo nano /etc/nginx/sites-available/default

und passen diese wie folgt an:

upstream backend {
   server <IP_VON_SIEM_INDEXSERVER_1>:8983;
   server <IP_VON_SIEM_INDEXSERVER_2>:8983;
}


# nur relevant bei LetsEncrypt  
server {
    listen 80;
 
    location ~ /.well-known {
        allow all;
    }
 
    location / {
        return 302 https://<IHRE_SIEM_URL>/solr/;
    }
 
    root /var/www/<IHRE_SIEM_URL>;
 
    server_name <IHRE_SIEM_URL>;
}

server {
    listen 443 ssl http2;

    server_name <IHRE_SIEM_URL>;
 
    ssl_protocols TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";
    ssl_ecdh_curve secp384r1;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=300s;
    resolver_timeout 5s;
    
    #$ mkdir /etc/nginx/ssl -p
    #$ openssl dhparam -out /etc/nginx/ssl/dhparam.pem 2048 
    
    ssl_dhparam /etc/nginx/ssl/dhparam.pem;
    ssl_certificate /etc/letsencrypt/live/<IHRE_SIEM_URL>/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/<IHRE_SIEM_URL>/privkey.pem;
 
    client_max_body_size 1024m;
 
    auth_basic "Restricted Content";
    auth_basic_user_file /etc/nginx/.htpasswd;
 
    location ~* "^/v1/" {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host              $host;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-Proto "https";
        proxy_set_header X-Forwarded-Ssl   "on";
    }
 
    location / {
        proxy_pass http://backend;
        proxy_set_header Host              $host;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-Proto "https";
        proxy_set_header X-Forwarded-Ssl   "on";
    }
}

Überprüfen Sie die nginx Konfiguration:
```
sudo nginx -t
```
Starten Sie den nginx neu, um die Konfiguration zu übernehmen:
```
sudo systemctl restart nginx
```

Installation SIEM Index Server

Docker installieren

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
    "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
    "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Regulieren Sie den Speicherbedarf der Docker Logs, in dem Sie diese wie folgt auf 100 Mb beschränken:

sudo nano /etc/docker/daemon.json

Folgendes einfügen:

{  
  "log-driver": "json-file",  
  "log-opts": {
    "max-size": "100m",
    "max-file": "30"  
  }
}

Docker Dienst neustarten:

sudo systemctl restart docker

Erstellen Sie einen Ordner für Docker und navigieren Sie in diesen:
```
sudo mkdir /opt/enginsight/enterprise -p
cd /opt/enginsight/enterprise
```

Passen Sie die docker-compose.yml an:

sudo nano docker-compose.yml

Fügen und ergänzen Sie folgende Konfiguration:

version: '3'
services:
 solr:
    restart: always
    image: solr:9.3
    ports:
      - "<IP_VOM_SIEM_INDEXSERVER>:8983:8983"
    volumes:
      - /var/solr:/var/solr/data
    environment:
      - ZK_HOST=<IP_VOM_SIEM_MANAGEMENTSERVER>:2181
      - SOLR_HOST=<IP_VOM_SIEM_INDEXSERVER>
      - SOLR_OPTS=-XX:G1HeapRegionSize=32M -Dpkiauth.ttl=5000 -Dsolr.log.level=WARN
      - SOLR_JAVA_MEM=-Xms<40%_RAM_IN_GB>g -Xmx<50%_RAM_IN_GB>g
    command: solr -f -cloud

<IP_VOM_SIEM_INDEXSERVER> entspricht der IP, des SIEM Index Servers.
<IP_VOM_SIEM_MANAGEMENTSERVER> entspricht der IP des SIEM Management Servers.
<40%_RAM_IN_GB> (Startgröße des Heaps (-Xms)) geben Sie 40%Ihres gesamten RAMs gerundet in Gigabyte als Initialspeicherwert an.
<50%_RAM_IN_GB> (Maximalgröße des Heaps (-Xmx)) geben Sie 40%Ihres gesamten RAMs gerundet in Gigabyte als Maximalspeicherwert an.

Legen Sie Verzeichnisse an und vergeben Sie Rechte, um darauf zuzugreifen:
```
sudo mkdir /var/solr
sudo chown 8983:8983 -R /var/solr
```
Die Verwendung des Nutzers 8983 aus dem Docker-Container ist korrekt und bedeutsam. Führen Sie diesen Schritt zwingend durch, um die Installation erfolgreich durchführen zu können.
Starten Sie den Docker Container:
```
sudo docker compose up -d
```
Überprüfen Sie, ob der Port ausschließlich für die interne Adresse offen ist. Hier für können Sie dienet-toolsinstallieren (sudo apt install net-tools).
```
netstat -tulpen
```
Das Ergebnis sollte wie folgt aussehen:
```
Proto Recv-Q Send-Q Local Address           Foreign Address         State       User       Inode      PID/Program name       
tcp        0      <interneIP>:8983          0.0.0.0:*               LISTEN      0         
```
Achten Sie darauf, dass unter Host die richtige IP Adresse erscheint.
Sollten Sie einen zuzsätzlichen Indexserver installieren wollen, passen Sie bitte die Konfiguration, wie in Schritt 3 unter nginx installieren erklärt, an.

Anpassung APP Server

Passen Sie die Konfiguration des Enginsight APP Servers und den Zugriff an, um mit Ihrem SIEM Management Server zu kommunizieren.

Wechseln Sie in die Konfigurationsdatei:

sudo nano /opt/enginsight/enterprise/conf/services/config.json

Fügen Sie in die Konfiguration folgenden Abschnitt ein:
```
"siem": {
  "basicAuth": {
    "username": "",
    "password": ""
  },
  "url": "",
  "numShards": 2,
  "replicationFactor": 1,
  "management": {
    "organisation": "IHRE_ORGANISATIONS_ID"
  }
},
```
Füllen Sie "basicAuth" mit Ihren Credentials aus, die Sie im Proxy hinterlegt haben.
Bei der URL tragen Sie die URL des SIEMs Servers ein oder dessen IP Adresse.
numShards geben die absolute Anzahl der Shards an und sind für das parallele Abarbeiten der Anfragen zuständig. Hier sollten mindestens 2 angegeben werden. Bei größeren Instanzen empfiehlt es sich, etwa die Hälfte der verfügbaren CPU-Kerne als Wert zu wählen. Bei einem Server mit 8 Kernen wären das entsprechend 4. Der replicationFactor ist für die Replication verantwortlich. Die Daten werden auf mehreren Servern verteilt. Der Vorteil ist, dass die anderen Index Server bei einem Ausfall eingreifen können. Jedoch steigt der Verbauch des Speichers. Sie können, wenn gewünscht, die Anzahl Ihrer Index Server für die Replikation eintragen. Alternativ lassen Sie das auf 1.
Die organisation entspricht der Organsisations ID, welche die Verwaltung der SIEM Cluster übernimmt. Wählen Sie dafür eine Organisation (wir empfehlen Ihre "Hauptorga").

Fügen Sie in der Konfiguration unter "api" noch "url": "IHRE_API_URL ", hinzu. Sodass Ihre Konfiguration wie folgt aussieht:

"siem": {
  "basicAuth": {
    "username": "<IHR_USERNAME>",
    "password": "<IHR_PASSWORT>"
  },
  "url": "<IHRE_SIEM_URl>",
  "numShards": 2,
  "replicationFactor": 1,
  "management": {
    "organisation": "IHRE_ORGANISATION_ID"
  }
},
"api": {
  "url": "<IHRE_API_URL>",
  ...

Wechseln Sie ins Enginsight Verzeichnis und starten Sie die setup.sh
```
cd /opt/enginsight/enterprise
sudo ./setup.sh
```
Regulieren Sie den Speicherbedarf der Docker Logs, in dem Sie diese wie folgt auf 100 Mb beschränken:
```
sudo nano /etc/docker/daemon.json
```
Fügen Sie folgendes ein:
```
{  
  "log-driver": "json-file",  
  "log-opts": {
    "max-size": "100m",
    "max-file": "30"  
  }
}
```
Starten Sie anschließend den Docker Dienst neu:
```
sudo systemctl restart docker
```
Stellen Sie einen Access Key für den SIEM Management Server aus.

Loggernaut installieren

Der Loggernaut dient dazu die Logs entgegen zu nehmen und zu verarbeiten

Loggen Sie sich auf Ihrem SIEM Management Server ein

Installieren Sie den Loggernaut wie folgt:

curl -sSL https://get.enginsight.com/loggernaut/latest/setup.sh | sudo -E bash -s \
    api=https://<API_URL> \
    accessKeyId=<ACCESS_KEY_ID> \
    accessKeySecret=<ACCESS_KEY_SECRET> \
    indices=http://<SIEM_INDEX_SERVER>:8983 \
    username=<IHR_USERNAME> \
    password=<IHR_PASSWORT>

Der Login mittels Username und Passwort erfolgt über Basic Authentification.

Wechseln Sie in die Enginsight Instanz und klicken Sie in den Reiter "SIEM". Die Oberfläche baut eine Verbindung zu den Servern auf, das kann einige Sekunden dauern.

BETA - Installation SIEM KI

Um die Funktionalitäten in der SIEM KI verwenden zu können, bedarf es einiger Konfigurationen.

Hierbei handelt es sich um eine Betafunktionalität. Bitte beachten Sie, dass es bei Vorhersagen der Metriken und der daraus resultierenden Anomalie-Erkennung vereinzelt zu Fehlern kommen kann.

Betroffene Komponenten updaten.
1. ui-m1
2. server-m2
3. loggernaut-m47
  Die aktuellen Versionen der einzelnen Komponenten finden Sie immer hier:
  https://github.com/enginsight/enterprise/blob/master/docker-compose.yml
Experimentellen ML Modus im Loggernaut aktivieren.
Passen Sie dazu die Konfigurationsdatei unter /opt/enginsight/loggernaut/config.json an, indem sie folgende Zeile auf Root Ebene hinzufügen:
```
"experimental": ["traicer"]
```
Starten Sie den Loggernaut danach neu um die Konfiguration zu übernehmen.
```
sudo systemctl restart ngs-loggernaut.service
```

Docker installieren.

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
    "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
    "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Regulieren Sie den Speicherbedarf der Docker Logs, Beschränken Sie diese wie folgt auf 100 Mb:

sudo nano /etc/docker/daemon.json

Folgendes einfügen:

{  
  "log-driver": "json-file",  
  "log-opts": {
    "max-size": "100m",
    "max-file": "30"  
  }
}

Docker Dienst neustarten:

sudo systemctl restart docker

Docker Compose anlegen.

Folgendes muss in der docker-compose.yml enthalten sein:

version: '3'
services:
  traicer:
    image: registry.enginsight.com/enginsight/traicer-m50:0.0.3
    restart: always
    volumes:
      - /var/traicer/data:/traicer/data
    environment:
      ADDRESS: 'wss://<SIEM_MANAGEMENT_ADRESSE>/v1/traicer'
      BASIC_AUTH_USER: '<SIEM_BASIC_AUTH_USER>'
      BASIC_AUTH_PASSWORD: '<SIEM_BASIC_AUTH_PASSWORD>'

Sollte das Machine Learning auf der selben Machine wie der Loggernaut laufen und zu große CPU Last erzeugen, sodass der Loggernaut den Logdurchsatz nicht mehr händeln kann, empfehlen wir die CPU-Shares des Containers zu reduzieren, damit andere Prozesse eine höhere Priorität haben.

Hierfür ist diese Anpassung an der docker-compose.yml notwendig:

version: '3'
services:
  traicer:
    cpu_shares: 512

Anpassungen an Nginx Config vom Management Server für Websocket Support.

Passen Sie folgende Datei an: /etc/nginx/sites-available/default

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

...

server {
  ...
  
  proxy_http_version 1.1;

  ...

  location ~* "^/v1/" {
    ...
    
    proxy_set_header Upgrade           $http_upgrade;
    proxy_set_header Connection        $connection_upgrade;

    ...
  }
}

Überprüfen Sie die Config auf Fehler:

sudo nginx -t

Starten Sie nginx neu um die Config zu übernehmen:

sudo systemctl restart nginx

Stellen Sie sicher, dass Sie über root-Rechte verfügen. Sollte dies nicht der Fall sein, melden Sie sich als Superuser an.
```
su - root
```
Stellen Sie sicher, dass die aktuelle Version von Docker und Docker Compose installiert ist. Die aktuellen Versionsnummern finden Sie hier: Docker Engine, Docker Compose. Je nach verwendeter Installation kann der Befehl für Docker Compose variieren:
```
docker compose version
```
oder
```
docker-compose -v
```
Installieren Sie Docker nicht über Snap oder bei der Installation des Betriebssystems, sondern installieren Sie Docker ausschließlich aus den Paketquellen der offiziellen Anleitung.
Loggen Sie sich bei Docker ein.
```
docker login registry.enginsight.com
```
Die Zugangsdaten erhalten Sie von uns.
Wenn es bei der Authentifizierung zu Problemen kommt, überprüfen Sie, ob ein aktueller gpg2 Key vorliegt und generieren Sie ihn gegebenenfalls automatisch:
apt install gnupg2
gpg2 --gen-key
Starten Sie den Container mit den eben durchgeführten Anpassungen.
```
sudo docker compose up -d
```
Starten Sie abschließend die update.sh, um Konfigurationsfehler auszuschließen.
```
sudo /opt/enginsight/traicer/update.sh
```

Mögliche Probleme:

Sollte Ihnen die Plattform anzeigen, dass sie keine Verbindung herstellen konnte, prüfen Sie bitte folgende Punkte:

Kann der APP Server den SIEM Management Server erreichen? Testen Sie dies mittels curl. Hierbei muss Status Code 200 zurückkommen
```
curl -v -u "<BENUTZERNAME>:<PASSWORT>" <IHRE_SIEM_DOMAIN>/v1/collections
```
Kann der SIEM Server den APP Server erreichen?
Wurden alle Firewall Freigaben aus dem Punkt Vorbereitung gesetzt?

Selbstsignierte Zertifikate:

Sollten Sie für Ihre SIEM URL ein selbstsigniertes Zertifikat oder eine Windows PKI nutzen, müssen Sie das root Zertifikat zunächst auf dem SIEM Management sowie auf dem App Server trusten. Weiterhin benötigt es eine Anpassung in der docker-compose.yml des App Servers.

Trusten Sie Ihr Zertifikat. Kopieren Sie ihr root Zertifikat auf dem SIEM Management nach /usr/local/share/ca-certificates/ und updaten Sie den CA Store sudo cp foo.crt /usr/local/share/ca-certificates/foo.crt sudo update-ca-certificates

ca.crt bitte durch den Namen Ihres Root Zertifikats ersetzen.

Wiederholen Sie dies für den App Server.

Passen Sie die docker-compose.yml auf dem App Server an. Navigieren Sie in den Ordner /opt/enginsight/enterprise auf dem App Server und öffnen Sie die Datei mittels:

sudo nano docker-compose.yml

Ergänzen Sie unter environment: und volumes: folgendes:

environment:
- NODE_EXTRA_CA_CERTS=/etc/ssl/cert.pem
volumes:
- "./conf/services/config.json.production:/etc/enginsight/server-m2/config.json"
- "/usr/local/share/ca-certificates/foo.crt:/etc/ssl/cert.pem"

Der Pfad /etc/nginx/cert.pem:/etc/ssl/cert.pem teilt sich wie folgt auf:

Links: Pfad der Chain auf dem Server Rechts: Pfad im Docker Container

Traicer Fehlerbehebung

Falls Sie selbstsignierte Zertifikate verwenden oder im Traicer-Log ein Fehler wie der Folgende auftritt, müssen Sie die Zertifikate explizit an den Traicer-Container übergeben.

manager.py:468: failed connecting to wss://<URL>/v1/traicer due to [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: self-signed certificate in certificate chain (_ssl.c:1000). Retrying in 0:00:12

Befolgen Sie hierfür die weiteren Schritte:

Anpassung der docker-compose.yml
Ergänzen Sie die docker-compose.yml, um das Zertifikat in den Container zu mounten und die notwendige Umgebungsvariable zu setzen. Ein Beispiel für die Konfiguration des Traicer-Dienstes:
```
traicer:
  image: registry.enginsight.com/enginsight/traicer-m50:0.0.3
  restart: always
  volumes:
    - /var/traicer/data:/traicer/data
    - /path/to/your/certificate.pem:/etc/ssl/cert.pem
  environment:
    ADDRESS: 'wss://<URL>/v1/traicer'
    BASIC_AUTH_USER: '<USER>'
    BASIC_AUTH_PASSWORD: '<PASSWORT>'
    EXTRA_CA_CERTS: /etc/ssl/cert.pem
```
Erläuterung:
- <path/to/your/certificate.pem>: Ersetzen Sie dies durch den Pfad zu Ihrem Zertifikat.
- EXTRA_CA_CERTS: Diese Umgebungsvariable gibt an, wo sich die zusätzlichen Zertifikate im Container befinden.
- ADDRESS ohne doppeltes https://: Stellen Sie sicher, dass der Wert korrekt ist. Ein häufiger Fehler ist: Falsch: wss://https://<url>/v1/traicer Richtig: wss://<url>/v1/traicer.
Container neu starten
Führen Sie nach der Anpassung den folgenden Befehl aus, um die Änderungen anzuwenden:
```
sudo docker-compose up -d
```

Fügen Sie die ersten Logs hinzu:

Sie werden zu Beginn feststellen, dass das SIEM sich bereits mit Logs füllt. Diese kommen standardmäßig aus dem IDS, IPS, FIM, etc. Die Quellen können Sie unter SIEM -> Data Lake -> ngs.source einsehen.

Logs vom Agent

Um die Logs, wie Syslog (Linux), EventLog (Windows) und Unified Logs (MacOs) zu erhalten, müssen Sie dies zunächst im Policy Manager erlauben. Navigieren Sie hierfür zu Hosts -> Policy Manager und erstellen Sie eine neue Policy namens SIEM.

Bestimmen Sie mittels Tags, welcher Host Logs schicken darf und aktivieren Sie unter Erweiterte Einstellungen "Auswertung von Systemlogs erlauben".

Navigieren Sie nun zurück in den Reiter SIEM. Unter Integrierte Kollektoren finden Sie die einzelnen Betriebssysteme. Hier können Sie oben rechts einen neuen Kollektor hinzufügen.

Vergeben Sie einen Namen für das jeweilige Betriebssystem was geloggt werden soll. Aktivieren Sie das Logging und ordnen Sie es einem Tag zu. Im Anschluss können Sie die Kanäle auswählen, über die die Logs gesammelt werden sollen.

Anbindung von Geräten, ohne Agent (z.B. Firewall)

Sie können an das SIEM auch Geräte anbinden, welche keinen Agent installiert haben. Hierfür definieren Sie einen Agent, welcher die Logs einsammeln soll. Navigieren Sie dafür in das SIEM -> Event Relais.

Wählen Sie einen Namen, mit der Sie eindeutig Ihren Kollektor identifizieren können. Aktivieren Sie erneut das Logging und definieren Sie unter Host einen Client oder Server, welcher die Logs von dem Gerät (z.B.) Firewall entgegen nehmen soll. Wählen Sie zudem das Format aus und entscheiden Sie, über welchen Port und welchem Protokoll die Daten gesendet werden sollen.

Es ist möglich mehrere Kollektoren zu konfigurieren. Das ist vor allem bei mehreren Netzen sinnvoll, um keine neuen Firewall Regeln konfigurieren zu müssen, da pro Netz ein Kollektor genutzt werden kann.

VorherigeLoad Balancing NächsteDeinstallation

Zuletzt aktualisiert vor 4 Tagen

War das hilfreich?