bruneaug/dshield-siemRaccolta log sensore DShield con ELK
Questa è una fork e un aggiornamento significativo rispetto alla pubblicazione iniziale sul sito dell'ISC Storm Center di Scott Jensen come documento BACS e agli script pubblicati su Github.
https://github.com/fkadriver/Dshield-ELK
https://isc.sans.edu/diary/DShield+Sensor+Monitoring+with+a+Docker+ELK+Stack+Guest+Diary/30118
Questa è un buon riferimento su come usare DShield-SIEM per l'analisi: https://isc.sans.edu/diary/30962/
Questo fornisce una panoramica su come viene effettuata la raccolta dei log con il sensore DShield.
https://github.com/bruneaug/DShield-SIEM/blob/main/Troubleshooting/DShield-SIEM-Flow.png
Questo docker è costruito su misura per essere utilizzato con il DShield Honeypot per raccogliere e analizzare i log e raccogliere i dati per renderli facilmente ricercabili per scopi di ricerca. L'installazione consigliata prevede di installare il sensore DShield su un Raspberry Pi con Raspbian OS o su un sistema con Ubuntu 24.04 LTS, sia nella propria rete che nel cloud di propria scelta.
Nota: Questo deve essere installato su un server separato come indicato di seguito.
Nota: Per aggiornare i componenti del server ELK, seguire questi passaggi:
https://github.com/bruneaug/DShield-SIEM/blob/main/README.md#download-github-update
Installare docker come utente ($):````
sudo apt-get install ca-certificates curl gnupg network-manager txt2html
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
Note: You may need to take the next line, remove the backlash () and put everythin in a single line in Notepad to run this echo.
echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu
"$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update && sudo apt upgrade
sudo reboot (if update were applied)
sudo apt-get install -y jq docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin pip
sudo systemctl enable docker
sudo systemctl start docker.service
Conferma che il servizio docker sia in esecuzione<br>````
sudo systemctl status docker.service
Aggiungi i seguenti nomi server ELK es01 kibana fleet-server heartbeat logstash filebeat filebeat01
a /etc/hosts dopo l'indirizzo IP e il nome server:
````
sudo vi /etc/hosts
Aggiungi questo a /etc/hosts dopo gli indirizzi IP del server ELK<br>
127.0.0.1 sensor es01 ...<br>
192.168.25.80 sensor es01 ...<br>````
es01 kibana fleet-server heartbeat logstash filebeat filebeat01
Modifica il file sysctl.conf:
````
sudo vi /etc/sysctl.conf
Aggiungi quanto segue in fondo al file:<br>````
vm.max_map_count=262144
Aggiungi e salvalo. Questo è per Elasticsearch quando si usa Docker.
sudo iptables -nL
# Configura e installa DShield ELK
Usando l'account utente ($), esegui i seguenti comandi:<br>````
git clone https://github.com/bruneaug/DShield-SIEM.git
mkdir scripts
mv DShield-SIEM/AddOnScripts/*.sh scripts
chmod 754 scripts/*.sh
cd ~/DShield-SIEM
Nota: Prima dell'installazione, puoi modificare il file .env (ls -la per vederlo) per apportare le modifiche desiderate.
- La password predefinita corrente per elastic è student
I limiti di memoria in .env sono la quantità massima di memoria che docker allocherà per ciascuno dei container ELK.
Di default è 3GB per Elasticsearch, ma può essere ampliata se hai le risorse necessarie
Modifica il file .env e configuralo per il tuo stack ELK.
````
vi .env
- Aggiorna le seguenti variabili nel file **.env** per adattarle alle informazioni DNS, hostname, IP e alla password Elastic predefinita del tuo server ELK, se desideri modificarle: <br>
- HOSTNAME="ubuntu"
- DNS_SERVER="9.9.9.9"
- IPADDRESS="192.168.25.231"
- ELASTIC_PASSWORD=student
- ES_MEM = Elasticsearch -> 4g, KB_MEM = Kibana -> 2g
- Se desideri modificare le informazioni predefinite sui nameserver e la posizione della tua rete privata locale per l'indirizzo di destinazione (ad es. mappatura sensore DShield - attualmente impostata per **Ottawa, Canada**), modifica la seguente directory per i file prima di caricare docker:<br>````
cd logstash/pipeline
Modifica heartbeat.yml per cambiare l'IP del sensore (denominato PI) con il tuo IP del sensore. Kibana heartbeat controlla lo stato dei tuoi servizi e determina se sono disponibili.
Aggiorna questo IP e hostname per adattarli al tuo sensore.
Nota: Puoi copiare e aggiungere le stesse 5 righe se hai più di un sensore che desideri monitorare
Questo può essere visualizzato in Observability -> Uptime Monitors
Questa riga è l'indirizzo IP del sensore. Se non riceve una risposta durante la connessione a TCP 12222, lo contrassegnerà come down nell'interfaccia.
Questa operazione viene avviata dal server ELK per verificare la risposta del sensore.
Aggiorna questa riga: hosts: ["192.168.25.165"]
````
vi ~/DShield-SIEM/heartbeat/heartbeat.yml
Lo script **change_perms.sh** configurerà alcuni dei file prima di avviare l'installazione dei componenti docker.<br>
Lo script aggiornerà anche l'indirizzo IP utilizzato nella query della dashboard all'IP del tuo stack ELK.<br>````
~/scripts/change_perms.sh
~/scripts/get_researchers.sh
Ora esegui docker compose per creare le applicazioni del server ELK.
Questo creerà: Kibana, Elasticsearch, elastic-agent, Logstash e caricherà i parser di Cowrie, i file di configurazione e la dashboard.
````
sudo docker compose up -d
Installazione completata
<img width="375" height="354" alt="image" src="https://assets.kitploit.com/production/public/readmes/50066/b192e2cc430ca7eaa43934ebde637400b29d23212dce39e81f521b0806df1bc0.png" />
# Aggiungi ca.crt ai certificati attendibili del server
- Aggiungi ca.crt all'elenco dei certificati attendibili del server```
sudo cp /var/lib/docker/volumes/dshield-elk_certs/_data/ca/ca.crt /usr/local/share/ca-certificates/dshield.crt
```
- Aggiorna i certificati attendibili ```
sudo update-ca-certificates
```
### Aggiunta di dashboard e firme SIEM a Kibana
Questo carica le dashboard del SIEM DShield e le firme SIEM in Kibana.<br>```
~/scripts/dashboard-setup.sh
```
### Elenco delle directory Docker
Questo comando mostra l'elenco delle directory Docker in uso dopo che tutti i componenti di Elasticsearch sono stati installati.<br>
Man mano che i dati vengono aggiunti a Elasticsearch, puoi anche monitorare, tramite il comando seguente o all'interno di ELK, la quantità di disco disponibile per l'archiviazione.<br>````
sudo du --human-readable --max-depth 1 --no-dereference --one-file-system /var/lib/docker
Usando netstat, questi 4 servizi dovrebbero ora essere in ascolto.
```
netstat -an | grep '80|9200|9300|8220|5601|5044|5066|5067|5068|9600'
<pre>
tcp 0 0 0.0.0.0:80 0.0.0.0:* LISTEN ---> Local CyberChef
tcp 0 0 0.0.0.0:5601 0.0.0.0:* LISTEN ---> Kibana Web Access
tcp 0 0 0.0.0.0:8080 0.0.0.0:* LISTEN ---> Local Attack Navigator
tcp 0 0 0.0.0.0:8220 0.0.0.0:* LISTEN ---> elastic-agent Service
tcp 0 0 0.0.0.0:9200 0.0.0.0:* LISTEN ---> Elasticsearch Service
tcp 0 0 0.0.0.0:9300 0.0.0.0:* LISTEN ---> Elasticsearch Cluster Service
tcp 0 0 0.0.0.0:5044 0.0.0.0:* LISTEN ---> Logstash Data Collection
tcp 0 0 0.0.0.0:5066 0.0.0.0:* LISTEN ---> Metricbeat Stack Node Information
tcp 0 0 0.0.0.0:5067 0.0.0.0:* LISTEN ---> Filebeat Stack Node Information
tcp 0 0 0.0.0.0:5068 0.0.0.0:* LISTEN ---> Filebeat Stack Node Information (Process ISC Threat Intel to Logstash)
tcp 0 0 0.0.0.0:9600 0.0.0.0:* LISTEN ---> Logstash Stack Node and Pipeline Information
tcp6 0 0 :::80 :::* LISTEN
tcp6 0 0 :::5601 :::* LISTEN
tcp6 0 0 :::8080 :::* LISTEN
tcp6 0 0 :::8220 :::* LISTEN
tcp6 0 0 :::9200 :::* LISTEN
tcp6 0 0 :::9300 :::* LISTEN
tcp6 0 0 :::5044 :::* LISTEN
tcp6 0 0 :::5066 :::* LISTEN
tcp6 0 0 :::5067 :::* LISTEN
tcp6 0 0 :::5068 :::* LISTEN
tcp6 0 0 :::9600 :::* LISTEN
</pre>
# Caricamento dei modelli Filebeat predefiniti in Kibana
Questo installerà i modelli e le dashboard predefiniti che possono essere utilizzati per memorizzare i dati netflow provenienti dai sensori DShield remoti.<br>
Affinché Logstash inizi a memorizzare i dati, è necessario eseguire i seguenti comandi. Il primo passo è accedere a filebeat:<br>````
sudo docker exec -ti filebeat bash
Successivamente, esegui questo comando Filebeat per caricare i template in Kibana:
````
./filebeat setup -e
# Accesso all'interfaccia di Kibana
Dopo che docker ha terminato l'installazione di tutti i componenti docker ELK, ora è il momento di accedere allo stack ELK utilizzando l'IP del server Ubuntu.<br>
- Accedi a Kibana con nome utente: **elastic** e password predefinita _se non è stata cambiata_: **student**<br>
Accesso Web: https://serverIP
# Configurazione della gestione dello stack ELK
Per visualizzare lo stato di salute dello stack ELK, è necessario configurare il monitoraggio dello stack navigando fino a: Management -> Stack Monitoring<br>
- Questo passaggio è necessario solo se l'installazione non ha configurato automaticamente Stack Monitoring<br>
- Seleziona "_Or, set up with self monitoring_"<br>
- Il monitoraggio è attualmente disattivato -> Seleziona: _Turn on monitoring_<br>
# Configurazione del fleet-agent
Il fleet-agent (ovvero un elastic-agent in esecuzione sullo stack ELK) verrà utilizzato per acquisire threat intelligence.<br>
- Dal menu a discesa, seleziona Management → Fleet →Settings → Edit Outputs (Actions)<br>
- Accedi al server via SSH<br>
- Copia il certificato ca.crt in /tmp<br>````
sudo cp /var/lib/docker/volumes/dshield-elk_certs/_data/ca/ca.crt /tmp
- L'output sarà simile a questo:<br>
673FB617E15CCCE73F9B647EF99449642A19CFC1D75BF5772047DA99DB950844
- Ottieni il contenuto del certificato CA di Elasticsearch da applicare alla configurazione YAML avanzata. Digita il comando perché non si copia bene<br>````
sudo cat /tmp/ca.crt | sed -r 's/(.*)/ \1/g'
Segui l'esempio della guida Troubleshooting fleet-server-examples riportata nell'URL sopra per il formato corretto.
sed aggiungerà i 4 spazi con il comando precedente al certificato CA
Dopo aver aggiunto le informazioni sul certificato, salva e applica queste impostazioni.
Poi Save and deploy
In Settings, configura gli host del Fleet server tramite Edit oppure Add Fleet Server configurato come segue:
La fase successiva è selezionare Agent Policy → Add Agent → Enroll in Fleet → Add Fleet Server
Avremo bisogno di queste informazioni per configurare il nostro fleet server.
Accedi via SSH al fleet-server e assicurati che il fleet-server sia in esecuzione prima di configurare il nostro agente:
````
sudo docker exec -ti fleet-server bash
./elastic-agent status (check it is running)
./elastic-agent restart (if it doesn't appear to be running, force a restart, and recheck the status)
Questo è un esempio di ciò che deve essere copiato nel fleet server. Assicurati che l'ES del fleet server sia: https://es01:9200<br>
Aggiungi la sezione in grassetto dopo port=8220 perché i certificati sono autogenerati. Questo garantirà che l'agente riceva l'aggiornamento.<br>
Il token e l'impronta digitale saranno diversi da questo esempio<br>
Copia l'elastic-agent di enrol qui sotto e sostituisci queste 2 righe prese dal tuo server, tutto il resto rimane uguale.<br>
<pre>
--fleet-server-service-token=AAEAAWVsYXN0aWMvZmxlZXQtc2VydmVyL3Rva2VuLTE3MzEwOTcwODU3MzI6VjMyLU13cmFUOUM1eUFvMUhVUFl5QQ \
--fleet-server-es-ca-trusted-fingerprint=0D9A25F4C147EB3A496253525DF6F039CF3C19776E64A1F77CEFCCD08B76BC61 \
</pre>
Mentre sei connesso al fleet-agent, registra l'elastic-agent nel tuo fleet-agent:
Usa questo modello per installare il tuo certificato e assicurati di sostituirlo con il tuo<br>
fleet-server-service-token & fleet-server-es-ca-trusted-fingerprint<br>````
elastic-agent enroll \
--url=https://fleet-server:8220 \
--fleet-server-es=https://es01:9200 \
--fleet-server-service-token=AAEAAWVsYXN0aWMvZmxlZXQtc2VydmVyL3Rva2VuLTE3MzEwOTcwODU3MzI6VjMyLU13cmFUOUM1eUFvMUhVUFl5QQ \
--fleet-server-policy=fleet-server-policy \
--fleet-server-es-ca=/certs/es01/es01.crt \
--fleet-server-es-ca-trusted-fingerprint=0D9A25F4C147EB3A496253525DF6F039CF3C19776E64A1F77CEFCCD08B76BC61 \
--fleet-server-port=8220 \
--certificate-authorities=/certs/ca/ca.crt \
--fleet-server-cert=/certs/fleet-server/fleet-server.crt \
--fleet-server-cert-key=/certs/fleet-server/fleet-server.key \
--elastic-agent-cert=/certs/fleet-server/fleet-server.crt \
--elastic-agent-cert-key=/certs/fleet-server/fleet-server.key \
--fleet-server-es-cert=/certs/fleet-server/fleet-server.crt \
--fleet-server-es-cert-key=/certs/fleet-server/fleet-server.key
Questa operazione sostituirà le impostazioni correnti. Vuoi continuare? [Y/n]: Y
Agente Elastic registrato con successo.
Dalla tua posizione attuale, verifica che sia stato installato correttamente
````
./elastic-agent status
./elastic-agent restart (if you got what appears to be errors, force a restart and check the status)
Ora che il Fleet Server è connesso, chiudi questa finestra e procediamo al passaggio successivo.
In Elastic Management → Fleet, aggiorna gli Agents e questo è ciò che appare:
Il server è ora pronto per installare gli agenti Threat Intel da utilizzare in Security (parte SIEM) contro i log dell'honeypot.<br>
Il passo successivo è selezionare Agent policies → Fleet Server Policy → Add integration:<br>
Usa questa Dashboard per visualizzare le metriche raccolte da elastic-agent:<br>
- Seleziona e aggiungi AlienVault OTX (è necessaria una chiave API)<br>
- Seleziona AbuseCH (è necessaria una chiave API)<br>
- Seleziona Threat Intelligence Utilities<br>
- Elasticsearch<br>
- Seleziona Kibana<br>
- Seleziona Docker<br>
# Esempio di Fleet Server Policy
- In Elastic Management → Installed Integration<br>
- Seleziona ciascuna integrazione installata, poi seleziona Settings e abilita la scheda per _mantenere la policy aggiornata_:<br>
## Configurazione di Security → Rules
- Seleziona Rules → Detection rules (SIEM) → Add Elastic rules
- In Search Tags: Rule Type: Threat Intel (aggiungi almeno queste 4 regole)
- Installa e abilita queste 4 regole
- Threat Intel Indicator Match - Cowrie (regola personalizzata caricata e abilitata quando docker carica tutti i componenti dello stack ELK)
- Threat Intel Windows Registry Indicator Match
- Threat Intel Hash Indicator Match
- Threat Intel URL Indicator Match
- Puoi esaminare le regole e abilitare quelle altre che desideri provare sui dati del tuo honeypot.<br>
## Revisione dell'attività catturata dalle regole nel trend degli Alert
Se alcuni dei threat intel di cui sopra sono stati aggiunti a elastic-agent, e cowrie* è stato aggiunto a Management -> Advanced Settings durante l'installazione iniziale, ora può tracciare le regole che corrispondono nei trend degli alert della parte SIEM dello stack ELK.<br>
Questo è l'output da Management → Stack Management → Advanced Settings<br>
Se viene trovata una corrispondenza con un threat intel, il SIEM mostrerà la seguente attività che ora può essere investigata:<br>
# Configurazione di Filebeat su DShield Sensor - Log verso ELK
Il passo successivo è aggiungere il pacchetto Filebeat al DShield Sensor per inviare i log a Elasticsearch.<br>
Utilizza i seguenti passaggi per installare Filebeat usando i comandi seguenti presi da questo riferimento [3]: <br>````
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
sudo apt-get install apt-transport-https
echo "deb https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-8.x.list
echo "deb https://artifacts.elastic.co/packages/oss-8.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-8.x.list
sudo apt-get update
Dopo l'installazione, mettiamo un hold su filebeat in modo da poter aggiornare il sensore senza cambiare la versione di filebeat. La versione di filebeat
dovrebbe sempre corrispondere alla versione docker di Elasticsearc/Kibana.
Linux - X86_64```
wget https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-8.19.15-amd64.deb
sudo apt install ./filebeat-8.19.15-amd64.deb
sudo apt-mark hold filebeat
<ins>PI - aarch64</ins>```
wget https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-8.19.15-arm64.deb
sudo apt install ./filebeat-8.19.15-arm64.deb
sudo apt-mark hold filebeat
Per aggiornare filebeat, quando arriverà il momento, dovrai rimuovere l'hold. Controlla prima se c'è un hold su filebeat prima di rimuoverlo
```
sudo apt-mark showhold
sudo apt-mark unhold filebeat
Se vuoi usare Zeek sul tuo sensore DShield, consulta questi passaggi di installazione [passaggi](https://github.com/bruneaug/DShield-SIEM/blob/main/AddOn/Configure_Zeek_DShield_Sensor.md)
### Configurazione del sensore cloud - Filebeat -> Router domestico -> Logstash
Per connetterti da un sensore cloud al tuo ELK Stack locale, devi fare quanto segue:
- Configura il router di casa per fare NAT verso l'indirizzo IP locale del tuo ELK Stack<br>
- Usa l'indirizzo IP del router (ti consiglio di aggiungere un hostname al tuo IP di casa nel caso cambi) dal tuo sensore per connetterti al router di casa<br>
- La connessione finale dovrebbe essere così: sensore -> IP del router NAT -> ELK Stack
### Trasferisci tutti i file del sensore al DShield Sensor
Segui questo URL per scaricare tutti i file relativi al DShield Sensor<br>
https://github.com/bruneaug/DShield-Sensor````
git clone https://github.com/bruneaug/DShield-Sensor.git
sudo cp ~/DShield-Sensor/filebeat/filebeat.yml /etc/filebeat/filebeat.yml
output.logstash:<br>
hosts: ["192.168.25.23:5044"]<br>
#hosts: ["logstash.com:5044"]<br>
### Risoluzione dei problemi di Filebeat````
sudo su -
filebeat test config
Output previsto: Config OK
````
filebeat test output
<pre>
logstash: 192.168.25.231:5044...
connection...
parse host... OK
dns lookup... OK
addresses: 192.168.25.231
dial up... OK
TLS... WARN secure connection disabled
talk to server... OK
</pre>
## Avvia Filebeat````
sudo systemctl enable filebeat
sudo systemctl start filebeat
sudo systemctl status filebeat
Filebeat tiene traccia degli eventi che ha elaborato tramite un file chiamato log.json; se viene eliminato, tutti gli eventi precedentemente inviati a Elasticsearch verranno rielaborati al riavvio di filebeat.
La posizione di questo file:
sudo su -````
cd /var/lib/filebeat/registry/filebeat
Se hai intenzione di reinviare tutti i log perché il tuo server ELK è stato ricostruito, _arresta filebeat, elimina log.json e riavvia filebeat_.
Di solito ci vorrà un po' di tempo prima che la dashboard della ELK Stack si aggiorni. Se vuoi verificare se sta inviando i log alla ELK Stack, puoi<br>
- tail -f log.json
- Cerca gli ultimi 30 giorni nella dashboard mentre si aggiorna
# Interface - Logs DShield Sensor Overview
Per accedere alla Dashboard seleziona Analytics -> Dashboard -> **[Logs DShield Sensor] Overview**<br>
## Aggiunta di ca.crt al browser della workstation
Segui i passaggi in questa [Pagina](https://github.com/bruneaug/DShield-SIEM/blob/main/AddOn/Workstation_Browser_CA_Certificate.md) per aggiungere a Kibana il ca.crt utilizzato dal server ELK.<br>
# Comandi Docker utili
Fai riferimento a questa pagina per un elenco di comandi docker utili.<br>
https://github.com/bruneaug/DShield-SIEM/edit/main/Troubleshooting/docker_useful_commands..md
# Informazioni su Elastic con la Console
Questi comandi vengono eseguiti da Dev Tool -> Console<br>
GET _nodes/http?pretty (Ottieni un elenco e informazioni su tutti i nodi)<br>
GET _security/_authenticate<br>
GET /_cat/nodes?v=true<br>
# Script di analisi DShield e codice degli studenti
Questa è un elenco di script e codice che gli studenti del programma BACS hanno scritto per aiutare nell'analisi dei log.<br>
Jesse La Grew [cowrieprocessor](https://github.com/jslagrew/cowrieprocessor)<br>
jrjobe [DShield-Cowrie-json-Parser](https://github.com/jrjobe/DShield-Cowrie-json-Parser)<br>
ham-sauce [vt_cowrie](https://github.com/ham-sauce/vt_cowrie)<br>
NickTheSecurityDude [dshield-honeypot-scripts](https://github.com/NickTheSecurityDude/dshield-honeypot-scripts/tree/main) e [Post LinkedIn](https://www.linkedin.com/pulse/how-i-used-honeypot-track-analyze-cyberattacks-nicholas-gilbert-jcste)<br>
Josh Gilman [DShieldKickStarter](https://github.com/iamjoshgilman/DShieldKickStarter)<br>
kcustom11 [dshield-azure](https://github.com/kcustom11/dshield-azure) Azure Terraform<br>
Boggby [ec2-honeypot-template](https://github.com/Boggby/ec2-honeypot-template)<br>
amelete11235
[homelab](https://github.com/amelete11235/homelab/blob/main/Installing%20DShield%20SIEM%20on%20a%20Raspberry%20Pi%205%20-%208%20GB%20RAM/Installing%20DShield%20SIEM%20on%20a%20Raspberry%20Pi%205%20-%208%20GB%20RAM.md) DShiel SIEM Raspberry 5<br>
William Constantino [Cowrie logfile_investigation with Python](https://github.com/JJWCons/log-scripts/blob/main/logfile_investigation.py)<br>
William Constantino [Cowrie single_multi_IP with Python](https://github.com/JJWCons/log-scripts/blob/main/single_multi_IP.py)<br>
Steven C. Peterson [DShield Model Context Protocol](https://github.com/datagen24/dsheild-mcp)<br>
Nathan Smisson [dshield-tooling](https://github.com/neurohypophysis/dshield-tooling)<br>
# Riferimenti
[1] https://isc.sans.edu/tools/honeypot/<br>
[2] https://www.elastic.co/downloads/beats/filebeat<br>
[3] https://www.elastic.co/guide/en/beats/filebeat/8.8/setup-repositories.html#_apt<br>
[4] https://isc.sans.edu/diary/DShield+Honeypot+Activity+for+May+2023/29932<br>
[5] https://isc.sans.edu/diary/DShield+Sensor+JSON+Log+to+Elasticsearch/29458<br>
[6] https://isc.sans.edu/diary/DShield+Sensor+JSON+Log+Analysis/29412<br>
[7] https://github.com/jslagrew/cowrieprocessor/blob/main/submit_vtfiles.py<br>
[8] https://handlers.sans.edu/gbruneau/elastic.htm<br>
[9] https://www.elastic.co/guide/en/fleet/current/secure-connections.html<br>
[10] https://www.docker.elastic.co/<br>
[11] https://github.com/gchq/CyberChef<br>
[12] https://github.com/mitre-attack/attack-navigator/pkgs/container/attack-navigator