Détecter les anomalies dans Suricata

Introduction

Dans ce laboratoire, vous apprendrez à détecter les anomalies réseau à l'aide de Suricata, un puissant moteur de détection des menaces open-source. Vous explorerez les fonctionnalités clés telles que la configuration des règles, la surveillance du trafic et l'analyse des alertes pour identifier les menaces potentielles pour la sécurité.

Les exercices pratiques vous guideront à travers la configuration de Suricata, la création de règles de base et l'inspection en temps réel du trafic. Vous acquerrez une expérience pratique dans la détection d'activités suspectes telles que les requêtes de ping ICMP et la personnalisation des règles pour des scénarios de menace spécifiques.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL wireshark(("Wireshark")) -.-> wireshark/WiresharkGroup(["Wireshark"]) wireshark/WiresharkGroup -.-> wireshark/packet_capture("Packet Capture") wireshark/WiresharkGroup -.-> wireshark/display_filters("Display Filters") wireshark/WiresharkGroup -.-> wireshark/export_packets("Exporting Packets") wireshark/WiresharkGroup -.-> wireshark/packet_analysis("Packet Analysis") subgraph Lab Skills wireshark/packet_capture -.-> lab-549934{{"Détecter les anomalies dans Suricata"}} wireshark/display_filters -.-> lab-549934{{"Détecter les anomalies dans Suricata"}} wireshark/export_packets -.-> lab-549934{{"Détecter les anomalies dans Suricata"}} wireshark/packet_analysis -.-> lab-549934{{"Détecter les anomalies dans Suricata"}} end

Installer Suricata

Dans cette étape, vous allez installer Suricata, un moteur de détection des menaces réseau open-source. Suricata agit comme une caméra de sécurité pour votre réseau, analysant en permanence le trafic pour identifier les menaces potentielles. Il peut effectuer trois fonctions clés : la détection d'intrusion en temps réel (IDS - Intrusion Detection System) pour surveiller les attaques, la prévention d'intrusion en ligne (IPS - Intrusion Prevention System) pour bloquer le trafic malveillant et la surveillance de la sécurité réseau pour enregistrer toute l'activité.

Commençons le processus d'installation étape par étape :

Tout d'abord, nous devons mettre à jour la liste des paquets. Cela garantit que votre système connaît les dernières versions de logiciels disponibles avant d'installer quoi que ce soit :
```
sudo apt update
```
La commande sudo vous donne les privilèges d'administrateur, tandis que apt update met à jour la liste des paquets disponibles sur votre système.
Maintenant, nous allons installer Suricata ainsi que tous ses composants nécessaires (dépendances). Le drapeau -y confirme automatiquement l'installation :
```
sudo apt install -y suricata
```
Cette commande télécharge et installe le paquet logiciel Suricata à partir des dépôts officiels d'Ubuntu.
Après l'installation, vérifions que tout a fonctionné correctement en vérifiant la version installée :
```
suricata -V
```
Vous devriez voir une sortie similaire à :
```
This is Suricata version 6.0.3 RELEASE
```
Le drapeau -V demande à Suricata d'afficher ses informations de version. Voir cette sortie confirme que l'installation a réussi.
Le comportement de Suricata est contrôlé par un fichier de configuration. Vérifions si ce fichier important existe dans son emplacement par défaut :
```
ls /etc/suricata/suricata.yaml
```
Le répertoire /etc/suricata/ est généralement l'endroit où Linux stocke les fichiers de configuration pour les applications système.
Enfin, Suricata a besoin de règles pour savoir quoi rechercher dans le trafic réseau. Ces règles sont comme un ensemble d'instructions indiquant à Suricata ce qui constitue une activité suspecte. Les règles par défaut sont stockées dans :
```
ls /var/lib/suricata/rules
```
Le répertoire /var/lib/suricata/rules contient les fichiers de règles fournis avec l'installation de Suricata. Nous travaillerons avec ces règles plus tard dans le laboratoire.

Configurer des règles de base

Dans cette étape, vous allez configurer des règles de détection de base pour Suricata. Les règles sont le composant central qui indique à Suricata quoi rechercher dans le trafic réseau. Imaginez-les comme un ensemble d'instructions qui définissent des motifs suspects ou des menaces connues.

Tout d'abord, accédez au répertoire des règles de Suricata où tous les fichiers de règles sont stockés :
```
cd /var/lib/suricata/rules
```
C'est là que Suricata conserve ses fichiers de règles par défaut et personnalisés. L'emplacement du répertoire est spécifié dans la configuration de Suricata.
Liste les fichiers de règles existants pour voir ce qui est déjà disponible :
```
ls
```
Vous devriez voir plusieurs fichiers .rules tels que suricata.rules. Ces fichiers contiennent différentes catégories de règles que Suricata utilise pour la détection.
Examinons la structure d'une règle de base. Ouvrez le fichier principal de règles à l'aide de l'éditeur nano :
```
sudo nano suricata.rules
```
L'éditeur nano est un éditeur de texte simple que nous utiliserons pour modifier les règles. Vous verrez de nombreuses règles existantes avec des structures similaires.
Ajoutez une règle simple pour détecter les requêtes de ping ICMP (ajoutez - la à la fin du fichier) :
```
alert icmp any any -> any any (msg:"ICMP Ping Detected"; itype:8; sid:1000001; rev:1;)
```
Décortiquons ce que fait cette règle :
- alert : Indique à Suricata de générer une alerte lorsqu'il y a correspondance.
- icmp : S'applique au trafic du protocole ICMP.
- any any -> any any : Correspond à n'importe quelle adresse IP/port source vers n'importe quelle adresse IP/port de destination.
- msg : Le message d'alerte qui apparaîtra dans les journaux.
- itype:8 : Correspond spécifiquement au type 8 ICMP (requêtes de ping).
- sid : Identifiant unique de la règle (1000001+ pour les règles personnalisées).
- rev : Numéro de révision de la règle.
Enregistrez le fichier (Ctrl + O, Entrée, Ctrl + X dans nano). Cela enregistre votre nouvelle règle de manière permanente.
Vérifiez que la syntaxe de la règle est correcte avant de l'appliquer :
```
sudo suricata -T -c /etc/suricata/suricata.yaml -v
```
Le drapeau -T teste la configuration. Vous devriez voir une sortie se terminant par :
```
Configuration provided was successfully loaded. Exiting.
```
Cela confirme que votre règle est correctement formatée.
Redémarrez Suricata pour charger les nouvelles règles et commencer la surveillance :
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
La première commande arrête toute instance de Suricata en cours d'exécution, tandis que la deuxième la redémarre avec vos nouvelles règles, en surveillant l'interface eth0.

Surveiller le trafic en direct

Dans cette étape, nous allons observer comment Suricata surveille le trafic réseau en temps réel et génère des alertes en fonction des règles que nous avons configurées précédemment. C'est la fonctionnalité principale de tout système de détection d'intrusion (IDS - Intrusion Detection System) : surveiller les paquets réseau et signaler les activités suspectes.

Tout d'abord, nous devons démarrer Suricata en mode de capture en direct. Les commandes suivantes arrêteront d'abord toute instance de Suricata en cours d'exécution (si elle existe) puis démarreront une nouvelle instance pour surveiller l'interface eth0 :
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
Le drapeau -c spécifie notre fichier de configuration, tandis que -i indique à Suricata quelle interface réseau surveiller.
Maintenant, générons un peu de trafic de test qui devrait déclencher notre règle ICMP de l'étape précédente. Ouvrez un nouveau terminal et exécutez :
```
ping -c 3 8.8.8.8
```
Cela envoie 3 paquets de ping ICMP au serveur DNS de Google (8.8.8.8). Étant donné que nous avons créé une règle pour détecter le trafic ICMP, Suricata devrait enregistrer cette activité.
Suricata écrit les alertes dans le fichier /var/log/suricata/fast.log. Pour surveiller ces alertes en temps réel, utilisez :
```
sudo tail -f /var/log/suricata/fast.log
```
La commande tail -f affiche en continu les nouvelles lignes ajoutées au fichier. Vous devriez voir une sortie similaire à :
```
01/01/2023-12:34:56.123456  [**] [1:1000001:1] ICMP Ping Detected [**] [Classification: (null)] [Priority: 3] {ICMP} 192.168.1.1 -> 8.8.8.8
```
Cela montre l'horodatage, l'identifiant de la règle (1:1000001:1), le message d'alerte et les adresses IP source/destination.
Pour des journaux plus détaillés au format JSON, nous pouvons examiner le fichier eve.json. La commande suivante filtre et affiche joliment uniquement les événements d'alerte :
```
sudo tail -f /var/log/suricata/eve.json | jq '. | select(.event_type == "alert")'
```
L'outil jq aide à analyser et formater la sortie JSON, la rendant plus facile à lire.
Pour afficher des statistiques sur le trafic que Suricata traite, y compris le nombre d'alertes générées :
```
sudo suricatasc -c stats
```
Recherchez des compteurs tels que detect.alert dans la sortie - cela montre combien de fois nos règles ont déclenché des alertes.
Lorsque vous avez terminé d'observer le trafic, appuyez sur Ctrl + C dans toutes les fenêtres de terminal où vous surveillez les journaux pour arrêter la sortie continue.

Examiner les alertes générées

Dans cette étape, vous allez analyser les alertes générées par Suricata lors de la session de surveillance précédente. Cela vous aidera à comprendre quels motifs de trafic ont déclenché vos règles. Lorsque vous travaillez avec des systèmes de détection d'intrusion, l'examen des alertes est crucial pour identifier les menaces potentielles à la sécurité et affiner vos règles de détection.

Tout d'abord, vérifiez le journal d'alertes de base :
```
sudo cat /var/log/suricata/fast.log
```
Cette commande affiche les alertes horodatées dans un format simple et lisible par l'homme. Le fichier fast.log est le fichier de sortie d'alertes par défaut de Suricata. Recherchez les entrées contenant "ICMP Ping Detected" - celles-ci indiquent les requêtes de ping qui correspondent à votre règle de détection.
Pour une analyse plus détaillée, examinez le journal JSON structuré :
```
sudo cat /var/log/suricata/eve.json | jq '. | select(.event_type == "alert")'
```
Le fichier eve.json contient des journaux complets lisibles par machine au format JSON. Nous utilisons jq pour filtrer uniquement les événements d'alerte. Cela fournit des informations détaillées, notamment :
- Les adresses IP source et destination
- Des horodatages précis
- Les détails complets de la règle
- Les informations sur la charge utile du paquet (lorsque configuré)
Pour compter combien de fois chaque alerte a été déclenchée :
```
sudo grep -o "ICMP Ping Detected" /var/log/suricata/fast.log | wc -l
```
Ce pipeline extrait d'abord toutes les occurrences de "ICMP Ping Detected" à l'aide de grep -o, puis les compte avec wc -l. Cela permet de quantifier la fréquence à laquelle cet événement se produit.
Pour obtenir un résumé des types d'alertes :
```
sudo jq -r '.alert.signature' /var/log/suricata/eve.json | sort | uniq -c
```
Cette commande extrait toutes les signatures d'alerte (noms de règles), les trie par ordre alphabétique, puis compte les occurrences uniques. Elle vous donne une vue d'ensemble des règles qui se déclenchent le plus souvent.
Pour afficher les alertes avec les informations sur l'adresse IP source :
```
sudo jq -r 'select(.event_type == "alert") | [.timestamp, .src_ip, .alert.signature] | @tsv' /var/log/suricata/eve.json
```
Cette requête jq avancée crée une sortie séparée par des tabulations affichant l'horodatage, l'adresse IP source et la signature de l'alerte pour chaque événement. Le format @tsv facilite l'importation dans des tableurs.
Pour vérifier les 5 dernières alertes :
```
sudo tail -n 5 /var/log/suricata/fast.log
```
La commande tail affiche les dernières lignes d'un fichier. Cela est utile pour vérifier rapidement l'activité récente sans avoir à parcourir l'ensemble du journal.

Ajouter une règle personnalisée

Dans cette étape, vous allez apprendre à créer et tester votre propre règle Suricata pour détecter des motifs spécifiques dans le trafic réseau. Nous allons nous concentrer sur la détection des requêtes HTTP vers un domaine de test (example.com) comme exemple pratique. Les règles personnalisées vous permettent d'étendre les capacités de détection de Suricata au-delà de son ensemble de règles par défaut.

Tout d'abord, accédez au répertoire des règles où Suricata stocke ses règles de détection :
```
cd /var/lib/suricata/rules
```
C'est généralement là que tous les fichiers de règles Suricata sont stockés. Nous allons ajouter nos règles personnalisées ici pour les organiser avec les règles existantes.
Créez un nouveau fichier de règles spécifiquement pour vos règles personnalisées :
```
sudo nano custom.rules
```
L'utilisation de sudo est nécessaire car le répertoire des règles nécessite des privilèges administratifs pour être modifié. Nous nommons le fichier custom.rules pour le distinguer clairement des fichiers de règles par défaut de Suricata.
Ajoutez la règle suivante pour détecter les requêtes HTTP vers example.com :
```
alert http any any -> any any (msg:"HTTP Request to example.com"; flow:to_server; http.host; content:"example.com"; nocase; sid:1000002; rev:1;)
```
Analysons ce que fait cette règle :
- alert http : Déclenche une alerte pour le trafic HTTP
- any any -> any any : S'applique au trafic d'un port source quelconque vers un port de destination quelconque
- msg : Fournit un message d'alerte lisible par l'homme
- flow:to_server : Ne correspond qu'au trafic allant vers les serveurs
- http.host : Examine l'en-tête HTTP Host
- content:"example.com" : Recherche ce domaine spécifique
- nocase : Rend la correspondance insensible à la casse
- sid:1000002 : Donne à la règle un identifiant unique (au-dessus de 1 000 000 pour les règles personnalisées)
- rev:1 : Indique que c'est la première version de la règle
Enregistrez le fichier dans l'éditeur nano en appuyant sur Ctrl + O (écriture), puis Entrée pour confirmer, et Ctrl + X pour quitter.
Maintenant, nous devons indiquer à Suricata de charger notre nouveau fichier de règles. Modifiez la configuration principale :
```
sudo nano /etc/suricata/suricata.yaml
```
Trouvez la section rule-files: (généralement aux environs de la ligne 50 - 60) et ajoutez :
```
- custom.rules
```
Cette addition garantit que Suricata chargera nos règles personnalisées au démarrage.
Avant d'appliquer les modifications, vérifiez que la syntaxe de la règle est correcte :
```
sudo suricata -T -c /etc/suricata/suricata.yaml -v
```
Le drapeau -T indique à Suricata de tester la configuration sans réellement la lancer. Cela permet de détecter toute erreur de syntaxe dans vos règles avant qu'elles ne soient utilisées.
Redémarrez Suricata pour charger la nouvelle règle :
```
sudo pkill suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
```
La première commande arrête toute instance de Suricata en cours d'exécution, tandis que la deuxième la relance avec notre configuration mise à jour.
Pour tester si notre règle fonctionne, générez un peu de trafic HTTP vers example.com :
```
curl http://example.com
```
Cette commande effectue une simple requête HTTP qui devrait déclencher notre nouvelle règle.
Enfin, vérifiez si Suricata a détecté le trafic en affichant les dernières alertes :
```
sudo tail -n 5 /var/log/suricata/fast.log
```
Vous devriez voir une alerte correspondant au message de notre règle personnalisée concernant les requêtes HTTP vers example.com. Sinon, vérifiez chaque étape et assurez-vous que la syntaxe de la règle est correcte.

Résumé

Dans ce laboratoire, vous avez appris à installer et configurer Suricata, un moteur de détection des menaces réseau open-source. Le processus a inclus la mise à jour des paquets, l'installation des dépendances et la vérification de l'installation en vérifiant le fichier de configuration et le répertoire des règles.

Vous avez également exploré la création de règles de détection personnalisées en ajoutant une règle pour les requêtes de ping ICMP, en comprenant sa structure et ses composants. Enfin, vous avez vérifié la syntaxe de la règle pour vous assurer que Suricata peut surveiller efficacement le trafic réseau et générer des alertes en cas d'anomalies.