1. Introduction et notions fondamentales

La protection du périmètre réseau et la visibilité sur les flux internes reposent souvent sur deux types complémentaires d’outils :

• IDS (Intrusion Detection System) : détection passive, génère des alertes à partir de signatures ou d’analyses comportementales.
• IPS (Intrusion Prevention System) : détection et action (bloquer / neutraliser) en inline.

Ce tutoriel couvre déploiement, règles, modes inline, intégration SIEM, tests et orchestration. Les choix proposés (Suricata, Snort, Zeek) sont tous open-source ou disposant d’options communautaires robustes, adaptés à un SOC interne.

2. Choix d’une solution IDS/IPS (comparatif rapide)

• Suricata (OISF) — haut débit, multi-thread, bon support EVE JSON pour intégration SIEM. Recommandé pour la plupart des déploiements modernes.
  Site officiel : https://suricata.io/
• Snort (Cisco Talos) — maturité, large base de règles (Snort Community Rules, VRT). Recommandé si votre équipe est familière à Snort.
  Site officiel : https://www.snort.org/
• Zeek (ex Bro) — approche orientée protocole et métadonnées (logs très riches), non signature-first ; excellent pour analyses forensiques.
  Site officiel : https://zeek.org/

Recommandation SOC : pour un déploiement initial, combiner Suricata (détection/signature, IPS possible) + Zeek (contexte protocolaire et métadonnées), avec ingestion centralisée dans ELK/Splunk.

3. Architecture recommandée pour un SOC interne (topologie)

Topologie simple et extensible :

• Edge TAP / Mirror (SPAN) → Sensor Suricata (IDS mode) → Log collector (Filebeat/Logstash) → ELK / Splunk.
• Inline (IPS) : Suricata en mode NFQUEUE ou appliance inline (bridge), placé devant DMZ ou segment critique.
• Zeek : sur un port mirror séparé pour enrichissement des logs (conn, http, ssl, dns, files).
• SIEM : centralise EVE JSON (Suricata), Zeek logs et hôtes/EDR/Firewall.
• SOAR / TheHive : actions automatiques et playbooks d’escalade.

4. Prérequis matériels & logiciels

Matériel recommandé (sensor haute performance) :

• 8–16 vCPU, 16–64 GB RAM, SSD NVMe, 10 Gbps NIC (pour trafic élevé).
  Logiciels :
• Ubuntu Server 22.04 LTS (exemples) ou CentOS/RHEL.
• Suricata (version 6.x+ recommandé) : https://suricata.io/
• Zeek (version 4.x) : https://zeek.org/
• ELK Stack (Elasticsearch, Logstash, Kibana) ou Splunk Enterprise.
• Filebeat / Logstash pour ingestion.
• suricata-update pour gestion automatique des règles.
• Optional : OPNsense/pfSense appliance for inline mode.

5. Déploiement étape par étape : Suricata (Ubuntu) — installation, configuration, mise en IPS

5.1 Installation de Suricata sur Ubuntu 22.04 (CLI) — pas à pas (ligne de commande équivalente)

Prérequis : accès SSH administrateur vers la VM/serveur sensor.

1. Ouvrir un terminal SSH sur la machine sensor : ssh ubuntu@sensor.example.local (ou via console).
2. Mettre à jour le système :
   • Tapez : sudo apt update && sudo apt upgrade -y
3. Installer dépendances :
   • Tapez : sudo apt install -y software-properties-common ca-certificates lsb-release curl apt-transport-https
4. Ajouter le dépôt officiel OISF / Suricata (si disponible) :
   • Tapez : sudo add-apt-repository ppa:oisf/suricata-stable -y
     (si PPA non souhaité, compiler depuis source est possible; la méthode via dépôt est plus simple pour LAB)
5. Installer Suricata :
   • Tapez : sudo apt update && sudo apt install -y suricata
6. Vérifier la version :
   • Tapez : suricata --build-info
   • Vérification visuelle : sortie montre Suricata VERSION et options.

5.2 Configuration initiale (suricata.yaml) — pas à pas

1. Sauvegarder le fichier de configuration :
   • Tapez : sudo cp /etc/suricata/suricata.yaml /etc/suricata/suricata.yaml.bak
2. Ouvrir le fichier en édition :
   • Tapez : sudo nano /etc/suricata/suricata.yaml
3. Points clés à modifier :
   • default-log-dir : généralement /var/log/suricata
   • EVE output (JSON) : localiser la section outputs: puis - eve-log: et activez :

- eve-log:
    enabled: yes
    filetype: regular
    filename: eve.json
    types:
      - alert:
          payload: yes
          payload-printable: yes
          packet: yes
          http-body: yes
      - http: yes
      - dns: yes
      - tls: yes
      - flow: yes

• af-packet/pcap interface : si capture en mode AF_PACKET (performant), localiser af-packet section et ajoutez l’interface (ex : – interface: eth1).
• run-as user/group : généralement suricata/suricata.

4. Sauvegarder et quitter (dans nano : Ctrl+O puis Entrée, Ctrl+X).

5.3 Tester Suricata en mode IDS (capture depuis interface)

1. Lancer Suricata manuellement (mode interactif pour debug) :
   • Tapez : sudo suricata -c /etc/suricata/suricata.yaml -i eth1 -v
   • -i eth1 indique l’interface à surveiller.
2. Exécuter en service systemd :
   • Tapez : sudo systemctl enable --now suricata
   • Vérifier status : sudo systemctl status suricata
3. Vérifier logs EVE JSON :
   • Tapez : sudo tail -f /var/log/suricata/eve.json

5.4 Activer la prévention (IPS) — mode inline via NFQUEUE (suricata + iptables)

Attention : mode IPS bloque le trafic ; ne pas activer en production sans tests.

1. Installer libnetfilter_queue (si non présent) :
   • Tapez : sudo apt install -y libnetfilter-queue-dev
2. Reconfigurer Suricata pour NFQUEUE :
   • Ouvrir /etc/suricata/suricata.yaml → section nfq ou af-packet selon version. Exemple NFQUEUE configuration (ajouter under af-packet not required):

nfq:
  - id: 0
    copy-mode: ips
    fail-open: no

3. Configurer iptables to send traffic to NFQUEUE (ex : blocage HTTP sortant ou test) :

• Tapez : sudo iptables -I FORWARD -p tcp –dport 80 -j NFQUEUE –queue-num 0
• Pour tester sur interface locale : sudo iptables -I INPUT -p tcp –dport 80 -j NFQUEUE –queue-num 0

4. Relancer Suricata (systemd restart) :

• Tapez : sudo systemctl restart suricata

5. Vérifier comportement : injectez un trafic de test (non-malveillant) et observez eve.json et logs sudo journalctl -u suricata -f.

Remarque : sur des appliances (OPNsense / pfSense) l’IPS se configure via l’interface web (cf. section 10).

6. Déploiement étape par étape : Snort (Ubuntu) — installation et règles de base

6.1 Installation Snort 2.9/3.x (CLI)

1. Mettre à jour :
   • Tapez : sudo apt update && sudo apt upgrade -y
2. Installer dépendances :
   • Tapez : sudo apt install -y build-essential libpcap-dev libpcre3-dev libdumbnet-dev bison flex zlib1g-dev liblzma-dev openssl libssl-dev
3. Télécharger Snort :
   • Aller sur https://www.snort.org/downloads (URL complète : https://www.snort.org/downloads) et récupérer la version community ou stable.
   • Sur serveur : curl -O https://www.snort.org/downloads/snort/snort-<version>.tar.gz (adapter).
4. Compiler et installer (exemple abrégé) :
   • tar -xvzf snort-<version>.tar.gz && cd snort-<version>
   • ./configure --enable-sourcefire && make && sudo make install
5. Vérifier : snort -V

6.2 Configurer les règles Snort (pulledpork / oinkmaster)

1. Installer pulledpork (gestionnaire de règles VRT/ET) : consulter https://github.com/shirkdog/pulledpork (URL complète : https://github.com/shirkdog/pulledpork)
2. Configurer pulledpork : éditer /etc/pulledpork/pulledpork.conf en insérant vos Oinkcode (si VRT) ou utiliser Emerging Threats rules (ET Open).
3. Télécharger et déployer les règles :
   • sudo pulledpork.pl -c /etc/pulledpork/pulledpork.conf -g
4. Tester Snort :
   • Commande test : sudo snort -c /etc/snort/snort.conf -i eth1 -A console
   • Vérifier logs /var/log/snort/.

7. Déploiement étape par étape : Zeek — capture et extraction de logs réseau

7.1 Installation Zeek (Ubuntu)

1. Installer dépendances :
   • sudo apt update && sudo apt install -y cmake make gcc g++ flex bison libpcap-dev libssl-dev python3
2. Télécharger & installer :
   • curl -LO https://download.zeek.org/zeek-4.2.0.tar.gz (adapter version)
   • tar -xzf zeek-4.2.0.tar.gz && cd zeek-4.2.0
   • ./configure --prefix=/opt/zeek && make && sudo make install
3. Ajouter user zeek :
   • sudo useradd -m -s /bin/bash zeek
4. Démarrer Zeek (sur interface eth1) :
   • sudo /opt/zeek/bin/zeekctl deploy

7.2 Fichiers logs Zeek essentiels

• conn.log — connexions réseau (IP, ports, bytes)
• http.log — requêtes HTTP (user-agent, URL)
• dns.log — requêtes DNS
• files.log — transferts de fichiers

7.3 Intégration E/S

• Copier les logs Zeek (par ex. /opt/zeek/logs/current/) vers Logstash/Filebeat pour ingestion dans ELK.

8. Intégration avec SIEM (ELK / Splunk) — ingestion et dashboards

8.1 Ingestion Suricata EVE JSON dans ELK (Filebeat)

1. Installer Filebeat sur sensor :
   • sudo apt install filebeat
2. Enable suricata module (optionnel) :
   • sudo filebeat modules enable suricata
3. Editer filebeat config :
   • Ouvrir /etc/filebeat/filebeat.yml et ajouter output Elasticsearch or Logstash.
   • Pour Logstash : ajouter input: - type: log paths: - /var/log/suricata/eve.json et config pipeline.
4. Start Filebeat :
   • sudo systemctl enable --now filebeat
5. Kibana : créer index pattern filebeat-* ou suricata-* et importer dashboards.

8.2 Ingestion Zeek logs

• Configurer Filebeat prospectors for /opt/zeek/logs/current/*.log, utiliser Zeek module in Filebeat (if available) to parse fields.

8.3 Exemple Search / Dashboard (Splunk)

• Search to find Suricata alerts:

index=suricata sourcetype=suricata:eve alert.signature:"ET SCAN"

• Créer dashboards pour top signatures, top src_ip, top dest ports, alerts per minute.

9. Règles, signatures et gestionnaire de règles (suricata-update, Emerging Threats)

9.1 suricata-update (Suricata rule manager)

1. Installer suricata-update : sudo apt install -y suricata-update (ou pip)
2. Ajouter feed Emerging Threats OSS (ex.):
   • sudo suricata-update add-source --name et "https://rules.emergingthreats.net/open/suricata-6.0/emerging.rules.tar.gz"
3. Mettre à jour et déployer :
   • sudo suricata-update
   • sudo systemctl restart suricata

9.2 Exemple de règle Suricata (alerte uniquement — fichier .rules)

alert tcp any any -> $HOME_NET 80 (msg:"TEST HTTP User-Agent Suspicious"; flow:to_server,established; http.user_agent; content:"sqlmap"; nocase; sid:1000001; rev:1; classtype:web-application-attack; priority:2;)

• Explication : alerte si User-Agent contient sqlmap (scanner connu). Ne pas encourager l’utilisation d’outils offensifs ; cette règle sert uniquement de test.

9.3 Gestion des false positives : suppression via thresholding & suppress-list

• Suricata : threshold.conf / suppress directives, ou via Suricata Manager (SELKS, EveBox) pour gérer suppression.

10. Mode inline (IPS) : NFQUEUE vs. bridge/inline hardware (pfSense / OPNsense)

10.1 Option A — NFQUEUE (Linux) — pas-à-pas (voir section 5.4)

• Avantages : flexible, pas de matériel spécifique.
• Inconvénients : performance limitée à CPU & libnetfilter_queue.

10.2 Option B — Appliance (OPNsense avec Suricata plugin) — pas à pas (interface web)

Préparation : accès web OPNsense admin (https://opnsense.example.local).

1. Se connecter : ouvrez navigateur → https://opnsense.example.local → authentifiez-vous.
2. Installer plugin Suricata (si non installé) :
   • Menu System → Firmware → Plugins → chercher os-suricata → cliquer +Install → confirmer.
3. Configurer Suricata :
   • Menu Services → Intrusion Detection → onglet Administration → activer Enable IDS → set Mode to IPS (inline).
   • Onglet Interfaces → click + Add → sélectionner interface (ex: LAN, WAN), Enable, choose Block Offenders/Drop action.
4. Rules : onglet Rules → sélectionner feed Emerging Threats OSS ou ET Pro (si licence) → Apply rules → Update Rules.
5. Tuning & logging : onglet Log → vérifier alert logs et bloqués.
6. Tester : générer un accès de test (navigateur) correspondant à une règle test.
7. Sauvegarder : Menu System → Configuration → Backups.

Remarque : pfSense suit flux semblable via package Suricata ; OPNsense est renseigné ici comme exemple.

11. Tests et validation (scénarios non-destructifs)

Principe : tester détection sans attaquer autrui. Utiliser des évènements de test bénins ou pcap de test.

11.1 Test signature simple (user-agent)

1. Navigateur : ouvrir Chrome/Firefox → Developer Tools → Network → user-agent override plugin or curl:
   • curl -A "sqlmap/1.0" http://example.com
2. Vérifier : Suricata eve.json doit contenir alert with sid 1000001; SIEM doit indexer l’alerte.

11.2 Replay PCAP (tcpreplay) — test offline

1. Obtenir pcap d’exemple (pcap innocuous sample) depuis une source publique et légale (par ex. sample pcap from Wireshark sample captures — https://wiki.wireshark.org/SampleCaptures).
   • Télécharger pcap sur sensor.
2. Installer tcpreplay : sudo apt install -y tcpreplay
3. Replay pcap : sudo tcpreplay -i eth1 sample.pcap
4. Vérifier logs sur Suricata/Zeek.

12. Tuning et réduction des faux positifs — méthode scientifique

1. Collecte de base : 14–30 jours d’observations normales par segment.
2. Baseline : calculer percentile (p95/p99) pour volumes, user agents, connexions par source.
3. Whitelist/Allowlist : interdire des sources connues (scanners internes, sauvegardes) via suppression lists.
4. Throttling : utiliser suppression (Suricata suppress), threshold.conf ou ElastAlert aggregate/suppress.
5. Score de confiance : corréler signatures multiples (ex : alert signature + Zeek conn anomalies + firewall deny) avant escalade.
6. Feedback loop : SOC tagge alertes FP → pipelines CI mettent à jour suppression rules (GitOps).

13. Remédiation automatique et playbooks d’escalade (TheHive / SOAR)

13.1 Exemple playbook (TheHive JSON — modèle)

• Tache 1 : Valider alert (enrichir IP via GeoIP + TI).
• Tache 2 : Check EDR (endpoint telemetry).
• Tache 3 : Containment (block IP via firewall API).
• Tache 4 : Create ticket ServiceNow (via API).
• Tache 5 : Forensic & report.

Exemple de requête API ServiceNow (curl) pour créer incident (pas à pas en CLI) :

curl -k -u 'svc_snm:password' \
  -H "Content-Type: application/json" \
  -X POST "https://instance.service-now.com/api/now/table/incident" \
  --data '{"short_description":"Suricata alert: SQLMAP UA detected","category":"Security","urgency":"2","comments":"See Suricata alert ID: 1000001"}'

Remplacer credentials par secrets stockés en vault.

14. Monitoring, KPIs et reporting SOC

KPIs à suivre :

• Nombre d’alertes par jour / règle
• Taux FP (fausses alertes) par règle
• MTTA (Mean Time To Acknowledge)
• MTTR (Mean Time To Remediate)
• Couverture: % segments réseau monitorés

Dashboards recommandés :

• Suricata top 10 signatures par volume
• Top source IPs générant alerts
• Alerts timeline (per minute)
• Correlation: Suricata alerts vs Zeek conn anomalies

---

15. Hardening, sauvegarde et reprise d’activité

1. Versionner : stocker suricata.yaml, rules, suppression lists dans Git privé (branching).
2. Sécuriser : run Suricata under non-root user; protect config files (chmod 640) ; vault secrets.
3. Backup : snapshot config + rules + writeback indices (Elasticsearch snapshots).
4. DR plan : processus pour re-déployer sensors (Ansible playbook fourni en annexe).

16. Annexes : scripts, règles d’exemple, templates d’escalade, checklists

16.1 Script d’installation rapide Suricata (Ubuntu) — install_suricata.sh (exécuter en LAB)

#!/bin/bash
set -e
sudo apt update && sudo apt upgrade -y
sudo apt install -y curl gnupg2 lsb-release software-properties-common
sudo add-apt-repository ppa:oisf/suricata-stable -y
sudo apt update
sudo apt install -y suricata
sudo cp /etc/suricata/suricata.yaml /etc/suricata/suricata.yaml.bak
# Basic eve.json enable (append or adjust existing)
sudo sed -i 's/^[[:space:]]*enabled: no/        enabled: yes/' /etc/suricata/suricata.yaml
sudo systemctl enable --now suricata
echo "Suricata installed and started. Check /var/log/suricata/eve.json"

Important : adapter à votre distro et valider chaque étape avant production.

16.2 Exemple de règle Suricata (fichier local.rules) — détection simple

alert http $EXTERNAL_NET any -> $HOME_NET $HTTP_PORTS (msg:"ET POLICY Suspicious SQLMAP UA"; http.user_agent; content:"sqlmap"; nocase; sid:1000002; rev:1;)

16.3 Template d’escalade (SOC → DSI) — court

• Titre : Incident réseau : signature Suricata <signature_name>
• Description : heure, sensor, src_ip, dst_ip, signature, evidences (Zeek conn, pcap path)
• Actions recommandées : block IP (Yes/No), isolate host (Yes/No), open ticket, forensic owner.
• Contacts : SOC lead, N2, DSI security.

16.4 Checklist rapide avant passage en IPS

• Sensors validés en IDS mode depuis 7 jours
• Suppression list initiale appliquée (scanners connus)
• Tests de charge et performance OK (throughput acceptable)
• Procédure rollback testée (iptables flush / remove NFQUEUE)
• Playbook d’escalade prêt et PR validé

Remarques finales et bonnes pratiques

• Ne pas activer IPS en production avant tests exhaustifs et un plan de rollback.
• Versionnez les règles et la config dans Git et appliquez CI pour les modifications.
• Sécurisez les credentials (ServiceNow, TheHive, SIEM) via Vault.
• Documentez chaque règle significative et conservez un registre des exceptions (allowlist).
• Formez les analystes SOC sur les cas d’usage et playbooks — l’outil est efficace si les processus sont matures.

Conclusion

La mise en place d’un IDS/IPS moderne est un projet itératif : déployer en IDS, collecter des données, tuner les règles, puis passer en IPS seulement lorsque la confiance (FP faible, playbooks validés) est acquise. L’association Suricata + Zeek + SIEM offre un fort pouvoir de détection et une base solide pour un SOC.

Besoin d’un déploiement pilote ou d’un audit complet ?
Nous proposons un service clé en main : POC 2 semaines (installation de sensors, intégration SIEM, tuning initial et playbooks TheHive).
Procédure de contact :

1. Cliquez sur le bouton ci-dessous pour accéder au formulaire de Contact de la société.
2. Remplissez le formulaire avec : objet “POC IDS/IPS”, périmètre (nombre de sites), interlocuteur DSI/RSSI et urgences.
3. Cliquer sur Envoyer.
   Un responsable technique vous recontactera sous 48 heures ouvrées pour cadrage et proposition.

Liens externes recommandés

• Suricata — Site officiel : https://suricata.io/
• Snort — Site officiel : https://www.snort.org/
• Zeek — Site officiel : https://zeek.org/
• Emerging Threats rules (ET Open) : https://rules.emergingthreats.net/open/suricata-5.0/
• Suricata EVE JSON format docs : https://suricata.readthedocs.io/en/latest/output/eve/eve-json-output.html
• Filebeat — modules Suricata / Zeek : https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-modules.html
• tcpreplay (replay PCAP) : https://tcpreplay.appneta.com/
• TheHive Project (SOAR) : https://thehive-project.org/
• ServiceNow REST API docs : https://developer.servicenow.com/
• OPNsense Suricata plugin documentation : https://docs.opnsense.org/manual/how-tos/suricata.html