1. Introduction et installation

Wireshark est l'analyseur de protocoles réseau le plus utilisé au monde. Il permet de capturer et d'analyser le trafic réseau en temps réel ou à partir de fichiers de capture (pcap/pcapng).

Installation sur Linux (Debian/Ubuntu)

sudo apt update
sudo apt install wireshark
# Ajouter l'utilisateur au groupe wireshark pour capturer sans root
sudo usermod -aG wireshark $USER

Installation sur Linux (CentOS/RHEL/Fedora)

sudo dnf install wireshark wireshark-cli

Installation sur macOS

brew install --cask wireshark

Installation sur Windows

Télécharger l'installeur depuis https://www.wireshark.org/download.html. L'installation inclut Npcap pour la capture de paquets.

2. Interface et navigation

Les trois panneaux principaux

Panneau liste de paquets (haut) : affiche tous les paquets capturés avec un résumé pour chacun (numéro, temps, source, destination, protocole, longueur, info).

Panneau détails du paquet (milieu) : affiche les couches protocolaires du paquet sélectionné sous forme d'arbre dépliable.

Panneau octets (bas) : affiche le contenu brut du paquet en hexadécimal et ASCII.

Colonnes personnalisées

Clic droit sur un champ dans le panneau détails > Apply as Column pour ajouter une colonne personnalisée. Exemples utiles :

# Colonnes recommandées à ajouter :
# - tcp.stream    (numéro du flux TCP)
# - http.host     (nom d'hôte HTTP)
# - tls.handshake.extensions_server_name (SNI)
# - dns.qry.name  (requête DNS)

Profils de configuration

Menu Edit > Configuration Profiles ou clic droit en bas à droite sur le profil actif. Les profils permettent de sauvegarder différentes configurations (colonnes, couleurs, filtres) selon le contexte d'analyse.

3. Filtres d'affichage - Syntaxe de base

Les filtres d'affichage (Display Filters) permettent de filtrer les paquets déjà capturés. Ils s'appliquent dans la barre de filtre en haut de la fenêtre principale.

Opérateurs de comparaison

# Égalité
ip.addr == 192.168.1.1

# Différent
ip.addr != 192.168.1.1

# Supérieur / inférieur
tcp.port > 1024
frame.len < 100

# Supérieur ou égal / inférieur ou égal
tcp.window_size >= 65535
ip.ttl <= 64

# Contient (recherche de sous-chaîne)
http.user_agent contains "Mozilla"
frame contains "password"

# Correspond à une expression régulière
http.host matches ".*\\.example\\.com"
http.request.uri matches "\\.(php|asp|jsp)"

# Appartient à un ensemble
tcp.port in {80, 443, 8080}
http.request.method in {"GET", "POST"}

Opérateurs logiques

# ET
ip.src == 192.168.1.1 and tcp.port == 80
ip.src == 192.168.1.1 && tcp.port == 80

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

# NON
not arp
!dns

# Combinaisons avec parenthèses
(ip.src == 192.168.1.1 or ip.src == 192.168.1.2) and tcp.port == 80
tcp.port == 443 and !(ip.dst == 10.0.0.0/8)

4. Filtres par protocole

Ethernet (couche 2)

# Par adresse MAC (source ou destination)
eth.addr == aa:bb:cc:dd:ee:ff

# Par adresse MAC source
eth.src == aa:bb:cc:dd:ee:ff

# Par adresse MAC destination
eth.dst == aa:bb:cc:dd:ee:ff

# Par type Ethernet (0x0800 = IPv4, 0x0806 = ARP, 0x86dd = IPv6)
eth.type == 0x0800

# Trafic broadcast
eth.dst == ff:ff:ff:ff:ff:ff

IP (couche 3)

# Par adresse IP (source ou destination)
ip.addr == 192.168.1.1

# Par adresse IP source
ip.src == 192.168.1.1

# Par adresse IP destination
ip.dst == 10.0.0.0/8

# Par protocole IP (6=TCP, 17=UDP, 1=ICMP)
ip.proto == 6

# Par TTL
ip.ttl == 128
ip.ttl < 64

# Par longueur du paquet
ip.len > 1000

# Exclure un réseau
!(ip.addr == 10.0.0.0/8)

IPv6

# Par adresse IPv6
ipv6.addr == fe80::1

# Par adresse source IPv6
ipv6.src == 2001:db8::1

# Par adresse destination IPv6
ipv6.dst == ::1

TCP (couche 4)

# Par port (source ou destination)
tcp.port == 80

# Par port source
tcp.srcport == 443

# Par port destination
tcp.dstport == 22

# Par flags TCP
tcp.flags.syn == 1
tcp.flags.ack == 1
tcp.flags.rst == 1
tcp.flags.fin == 1
tcp.flags.push == 1

# SYN seul (début de connexion)
tcp.flags.syn == 1 and tcp.flags.ack == 0

# SYN-ACK (réponse de connexion)
tcp.flags.syn == 1 and tcp.flags.ack == 1

# RST (connexion refusée ou réinitialisée)
tcp.flags.rst == 1

# Par numéro de séquence
tcp.seq == 0

# Par longueur des données TCP
tcp.len > 0

# Par flux TCP (suit une conversation complète)
tcp.stream == 5

# Retransmissions TCP
tcp.analysis.retransmission

# Duplicated ACKs
tcp.analysis.duplicate_ack

# Zero Window
tcp.analysis.zero_window

UDP (couche 4)

# Par port (source ou destination)
udp.port == 53

# Par port source
udp.srcport == 67

# Par port destination
udp.dstport == 68

# Par longueur
udp.length > 512

HTTP

# Tout le trafic HTTP
http

# Requêtes HTTP uniquement
http.request

# Réponses HTTP uniquement
http.response

# Par méthode HTTP
http.request.method == "GET"
http.request.method == "POST"
http.request.method == "PUT"
http.request.method == "DELETE"

# Par nom d'hôte
http.host == "www.exemple.com"
http.host contains "exemple"

# Par URI
http.request.uri contains "/admin"
http.request.uri contains "/api/"

# Par code de réponse
http.response.code == 200
http.response.code == 404
http.response.code >= 400
http.response.code >= 500

# Par type de contenu
http.content_type contains "json"
http.content_type contains "html"

# Par User-Agent
http.user_agent contains "curl"
http.user_agent contains "Python"

# Par cookie
http.cookie contains "session"

# Requêtes POST avec données
http.request.method == "POST" and http.file_data

HTTPS / TLS

# Tout le trafic TLS
tls

# Handshake TLS
tls.handshake

# Type de handshake (1=ClientHello, 2=ServerHello, 11=Certificate)
tls.handshake.type == 1
tls.handshake.type == 2

# Par version TLS (0x0303 = TLS 1.2, 0x0304 = TLS 1.3)
tls.record.version == 0x0303

# Par SNI (Server Name Indication)
tls.handshake.extensions_server_name == "www.exemple.com"
tls.handshake.extensions_server_name contains "exemple"

# Alertes TLS
tls.alert_message

DNS

# Tout le trafic DNS
dns

# Par nom de requête
dns.qry.name == "www.exemple.com"
dns.qry.name contains "exemple"

# Par type de requête (1=A, 2=NS, 5=CNAME, 15=MX, 16=TXT, 28=AAAA)
dns.qry.type == 1
dns.qry.type == 28

# Réponses DNS avec adresses
dns.a == 192.168.1.1

# Par nom de réponse
dns.resp.name contains "exemple"

# Requêtes DNS uniquement
dns.flags.response == 0

# Réponses DNS uniquement
dns.flags.response == 1

# Réponses DNS avec erreurs (NXDOMAIN, SERVFAIL)
dns.flags.rcode != 0
dns.flags.rcode == 3

DHCP

# Tout le trafic DHCP
dhcp

# Par type de message (1=Discover, 2=Offer, 3=Request, 5=ACK)
dhcp.type == 1

# Par nom d'hôte demandé
dhcp.option.hostname contains "PC"

# Par adresse IP demandée
dhcp.option.requested_ip_address == 192.168.1.100

ICMP

# Tout le trafic ICMP
icmp

# Par type (0=Echo Reply, 3=Dest Unreachable, 8=Echo Request, 11=Time Exceeded)
icmp.type == 8
icmp.type == 0

# Par code
icmp.code == 0

# Ping (requêtes et réponses)
icmp.type == 8 or icmp.type == 0

# Destination inaccessible
icmp.type == 3

ARP

# Tout le trafic ARP
arp

# Requêtes ARP (opcode 1)
arp.opcode == 1

# Réponses ARP (opcode 2)
arp.opcode == 2

# Par adresse IP source
arp.src.proto_ipv4 == 192.168.1.1

# Par adresse IP destination
arp.dst.proto_ipv4 == 192.168.1.254

SMB

# Tout le trafic SMB
smb || smb2

# Par commande SMB1
smb.cmd == 0x72

# Par commande SMB2 (0=Negotiate, 1=SessionSetup, 3=TreeConnect, 5=Create, 8=Read, 9=Write)
smb2.cmd == 5

# Accès aux fichiers SMB2
smb2.filename contains "document"

FTP

# Tout le trafic FTP
ftp

# Par commande FTP
ftp.request.command == "USER"
ftp.request.command == "PASS"
ftp.request.command == "RETR"
ftp.request.command == "STOR"

# Par code de réponse FTP
ftp.response.code == 230
ftp.response.code == 530

SMTP

# Tout le trafic SMTP
smtp

# Par commande SMTP
smtp.req.command == "EHLO"
smtp.req.command == "MAIL"
smtp.req.command == "RCPT"
smtp.req.command == "DATA"
smtp.req.command == "AUTH"

5. Filtres de capture (BPF)

Les filtres de capture utilisent la syntaxe BPF (Berkeley Packet Filter) et s'appliquent avant la capture. Ils sont plus performants mais moins expressifs que les filtres d'affichage. On les configure dans l'écran de démarrage ou via Capture > Options.

Filtres par hôte

# Trafic vers/depuis un hôte
host 192.168.1.1

# Trafic source
src host 192.168.1.1

# Trafic destination
dst host 192.168.1.1

# Par nom DNS
host www.exemple.com

Filtres par réseau

# Tout le trafic d'un sous-réseau
net 192.168.1.0/24

# Source d'un sous-réseau
src net 10.0.0.0/8

# Destination d'un sous-réseau
dst net 172.16.0.0/12

Filtres par port

# Par port (TCP et UDP)
port 80

# Port source
src port 443

# Port destination
dst port 22

# Plage de ports
portrange 8000-9000

# Plusieurs ports
port 80 or port 443

Filtres par protocole

# TCP uniquement
tcp

# UDP uniquement
udp

# ICMP uniquement
icmp

# Trafic Ethernet ARP
ether proto arp

# VLAN
vlan

Combinaisons

# Trafic HTTP depuis un hôte spécifique
host 192.168.1.1 and tcp port 80

# Trafic DNS
udp port 53

# Tout sauf le trafic ARP et ICMP
not arp and not icmp

# Trafic entre deux hôtes
host 192.168.1.1 and host 192.168.1.2

# Trafic TCP SYN
tcp[tcpflags] & (tcp-syn) != 0

# Trafic TCP SYN sans ACK
tcp[tcpflags] & (tcp-syn|tcp-ack) == tcp-syn

# Paquets de plus de 1000 octets
greater 1000

# Paquets de moins de 100 octets
less 100

6. Filtres utiles pour la sécurité

Détection de scan de ports

# SYN scan (beaucoup de SYN sans ACK depuis une même source)
tcp.flags.syn == 1 and tcp.flags.ack == 0

# Paquets RST (ports fermés répondant au scan)
tcp.flags.rst == 1

# Scan NULL (aucun flag)
tcp.flags == 0x000

# Scan FIN
tcp.flags == 0x001

# Scan Xmas (FIN+PSH+URG)
tcp.flags == 0x029

# ICMP Port Unreachable (scan UDP)
icmp.type == 3 and icmp.code == 3

Détection ARP Spoofing

# Réponses ARP (gratuitous ARP ou empoisonnement)
arp.opcode == 2

# ARP avec adresses dupliquées (comparer les réponses)
arp.duplicate-address-detected

# ARP gratuit (annonce non sollicitée)
arp.isgratuitous == 1

Analyse de malware et communication C2

# Requêtes DNS suspectes (noms très longs = potentiel tunneling)
dns.qry.name.len > 50

# Requêtes DNS de type TXT (utilisé pour exfiltration)
dns.qry.type == 16

# Trafic HTTP vers des IP directes (pas de nom d'hôte)
http.request and !http.host contains "."

# Trafic sortant sur des ports non standard
tcp.dstport > 1024 and !(tcp.dstport == 8080 or tcp.dstport == 8443)

# Connexions HTTPS avec SNI suspect
tls.handshake.type == 1 and tls.handshake.extensions_server_name contains ".xyz"

# User-Agents suspects
http.user_agent matches "(curl|wget|python|powershell|certutil)"

Identifiants en clair

# Authentification FTP
ftp.request.command == "USER" or ftp.request.command == "PASS"

# Authentification HTTP Basic (encodé Base64 mais pas chiffré)
http.authbasic

# Données POST contenant des mots de passe potentiels
http.request.method == "POST" and frame contains "password"
http.request.method == "POST" and frame contains "login"

# Trafic Telnet (tout en clair)
telnet

# SMTP avec authentification
smtp.req.command == "AUTH"

# POP3 authentification
pop.request.command == "USER" or pop.request.command == "PASS"

Indicateurs de DNS Tunneling

# Requêtes DNS anormalement longues
dns.qry.name.len > 50

# Volume élevé de requêtes TXT
dns.qry.type == 16

# Requêtes DNS vers un serveur spécifique (non légitime)
dns and ip.dst != 8.8.8.8 and ip.dst != 8.8.4.4 and udp.dstport == 53

# Réponses DNS volumineuses
dns.flags.response == 1 and udp.length > 512

Détection de beaconing

# Trafic régulier vers une même destination (analyser avec Statistics > I/O Graph)
ip.dst == ADRESSE_SUSPECTE

# Connexions HTTP répétitives
http.request and ip.dst == ADRESSE_SUSPECTE

# Connexions TLS répétitives (observer les ClientHello)
tls.handshake.type == 1 and ip.dst == ADRESSE_SUSPECTE

7. Statistiques utiles

Conversations (Statistics > Conversations)

Affiche toutes les paires d'hôtes communicants avec le volume de données échangées. Onglets Ethernet, IPv4, IPv6, TCP, UDP. Triez par octets pour identifier les flux les plus volumineux.

Endpoints (Statistics > Endpoints)

Liste tous les hôtes observés dans la capture avec le nombre de paquets et octets envoyés/reçus. Utile pour identifier les machines les plus actives.

Protocol Hierarchy (Statistics > Protocol Hierarchy)

Vue hiérarchique de tous les protocoles détectés avec leur pourcentage du trafic total. Permet d'identifier rapidement des protocoles inhabituels.

Flow Graph (Statistics > Flow Graph)

Diagramme de séquence montrant les échanges entre les hôtes. Très utile pour visualiser les handshakes TCP, les échanges HTTP ou les problèmes de connexion.

I/O Graph (Statistics > I/O Graphs)

Graphique temporel du volume de trafic. Permet d'appliquer des filtres pour comparer différents flux. Utile pour détecter le beaconing (pics réguliers).

DNS (Statistics > DNS)

Statistiques spécifiques DNS : types de requêtes, codes de réponse, temps de réponse. Utile pour détecter les anomalies DNS.

HTTP (Statistics > HTTP)

Statistiques HTTP : requêtes par serveur, codes de réponse, types de contenu, distributions de méthodes.

8. Tshark (CLI)

Tshark est la version en ligne de commande de Wireshark, idéale pour l'automatisation et l'analyse sur des serveurs sans interface graphique.

Capture basique

# Capturer sur l'interface eth0
tshark -i eth0

# Lister les interfaces disponibles
tshark -D

# Capturer avec un filtre BPF
tshark -i eth0 -f "tcp port 80"

# Limiter le nombre de paquets capturés
tshark -i eth0 -c 1000

# Sauvegarder dans un fichier
tshark -i eth0 -w capture.pcapng

Lire un fichier de capture

# Lire un fichier pcap
tshark -r capture.pcapng

# Appliquer un filtre d'affichage
tshark -r capture.pcapng -Y "http.request"

# Afficher des champs spécifiques
tshark -r capture.pcapng -Y "http.request" -T fields -e http.host -e http.request.uri

# Format JSON
tshark -r capture.pcapng -Y "dns" -T json

Analyses courantes

# Extraire les requêtes DNS
tshark -r capture.pcapng -Y "dns.flags.response == 0" -T fields -e dns.qry.name | sort | uniq -c | sort -rn

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

# Extraire les adresses IP uniques
tshark -r capture.pcapng -T fields -e ip.src -e ip.dst | sort -u

# Statistiques de conversations
tshark -r capture.pcapng -q -z conv,tcp

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

# Extraire les certificats SSL
tshark -r capture.pcapng -Y "tls.handshake.type == 11" -T fields -e tls.handshake.certificate

# Top des requêtes HTTP
tshark -r capture.pcapng -q -z http,tree

# Statistiques DNS
tshark -r capture.pcapng -q -z dns,tree

# Suivre un flux TCP
tshark -r capture.pcapng -q -z follow,tcp,ascii,5

# Extraire les user-agents
tshark -r capture.pcapng -Y "http.user_agent" -T fields -e http.user_agent | sort | uniq -c | sort -rn

Capture avec rotation de fichiers

# Rotation après 100 Mo, garder 10 fichiers
tshark -i eth0 -b filesize:100000 -b files:10 -w capture.pcapng

# Rotation toutes les heures
tshark -i eth0 -b duration:3600 -b files:24 -w capture.pcapng

9. Astuces et bonnes pratiques

Raccourcis clavier essentiels

Ctrl+E        Démarrer/arrêter la capture
Ctrl+F        Rechercher dans les paquets
Ctrl+G        Aller au paquet numéro X
Ctrl+Shift+N  Créer un filtre depuis la sélection
Ctrl+.        Paquet suivant dans le flux
Ctrl+,        Paquet précédent dans le flux

Suivre un flux

Clic droit sur un paquet > Follow > TCP Stream (ou UDP, TLS, HTTP) pour voir l'intégralité de la conversation. Chaque direction est colorée différemment.

Marquer et commenter les paquets

# Ctrl+M pour marquer un paquet
# Clic droit > Packet Comment pour ajouter un commentaire
# Les marquages et commentaires sont sauvegardés dans les fichiers pcapng

Exporter des objets

Menu File > Export Objects pour extraire les fichiers transférés via HTTP, SMB, TFTP, IMF (emails). Très utile en investigation pour récupérer les pièces jointes ou fichiers téléchargés.

Règles de coloration personnalisées

Menu View > Coloring Rules. Ajoutez des règles pour mettre en évidence le trafic suspect. Exemples :

# Rouge pour les connexions RST
tcp.flags.rst == 1

# Orange pour les erreurs HTTP
http.response.code >= 400

# Jaune pour les requêtes DNS échouées
dns.flags.rcode != 0

Bonnes pratiques de capture

Limiter la capture : Utilisez toujours des filtres de capture BPF pour éviter de capturer tout le trafic. Cela réduit la taille des fichiers et améliore les performances.

Rotation de fichiers : Pour les captures longues, configurez la rotation automatique pour éviter des fichiers trop volumineux.

Nommer les fichiers : Incluez la date, l'interface et le contexte dans le nom du fichier (ex: 20250115_eth0_incident42.pcapng).

Sauvegarder en pcapng : Préférez le format pcapng au format pcap classique, car il supporte les commentaires, les métadonnées et les captures multi-interfaces.

Documenter l'analyse : Utilisez les commentaires de paquets et les profils pour garder une trace de votre analyse.