bruneaug/dshield-siemDShield Sensor Log Collection with ELK
Ceci est un fork et une mise à jour importante de la publication initiale sur le site Web ISC Storm Center par Scott Jensen en tant que document BACS et des scripts publiés sur Github.
https://github.com/fkadriver/Dshield-ELK
https://isc.sans.edu/diary/DShield+Sensor+Monitoring+with+a+Docker+ELK+Stack+Guest+Diary/30118
Ceci est une bonne référence sur la façon d'utiliser DShield-SIEM pour l'analyse : https://isc.sans.edu/diary/30962/
Ceci donne un aperçu de la façon dont la collecte des journaux est effectuée avec le capteur DShield.
https://github.com/bruneaug/DShield-SIEM/blob/main/Troubleshooting/DShield-SIEM-Flow.png
Ce docker est construit sur mesure pour être utilisé avec le DShield Honeypot afin de collecter et d'analyser les journaux et de rassembler les données pour faciliter la recherche à des fins de recherche. L'installation suggérée consiste à installer le capteur DShield sur un Raspberry utilisant le système d'exploitation Raspbian Pi ou un système exécutant Ubuntu 24.04 LTS, que ce soit sur votre réseau ou dans le cloud de votre choix.
Remarque : Ceci doit être installé sur un serveur séparé conformément aux instructions ci-dessous.
Remarque : Pour mettre à jour les composants du serveur ELK, suivez ces étapes :
https://github.com/bruneaug/DShield-SIEM/blob/main/README.md#download-github-update
Installez Docker avec le compte utilisateur ($) :````
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
Confirmez que le service docker est en cours d'exécution<br>````
sudo systemctl status docker.service
Ajoutez le nom de serveur ELK suivant es01 kibana fleet-server heartbeat logstash filebeat filebeat01
dans /etc/hosts après l'adresse IP et le nom du serveur :
````
sudo vi /etc/hosts
Ajoutez ceci à /etc/hosts après les adresses IP du serveur ELK<br>
127.0.0.1 sensor es01 ...<br>
192.168.25.80 sensor es01 ...<br>````
es01 kibana fleet-server heartbeat logstash filebeat filebeat01
Modifiez le fichier sysctl.conf :
````
sudo vi /etc/sysctl.conf
Ajoutez ce qui suit en bas du fichier :<br>````
vm.max_map_count=262144
Ajoutez-le et enregistrez-le. Ceci est pour Elasticsearch lors de l'utilisation de Docker.
sudo iptables -nL
# Configurer et installer DShield ELK
En utilisant le compte utilisateur ($), exécutez les commandes suivantes:<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
Note : Avant l'installation, vous pouvez modifier le fichier .env (ls -la pour le voir) pour apporter les modifications souhaitées.
- Le mot de passe par défaut actuel pour elastic est student
Les limites de mémoire dans .env sont la quantité maximale de mémoire que docker allouera à chacun des conteneurs ELK.
Par défaut, 3GB pour Elasticsearch, mais cela peut être étendu si vous avez les ressources nécessaires
Modifiez le fichier .env et configurez-le pour votre propre stack ELK
````
vi .env
- Mettez à jour les variables suivantes dans le fichier **.env** pour qu'elles correspondent aux informations DNS, au nom d'hôte, à l'adresse IP de votre serveur ELK et au mot de passe Elastic par défaut si vous souhaitez le modifier : <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
- Si vous souhaitez modifier les informations du ou des serveurs de noms par défaut ainsi que l'emplacement de votre réseau privé local pour l'adresse de destination (c'est-à-dire le mappage du capteur DShield - actuellement configuré pour **Ottawa, Canada**), modifiez le répertoire suivant pour les fichiers avant de charger docker :<br>````
cd logstash/pipeline
Modifiez heartbeat.yml pour remplacer l'IP du capteur (nommée PI) par votre propre IP de capteur. Le heartbeat de Kibana vérifie l'état de vos services et détermine s'ils sont disponibles.
Mettez à jour cette IP et ce nom d'hôte pour refléter votre capteur.
Remarque : Vous pouvez copier et ajouter les mêmes 5 lignes si vous avez plusieurs capteurs à surveiller.
Cela peut être consulté dans Observability -> Uptime Monitors
Cette ligne correspond à l'adresse IP du capteur. Si aucune réponse n'est reçue lors de la connexion au port TCP 12222, le capteur sera marqué comme hors ligne dans l'interface.
Cette vérification est initiée par le serveur ELK pour contrôler la réponse du capteur.
Mettez à jour cette ligne : hosts: ["192.168.25.165"]
````
vi ~/DShield-SIEM/heartbeat/heartbeat.yml
Le script **change_perms.sh** configurera certains fichiers avant de démarrer l'installation des composants docker.<br>
Le script mettra également à jour l'adresse IP utilisée dans la requête du tableau de bord avec l'adresse IP de votre stack ELK.<br>````
~/scripts/change_perms.sh
~/scripts/get_researchers.sh
Exécutez maintenant docker compose pour construire les applications serveur ELK.
Cela va construire : Kibana, Elasticsearch, elastic-agent, Logstash et charger les analyseurs Cowrie, les fichiers de configuration et le tableau de bord.
````
sudo docker compose up -d
Installation terminée
<img width="375" height="354" alt="image" src="https://assets.kitploit.com/production/public/readmes/50066/b192e2cc430ca7eaa43934ebde637400b29d23212dce39e81f521b0806df1bc0.png" />
# Ajouter ca.crt au certificat de confiance du serveur
- Ajouter ca.crt à la liste des certificats de confiance du serveur```
sudo cp /var/lib/docker/volumes/dshield-elk_certs/_data/ca/ca.crt /usr/local/share/ca-certificates/dshield.crt
```
- Mettre à jour les certificats de confiance ```
sudo update-ca-certificates
```
### Ajout de tableaux de bord et de signatures SIEM à Kibana
Cela charge les tableaux de bord DShield SIEM et les signatures SIEM dans Kibana.<br>```
~/scripts/dashboard-setup.sh
```
### Liste des répertoires Docker
Cette commande affiche la liste des répertoires Docker utilisés une fois tous les composants Elasticsearch installés.<br>
À mesure que des données sont ajoutées à Elasticsearch, vous pouvez également surveiller, soit avec la commande ci-dessous, soit dans ELK, la quantité d'espace disque disponible pour le stockage.<br>````
sudo du --human-readable --max-depth 1 --no-dereference --one-file-system /var/lib/docker
À l'aide de netstat, ces 4 services devraient maintenant être à l'écoute.
```
netstat -an | grep '80|9200|9300|8220|5601|5044|5066|5067|5068|9600'
Voici la sortie que vous devriez voir :<br>
<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>
# Chargement des modèles Filebeat par défaut dans Kibana
Ceci installera les modèles et tableaux de bord par défaut qui peuvent être utilisés pour stocker les données netflow des capteurs DShield distants.<br>
Pour que Logstash commence à stocker des données, les commandes suivantes doivent être exécutées. La première étape est de se connecter à filebeat :````
sudo docker exec -ti filebeat bash
Ensuite, exécutez cette commande Filebeat pour charger les modèles dans Kibana :
````
./filebeat setup -e
# Accéder à l'interface Kibana
Une fois que docker a fini d'installer tous les composants docker ELK, il est maintenant temps de vous connecter à la stack ELK en utilisant l'adresse IP de votre serveur Ubuntu.<br>
- Connectez-vous à Kibana avec le nom d'utilisateur : **elastic** et le mot de passe par défaut _s'il n'a pas été changé_ : **student**<br>
Accès web : https://serverIP
# Configuration de la gestion de la stack ELK
Afin de voir l'état de santé de la stack ELK, il est nécessaire de configurer la surveillance de la stack en naviguant vers : Management -> Stack Monitoring<br>
- Cette étape n'est nécessaire que si l'installation n'a pas configuré automatiquement Stack Monitoring<br>
- Sélectionnez "_Or, set up with self monitoring_"<br>
- La surveillance est actuellement désactivée -> Sélectionnez : _Turn on monitoring_<br>
# Configuration du fleet-agent
Le fleet-agent (il s'agit d'un elastic-agent exécuté sur la stack ELK) sera utilisé pour ingérer la threat intelligence.<br>
- Dans le menu déroulant, sélectionnez Management → Fleet →Settings → Edit Outputs (Actions)<br>
- Connectez-vous au serveur via SSH<br>
- Copiez le certificat ca.crt vers /tmp<br>````
sudo cp /var/lib/docker/volumes/dshield-elk_certs/_data/ca/ca.crt /tmp
- Le résultat ressemblera à ceci :<br>
673FB617E15CCCE73F9B647EF99449642A19CFC1D75BF5772047DA99DB950844
- Récupérez le contenu du certificat CA d'Elasticsearch à appliquer à la configuration YAML avancée. Saisissez la commande car elle ne se copie pas bien<br>````
sudo cat /tmp/ca.crt | sed -r 's/(.*)/ \1/g'
Suivez l'exemple du guide de dépannage fleet-server-examples dont l'URL figure ci-dessus pour le format correct.
sed ajoutera les 4 espaces avec la commande précédente contre le certificat CA
Après avoir ajouté les informations du certificat, enregistrez et appliquez ces paramètres.
Ensuite, cliquez sur Enregistrer et déployer
Sous Paramètres, configurez les hôtes du serveur Fleet en modifiant ou en ajoutant un serveur Fleet configuré comme suit :
La phase suivante consiste à sélectionner Politique d'agent → Ajouter un agent → Enrôler dans Fleet → Ajouter un serveur Fleet
Nous allons avoir besoin de ces informations pour configurer notre serveur Fleet.
Connectez-vous en SSH au fleet-server et assurez-vous que le fleet-server est en cours d'exécution avant de configurer notre agent :
````
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)
Voici un exemple de ce qui doit être copié sur le serveur fleet. Assurez-vous que l'ES du serveur fleet est : https://es01:9200<br>
Ajoutez la section en gras après port=8220 car les certificats sont auto-générés. Cela garantira que l'agent accepte la mise à jour.<br>
Le jeton et l'empreinte numérique seront différents de cet exemple<br>
Copiez l'agent elastic-enrol ci-dessous et remplacez ces 2 lignes provenant de votre propre serveur, tout le reste restant identique.<br>
<pre>
--fleet-server-service-token=AAEAAWVsYXN0aWMvZmxlZXQtc2VydmVyL3Rva2VuLTE3MzEwOTcwODU3MzI6VjMyLU13cmFUOUM1eUFvMUhVUFl5QQ \
--fleet-server-es-ca-trusted-fingerprint=0D9A25F4C147EB3A496253525DF6F039CF3C19776E64A1F77CEFCCD08B76BC61 \
</pre>
Une fois connecté à l'agent fleet, enrôlez l'elastic-agent dans votre agent fleet :
Utilisez ce modèle pour installer votre certificat et assurez-vous de le remplacer par le vôtre<br>
fleet-server-service-token et 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
Cela remplacera vos paramètres actuels. Voulez-vous continuer ? [Y/n]: Y
Agent Elastic enrôlé avec succès.
Depuis votre emplacement actuel, vérifiez qu'il s'est installé correctement
````
./elastic-agent status
./elastic-agent restart (if you got what appears to be errors, force a restart and check the status)
Maintenant que le Fleet Server est connecté, fermez cette fenêtre et passons à l’étape suivante.
Dans Elastic Management → Fleet, actualisez Agents et voici ce qui s’affiche :
Le serveur est maintenant prêt à installer des agents Threat Intel à utiliser dans Security (partie SIEM) contre les journaux du honeypot.<br>
L’étape suivante consiste à sélectionner Agent policies → Fleet Server Policy → Add integration :<br>
Utilisez ce tableau de bord pour consulter les métriques collectées par elastic-agent :<br>
- Sélectionnez et ajoutez AlienVault OTX (une clé API est requise)<br>
- Sélectionnez AbuseCH (une clé API est requise)<br>
- Sélectionnez Threat Intelligence Utilities<br>
- Elasticsearch<br>
- Sélectionnez Kibana<br>
- Sélectionnez Docker<br>
# Exemple de politique Fleet Server
- Dans Elastic Management → Installed Integration<br>
- Sélectionnez chacune des intégrations installées, puis sélectionnez Settings et activez l’onglet pour _garder la politique à jour_ :<br>
## Configuration de Security → Rules
- Sélectionnez Rules → Detection rules (SIEM) → Add Elastic rules
- Sous Search Tags : Rule Type : Threat Intel (ajoutez au minimum ces 4 règles)
- Installez et activez ces 4 règles
- Threat Intel Indicator Match - Cowrie (règle personnalisée chargée et activée lorsque docker charge tous les composants de la pile ELK)
- Threat Intel Windows Registry Indicator Match
- Threat Intel Hash Indicator Match
- Threat Intel URL Indicator Match
- Vous pouvez parcourir les règles et activer celles que vous souhaitez tester sur les données de votre honeypot.<br>
## Examiner l’activité capturée par les règles dans la tendance des alertes
Si certains des éléments Threat Intel ci-dessus ont été ajoutés à elastic-agent, et que cowrie* a été ajouté à Management → Advanced Settings lors de l’installation initiale, il peut désormais suivre les règles qui correspondent dans les tendances d’alertes de la partie SIEM de la pile ELK.<br>
Voici la sortie de Management → Stack Management → Advanced Settings<br>
Si une correspondance de threat intel est trouvée, le SIEM affichera l’activité suivante qui peut maintenant être étudiée :<br>
# Configuration de Filebeat sur le capteur DShield - Journaux vers ELK
L’étape suivante consiste à ajouter le paquet Filebeat au capteur DShield pour envoyer les journaux à Elasticsearch.<br>
Utilisez les étapes suivantes pour installer Filebeat à l’aide des commandes ci-dessous, tirées de cette référence [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
Après l'installation, nous plaçons un hold sur filebeat afin que vous puissiez mettre à jour le capteur sans changer la version de filebeat. La version de filebeat
doit toujours correspondre à la version docker d'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
In order to update filebeat, le moment venu, vous devrez supprimer le hold. Vérifiez d'abord s'il y a un hold sur filebeat avant de le supprimer
```
sudo apt-mark showhold
sudo apt-mark unhold filebeat
Si vous souhaitez utiliser Zeek sur votre capteur DShield, consultez ces [étapes](https://github.com/bruneaug/DShield-SIEM/blob/main/AddOn/Configure_Zeek_DShield_Sensor.md) d'installation.
### Configuration du capteur cloud - Filebeat -> Routeur domestique -> Logstash
Pour vous connecter depuis un capteur cloud vers votre pile ELK locale, vous devez effectuer les opérations suivantes :
- Configurez le routeur domestique pour faire du NAT vers l'adresse IP locale de votre pile ELK<br>
- Utilisez l'adresse IP du routeur (je recommande d'ajouter un nom d'hôte à votre IP domestique au cas où elle changerait) depuis votre capteur pour vous connecter à votre routeur domestique<br>
- La connexion finale devrait ressembler à ceci : capteur -> IP du routeur NAT -> pile ELK
### Transférer tous les fichiers du capteur vers le capteur DShield
Suivez cette URL pour télécharger tous les fichiers liés au capteur DShield<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>
### Dépannage de Filebeat````
sudo su -
filebeat test config
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>
## Démarrer Filebeat````
sudo systemctl enable filebeat
sudo systemctl start filebeat
sudo systemctl status filebeat
Filebeat suit les événements qu'il a traités à l'aide d'un fichier nommé log.json ; s'il est supprimé, tous les événements précédemment envoyés à Elasticsearch seront retraités au redémarrage de Filebeat.
L'emplacement de ce fichier :
sudo su -````
cd /var/lib/filebeat/registry/filebeat
Si vous prévoyez de renvoyer tous les journaux parce que votre serveur ELK a été reconstruit, _arrêtez filebeat, supprimez log.json et redémarrez filebeat_.
Il faudra généralement un certain temps pour que le tableau de bord ELK Stack rattrape son retard. Si vous cherchez à vérifier s'il envoie les journaux à l'ELK Stack, vous pouvez<br>
- tail -f log.json
- Recherchez les 30 derniers jours dans le tableau de bord pendant qu'il rattrape son retard.
# Interface - Aperçu des journaux du capteur DShield
Pour accéder au tableau de bord, sélectionnez Analytics -> Dashboard -> **[Logs DShield Sensor] Overview**<br>
## Ajout de ca.crt au navigateur du poste de travail
Suivez les étapes de cette [page](https://github.com/bruneaug/DShield-SIEM/blob/main/AddOn/Workstation_Browser_CA_Certificate.md) pour ajouter à Kibana le ca.crt utilisé par le serveur ELK.<br>
# Commandes Docker utiles
Reportez-vous à cette page pour une liste de commandes Docker utiles.<br>
https://github.com/bruneaug/DShield-SIEM/edit/main/Troubleshooting/docker_useful_commands..md
# Informations sur Elastic avec la Console
Ces commandes sont exécutées depuis Dev Tool -> Console<br>
GET _nodes/http?pretty (Obtenir une liste et des informations sur tous les nœuds)<br>
GET _security/_authenticate<br>
GET /_cat/nodes?v=true<br>
# Scripts et code d'analyse DShield par les étudiants
Voici une liste de scripts et de code que les étudiants du programme BACS ont écrits pour faciliter l'analyse des journaux.<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) et [publication 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>
# Références
[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