On a tous déjà eu ce moment un peu désagréable en TP ou en prod. Un flux réseau « normal », des users qui jurent qu’ils n’ont rien fait… et pourtant, ça sort. Lentement, régulièrement, parfois en rafales. Et là tu ouvres Wireshark, tu regardes l’océan de paquets, et tu te dis que tu vas y passer la nuit.
En pratique, non. Pas forcément.
Dans ce billet pour BTS SIO2 SISR Tech Lab (oui, celui que tu lis sur https://sio1blog.blogspot.com/), je te donne 7 filtres Wireshark très concrets, orientés « je veux repérer une exfiltration vite ». Pas une enquête forensique de 3 jours. Juste une shortlist efficace pour trier, isoler, puis creuser.
Important : ici on parle de filtres d’affichage Wireshark (display filters), pas des filtres de capture (tcpdump style).
Préparation rapide (30 secondes, mais ça change tout)
Avant de filtrer comme un fou, fais deux trucs :
- Identifie la machine suspecte (IP ou MAC).
- Ajoute des colonnes utiles (clic droit sur un champ → « appliquer comme colonne ») :
ip.src,ip.dsttcp.streamhttp.host(si HTTP)tls.handshake.extensions_server_name(SNI)dns.qry.name(si DNS)
Tu gagnes du temps ensuite. Vraiment.
Image (rappel visuel) :
Filtre 1 : se concentrer sur un hôte (le point de départ)
Le filtre le plus bête, mais c’est celui qui évite de se perdre.
wireshark ip.addr == 192.168.1.50
Variante si tu veux séparer sens sortant et entrant :
wireshark ip.src == 192.168.1.50
Ou uniquement ce qui revient :
wireshark ip.dst == 192.168.1.50
Pourquoi c’est utile pour l’exfiltration ? Parce que tu veux d’abord voir tout ce que la machine fait, puis repérer un schéma : destinations rares, volumes, répétitions, protocoles inattendus.
Petit conseil « terrain » : commence large avec ip.addr, puis bascule en ip.src quand tu cherches du sortant.
Filtre 2 : repérer les gros transferts TCP (souvent là que ça fuit)
Wireshark permet de filtrer sur les tailles de segments TCP. On ne mesure pas exactement « le fichier volé », mais on voit vite des paquets chargés qui s’enchaînent.
wireshark ip.src == 192.168.1.50 && tcp.len > 1000
Si tu veux être encore plus agressif :
wireshark ip.src == 192.168.1.50 && tcp.len >= 1300
Interprétation rapide :
- Beaucoup de
tcp.lenélevés vers un mêmeip.dst: upload probable. - Rafales périodiques : exfiltration par lots (tâche planifiée, malware « discret », agent…).
Ensuite, pour confirmer, tu peux aller dans Statistics → Conversations et trier par bytes. Mais là on sort du « filtre pur », même si c’est l’étape logique.
Image (illustration des stats) :
Filtre 3 : détecter des connexions vers des ports « pas habituels »
L’exfiltration adore se cacher sur des ports qui ne crient pas « web ». Ou alors elle utilise un port standard mais avec une destination chelou. Ici on fait simple : on sort du 80/443 et on regarde le reste.
wireshark ip.src == 192.168.1.50 && tcp && !(tcp.port == 80 || tcp.port == 443)
Variante avec UDP aussi :
wireshark ip.src == 192.168.1.50 && !(tcp.port == 80 || tcp.port == 443 || udp.port == 53)
Ce que tu cherches :
22(SSH),21(FTP),445(SMB),3389(RDP) vers l’extérieur, c’est souvent bizarre en contexte client.- Ports hauts aléatoires vers une IP publique unique, stable : tunnel, C2, ou outil maison.
Astuce : une fois un port repéré, filtre dessus, puis suis le flux (clic droit → « suivre »).
Filtre 4 : exfiltration HTTP en clair (quand c’est « trop facile »)
Quand ce n’est pas chiffré, Wireshark devient presque injuste.
4.1 Trouver les requêtes POST (upload classique)
wireshark http.request.method == "POST" && ip.src == 192.168.1.50
Tu peux élargir à PUT :
wireshark (ip.src == 192.168.1.50) && (http.request.method == "POST" || http.request.method == "PUT")
4.2 Repérer un user-agent louche
Souvent, des outils automatisés ou des malwares ont des user-agent très basiques, ou carrément suspects.
wireshark ip.src == 192.168.1.50 && http.user_agent
Puis tu lis la colonne ou le détail. Si tu veux filtrer un cas typique :
wireshark ip.src == 192.168.1.50 && http.user_agent contains "curl"
Ou :
wireshark ip.src == 192.168.1.50 && http.user_agent contains "python"
4.3 Chercher des paramètres qui sentent la fuite
Pas universel, mais parfois tu vois des trucs du style file=, upload=, token=.
wireshark ip.src == 192.168.1.50 && http.request.uri contains "upload"
Filtre 5 : exfiltration HTTPS via SNI (voir où ça part, même si c’est chiffré)
Quand c’est du TLS, tu ne vois pas le contenu (sauf inspection TLS avec clés, et c’est un autre sujet). Mais tu peux déjà voir le nom de domaine via SNI, quand il est présent.
wireshark ip.src == 192.168.1.50 && tls.handshake.extensions_server_name
Et si tu veux un domaine spécifique :
wireshark ip.src == 192.168.1.50 && tls.handshake.extensions_server_name contains "dropbox"
Ou pour repérer des domaines chelous style aléatoires : tu regardes la liste, tu « sens » le truc. Oui, c’est empirique, mais en incident réel c’est souvent comme ça que ça commence.
Image (TLS handshake dans Wireshark) :
Filtre 6 : DNS, l’exfiltration « discrète » (et les domaines bizarres)
Il y a deux grandes utilisations côté exfil :
- DNS comme canal (données encodées dans des sous-domaines).
- DNS comme indicateur (domaines générés, nouveaux domaines, etc.).
6.1 Voir toutes les requêtes DNS de l’hôte
wireshark ip.src == 192.168.1.50 && dns.qry.name
6.2 Repérer des noms anormalement longs
Wireshark ne donne pas un filtre « longueur » direct super élégant, donc on fait souvent au feeling. Mais tu peux déjà repérer les requêtes TXT, parfois utilisées.
wireshark ip.src == 192.168.1.50 && dns && dns.qry.type == 16
Type 16 = TXT.
Autre piste : beaucoup de requêtes NXDOMAIN, typique de DGA (domain generation algorithm) ou d’un code qui teste des domaines.
wireshark ip.src == 192.168.1.50 && dns.flags.rcode == 3
Si tu vois 200 NXDOMAIN en 2 minutes, ce n’est pas « juste un bug ». Enfin… rarement.
Filtre 7 : ICMP et UDP « pas nets » (tunnels, bricolages, canaux alternatifs)
C’est moins fréquent que HTTPS, mais quand ça arrive, ça saute aux yeux si tu filtres bien.
7.1 ICMP avec payload (ping qui transporte des données)
wireshark ip.src == 192.168.1.50 && icmp && data
Tu peux aussi regarder la taille :
wireshark ip.src == 192.168.1.50 && icmp && frame.len > 200
Un ping normal peut être gros, oui. Mais des rafales régulières de gros ICMP vers une IP publique, c’est une discussion.
7.2 UDP vers des ports inhabituels
wireshark ip.src == 192.168.1.50 && udp && !(udp.port == 53 || udp.port == 123)
On exclut 53 (DNS) et 123 (NTP). Adapte selon ton contexte.
7.3 Détecter du QUIC (HTTP/3) qui cache du trafic web
Le QUIC passe en UDP, souvent sur 443. Si tu vois un hôte qui part en « UDP 443 » alors que tu ne t’y attends pas, ça vaut le coup.
wireshark ip.src == 192.168.1.50 && udp.port == 443
Mini méthode : comment enchaîner ces filtres sans tourner en rond
Je te donne un flow simple, celui que je fais en TP avec des étudiants quand on simule une fuite.
ip.addr == Xip.src == X && tcp.len > 1000ip.src == X && tcp && !(tcp.port == 80 || tcp.port == 443)- Si web clair :
http.request.method == "POST" && ip.src == X - Si TLS :
ip.src == X && tls.handshake.extensions_server_name - DNS :
ip.src == X && dns.qry.namepuis NXDOMAIN si besoin - Canaux alternatifs : ICMP, UDP, QUIC
Et ensuite seulement : tu suis un ou deux flux (tcp.stream) et tu lis. Parce que filtrer c’est bien, mais à un moment tu dois regarder l’histoire du flux.
Pièges classiques (je les mets parce qu’on se fait avoir)
- CDN et cloud : une exfiltration peut aller sur un domaine « légitime » (Azure, Google, Amazon) via un bucket ou un endpoint. Le SNI peut sembler normal. Donc tu regardes aussi le volume et la régularité.
- Split tunneling VPN : tu crois que ça sort vers internet, mais en fait ça part dans un tunnel. Vérifie les interfaces, les IP internes, les routes.
- Heure et capture : un PCAP trop court, tu rates le moment clé. Ou alors tu captures au mauvais endroit (SPAN mal fait, VLAN oublié). Classique.
Un petit lab à refaire (si tu veux t’entraîner vite)
Pour rester dans l’esprit du BTS SIO2 SISR Tech Lab, le mieux c’est de pratiquer. Monte un mini scénario :
- Une VM client (Linux ou Windows)
- Un serveur web simple (ou un serveur SSH)
- Un fichier « sensible »
- Tu simules un upload (curl POST, scp, ou même une requête DNS un peu sale)
- Tu captures avec Wireshark depuis un port miroir ou en local
Ensuite tu appliques les 7 filtres, un par un, et tu notes lequel te donne le signal le plus rapide selon le protocole choisi.
Si tu veux, je peux aussi te proposer une fiche TP complète à publier sur le blog, format BTS, avec objectifs, topo, questions, et correction.
Récap des 7 filtres (copier coller)
- Hôte (tout)
wireshark ip.addr == 192.168.1.50 - Sortant uniquement
wireshark ip.src == 192.168.1.50 - Gros segments TCP
wireshark ip.src == 192.168.1.50 && tcp.len > 1000 - Ports non web
wireshark ip.src == 192.168.1.50 && tcp && !(tcp.port == 80 || tcp.port == 443) - HTTP POST / PUT
wireshark (ip.src == 192.168.1.50) && (http.request.method == "POST" || http.request.method == "PUT") - TLS SNI (où ça part)
wireshark ip.src == 192.168.1.50 && tls.handshake.extensions_server_name - DNS suspects (TXT ou NXDOMAIN)
wireshark ip.src == 192.168.1.50 && dns && dns.qry.type == 16
et
wireshark ip.src == 192.168.1.50 && dns.flags.rcode == 3
Conclusion (simple, utile)
Trouver une exfiltration dans Wireshark, ce n’est pas « magique ». C’est surtout une histoire de tri rapide. Tu passes de 200 000 paquets à 200, puis à 20, et là tu peux réfléchir.
Garde cette page sous la main, et si tu veux d’autres contenus du même style (labs réseau, cybersécurité, supervision), passe sur BTS SIO2 SISR Tech Lab sur https://sio1blog.blogspot.com/ et pioche. On construit une vraie boîte à outils, petit à petit, pour le quotidien SISR.
Questions fréquemment posées
Quels sont les premiers préparatifs avant d'utiliser des filtres Wireshark pour détecter une exfiltration ?
Avant de filtrer, il est essentiel d'identifier la machine suspecte (via son IP ou MAC) et d'ajouter des colonnes utiles dans Wireshark telles que ip.src, ip.dst, tcp.stream, http.host, tls.handshake.extensions_server_name (SNI) et dns.qry.name. Cela permet de gagner un temps précieux lors de l'analyse.
Comment filtrer efficacement le trafic réseau d'une machine suspecte dans Wireshark ?
Le filtre de base consiste à se concentrer sur une adresse IP spécifique avec : ip.addr == [IP de la machine]. Pour distinguer le trafic sortant du trafic entrant, utilisez ip.src == [IP] pour le trafic sortant ou ip.dst == [IP] pour le trafic entrant. Cela aide à repérer les destinations rares, volumes et protocoles inhabituels.
Comment repérer rapidement les gros transferts TCP susceptibles d'être liés à une exfiltration ?
Utilisez un filtre combinant l'adresse source et la taille des segments TCP comme : ip.src == [IP] && tcp.len > 1000. Des paquets TCP volumineux en rafale vers une même destination suggèrent un upload important, potentiellement une exfiltration.
Quels ports surveiller pour détecter des connexions réseau inhabituelles pouvant indiquer une fuite de données ?
Il est conseillé d'exclure les ports standards comme 80 (HTTP), 443 (HTTPS) et 53 (DNS) puis d'observer les connexions sur des ports moins courants tels que 22 (SSH), 21 (FTP), 445 (SMB), ou 3389 (RDP). Des connexions sortantes sur ces ports peuvent être suspectes en contexte client.
Comment identifier une exfiltration HTTP en clair avec Wireshark ?
Pour détecter une exfiltration via HTTP non chiffré, filtrez les requêtes POST ou PUT émises par la machine suspecte avec : http.request.method == "POST" && ip.src == [IP] ou en élargissant à PUT. De plus, repérez des user-agent atypiques qui peuvent indiquer un outil automatisé ou un malware.
Quelle est la différence entre les filtres d'affichage et les filtres de capture dans Wireshark ?
Les filtres d'affichage (display filters) servent à trier et analyser les paquets déjà capturés, tandis que les filtres de capture (comme ceux utilisés dans tcpdump) limitent quels paquets sont enregistrés pendant la capture. Cet article se concentre uniquement sur les filtres d'affichage pour une détection rapide d'exfiltration.
0 Commentaires