Suricata IPS : passer de la détection au blocage sans se couper du serveur

Licorne Geekeries pilotant une passerelle Suricata qui laisse passer le trafic légitime et bloque quelques paquets malveillants

Bonjour à tous, mon Suricata IPS est enfin en production. J’écris « enfin » parce que Suricata était déjà installé (depuis longtemps), lançait des dizaines de milliers de règles et remplissait consciencieusement ses logs. Il ne bloquait pourtant absolument rien. Passer de « je vois une attaque » à « je l’arrête » paraissait être une petite étape, mais je suis resté 3 semaines sur le sujet :’) !

Mon environnement n’a rien d’exotique : un serveur Debian exposé sur Internet, plusieurs services Docker et Nginx Proxy Manager, que vous connaissez maintenant mieux que moi, le tout devant les applications web. Le firewall a été remis au propre dans mon article sur la modernisation d’iptables sans casser Docker. Je voulais maintenant que Suricata ne se contente plus de commenter les scans depuis le bord du terrain.

Après plusieurs semaines de tests, de périodes d’observation et de « surtout, ne touche plus à rien pendant que je vérifie », le résultat est étonnamment sobre : 52 046 règles analysent le trafic, mais seulement 47 sont autorisées à bloquer. C’est cette méthode progressive que je vous propose aujourd’hui, pas toute l’archéologie de mon serveur.

IDS, IPS : une lettre et beaucoup plus de responsabilités

En mode IDS, Suricata observe une copie du trafic. Il peut lever une alerte, produire un événement EVE en JSON et alimenter votre outil de supervision. S’il s’arrête ou se trompe, le trafic continue sa route.

En mode IPS, Suricata se place en travers du chemin. Avec NFQUEUE, une règle Netfilter envoie un paquet au moteur, qui rend ensuite son verdict : accepter ou bloquer. La documentation officielle du mode IPS sous Linux présente ce fonctionnement avec iptables et nftables.

Un IDS peut être bruyant. Un IPS bruyant devient rapidement le problème qu’il était censé résoudre. J’ai donc séparé le chantier en trois paliers : une baseline IDS propre, un passage inline sans aucun blocage, puis une petite liste de signatures validées une par une.

Premier piège : Suricata tournait, mais ne voyait rien

Au début de l’audit, le processus Suricata utilisait déjà l’option NFQUEUE. Très bien, sauf qu’aucune règle du firewall n’envoyait de paquet dans cette queue. Le service était actif, la configuration semblait sérieuse et les compteurs restaient désespérément à zéro. La sécurité décorative dans toute sa splendeur <3.

La vérification est simple : un service démarré ne prouve pas qu’il inspecte du trafic. Il faut regarder simultanément le mode de capture, le listener NFQUEUE, les compteurs du firewall et les nouveaux événements :

sudo suricata --build-info | grep -i NFQ
sudo systemctl status suricata
sudo cat /proc/net/netfilter/nfnetlink_queue
sudo iptables -vnL
sudo ip6tables -vnL
sudo tail -f /var/log/suricata/eve.json

Le nom du fichier EVE peut évidemment différer. Chez moi, il a été volontairement limité aux alertes, anomalies utiles et décisions de blocage. Les flux complets, statistiques périodiques et autres événements bavards restent ailleurs. Avant d’envoyer plusieurs gigaoctets de JSON dans Splunk, Elasticsearch ou Loki, commencez par vous demander ce que vous comptez réellement relire.

Deuxième piège : Docker change le chemin des paquets

Sur un service écoutant directement sur l’hôte, le trafic entrant passe normalement dans INPUT et les réponses dans OUTPUT. Avec un port IPv4 publié par Docker, le paquet peut être « translaté » et traverser FORWARD et DOCKER-USER. Selon votre configuration IPv6 et l’utilisation de docker-proxy, la seconde pile IP peut suivre un autre chemin. Mais keep it simple Linux surtout !

Il n’existe donc pas une règle NFQUEUE universelle à copier depuis un forum. Depuis un client extérieur, générez quelques requêtes HTTP et HTTPS, puis observez les compteurs :

sudo iptables -vnL INPUT --line-numbers
sudo iptables -vnL DOCKER-USER --line-numbers
sudo ip6tables -vnL INPUT --line-numbers
sudo ip6tables -vnL DOCKER-USER --line-numbers

Votre règle Suricata doit être placée sur le chemin réellement emprunté, dans les deux sens nécessaires au suivi de la connexion. Elle doit également venir après les décisions de blocage déjà prises par le firewall, Fail2ban ou CrowdSec. En mode NFQUEUE accept, un paquet accepté par Suricata ne poursuit pas forcément l’évaluation des règles suivantes. L’ordre n’est donc pas un détail cosmétique quand on joue avec iptables…

Enfin, je n’ai envoyé dans la queue que le trafic web public TCP 80 et 443. SSH, les connexions sortantes du serveur et les autres conteneurs restent hors périmètre. mais on reviendra sur le pourquoi.

Configurer Suricata IPS en trois paliers

1. Construire une baseline IDS exploitable

Avant NFQUEUE, votre IDS doit déjà fonctionner. Vérifiez que HOME_NET décrit bien les adresses protégées, que le fichier de règles existe, que le moteur les charge sans erreur et que les événements EVE arrivent avec un horodatage correct. Laissez tourner cette baseline assez longtemps pour repérer les signatures qui produisent du bruit en continu.

Une sortie EVE volontairement étroite peut ressembler à ceci :

outputs:
  - eve-log:
      enabled: yes
      filename: eve-security.json
      filemode: 640
      community-id: true
      types:
        - alert:
            tagged-packets: no
            verdict: yes
        - anomaly:
            enabled: yes
            types:
              decode: no
              stream: no
              applayer: yes
            packethdr: no
        - drop:
            alerts: yes
            flows: start
            verdict: yes

Le verdict final est précieux : une alerte peut avoir été autorisée alors qu’une autre signature a provoqué le blocage du même paquet. Quant à flows: start, il évite d’écrire une ligne pour chaque paquet rejeté d’un flux déjà condamné.

Validez toujours la configuration avant un redémarrage :

sudo suricata -T -c /etc/suricata/suricata.yaml
sudo suricatasc -c ruleset-stats

2. Passer inline, mais sans donner de dents aux règles

Le mode « shadow inline » a été le palier le plus rassurant du projet. Les paquets traversent réellement Suricata via NFQUEUE, mais toutes les actions actives ont été converties en alert. Le chemin réseau est donc testé avant la politique de blocage.

Avec Suricata-Update, un fichier modify.conf peut neutraliser les actions bloquantes pendant cette phase :

# /etc/suricata/modify.conf pour la phase shadow
re:. "^(drop|reject|pass) " "alert "

Regénérez ensuite le ruleset, testez-le et comptez ses actions. Le résultat attendu à ce stade est simple : beaucoup d’alertes, zéro drop, zéro reject et zéro pass non prévu.

sudo suricata-update
sudo suricata -T -c /etc/suricata/suricata.yaml

awk '
  /^[[:space:]]*(alert|drop|reject|pass)[[:space:]]+/ { count[$1]++ }
  END { for (action in count) print action, count[action] }
' /var/lib/suricata/rules/suricata.rules

Suricata doit alors écouter la queue choisie, par exemple la queue 0. Dans le fichier YAML, j’ai conservé le mode accept et le comportement fail-open du moteur :

nfq:
  mode: accept
  fail-open: yes

stream:
  inline: auto

Et le service systemd doit démarrer Suricata avec l’option correspondante :

suricata -D -q 0 -c /etc/suricata/suricata.yaml   --pidfile /run/suricata/suricata.pid

Comme d’hab, ne copiez pas aveuglément cette ligne… Commencez par systemctl cat suricata, conservez les options exigées par votre paquet et remplacez seulement le mode de capture. Une unité systemd mal assortie à son type de service est une autre façon très efficace de créer une panne qui ressemble à un problème réseau.

3. Relier le firewall avec une vraie sortie de secours

Le moteur NFQUEUE doit être prêt avant que le firewall commence à lui envoyer des paquets. La chaîne dédiée contient ensuite une règle de ce type :

-A SURICATA-WEB -j NFQUEUE --queue-num 0 --queue-bypass

–queue-bypass est essentiel : si aucun programme n’écoute la queue, la règle se comporte comme une acceptation et le service reste joignable. En contrepartie, Suricata ne protège plus le trafic pendant cette absence. C’est du fail-open assumé (classique sur 99% des IPS déployés en prof), choisi pour préserver la disponibilité.

Ce bypass au niveau de la règle firewall et nfq.fail-open ne couvrent pas exactement le même scénario. Le premier protège contre l’absence du listener ; le second aide le moteur à laisser passer en cas de surcharge interne. J’ai testé les deux, au lieu de considérer que le mot « open » suffisait à porter bonheur.

Voici les formes générales des hooks. Les valeurs et surtout leur position doivent venir de vos propres compteurs :

# Service web écoutant sur l'hôte
-A INPUT  -i <interface-publique> -p tcp -m multiport   --dports 80,443 -j SURICATA-WEB
-A OUTPUT -o <interface-publique> -p tcp -m multiport   --sports 80,443 -j SURICATA-WEB

# Reverse proxy publié par Docker en IPv4
-A DOCKER-USER -i <interface-publique> -o <bridge-proxy>   -d <ip-du-proxy>/32 -p tcp -m multiport   --dports 80,443 -j SURICATA-WEB
-A DOCKER-USER -i <bridge-proxy> -o <interface-publique>   -s <ip-du-proxy>/32 -p tcp -m multiport   --sports 80,443 -j SURICATA-WEB

Ces lignes sont des templates, pas une ordonnance. Si votre reverse proxy change d’adresse à chaque recréation, commencez par lui donner une identité réseau stable ou construisez vos règles depuis l’état Docker contrôlé. Et si vos compteurs ne progressent pas pendant un test externe, vous n’avez pas trouvé le bon chemin.

Le How-to complet, sans roulette russe en SSH

Préparer le rollback

Gardez une console indépendante et une seconde session SSH ouverte. Sauvegardez la configuration Suricata, l’unité systemd effective et les deux piles du firewall dans un dossier root daté :

BACKUP="/root/suricata-before-ips-$(date -u +%Y%m%dT%H%M%SZ)"
sudo install -d -m 700 "$BACKUP"
sudo cp -a /etc/suricata "$BACKUP/"
sudo systemctl cat suricata | sudo tee "$BACKUP/suricata.service.txt" >/dev/null
sudo iptables-save | sudo tee "$BACKUP/rules.v4" >/dev/null
sudo ip6tables-save | sudo tee "$BACKUP/rules.v6" >/dev/null
sudo sha256sum "$BACKUP"/rules.v4 "$BACKUP"/rules.v6

Construisez ensuite des fichiers candidats à partir des captures, ajoutez uniquement vos chaînes et hooks NFQUEUE stables, puis faites tester la syntaxe par le noyau :

sudo iptables-restore --test rules.v4.candidate
sudo ip6tables-restore --test rules.v6.candidate

Pour le premier passage en production, iptables-apply et ip6tables-apply offrent un rollback interactif très pratique :

sudo iptables-apply -t 120 rules.v4.candidate
sudo ip6tables-apply -t 120 rules.v6.candidate

Si vous ne confirmez pas dans le terminal, l’ancien ruleset revient automatiquement. Utilisez bien un vrai terminal interactif : sans pseudo-terminal, mon premier essai a chargé le candidat puis l’a restauré immédiatement. Au moins, le rollback avait réussi son examen avant le reste.

Valider le mode shadow

Pendant la fenêtre de confirmation, testez une session SSH existante et une nouvelle, puis le site en IPv4 et IPv6. Contrôlez également que les compteurs NFQUEUE augmentent et que Suricata ne remonte ni règle en échec ni erreur de queue :

curl -4 -I https://votre-site.example
curl -6 -I https://votre-site.example

sudo iptables -vnL SURICATA-WEB
sudo ip6tables -vnL SURICATA-WEB
sudo suricatasc -c ruleset-stats
sudo journalctl -u suricata -p warning --since "10 minutes ago"

Avec une console de secours réellement disponible, arrêtez brièvement Suricata et répétez le test web. Le trafic doit continuer grâce à –queue-bypass, puis les compteurs doivent repartir après le redémarrage du moteur. Ce test transforme une option rassurante dans un fichier en comportement réellement observé.

Laissez ensuite fonctionner le mode shadow pendant quelques jours. Une supervision sophistiquée (genre… Splunk !) n’est pas obligatoire pour commencer : jq permet déjà d’agréger les signatures sans afficher les adresses ni les requêtes :

sudo jq -r '
  select(.event_type == "alert")
  | [.alert.signature_id, .alert.signature] | @tsv
' /var/log/suricata/eve-security.json | sort | uniq -c | sort -nr | head

Choisir ce qui mérite vraiment de bloquer

La fréquence ne suffit pas. Une règle déclenchée mille fois peut simplement détecter un crawler, une anomalie de flux ou une chaîne de caractères banale. J’ai retenu les signatures qui décrivaient une requête très précise vers un secret, un fichier de sauvegarde ou une exploitation incompatible avec les applications exposées. Les heuristiques SQL ou PHP génériques, les anomalies de parseur et les règles de réputation sont restées en alerte.

La gestion officielle des règles avec Suricata-Update prévoit un fichier drop.conf. Il contient uniquement les SID approuvés :

# /etc/suricata/drop.conf
# Un SID par ligne, après validation dans vos propres événements
<SID_VALIDÉ_1>
<SID_VALIDÉ_2>

À la sortie du mode shadow, retirez la conversion globale de modify.conf. Si votre feed contient déjà des règles drop ou reject non approuvées, neutralisez-les explicitement par SID. Suricata-Update applique drop.conf avant modify.conf : vérifiez donc toujours le résultat généré. Testez hors ligne avant de charger la conf, puis utilisez le socket de contrôle pour éviter un redémarrage complet :

sudo suricata-update
sudo suricata -T -c /etc/suricata/suricata.yaml

awk '/^[[:space:]]*drop[[:space:]]+/ { drops++ }
     END { print "drop", drops+0 }'   /var/lib/suricata/rules/suricata.rules

sudo suricatasc -c reload-rules
sudo suricatasc -c ruleset-stats

Commencez avec un petit groupe. Vérifiez dans EVE que alert.action indique le blocage et que le verdict final confirme le drop. Toute requête plausible doit être considérée comme une candidate au rollback, pas comme un faux positif à expliquer après coup.

Rendre la configuration persistante, puis tester le redémarrage

Une validation live ne prouve pas que le serveur reviendra dans le même état au prochain boot. Docker, Fail2ban, CrowdSec et d’autres services reconstruisent leurs propres chaînes. Si vous figez leurs données temporaires dans votre fichier persistant, ou si votre hook Suricata revient avant leurs blocages, l’ordre final peut changer.

Ne persistez que les chaînes et les hooks stables dont vous êtes propriétaire. Après un redémarrage contrôlé, recommencez les tests IPv4, IPv6, SSH, NFQUEUE, règles chargées et événements. C’est moins spectaculaire qu’une capture d’écran avec un gros bouton vert, mais nettement plus utile le dimanche matin.

Et HTTPS dans tout ça ?

Sur l’interface publique, Suricata voit la connexion TLS, ses métadonnées et les caractéristiques réseau. Il ne voit pas le chemin HTTP ou le corps d’une requête HTTPS normale, puisqu’ils sont chiffrés jusqu’au reverse proxy. Il peut néanmoins analyser le HTTP envoyé en clair et certaines attaques réseau ou TLS.

J’ai envisagé de lui faire inspecter le trafic déchiffré entre Nginx Proxy Manager et les applications Docker. Techniquement, on peut imaginer des bridges, des gateways ou des relais supplémentaires. Dans mon architecture, cela ajoutait surtout de l’adhérence, des chemins réseau particuliers et de nouvelles façons de casser le « lift and shift » que j’aime tant de mes containers.

La conclusion est plus simple : Suricata IPS reste la protection réseau de bordure du serveur. La protection applicative du HTTP déchiffré appartient à un WAF placé après la terminaison TLS. Les deux outils sont complémentaires ; tordre l’un pour lui faire jouer le rôle de l’autre n’a aucun sens.

52 046 règles, 47 autorisées à bloquer

Après les périodes d’observation, ma politique Suricata IPS autorise 47 signatures très ciblées à bloquer. Lors de la dernière phase de validation de 7 jours, 109 flux ont réellement été stoppés, sans requête légitime identifiée. Les autres règles continuent à produire des alertes. Elles ne sont pas « inutiles » : elles apportent du contexte sans obtenir le droit de casser une connexion.

Ce projet a été long parce que chaque étape devait survivre à un arrêt du moteur, un changement de ruleset, IPv4, IPv6, Docker et parfois un reboot, et surtout des longues périodes d’observation pour s’assurer que la conf était stable. La configuration finale, elle, reste simple. C’est plutôt bon signe.

J’ai mené le chantier avec Pwny, mon assistant Codex connecté au serveur que vous connaissez maintenant bien. Il pouvait inspecter l’état réel, préparer les candidats et comparer les logs. Les changements de firewall et les promotions de règles restaient soumis à mon accord, avec deux accès ouverts, un rollback armé et des critères de validation mesurables. Pour le coup, ce cadre a été plus important que la vitesse d’écriture des scripts.

Mon verdict sur Suricata IPS tient donc en une idée : rendez d’abord votre IPS inoffensif, puis rendez-le progressivement utile. Si vous commencez par transformer 50 000 alertes en 50 000 décisions de blocage, prévoyez peut-aussi un excellent forfait data pour accéder à la console de secours. Bref, testez, observez, bloquez peu… et surtout Geekez !

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. Découvrez comment les données de vos commentaires sont traitées.