Wireshark est l’analyseur de protocoles réseau de référence, distribué gratuitement sous licence GPLv2 par la Wireshark Foundation. Il décode plus de 3 000 protocoles et présente chaque paquet capturé avec son contenu détaillé. Ce tutoriel décrit l’installation, les filtres essentiels, et neuf scénarios d’analyse couramment rencontrés en production : détection de scan de ports, extraction de credentials en clair, extraction de fichiers, exfiltration DNS, dépannage TLS, isolation d’un flux suspect, capture distante, automatisation par script, et analyse forensique post-incident.

1 — Cadre légal et éthique

La capture de trafic réseau est encadrée par la loi n° 2008-12 du 25 janvier 2008 sur la protection des données à caractère personnel au Sénégal et par le Code pénal pour l’accès frauduleux à un système de traitement automatisé de données (article 431-7). Conditions cumulatives pour capturer légitimement :

Le réseau capturé est votre propriété ou celle de votre employeur, ET
L’opération est documentée (mandat écrit de l’administrateur du système ou de la direction), ET
Les utilisateurs sont informés en amont si la capture concerne leur trafic (charte informatique signée).

Pour de l’apprentissage, capturez uniquement votre propre trafic local ou utilisez des fichiers PCAP publics (Wireshark Sample Captures, malware-traffic-analysis.net).

2 — Installation

Sur Ubuntu/Debian :

sudo apt update
sudo apt install wireshark
sudo dpkg-reconfigure wireshark-common  # autoriser non-root
sudo usermod -aG wireshark $USER
newgrp wireshark

Sur macOS via Homebrew :

brew install --cask wireshark

Sur Windows : télécharger l’installeur officiel sur wireshark.org/download.html et installer Npcap (driver de capture) lors de l’installation.

Vérification :

wireshark --version
tshark --version

tshark est la version CLI utilisée pour les scripts et la capture distante (étape 8).

3 — Première capture

Lister les interfaces disponibles :

tshark -D

Démarrer une capture sur l’interface principale (typiquement eth0, wlan0, ou en0 sur macOS) :

sudo tshark -i eth0 -w capture.pcap -a duration:60

Cette commande capture pendant 60 secondes et écrit le résultat dans capture.pcap. Ouvrir ensuite dans l’interface graphique :

wireshark capture.pcap

4 — Filtres d’affichage

Les filtres d’affichage (display filters) s’appliquent après capture et n’altèrent pas le fichier. Saisis dans la barre verte de Wireshark.

Objectif	Filtre
HTTP uniquement	`http`
HTTPS / TLS	`tls`
DNS uniquement	`dns`
Trafic d’une IP source	`ip.src == 192.168.1.42`
Trafic vers une IP de destination	`ip.dst == 8.8.8.8`
Port TCP 80	`tcp.port == 80`
Port UDP 53	`udp.port == 53`
SYN sans ACK (début connexion)	`tcp.flags.syn == 1 && tcp.flags.ack == 0`
Reset TCP	`tcp.flags.reset == 1`
Combiner deux conditions	`http && ip.src == 192.168.1.42`
Exclusion	`!(arp \|\| icmp)`

Wireshark expose plus de 328 000 champs filtrables. La liste complète est documentée dans View > Internals > Supported Protocols.

5 — Filtres de capture (BPF)

Les filtres de capture (capture filters) utilisent la syntaxe BPF (Berkeley Packet Filter) et s’appliquent au moment de la capture, économisant CPU et stockage sur des trafics volumineux.

# Capturer uniquement le trafic HTTP/HTTPS
sudo tshark -i eth0 -f "tcp port 80 or tcp port 443" -w web.pcap

# Capturer une IP spécifique
sudo tshark -i eth0 -f "host 192.168.1.42" -w hote.pcap

# Capturer un sous-réseau
sudo tshark -i eth0 -f "net 192.168.1.0/24" -w lan.pcap

# Exclure ARP et broadcast
sudo tshark -i eth0 -f "not arp and not broadcast" -w utile.pcap

La syntaxe BPF n’est pas la même que celle des filtres d’affichage : pas de double ==, pas de &&, on utilise and, or, not en clair.

6 — Détecter un scan de ports

Un scan de ports laisse une signature reconnaissable : un grand nombre de paquets SYN vers la même cible, sur des ports différents, en quelques secondes, sans phase d’établissement complète (pas de ACK).

Filtre d’identification :

tcp.flags.syn == 1 && tcp.flags.ack == 0 && ip.dst == 192.168.1.10

Exporter la liste des ports ciblés via Statistics > Conversations > TCP, puis trier par « Bytes » descendant. Un scan TCP SYN classique (nmap -sS) génère plusieurs centaines de connexions vers la même IP destination en moins d’une minute.

Pour un scan plus furtif (FIN, NULL, Xmas), filtrer :

tcp.flags.fin == 1 && tcp.flags.ack == 0    # FIN scan
tcp.flags == 0x000                            # NULL scan
tcp.flags.fin == 1 && tcp.flags.psh == 1 && tcp.flags.urg == 1  # Xmas

7 — Extraire les credentials transmis en clair

Les protocoles non chiffrés (HTTP, FTP, Telnet, POP3, IMAP, SMTP non-STARTTLS) transmettent les identifiants en clair. Trois manipulations Wireshark :

HTTP POST avec authentification basique :

http.authbasic

Le champ http.authbasic contient l’en-tête Authorization en base64. Décodage :

echo "dXNlcjpwYXNzMTIz" | base64 -d
# user:pass123

FTP USER/PASS :

ftp.request.command == "USER" || ftp.request.command == "PASS"

Formulaires HTTP en clair :

http.request.method == "POST" && http contains "password"

Les paramètres POST apparaissent dans le panneau du bas, section HTML Form URL Encoded.

8 — Extraire les fichiers transférés

Pour reconstruire un fichier transféré en HTTP : File > Export Objects > HTTP. La fenêtre liste tous les objets HTTP reconstruits (HTML, JS, images, PDF). Sélectionner et « Save ».

Pour SMB et autres protocoles applicatifs : File > Export Objects > SMB.

Pour extraire en CLI :

tshark -r capture.pcap --export-objects http,./extracted_files/

9 — Détecter une exfiltration via DNS

Une exfiltration DNS encode des données dans des sous-domaines de longueur anormale (souvent 30 à 60 caractères) interrogés en TXT ou CNAME vers un domaine contrôlé par l’attaquant.

Filtrer les requêtes DNS suspectes :

dns.qry.name.len > 50

Statistiques par domaine de second niveau :

tshark -r capture.pcap -Y dns -T fields -e dns.qry.name | \
  awk -F'.' '{print $(NF-1)"."$NF}' | sort | uniq -c | sort -rn | head -20

Un domaine légitime (google.com, cloudflare.com) reçoit des requêtes courtes et répétitives. Un domaine d’exfiltration reçoit des sous-domaines uniques et longs avec un volume anormal.

10 — Déchiffrer du TLS

Le déchiffrement TLS dans Wireshark est possible si vous disposez d’au moins l’une de ces sources :

Le fichier de log SSLKEYLOGFILE — variable d’environnement SSLKEYLOGFILE=/tmp/sslkeys.log avant lancement de Firefox/Chrome/curl. Wireshark l’importe via Edit > Preferences > Protocols > TLS > (Pre)-Master-Secret log filename.
La clé privée RSA du serveur (uniquement si la suite de chiffrement n’utilise pas Perfect Forward Secrecy — donc plus rare en 2026 où ECDHE est par défaut).

Sans l’une de ces sources, le contenu TLS reste opaque. Vous voyez les SNI (Server Name Indication) et la taille des paquets, c’est tout.

# Filtre SNI pour identifier les domaines visités malgré le chiffrement
tls.handshake.extensions_server_name

11 — Statistiques rapides

Quatre rapports utiles disponibles dans le menu Statistics :

Protocol Hierarchy — répartition par protocole en pourcentage des paquets et des octets. Utile pour repérer un protocole anormal (un trafic Tor encapsulé apparaît souvent en TLS sur des ports inhabituels).
Conversations — paires source/destination triées par volume. Onglets IPv4, IPv6, TCP, UDP.
Endpoints — IPs uniques, paquets envoyés/reçus, géolocalisation si la base GeoIP est configurée.
I/O Graph — graphique du débit par seconde, multi-séries pour comparer plusieurs filtres simultanément.

Équivalent CLI :

# Protocol Hierarchy
tshark -r capture.pcap -q -z io,phs

# Conversations TCP
tshark -r capture.pcap -q -z conv,tcp

# Top 10 IPs sources
tshark -r capture.pcap -T fields -e ip.src | sort | uniq -c | sort -rn | head -10

12 — Capturer sur un serveur distant

Pour analyser le trafic d’un serveur Linux distant sans installer Wireshark sur la machine cible, deux approches.

Approche 1 — SSH + tshark en pipe :

ssh user@serveur "sudo tshark -i eth0 -w - -f 'not port 22'" | wireshark -k -i -

Le filtre not port 22 exclut le SSH lui-même pour éviter une boucle infinie de capture.

Approche 2 — tcpdump puis transfert :

ssh user@serveur "sudo tcpdump -i eth0 -w /tmp/cap.pcap -G 60 -W 1 -s 65535 'not port 22'"
scp user@serveur:/tmp/cap.pcap ./
wireshark cap.pcap

L’option -G 60 -W 1 arrête la capture après 60 secondes. -s 65535 capture le paquet complet sans troncature.

13 — Automatiser l’analyse en script

Pour un audit récurrent, scripter avec tshark et Python (bibliothèque pyshark).

# Script Python : extraire les requêtes HTTP suspectes
import pyshark

cap = pyshark.FileCapture('capture.pcap', display_filter='http.request')
for pkt in cap:
    try:
        host = pkt.http.host
        uri = pkt.http.request_uri
        if any(s in uri for s in ['/admin', '/wp-login', '/.env', '/.git']):
            print(f"{pkt.sniff_time} {pkt.ip.src} -> {host}{uri}")
    except AttributeError:
        continue
cap.close()

Installation :

pip install pyshark
# Nécessite tshark installé sur le système

14 — Cas pratique : trafic anormal sur un VPS Coolify

Symptôme : pic de trafic sortant d’un VPS Hostinger ou Hetzner hébergeant Coolify. Capture de 60 secondes :

sudo tshark -i eth0 -w /tmp/incident.pcap -a duration:60

Ouvrir dans Wireshark et lancer dans cet ordre :

Statistics > Endpoints > IPv4 — repérer les IPs externes avec le plus gros volume sortant. Les IPs cloud (AWS, GCP, Cloudflare) sont normales pour des registries Docker. Les IPs résidentielles ou en pays inhabituels sont à examiner.
Filtrer les conversations vers une IP suspecte : ip.dst == X.X.X.X.
Identifier le port et le protocole. SSH sortant (port 22) vers une IP non-administrateur peut indiquer un reverse shell. HTTPS vers un domaine récent (registreur whois < 30 jours) est suspect.
Examiner les SNI : tls.handshake.extensions_server_name contains "domaine-suspect".
Si DNS douteux : dns && dns.qry.name.len > 40.

Si la capture confirme un C2 ou une exfiltration, isoler le VPS via le pare-feu Hetzner Cloud Console ou Hostinger panel, snapshotter le disque pour forensique, et restaurer depuis backup vérifié.

Analyser le trafic réseau avec Wireshark — tutoriel pas-à-pas