Skip to content
Learni
Voir tous les tutoriels
Sécurité Informatique

Comment configurer Snort 3 IDS avancé en 2026

Read in English

Introduction

Snort 3, l'évolution majeure du célèbre système de détection d'intrusion open-source, offre une détection en temps réel des attaques réseau via des règles signatures et analyse stateful. En 2026, avec la montée des menaces zero-day et IoT, configurer Snort 3 avancé est essentiel pour les équipes SecOps. Ce tutoriel vous guide pas à pas : installation from source sur Ubuntu, tuning des préprocesseurs (stream5, http_inspect), règles personnalisées pour APT, outputs JSON pour SIEM, et optimisation perf (multithreading). Imaginez Snort comme un gardien vigilant filtrant le trafic comme un tamis fin détectant les anomalies subtiles. À la fin, vous déploirez un IDS production-ready, scalable à 10Gbps+, bookmarquez pour référence. (128 mots)

Prérequis

  • Serveur Ubuntu 22.04 LTS ou 24.04 avec au moins 4 cœurs, 8GB RAM et interface réseau dédiée (ex: eth1).
  • Accès root (sudo).
  • Connaissances avancées en Linux, TCP/IP, regex et Lua (pour Snort 3).
  • Outils : git, cmake, flex, bison, libpcap-dev.
  • Interface de test : générateur trafic comme Scapy ou nmap installé.

Installation des dépendances et Snort 3 from source

install-snort3.sh
#!/bin/bash
apt update && apt upgrade -y
apt install -y build-essential cmake cpputest libpcap-dev libpcre2-dev libnet1-dev zlib1g-dev luajit hwloc libdnet-dev libdumbnet-dev bison flex liblzma-dev openssl libssl-dev pkg-config libhwloc-dev libluajit-5.1-dev libunwind-dev libcmocka-dev
cd /opt
git clone https://github.com/snort3/snort3.git
cd snort3
./configure_cmake.sh --prefix=/usr/local --enable-tsc-clock
git clone https://github.com/snort3/extra.git
cd extra
./configure_cmake.sh --prefix=/usr/local --with-snort3
cd ../src
cmake -B build -DCMAKE_INSTALL_PREFIX=/usr/local -DCMAKE_BUILD_TYPE=Release
cmake --build build --target snort3 --parallel
cmake --install build
cd ../extra
cmake -B build -DCMAKE_INSTALL_PREFIX=/usr/local -DCMAKE_BUILD_TYPE=Release
cmake --build build --parallel
cmake --install build

Ce script installe toutes les dépendances critiques pour Snort 3 (LuaJIT pour scripts, hwloc pour affinité CPU) et compile from source pour les dernières features 2026. Utilisez --enable-tsc-clock pour timestamps précis en high-perf. Évitez les paquets APT obsolètes ; from source assure compatibilité kernel récent et optimisations.

Vérification et configuration initiale

Après installation, vérifiez avec snort -V (doit afficher 3.1+). Copiez les configs : cp /usr/local/etc/snort/*.lua /etc/snort/. Éditez /etc/snort/snort.lua pour HOME_NET (votre subnet, ex: "192.168.1.0/24"), EXTERNAL_NET ("any"). Activez multithreading via cpu = { priority = 1 }. Cette base prépare le terrain pour un IDS stateful.

Configuration principale snort.lua

/etc/snort/snort.lua
ips = {
  mode = inline,
  variables = default_variables,
  include = 'lua/snort_defaults.lua',
}
HOME_NET = '192.168.1.0/24'
EXTERNAL_NET = '!$HOME_NET'
ports = {
  http = 80,
  http2 = 8080,
  mysql = 3306,
  ssh = 22,
}
ipvar dns_servers [8.8.8.8,8.8.4.4]
ips =
{
  rules = [[ include /etc/snort/rules ]],
  enable_builtin_rules = true,
}
stream =
{
  variables =
    default_variables,
  tcp = { memcap = 4194304 },
}
appid =
{
  app_detector_dir = '/usr/local/lib',
  categories =
  {
    default = 1,
  },
}
http_inspect =
{
  global =
  {
    max_concurrent_sessions = 8388608,
  },
}
packet_tracer = { enable = true }
process =
{
  trace_level = 1,
  trace_log = '/var/log/snort/packet_trace.log',
}

Ce fichier Lua centralise la config Snort 3 : définit réseaux, active IPS inline (bloque vs alerte), stream pour TCP reassembly, appid pour L7 inspection, http_inspect pour anomalies HTTP. memcap limite mémoire ; ajustez pour >1Gbps. Piège : oublier appid rate-limite détection protocoles.

Règles locales personnalisées

/etc/snort/rules/local.rules
alert tcp $EXTERNAL_NET any -> $HOME_NET 22 (msg:"SSH Brute Force Attempt"; flow:to_server,established; content:"SSH-"; threshold:type both, track by_src, count 5, seconds 60; sid:1000001; rev:1;)

alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"SQL Injection Attempt"; flow:to_server,established; http.uri; content:"union select"; nocase; http.method; content:"GET|20|"; sid:1000002; rev:1; metadata:service http;)

drop tcp $EXTERNAL_NET any -> $HOME_NET 445 (msg:"SMB Exploit EternalBlue"; content:"|FF|SMB|25|`; flow:to_server,established; sid:1000003; rev:1;)

alert icmp $EXTERNAL_NET any -> $HOME_NET any (msg:"ICMP Ping Flood"; itype:8; threshold:type threshold, track by_dst, count 100, seconds 10; sid:1000004; rev:1;)

Règles custom pour menaces courantes : brute-force SSH (threshold), SQLi HTTP, EternalBlue SMB, ICMP flood. Utilisez drop pour IPS blocking. SIDs uniques >1000000 évitent conflits. Testez avec snort -R local.rules -r test.pcap ; regex nocase ignore maj/min.

Activation des préprocesseurs avancés

Préprocesseur stream_tcp reassemble TCP pour détecter fragmentation evasives, comme un puzzle reconstitué. appid identifie apps (ex: Tor), http_inspect parse headers pour anomalies (oversize POST). Dans snort.lua, liez-les via binder pour policies par zone. Cela élève Snort d'un simple sniffer à un IDS contextuel.

Configuration binder pour policies

/etc/snort/binds.lua
binder =
{
  { when = { proto = 'http' }, use = { type = 'policy', policy_id = 0 } },
  { when = { service = 'ssh' }, use = { type = 'policy', policy_id = 1 } },
  { when = { nets = '$HOME_NET' }, use = { type = 'policy', policy_id = 0 } },
  { when = { role = 'server' }, use = { type = 'policy', policy_id = 1 } },
}
policy_0 =
{
  ips = { rules = '/etc/snort/rules/policy0.rules' },
}
policy_1 =
{
  ips = { rules = '/etc/snort/rules/policy1.rules' },
  stream = { tcp = { memcap = 10485760 } },
}

Binder applique policies dynamiques par proto/service/net/role, optimisant ressources (policy1 pour serveurs high-mem). Créez policy0.rules/policy1.rules. Avantage : scalabilité multi-tenant. Piège : policies non-suppressives causent false positives ; supprimez via suppress.gen.

Outputs JSON pour SIEM et alertes

/etc/snort/alerts.lua
alert_json =
{
  limit = 1000,
  pkt_num = true,
  src_addr = true,
  dst_addr = true,
  src_port = true,
  dst_port = true,
  proto = true,
  action = true,
  details = true,
  msg = true,
  class = true,
  priority = true,
  rev = true,
  rule = true,
  time_stamp = true,
  file = true,
}
alert_full = { log = true, packet = true }
logfile = { file = true, limit_size = '10 MB', pkt_num = true }
packet_log = { file = '/var/log/snort/pkts.log', link_type = 'pcap' }

Configure outputs JSON structurés pour ELK/Splunk ingestion, avec timestamps RFC3339 et full packet capture. limit_size rote logs auto. Intégrez à ELK via Filebeat. Évitez unified2 obsolète ; JSON est natif Snort 3.

Lancement en mode IDS daemonisé

start-snort.sh
#!/bin/bash
mkdir -p /var/log/snort
chown snort:snort /var/log/snort
snort -c /etc/snort/snort.lua -i eth1 -A alert_json:alert.json -l /var/log/snort --daq afpacket -daq-mode read-file -daq-var buffer_size=65536 --daq-dir /usr/local/lib/daq --lua "ips.rules = '/etc/snort/rules/*.rules'" --enable-inline -Q --daq afpacket -i eth1:eth1 -q &
echo $! > /var/run/snort.pid
systemctl daemon-reload
cat <<EOF > /etc/systemd/system/snort.service
[Unit]
Description=Snort 3 IDS
After=network.target
[Service]
ExecStart=/usr/local/bin/snort -c /etc/snort/snort.lua -i eth1 -A alert_json -l /var/log/snort --daq afpacket --enable-inline -Q
Restart=always
User=snort
[Install]
WantedBy=multi-user.target
EOF
systemctl enable snort
systemctl start snort

Lance Snort daemonisé sur eth1 avec DAQ afpacket (zero-copy high-perf), inline queue (-Q) pour IPS. Crée systemd service persistant. --lua override rules runtime. Testez : tail -f /var/log/snort/alert.json. Piège : mauvais DAQ cause drops ; monitor snort -T.

Test et validation

Générez trafic malveillant : nmap -sS -p22 192.168.1.10 (5x pour threshold). Vérifiez alerts JSON : jq . /var/log/snort/alert.json. Utilisez snort -r capture.pcap -c snort.lua -A cmg pour offline analysis. Perf : snort_stats montre drops/Mbps.

Bonnes pratiques

  • Tuning perf : Utilisez hwloc pour pin CPU (ex: cores 4-7), DAQ afpacket avec RSS hash pour 10G+.
  • Règles hiérarchiques : Employez include + SIDs pour staging (test -> prod).
  • Suppression FP : suppress.gen par IP/proto au lieu de désactiver règles.
  • Backup state : Rotate pcap/logs via logrotate, intégrez à ELK pour corrélation.
  • Mise à jour : Script cron pour pull Snort rules Oinkcode Talos.

Erreurs courantes à éviter

  • Oublier DAQ compilation : Snort crash sur afpacket ; toujours ./configure_cmake.sh --enable-large-pcap.
  • HOME_NET mal défini : Alerte sur trafic légit ; utilisez ipvar dynamiques.
  • Pas de stream reassembly : Évasion frag ; forcez stream_tcp.invalidate = fragments.
  • Logs non-rotes : /var/log plein crash Snort ; set max_file_size.

Pour aller plus loin

Plongez dans Snort 3 Lua plugins pour ML anomaly detection. Ressources : Docs officielles Snort, Snort3 GitHub. Optimisez avec Suricata benchmark. Découvrez nos formations Learni en cybersécurité avancée pour certif SANS/GCIH.