Reniflage et usurpation

Reniflage de paquets (packet sniffing)

La capture ou le reniflage de paquets désigne l’action de capturer des paquets IP (Internet Protocol) pour les examiner ou les analyser. Le terme peut également être utilisé pour décrire les fichiers produits par les outils de capture de paquets, qui sont souvent enregistrés au format .pcap. Si la capture de paquets est une technique de dépannage courante pour les administrateurs réseau, elle est également utilisée pour examiner le trafic réseau à la recherche de menaces en matière de sécurité. À la suite d’une fuite de données ou d’un autre incident, les captures de paquets fournissent des indices essentiels qui facilitent les enquêtes. Pour les auteurs des cyberattaques, les captures de paquets peuvent être utilisées pour voler des mots de passe et d’autres données sensibles. Contrairement aux techniques de reconnaissance active telles que le balayage de ports, la capture de paquets peut être effectuée sans laisser de traces visibles aux enquêteurs.

Comment fonctionne la capture de paquets ?

Il existe plus d’une façon de capturer un paquet ! Les captures de paquets peuvent être réalisées à partir d’un équipement de réseau tel qu’un routeur ou un commutateur, d’un matériel dédié appelé « TAP », de l’ordinateur portable ou fixe d’un analyste, et même de dispositifs mobiles. L’approche utilisée dépend de l’objectif final. Cependant, quelle que soit la méthode choisie, la capture de paquets fonctionne en créant des copies de tout ou d’une partie des paquets passant par un point donné du réseau.

La capture de paquets à partir de votre propre machine est le moyen le plus simple de commencer, mais il y a quelques précautions à prendre. Par défaut, les interfaces réseau prêtent uniquement attention au trafic qui leur est destiné. Pour obtenir une vue plus complète du trafic réseau, vous devez mettre l’interface en mode Promiscuous ou en mode Monitor. N’oubliez pas que cette approche permet également de capturer une vue limitée du réseau. Sur un réseau câblé, par exemple, vous verrez uniquement le trafic sur le port du commutateur local auquel votre machine est connectée.

Afin de comprendre et d’analyser une capture de paquets, vous devez avoir des connaissances fondamentales sur les concepts de base des réseaux, notamment le modèle OSI. Bien qu’il puisse y avoir des différences entre différents outils spécifiques, les captures de paquets sont toujours constituées d’une charge utile et d’en-têtes. La charge utile se compose des données réelles transférées : il peut s’agir d’un film en streaming, de courriels, d’un ransomware ou de tout autre élément traversant un réseau. Les en-têtes de paquets contiennent toutes les informations critiques qui aident l’équipement réseau à décider de ce qu’il faut faire chaque paquet. Les adresses source et de destination sont les plus importantes, mais les paquets IP comportent un total de 14 en-têtes couvrant tous les aspects, de la classe de service au type de protocole. Un analyste réseau professionnel disposera de connaissances détaillées dans tous ces domaines, mais une compréhension générale de la structure des paquets suffit pour commencer à résoudre les problèmes de performance ou en apprendre davantage sur le fonctionnement des réseaux.

Outre les adresses source et de destination, certains des champs les plus importants du point de vue du dépannage peuvent inclure le point de code de services différenciés (DSCP), les drapeaux et le TTL. Le DSCP est utilisé pour garantir la qualité de service (QoS) et constitue un champ important pour le trafic en temps réel comme la voix sur IP (VoIP). Les drapeaux sont le plus souvent utilisés pour contrôler la fragmentation des paquets et peuvent devenir un problème lorsqu’un paquet doté du drapeau Ne pas fragmenter dépasse également la taille de l’unité de transmission maximale (MTU) d’une liaison réseau. Les valeurs TTL sont réduites après chaque saut et peuvent fournir des indices importants sur le chemin d’accès d’un paquet à travers le réseau.

Pour les types de trafic non chiffrés, les renifleurs de paquets peuvent aller au-delà des simples en-têtes et inspecter les données utiles réelles. Cela peut s’avérer extrêmement utile pour le dépannage des problèmes de réseau, mais constitue également un problème de sécurité potentiel lorsque des données sensibles telles que des identifiants et des mots de passe sont présentes. Pour comprendre la signification de la charge utile d’un paquet, il faut parfois connaître le protocole utilisé.

Les applications de capture de paquets et d’analyse réseau contiennent souvent des outils permettant de filtrer, de visualiser et d’inspecter de grandes quantités de données. Ces outils permettent une analyse qui n’est pas possible via l’inspection manuelle d’une capture de paquets. Les fichiers de capture peuvent également être intégrés à un système de détection d’intrusion/système de prévention d’intrusion (IDS/IPS), à un système de gestion des informations et des événements de sécurité (SIEM) ou à d’autres types de produits de sécurité à la recherche de signes d’une attaque ou fuite de données.

Formats, bibliothèques et filtres

En matière de capture de paquets, il existe toute une série de termes connexes qui peuvent rapidement prêter à confusion. Voici quelques-uns des termes les plus courants et importants que vous pourriez entendre.

Formats de capture de paquets

Bien que des outils de capture de paquets comme Wireshark puissent être utilisés pour inspecter le trafic en temps réel, il est plus courant d’enregistrer les captures dans un fichier pour une analyse ultérieure. Ces fichiers peuvent être enregistrés dans différents formats. Les fichiers .pcap sont les plus courants et sont généralement compatibles avec un large éventail d’analyseurs de réseau et d’autres outils. Le format .pcapng reprend le format simple .pcap avec de nouveaux champs et de nouvelles fonctionnalités. Il s’agit désormais du format par défaut pour l’enregistrement des fichiers dans Wireshark. Certains outils payants peuvent également utiliser des formats propriétaires. bibliothèques

Les bibliothèques

Les bibliothèques comme libpcap, winpcap et npcap sont les véritables piliers de la capture de paquets. Elles se connectent à la pile réseau d’un système d’exploitation et permettent d’observer les paquets circulant entre les interfaces. La plupart de ces bibliothèques sont des projets open-source, vous pouvez donc les trouver dans une grande variété d’outils de capture de paquets payants ou gratuits. Dans certains cas, vous devrez installer la bibliothèque séparément de l’outil.

Filtrage

La capture de paquets complets peut prendre beaucoup d’espace et demander plus de ressources au dispositif de capture. Dans la plupart des cas, cette méthode est également excessive : les informations les plus intéressantes ne représentent généralement qu’une infime partie du trafic total observé. Les captures de paquets sont souvent filtrées pour extraire les informations pertinentes. Ce filtrage peut être basé sur de nombreux éléments, de la charge utile à l’adresse IP en passant par une combinaison de facteurs.

Outils de capture de paquets

Un grand nombre d’outils différents sont disponibles pour capturer et analyser les paquets qui circulent sur votre réseau. Ces outils sont parfois appelés renifleurs de paquets. Voici les plus populaires :

Wireshark : L’outil de capture de paquets par excellence, Wireshark est indispensable pour de nombreux administrateurs réseau, analystes de sécurité et amateurs. Avec une interface graphique simple et de nombreuses fonctionnalités de tri, d’analyse et de compréhension du trafic, Wireshark combine une grande facilité d’utilisation et des capacités puissantes. Le module Wireshark intègre également un utilitaire de ligne de commande appelé tshark.
tcpdump : Léger, polyvalent et préinstallé sur de nombreux systèmes d’exploitation de type UNIX, tcpdump est un rêve devenu réalité pour les fans de l’interface de ligne de commande en matière de capture de paquets. Cet outil open source peut capturer rapidement des paquets pour les analyser ultérieurement avec des outils comme Wireshark, mais il dispose également de commandes et commutateurs en grand nombre qui lui sont propres et lui permettent de donner un sens à de grandes quantités de données réseau.

Cas d’utilisation de la capture de paquets et du renifleur de paquets

Bien que le terme « renifleur de paquets » puisse évoquer des images de pirates informatiques écoutant secrètement des communications sensibles, il en existe de nombreux usages légitimes. Voici quelques cas d’utilisation typiques :

Découverte d’actifs/reconnaissance passive

De par leur nature même, les paquets comportent des adresses source et de destination, de sorte qu’une capture de paquets peut être utilisée pour détecter les terminaux actifs sur un réseau donné. Avec suffisamment de données, il est même possible d’assurer la reconnaissance passive des terminaux. Lorsqu’elle est effectuée à des fins légitimes dans une entreprise, cette opération est appelée découverte ou inventaire. Cependant, la nature passive d’une capture de paquets est un excellent moyen pour les pirates malveillants de recueillir des informations pour les étapes ultérieures d’une attaque. Bien entendu, la même technique peut être utilisée par les adeptes de Red Team pour tester la sécurité d’une organisation

Dépannage

Lors du dépannage des problèmes de réseau, l’inspection du trafic réseau réel peut être le moyen le plus efficace de déterminer la cause première d’un problème. Les renifleurs de paquets permettent aux administrateurs et aux ingénieurs réseau de visualiser le contenu des paquets circulant sur le réseau. Cette fonctionnalité est essentielle pour dépanner les protocoles réseau fondamentaux tels que DHCP, ARP et DNS. Les captures de paquets ne révèlent cependant pas le contenu du trafic réseau chiffré.

Le reniflage des paquets peut aider à vérifier que le trafic emprunte le bon chemin sur le réseau et qu’il est traité selon la bonne priorité. Une liaison réseau saturée ou rompue est souvent facile à repérer dans une capture de paquets, car seule une partie d’une conversation généralement bilatérale est présente. Les connexions comportant un grand nombre de tentatives ou de paquets abandonnés sont souvent le signe d’une liaison trop sollicitée ou d’un matériel réseau défaillant.

Détection des intrusions

Le trafic réseau suspect peut être enregistré sous forme de capture de paquets et intégré dans une solution IDS, IPS ou SIEM pour une analyse plus approfondie. Les attaquants font tout leur possible pour se fondre dans le trafic réseau normal, mais une inspection minutieuse peut permettre de découvrir un trafic caché. Les adresses IP malveillantes connues, les charges utiles révélatrices et d’autres détails infimes peuvent tous être le signe d’une attaque. Même une action aussi inoffensive qu’une requête DNS, si elle est répétée à intervalles réguliers, peut dissimuler une balise de commande et de contrôle.

Réponse aux incidents et analyse

Les captures de paquets offrent une opportunité unique aux équipes en charge de la résolution des incidents. Les attaquants peuvent prendre des mesures pour effacer leurs traces sur les terminaux, mais ils ne peuvent pas annuler les paquets qui ont déjà traversé un réseau. Qu’il s’agisse de logiciels malveillants, d’exfiltration de données ou d’un autre type d’incident, les captures de paquets permettent souvent de repérer des signes d’attaque que les autres outils de sécurité ne voient pas. Comme l’en-tête d’un paquet contient toujours une adresse source et une adresse de destination, les équipes de réponse aux incidents peuvent utiliser les captures de paquets pour retracer le parcours d’un pirate sur le réseau ou repérer les signes d’exfiltration de données hors du réseau.

Usurpation de paquets (packet spoofing)

Lorsque l’on utilise la programmation typique des sockets pour envoyer des paquets, nous n’avons de contrôle que sur quelques champs des en-tête de PDU. Par exemple, si nous voulons envoyer un paquet IP, nous pouvons choisir l’adresse IP de destination, mais pas l’adresse IP source. Lorsque le paquet est envoyé, le système d’exploitation (et plus précisément le noyau) mettra l’adresse IP de l’hôte dans le champ IP source. Dans de nombreuses attaques sur le réseau, les paquets envoyés à la victime sont construits avec des informations fausses, irréalistes ou ciblées dans les en-têtes.

L’envoi de tels paquets s’appelle l’usurpation de paquets (packet spoofing), c’est-à-dire la falsification d’informations essentielles dans le paquet. Cette technique est largement utilisée par les attaquants du réseau à des fins malveillantes, bien que ce ne soit pas la seule raison de l’usurpation d’un paquet.

Les informations “falsifiées” dépendent du type d’attaque qui est mené. Pour comprendre le fonctionnement des attaques sur le réseau et acquérir une expérience pratique de ces attaques , il est essentiel de comprendre comment usurper (ou spoofer) des paquets. Il existe de nombreux outils qui nous permettent de faire cela, tels que Netwox et Scapy.

Dans ce cours, nous allons utiliser Scapy, un puissant outil de manipulation de paquets (module Python).

Mise en place du lab

Importer la machine ubuntu-seed.ova dans VMWare. Il s’agit d’une VM Ubuntu.
Démarrer la VM. Le mot de passe est “abc-123”.
Ouvrir un terminal et dans votre répertoir personnel, créer le fichier docker-compose.yaml dans lequel vous écrirez les informations ci-dessous :

services:
    attacker:
        image: handsonsecurity/seed-ubuntu:large
        container_name: seed-attacker
        tty: true
        cap_add:
                - ALL
        privileged: true
        volumes:
                - ./volumes:/volumes
        network_mode: host

    hostA:
        image: handsonsecurity/seed-ubuntu:large
        container_name: hostA-10.9.0.5
        tty: true
        cap_add:
                - ALL
        networks:
            net-10.9.0.0:
                ipv4_address: 10.9.0.5
        command: bash -c "/etc/init.d/openbsd-inetd start  && tail -f /dev/null"

    hostB:
        image: handsonsecurity/seed-ubuntu:large
        container_name: hostB-10.9.0.6
        tty: true
        cap_add:
                - ALL
        networks:
            net-10.9.0.0:
                ipv4_address: 10.9.0.6
        command: bash -c "/etc/init.d/openbsd-inetd start  && tail -f /dev/null"

networks:
    net-10.9.0.0:
        name: net-10.9.0.0
        ipam:
            config:
                - subnet: 10.9.0.0/24

Créer un répertoire nommé volumes toujours dans votre répertoire personnel :

$ mkdir volumes

La commande suivante va créer trois conteneurs : hostA (Alice), hostB (Bob), seed-attacker (Eve) :

$ docker-compose up

Les conteneurs sont comme de petites VM auxquelles vous pouvez vous connecter en ligne de commandes à l’aide de la commande suivante :

$ docker exec -it <nom du conteneur> /bin/bash

Les conteneurs ont les adresses IP suivantes :

HostA : 10.9.0.5
HostB : 10.9.0.6
seed-attacker : 10.9.0.1

Il est possible de créer les scripts à partir de la machine Ubuntu, à condition de les mettres dans le répertoire volumes.
Pour lancer les scripts depuis le conteneur de l’attaquant :

$ python3 volumes/<nom du script.py>

Sniffing et spoofing en utilisant Scapy

Sur la VM Ubuntu fournie, le module Python Scapy a déjà été installé. Si vous avez envie de l’installer sur votre propre machine :

sudo pip3 install scapy

Pour certains systèmes, pip3 peut ne pas être installé (ou même python3). Pour l’installer, référez-vous à la documentation de pip : https://pip.pypa.io/en/stable/installation/

Exemple 1

from scapy.all import *

print (" SNIFFING PACKETS . ..... ... ")
def print_pkt(pkt) :
    print("Source IP :", pkt[IP].src)
    print("Destination IP :", pkt[IP].dst)
    print("Protocol :", pkt[IP].proto)
    print ( " \n ")

pkt= sniff(iface="enp0s31f6", filter= 'icmp', prn=print_pkt)

Le programme ci-dessus utilise la fonction sniff() pour capturer des paquets . Pour chaque paquet capturé, la fonction callback print_pkt() est appelée. Cette fonction affiche une partie de l’information concernant le paquet.

Définir le filtre.

Lors de l’utilisation de sniff(), nous pouvons définir un filtre pour spécifier le type de paquets qui doivent être capturés. Le filtre de Scapy utilise la syntaxe BPF (la même que celle utilisée par tcpdump et pcap).

Pour plus d’informations sur la syntaxe BPF: https://www.ibm.com/docs/en/qsip/7.4?topic=queries-berkeley-packet-filters

Exemple 2 - Sniffing de paquets UDP ou ICMP

import scapy.all as scapy


packt = scapy.sniff(iface="enp0s31f6",
                   filter="udp or icmp",
                   count=10)


packt.summary()

Exemple 3 - En utilisant une fonction callback

import scapy.all as scapy

def process_packet(pkt):
   
   # pour afficher un paquet, on peut utiliser 
   # hexdump(pkt) ou pkt.show()
   pkt.show()
   print('----------------------------------')


filt = 'udp and dst portrange 50-55 or icmp'


scapy.sniff(iface="enp0s31f6",
           filter=filt,
           prn=process_packet)

Comprendre le système de classes en couche de Scapy

Itérer sur les couches TCP/IP

>>> from scapy.all import *
>>> transport =UDP(sport=1234, dport=1020)
>>> donnee='hello'
>>> ether=Ether(type='IPv4')
>>> pkt=ether/transport/donnee
>>> pkt
<Ether type=IPv4 |<IP frag=0 proto=udp |<UDP |<Raw load='hello' |>>>>


>>> pkt.payload
<IP frag=0 proto=udp |<UDP |<Raw load='hello' |>>>


>>> pkt.payload.payload
<UDP |<Raw load='hello' |>>

>>> pkt.payload.payload.payload
<Raw load='hello' |>

Accéder au données des différentes couches

<Ether type=IPv4 |<IP frag=0 proto=udp |<UDP |<Raw load='hello' |>>>>
>>> pkt.haslayer(UDP)
True
>>> pkt.haslayer(TCP)
0
>>> pkt.haslayer(Raw)
True
Accessing Layers
>>> pkt[UDP]
<UDP |<Raw load='hello' |>>
>>> pkt.getlayer(UDP)
<UDP |<Raw load='hello' |>>
>>> pkt[Raw]
<Raw load='hello' |>
>>> pkt[Raw].load
b'hello'

Usurpation d’identité

>>> ip = IP(src='1.2.3.4', dst='10.20.30.40')
>>> transport = UDP(sport=1234, dport=1020)
>>> donnee='Hello World'
>>> pkt=ip/transport/donnee
>>> pkt.show()

###[ IP ]###
  version   = 4
  ihl   	= None
  tos   	= 0x0
  len   	= None
  id    	= 1
  flags 	=
  frag  	= 0
  ttl   	= 64
  proto 	= udp
  chksum	= None
  src   	= 1.2.3.4
  dst   	= 10.20.30.40
  \options   \
###[ UDP ]###
 	sport 	= 1234
 	dport 	= 1020
 	len   	= None
 	chksum	= None
###[ Raw ]###
    	load  	= b'Hello World'

Spoofing d’un paquet ICMP

import scapy.all as scapy

print('SENDING SPOOFED ICMP PACKET.......')
ip = scapy.IP(src="1.2.3.4", dst="93.184.216.34")
icmp = scapy.ICMP()
pkt = ip/icmp
pkt.show()
scapy.send(pkt, verbose=0)

Spoofing de paquets UDP

Usurper des paquets UDP est similaire au spoofing de paquets ICMP, à l’exception que l’on doit définir les ports source et destination dans l’entête UDP, et ajouter des données (payload) au paquet

from scapy.all import *

print('SENDING SPOOFED UDP PACKET.......')
ip = IP(src="1.2.3.4", dst="10.9.0.5") # Couche IP
udp = UDP(sport=1234, dport=1020) # Couche transport
data = 'Hello World!' # Couche application
pkt = ip/udp/data
pkt.show()

send(pkt, verbose=0)

Dans le code ci-dessus, nous créons chaque partie du segment UDP, soit un objet IP, un objet UDP et un payload (string). Ensuite, nous les concaténons puis nous envoyons le paquet en utilisant la méthode send().

Si nous exécutons un serveur UDP en utilisant netcat nc -luv 1020 sur une machine d’adresse IP 10.9.0.5, (qui est l’adresse IP de destination utilisée dans le code), nous devrions être en mesure d’obtenir le message “Hello UDP”

Reniflage puis usurpation

Nous pouvons combiner les codes de reniflage et d’usurpation d’identité, de manière à renifler une requête et à forger immédiatement une réponse usurpée.

from scapy.all import *

def spoof_pkt(pkt):
   if ICMP in pkt and pkt[ICMP].type == 8:
       print('Original packet............')
       print(f'IP Source : {pkt[IP].src}')
       print(f'IP destination : {pkt[IP].dst}')

       ip = IP(src=pkt[IP].dst, dst=pkt[IP].src, ihl=pkt[IP].ihl)
       icmp = ICMP(type="echo-reply", code=0, seq=pkt[ICMP].seq, id=pkt[ICMP].id )

       if pkt.haslayer(Raw):
           data = pkt[Raw].load
           new_pkt = ip/icmp/data
       else:
           new_pkt = ip/icmp

       print('Spoofed packet...........')
       print(f'IP Source : {new_pkt[IP].src}')
       print(f'IP destination : {new_pkt[IP].dst}')
       print(f'ICMP : {new_pkt[ICMP]}')


       send(new_pkt, verbose=0)


pkt = sniff(iface='nom interface', filter='icmp and src host 192.168.130.162', prn=spoof_pkt)

L’exemple suivant renifle tous les paquets ICMP provenant de 192.168.130.162. Si le type du paquet ICMP est echo-request (la valeur du type est 8), le programme enverra immédiatement une réponse ICMP écho usurpée.

Attaques sur la couche liaison de données (MAC)

Rappel : Trame Ethernet, adresse MAC et protocole ARP

Ethernet :

L’adresse MAC constitue la partie inférieure de la couche liaison (couche 2 du modèle OSI). Elle insère et administre ce type d’adresses au sein des trames transmises. La trame Ethernet est le PDU de couche 2. Elle contient notamment (mais pas seulement) les adresses MAC source et destination

ARP

Lorsqu’un ordinateur rejoint un réseau local (LAN), une adresse IP lui est attribuée. Il peut s’agir d’une adresse IP statique qui ne change pas ou d’une adresse dynamique attribuée par un serveur DHCP. Lorsqu’un paquet destiné à cet ordinateur passe par une passerelle de réseau, celle-ci doit déterminer où l’envoyer, ce qui nécessite l’adresse MAC. Une passerelle réseau conserve une table de consultation - appelée cache ARP - qui répertorie toutes les correspondances connues entre les adresses IP et MAC.

Si la correspondance souhaitée existe dans le cache ARP, la passerelle peut envoyer le paquet à sa destination. Cependant, une adresse IP peut ne pas exister dans le cache si elle est nouvelle ou si elle a été purgée (les correspondances d’adresses ne sont généralement mises en cache que pendant quelques minutes). Dans ce cas, la passerelle doit déterminer quelle adresse MAC correspond à cette adresse IP.

C’est là que l’ARP entre en jeu. Une passerelle envoie une requête ARP à tous les ordinateurs du réseau local pour leur demander lequel d’entre eux utilise cette adresse IP. L’ordinateur possédant cette adresse IP renverra une réponse ARP contenant son adresse MAC. Lorsque la passerelle reçoit cette réponse ARP, elle peut envoyer le paquet à sa destination. Il enregistre également la correspondance entre l’adresse IP et l’adresse MAC dans son cache ARP afin de pouvoir acheminer correctement les paquets à l’avenir.

À quoi sert l’ARP ?

ARP établit une correspondance entre les adresses MAC de la couche 2 et les adresses IP de la couche 3. Cette fonction est essentielle pour l’acheminement du trafic sur le réseau. Sans ARP, les correspondances d’adresses IP/MAC devraient être créées et mises à jour manuellement, ce qui réduirait considérablement la convivialité du réseau.

Types d’ARP

Le protocole ARP principal découvre l’adresse MAC associée à une adresse IP en fonction des besoins. Voici quelques autres variantes du protocole :

ARP gratuit (gratuitous) : Généralement, une correspondance d’adresse IP/MAC n’est envoyée qu’en réponse à une demande de la passerelle. Avec l’ARP gratuit, un appareil annonce sa correspondance d’adresse IP/MAC sans qu’on le lui demande.
ARP inversé (RARP) : l’ARP est utilisé pour déterminer l’adresse MAC associée à une adresse IP. RARP est utilisé par les appareils qui ne connaissent pas leur adresse IP pour la découvrir.
ARP inverse (IARP) : alors que RARP est utilisé par un appareil pour trouver sa propre adresse IP sur la base d’une adresse MAC, IARP peut être utilisé par un autre appareil pour connaître l’adresse IP d’un appareil à partir de son adresse MAC.

Attaque par empoisonnement du cache ARP (ARP Cache Poisoning)

L’ARP est un protocole réseau qui repose sur la confiance. Lorsqu’une passerelle envoie une requête ARP, elle accepte la première réponse qu’elle reçoit. Le trafic à destination de cette adresse IP est ensuite acheminé vers l’adresse MAC indiquée.

Une attaque ARP spoofing ou ARP poisoning abuse de cette confiance. Dans cette attaque, l’attaquant envoie une réponse ARP ou un message ARP gratuit qui associe sa propre adresse MAC à l’adresse IP d’une cible. Les données destinées à la victime sont alors acheminées vers l’attaquant, ce qui peut être utilisé dans le cadre d’une attaque de type “man-in-the-middle” (MitM) pour voler des données sensibles ou d’une attaque par déni de service (DoS) si l’attaquant se contente de laisser tomber les paquets reçus.