Wireshark : Analyser le Trafic Réseau sous Linux

Introduction : pourquoi analyser le trafic réseau ?

L'analyse de trafic réseau, aussi appelée packet analysis ou sniffing, consiste à capturer et inspecter les paquets qui transitent sur un réseau. Elle répond à plusieurs cas d'usage fondamentaux :

• Débogage réseau : identifier les retransmissions TCP, les timeouts, les erreurs DNS, les connexions refusées.
• Sécurité offensive : détecter des protocoles non chiffrés transmettant des credentials, analyser le comportement d'un malware.
• Sécurité défensive : valider les règles de pare-feu, vérifier que le chiffrement TLS est bien en place, détecter des scans de ports.
• Forensics : reconstituer une attaque à posteriori à partir de fichiers pcap, extraire des fichiers transférés via HTTP ou SMB.
• Optimisation des performances : mesurer les latences, identifier les goulets d'étranglement, analyser les négociations TCP.

Wireshark est l'outil de référence pour toutes ces tâches. Il dissèque plus de 3 000 protocoles, s'intègre avec tshark pour l'automatisation, et peut lire des fichiers pcap issus de tcpdump, Suricata ou n'importe quel autre outil de capture.

Installation

Debian / Ubuntu

Wireshark est disponible dans les dépôts officiels. Lors de l'installation, un dialogue demande si les utilisateurs non-root doivent pouvoir capturer : choisissez Yes pour activer le groupe wireshark.

sudo apt update
sudo apt install -y wireshark wireshark-qt tshark

# Ajouter votre utilisateur au groupe wireshark
sudo usermod -aG wireshark $USER

# Recharger la session (ou déconnecter/reconnecter)
newgrp wireshark

CentOS / RHEL / Rocky Linux

sudo dnf install -y wireshark wireshark-cli

# Sur CentOS 7 avec yum
sudo yum install -y wireshark wireshark-gnome

# Ajouter l'utilisateur au groupe wireshark
sudo usermod -aG wireshark $USER

Capture sans root avec setcap

Pour autoriser la capture sans passer root, accordez les capacités réseau à dumpcap (le moteur de capture bas niveau de Wireshark) :

# Accorder les capacités nécessaires à dumpcap
sudo setcap cap_net_raw,cap_net_admin=eip /usr/bin/dumpcap

# Vérifier
getcap /usr/bin/dumpcap
# /usr/bin/dumpcap cap_net_raw,cap_net_admin=eip

Cette méthode est plus sûre que de lancer Wireshark en root car seul le processus de capture minimal obtient les privilèges élevés.

Vérifier l'installation

wireshark --version
tshark --version
dumpcap --version

Interface graphique : prise en main

Écran de démarrage

Au lancement, Wireshark affiche la liste des interfaces réseau disponibles avec un graphique d'activité en temps réel. Les interfaces actives montrent du mouvement. Les interfaces principales sont :

• eth0 / enp3s0 : interface Ethernet filaire
• wlan0 : interface Wi-Fi
• lo : loopback (trafic local)
• any : capture sur toutes les interfaces simultanément
• docker0, br-xxxxx : interfaces Docker et bridges

Menus principaux

• File : ouvrir/sauvegarder des fichiers pcap, fusionner des captures.
• Capture : démarrer/arrêter la capture, options avancées (buffer, rotation de fichiers).
• Analyze : appliquer des filtres, Follow Stream, décoder des protocoles.
• Statistics : I/O Graph, Conversations, Endpoints, Protocol Hierarchy.
• Telephony : analyse VoIP (SIP, RTP).
• Tools : générateur de clés, règles de colorisation.

Colonnes par défaut

La vue principale affiche les paquets avec ces colonnes : No. (numéro séquentiel), Time (timestamp), Source, Destination, Protocol, Length, Info. Chaque colonne est personnalisable via un clic droit.

Capture de paquets

Démarrage rapide

Double-cliquez sur une interface dans l'écran de démarrage pour lancer immédiatement la capture. La barre de statut affiche le nombre de paquets capturés et le débit.

Options de capture avancées

Via Capture → Options (ou Ctrl+K), vous pouvez configurer :

• Interface : sélectionner une ou plusieurs interfaces.
• Promiscuous mode : capturer tout le trafic du segment, pas seulement celui destiné à votre machine.
• Capture Filter : filtre BPF appliqué au niveau du kernel pour réduire les paquets capturés.
• Ring Buffer : rotation automatique des fichiers (utile pour les longues captures).
• Stop conditions : arrêter après N paquets, N secondes, ou N Mo.

Filtres de capture (BPF syntax)

Les filtres de capture utilisent la syntaxe BPF (Berkeley Packet Filter). Ils sont appliqués dans le kernel avant que les paquets n'atteignent Wireshark, ce qui réduit la charge CPU et la taille des captures.

# Capturer uniquement le trafic HTTP et HTTPS
port 80 or port 443

# Capturer le trafic d'un hôte spécifique
host 192.168.1.100

# Capturer le trafic d'un réseau entier
net 192.168.1.0/24

# Capturer uniquement TCP
tcp

# Capturer uniquement UDP
udp

# Capturer le trafic DNS (port 53 UDP et TCP)
port 53

# Capturer tout sauf le trafic SSH (évite de capturer sa propre session)
not port 22

# Combinaison : TCP vers/depuis un hôte sur des ports spécifiques
tcp and host 10.0.0.1 and (port 80 or port 443)

# Capturer ICMP (ping)
icmp

# Capturer un sous-réseau en excluant un hôte
net 10.0.0.0/8 and not host 10.0.0.1

Filtres d'affichage

Les filtres d'affichage de Wireshark ont leur propre syntaxe, distincte du BPF. Ils opèrent sur les champs des protocoles dissectés et offrent une granularité bien supérieure.

Filtres par protocole

# Afficher uniquement HTTP
http

# Afficher uniquement DNS
dns

# Afficher uniquement TLS
tls

# Afficher uniquement TCP
tcp

# Afficher uniquement UDP
udp

# Afficher uniquement ICMP
icmp

# Afficher uniquement ARP
arp

# Afficher DHCP
bootp

# Afficher NTP
ntp

# Afficher le trafic SMB
smb or smb2

Filtres par adresse IP et port

# Par adresse IP source ou destination
ip.addr == 192.168.1.100

# Par adresse IP source uniquement
ip.src == 192.168.1.100

# Par adresse IP destination uniquement
ip.dst == 8.8.8.8

# Par sous-réseau
ip.addr == 192.168.1.0/24

# Par port TCP (source ou destination)
tcp.port == 443

# Par port TCP destination uniquement
tcp.dstport == 80

# Par port TCP source
tcp.srcport == 443

# Par port UDP destination
udp.dstport == 53

# Par port UDP source ou destination
udp.port == 5353

Opérateurs et combinaisons

# ET logique
ip.addr == 192.168.1.1 && tcp.port == 80

# OU logique
tcp.port == 80 || tcp.port == 443

# Négation
!tcp.port == 22
not dns

# Contient une chaîne (sensible à la casse)
http.request.uri contains "login"

# Expression régulière
http.host matches ".*\.google\.com"

# Plage de valeurs
tcp.port >= 1024 && tcp.port <= 65535

# Champ présent (protocole avec flag spécifique)
tcp.flags.syn == 1

# Combinaison complexe : HTTP POST vers une IP spécifique
http.request.method == "POST" && ip.dst == 93.184.216.34

Filtres pratiques courants

# Afficher uniquement les requêtes HTTP GET
http.request.method == "GET"

# Afficher uniquement les réponses HTTP avec erreurs 4xx et 5xx
http.response.code >= 400

# Afficher les requêtes DNS de type A
dns.qry.type == 1

# Afficher les paquets TCP avec le flag RST (connexions réinitialisées)
tcp.flags.reset == 1

# Afficher les retransmissions TCP
tcp.analysis.retransmission

# Afficher les paquets TCP avec des problèmes analysés
tcp.analysis.flags

# Afficher uniquement les échanges TLS Client Hello
tls.handshake.type == 1

# Exclure le trafic loopback
ip.addr != 127.0.0.1

Analyse des protocoles

HTTP : méthodes, headers et reconstruction de flux

Wireshark dissèque entièrement HTTP/1.x. Pour voir une requête HTTP complète :

1. Appliquez le filtre http.
2. Cliquez sur un paquet de requête. Dans le panneau de dissection, dépliez Hypertext Transfer Protocol pour voir méthode, URI, headers.
3. Pour reconstruire l'échange complet, faites un clic droit → Follow → HTTP Stream. Wireshark reconstitue la requête et la réponse dans une fenêtre distincte.

# Filtres HTTP utiles
http.request.method == "POST"          # Requêtes POST (potentiellement avec données)
http.request.uri contains "/admin"     # Accès aux URLs d'administration
http.response.code == 200              # Réponses OK
http.response.code == 401             # Authentification requise
http.cookie                            # Paquets avec cookies
http.authorization                     # Paquets avec header Authorization

DNS : requêtes, réponses et enregistrements

Le protocole DNS est particulièrement utile pour détecter des comportements suspects : exfiltration DNS, utilisation de domaines malveillants, ou problèmes de résolution.

# Toutes les requêtes DNS
dns

# Uniquement les requêtes (pas les réponses)
dns.flags.response == 0

# Uniquement les réponses
dns.flags.response == 1

# Requêtes de type A (IPv4)
dns.qry.type == 1

# Requêtes de type AAAA (IPv6)
dns.qry.type == 28

# Requêtes de type MX (email)
dns.qry.type == 15

# Requêtes pour un domaine spécifique
dns.qry.name contains "example.com"

# Réponses avec un TTL très court (souvent signe de fast-flux)
dns.a.ttl < 60

Dans le panneau de dissection, une réponse DNS montre : la question, les Answer Records avec le TTL et l'adresse résolue, et les Additional Records. Un TTL de 0 indique que l'enregistrement ne doit pas être mis en cache.

TCP : flags, handshake et retransmissions

La compréhension des flags TCP est fondamentale pour diagnostiquer les problèmes réseau :

• SYN : initiation de connexion (début du handshake 3 voies).
• SYN-ACK : réponse du serveur au SYN.
• ACK : accusé de réception.
• FIN : fermeture propre de connexion.
• RST : réinitialisation brutale (connexion refusée ou erreur).
• PSH : pousser les données vers la couche application immédiatement.

# Visualiser un handshake TCP à 3 voies
tcp.flags.syn == 1

# Connexions refusées (RST en réponse à SYN)
tcp.flags.reset == 1 && tcp.flags.syn == 0

# Retransmissions TCP (indicateur de perte de paquets)
tcp.analysis.retransmission

# Duplicate ACK (signe de congestion ou de perte)
tcp.analysis.duplicate_ack

# Window size à zéro (récepteur saturé)
tcp.window_size == 0

# Paquets hors ordre
tcp.analysis.out_of_order

# Fermetures de connexion
tcp.flags.fin == 1

Le filtre tcp.analysis.flags affiche tous les paquets pour lesquels Wireshark a détecté une anomalie (retransmissions, ACK dupliqués, paquets hors ordre). C'est un excellent point de départ pour diagnostiquer les problèmes de performance.

TLS : négociation et inspection sans déchiffrement

Même sans déchiffrer le contenu, Wireshark permet d'analyser la négociation TLS. Le Client Hello est particulièrement riche en informations.

# Tous les échanges TLS
tls

# Client Hello (début de négociation)
tls.handshake.type == 1

# Server Hello
tls.handshake.type == 2

# Certificate (le certificat serveur)
tls.handshake.type == 11

# Finished (fin de handshake)
tls.handshake.type == 20

# TLS 1.3 uniquement
tls.record.version == 0x0304

# SNI (Server Name Indication) - révèle le domaine même en HTTPS
tls.handshake.extensions_server_name contains "example.com"

Le champ SNI (Server Name Indication) dans le Client Hello révèle le domaine cible même sur une connexion HTTPS. C'est pourquoi il est possible de monitorer les domaines visités sans déchiffrer le contenu.

Fonctionnalités avancées

Follow TCP/UDP Stream

La fonctionnalité Follow Stream reconstruit une conversation complète entre deux hôtes. Elle est essentielle pour analyser les échanges applicatifs.

1. Sélectionnez un paquet appartenant à la connexion.
2. Clic droit → Follow → TCP Stream (ou UDP Stream, ou TLS Stream si vous avez les clés).
3. La fenêtre affiche le dialogue client (rouge) et serveur (bleu) reconstitué.
4. Vous pouvez filtrer sur ce stream uniquement, sauvegarder le contenu en brut ou en texte.

Statistics : vue d'ensemble du trafic

Le menu Statistics offre plusieurs vues analytiques :

• Protocol Hierarchy : répartition du trafic par protocole en pourcentage. Idéal pour identifier les protocoles dominants ou inattendus.
• Conversations : liste toutes les paires source/destination avec le volume de données échangées. Permet d'identifier rapidement les gros émetteurs.
• Endpoints : liste tous les hôtes vus dans la capture avec leurs statistiques de trafic.
• I/O Graph : graphique du débit réseau en fonction du temps. Superposez plusieurs courbes avec différents filtres pour comparer le trafic normal vs suspect.
• Flow Graph : diagramme de séquence des échanges entre hôtes, idéal pour visualiser un handshake ou un protocole d'application.

Export Objects

Wireshark peut extraire les fichiers transférés sur le réseau via certains protocoles. Via File → Export Objects :

• HTTP : extrait les fichiers téléchargés (images, exécutables, documents) depuis le trafic HTTP.
• SMB : extrait les fichiers partagés via SMB/CIFS (partages Windows).
• DICOM : pour les environnements médicaux.
• TFTP : fichiers transférés via TFTP.

Cette fonctionnalité est précieuse en forensics pour récupérer les fichiers échangés lors d'un incident de sécurité.

Règles de colorisation

Wireshark colore automatiquement les paquets selon des règles prédéfinies. Vous pouvez les personnaliser via View → Coloring Rules. Par défaut :

• Vert : trafic HTTP standard.
• Bleu clair : trafic DNS.
• Noir : erreurs TCP (retransmissions, RST).
• Rouge : erreurs graves (checksum incorrect).

Créez vos propres règles pour mettre en évidence le trafic d'un hôte particulier, d'un protocole spécifique, ou d'un pattern suspect.

tshark en ligne de commande

tshark est l'équivalent CLI de Wireshark. Il utilise les mêmes moteurs de dissection et les mêmes filtres d'affichage, mais s'intègre dans des scripts et fonctionne sans interface graphique.

Capture basique

# Lister les interfaces disponibles
tshark -D

# Capturer sur eth0 avec sortie dans le terminal
tshark -i eth0

# Capturer avec un filtre de capture BPF
tshark -i eth0 -f "port 80 or port 443"

# Capturer et sauvegarder dans un fichier pcap
tshark -i eth0 -w /tmp/capture.pcap

# Capturer avec rotation de fichiers (1 fichier par 100 Mo, garder les 5 derniers)
tshark -i eth0 -b filesize:102400 -b files:5 -w /tmp/capture.pcap

# Capturer 1000 paquets puis s'arrêter
tshark -i eth0 -c 1000 -w /tmp/capture.pcap

# Capturer pendant 60 secondes
tshark -i eth0 -a duration:60 -w /tmp/capture.pcap

Lecture et filtrage de fichiers pcap

# Lire un fichier pcap
tshark -r /tmp/capture.pcap

# Lire avec un filtre d'affichage
tshark -r /tmp/capture.pcap -Y "http.request.method == POST"

# Extraire des champs spécifiques
tshark -r /tmp/capture.pcap -Y "dns" -T fields -e frame.time -e ip.src -e dns.qry.name

# Extraire les URLs HTTP
tshark -r /tmp/capture.pcap -Y "http.request" -T fields -e http.host -e http.request.uri

# Extraire les adresses IP sources et destinations
tshark -r /tmp/capture.pcap -T fields -e ip.src -e ip.dst | sort | uniq -c | sort -rn

# Compter les requêtes par domaine DNS
tshark -r /tmp/capture.pcap -Y "dns.flags.response == 0" -T fields -e dns.qry.name | sort | uniq -c | sort -rn

Export en JSON et CSV

# Export complet en JSON (très verbeux)
tshark -r /tmp/capture.pcap -T json > /tmp/capture.json

# Export en JSON avec filtres
tshark -r /tmp/capture.pcap -Y "http" -T json > /tmp/http_traffic.json

# Export de champs spécifiques en CSV (séparateur tabulation)
tshark -r /tmp/capture.pcap -T fields 
    -e frame.number 
    -e frame.time 
    -e ip.src 
    -e ip.dst 
    -e tcp.srcport 
    -e tcp.dstport 
    -e frame.len 
    -E separator=, 
    -E header=y 
    > /tmp/traffic.csv

# Export des flux HTTP avec les domaines et URIs
tshark -r /tmp/capture.pcap -Y "http.request" 
    -T fields 
    -e frame.time 
    -e ip.src 
    -e http.host 
    -e http.request.method 
    -e http.request.uri 
    -E separator=, 
    -E header=y 
    > /tmp/http_requests.csv

Statistiques en CLI

# Statistiques des conversations TCP
tshark -r /tmp/capture.pcap -q -z conv,tcp

# Statistiques des conversations UDP
tshark -r /tmp/capture.pcap -q -z conv,udp

# Hiérarchie des protocoles
tshark -r /tmp/capture.pcap -q -z io,phs

# Statistiques DNS
tshark -r /tmp/capture.pcap -q -z dns,tree

# Statistiques HTTP (codes de réponse, méthodes)
tshark -r /tmp/capture.pcap -q -z http,tree

# Endpoints (tous les hôtes)
tshark -r /tmp/capture.pcap -q -z endpoints,ip

Cas pratiques

Cas 1 : détecter un scan Nmap

Un scan Nmap SYN (half-open) envoie des paquets SYN vers de nombreux ports. Le pattern caractéristique est une rafale de SYN depuis une même source vers de nombreux ports de destination.

# Dans Wireshark, appliquer ce filtre pour voir les tentatives de connexion
tcp.flags.syn == 1 && tcp.flags.ack == 0

# tshark : compter les tentatives SYN par source
tshark -r /tmp/capture.pcap 
    -Y "tcp.flags.syn == 1 && tcp.flags.ack == 0" 
    -T fields -e ip.src -e tcp.dstport 
    | awk '{print $1}' | sort | uniq -c | sort -rn

# Détecter les réponses RST/ACK (ports fermés) qui suivent les SYN
tcp.flags.reset == 1 && tcp.flags.ack == 1

# Pattern complet d'un scan : beaucoup de SYN, beaucoup de RST-ACK en réponse
# Statistics → Conversations (TCP) dans Wireshark pour visualiser

Dans la vue Statistics → Conversations, un scan Nmap apparaît comme un hôte source qui initie des centaines de connexions TCP vers des ports différents du même hôte cible, avec presque aucun byte transféré par connexion.

Cas 2 : analyser une connexion HTTP

# Étape 1 : filtrer le trafic HTTP
http

# Étape 2 : identifier les requêtes POST (soumission de formulaires)
http.request.method == "POST"

# Étape 3 : Follow HTTP Stream sur une requête suspecte
# Clic droit → Follow → HTTP Stream

# Étape 4 : chercher des credentials en clair
http.authorization
# ou
http.request contains "password"

# Étape 5 : exporter les objets transférés
# File → Export Objects → HTTP

Cas 3 : identifier un problème TCP

# Étape 1 : afficher tous les paquets avec anomalies TCP
tcp.analysis.flags

# Étape 2 : focus sur les retransmissions
tcp.analysis.retransmission || tcp.analysis.fast_retransmission

# Étape 3 : chercher les connexions réinitialisées brutalement
tcp.flags.reset == 1

# Étape 4 : chercher les problèmes de fenêtre (congestion)
tcp.window_size_value == 0

# Étape 5 : visualiser le Round-Trip Time
# Statistics → TCP Stream Graphs → Round Trip Time

# Étape 6 : analyser avec tshark
tshark -r /tmp/capture.pcap -q -z tcp,stat,0

Cas 4 : analyser une résolution DNS suspecte

# Afficher toutes les requêtes DNS
dns.flags.response == 0

# Chercher des requêtes avec des sous-domaines très longs (exfiltration DNS)
dns.qry.name matches ".{50,}"

# Chercher des domaines DGA (Domain Generation Algorithm) - noms aléatoires
# Analyser visuellement dans Statistics → DNS

# tshark : extraire tous les domaines résolus
tshark -r /tmp/capture.pcap 
    -Y "dns.flags.response == 0" 
    -T fields 
    -e dns.qry.name 
    | sort | uniq -c | sort -rn | head -20

# Détecter les requêtes vers des serveurs DNS non autorisés (hors 8.8.8.8 par exemple)
dns && ip.dst != 8.8.8.8 && ip.dst != 1.1.1.1

Bonnes pratiques légales et RGPD

Règles fondamentales

• Autorisation explicite : ne capturez jamais sur un réseau sans autorisation écrite du propriétaire ou de l'administrateur responsable.
• Réseau propre : sur vos propres équipements (lab, VM de test, réseau domestique), aucune contrainte particulière.
• Environnement professionnel : politique de sécurité et charte informatique obligatoires. Les captures doivent être documentées et justifiées.
• Données personnelles : les captures réseau peuvent contenir des données personnelles (noms, emails, mots de passe). Le RGPD impose de minimiser la collecte, de sécuriser le stockage et de limiter la durée de conservation.
• Chiffrement des captures : un fichier pcap peut contenir des informations très sensibles. Chiffrez-les avec GPG ou VeraCrypt avant stockage ou transfert.

Recommandations opérationnelles

• Utilisez des filtres de capture pour limiter la collecte aux données strictement nécessaires à votre analyse.
• Supprimez les fichiers pcap après analyse ou archivez-les de manière sécurisée avec une durée de rétention définie.
• Documentez chaque capture : date, interface, raison, périmètre, responsable.
• En environnement de production, privilégiez les outils passifs (port mirroring, SPAN) plutôt que le mode promiscuous qui peut intercepter le trafic d'autres machines.
• Sur les réseaux commutés (switchés), vous ne voyez par défaut que le trafic de votre propre machine et les broadcasts. Pour capturer le trafic d'autres hôtes, il faut un SPAN port ou un réseau hub.

Conclusion

Wireshark est un outil fondamental pour tout professionnel de l'informatique, du développeur réseau au spécialiste en sécurité. Sa maîtrise permet de diagnostiquer des problèmes réseau complexes, de valider la sécurité d'une infrastructure, et d'analyser des incidents a posteriori.

Les points clés à retenir : utilisez les filtres de capture BPF pour réduire la charge dès la collecte, maîtrisez les filtres d'affichage Wireshark pour naviguer efficacement dans vos captures, et utilisez tshark pour automatiser vos analyses et les intégrer dans vos workflows de sécurité. Enfin, respectez toujours le cadre légal : l'analyse de trafic est un outil puissant qui exige une utilisation responsable et autorisée.