# Tampering

## 📑 **Índice**

1. [Fundamentos do Tampering](#-fundamentos-do-tampering)
2. [Tipos de Ataques de Tampering](#-tipos-de-ataques-de-tampering)
3. [Técnicas de Bypass de Proteções](#-técnicas-de-bypass-de-proteções)
4. [Ataques a Sistemas Embarcados](#-ataques-a-sistemas-embarcados)
5. [Ataques a POS e Terminais de Pagamento](#-ataques-a-pos-e-terminais-de-pagamento)
6. [Ferramentas e Equipamentos](#-ferramentas-e-equipamentos)
7. [Detecção e Prevenção](#-detecção-e-prevenção)
8. [Custos e Onde Comprar](#-custos-e-onde-comprar)

***

## 🔍 **Fundamentos do Tampering**

### **O que é Tampering?**

**Tampering (Violação)** é o ato de modificar fisicamente um dispositivo eletrônico para alterar seu comportamento, contornar mecanismos de segurança, extrair informações sensíveis ou obter funcionalidades não autorizadas. Diferente de ataques de software, o tampering envolve manipulação direta do hardware, como abrir o dispositivo, soldar fios, remover componentes, ou modificar trilhas de PCB.

### **Contexto Histórico**

```yaml
Evolução do Tampering:
  1970s: Primeiros ataques a fliperamas (créditos grátis)
  1980s: Modchips para consoles de videogame
  1990s: Decodificadores de TV por assinatura
  2000s: Desbloqueio de celulares (SIM unlock)
  2010s: Ataques a terminais POS e ATMs
  2015: Bypass de secure boot em dispositivos IoT
  2020: Ataques a hardware de criptomoedas
  2024: Técnicas avançadas de micro-soldagem

Motivação:
  ✅ Obter funcionalidades pagas (grátis)
  ✅ Extrair chaves criptográficas
  ✅ Clonar dispositivos seguros
  ✅ Bypass de proteções de software
  ✅ Engenharia reversa de hardware
```

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

```mermaid
graph TD
    subgraph "Dispositivo Alvo"
        A[Processador] --- B[Memória Flash]
        A --- C[Sensor Tamper]
        A --- D[Interface de Debug]
        A --- E[Boot ROM]
    end
    
    subgraph "Ações de Tampering"
        F[Corte de Trilhas] --> A
        G[Injeção de Sinal] --> D
        H[Bypass de Sensor] --> C
        I[Leitura de Flash] --> B
        J[Modificação de Boot] --> E
    end
```

***

## 🎯 **Tipos de Ataques de Tampering**

### **Comparação de Técnicas**

| Técnica                    | Alvo                | Dificuldade       | Equipamento       | Detectabilidade |
| -------------------------- | ------------------- | ----------------- | ----------------- | --------------- |
| **Corte de Trilhas**       | Sensores, proteções | Baixa             | Estilete, lupa    | Alta (visual)   |
| **Solda de Fios**          | Debug interfaces    | Média             | Ferro de solda    | Média           |
| **Dessoldagem**            | Chips de memória    | Alta              | Estação de reflow | Alta            |
| **Micro-probing**          | Pinos internos      | Muito Alta        | Micro-manipulador | Muito Baixa     |
| **Decapagem**              | Die do chip         | Muito Alta        | Ácidos, laser     | Irreversível    |
| **Laser Cutter**           | Trilhas finas       | Alta              | Laser             | Baixa           |
| **FIB (Focused Ion Beam)** | Circuitos internos  | Extremamente Alta | FIB machine       | Indetectável    |

***

## ✂️ **Técnicas de Bypass de Proteções**

### **1. Bypass de Sensores Tamper**

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

class TamperBypass:
    """
    Técnicas para bypass de sensores tamper
    """
    
    @staticmethod
    def identify_tamper_mesh(pcb_image):
        """
        Identificar malha tamper na PCB
        """
        print("[*] Identificando malha tamper:")
        print("    - Trilhas muito finas (0.1-0.2mm)")
        print("    - Padrão de zigue-zague ou malha")
        print("    - Localizada em bordas ou sob chips")
        print("    - Conectada a pino de interrupção")
        
        return True
    
    @staticmethod
    def bypass_single_layer_mesh():
        """
        Bypass de malha de camada única
        """
        print("[*] Bypass de malha de camada única:")
        print("    1. Localizar pontos de entrada/saída da malha")
        print("    2. Cortar trilhas antes do conector do processador")
        print("    3. Aplicar tensão constante (3.3V) no pino de monitoramento")
        print("    4. Verificar continuidade com multímetro")
        
        return True
    
    @staticmethod
    def bypass_multi_layer_mesh():
        """
        Bypass de malha multicamadas
        """
        print("[*] Bypass de malha multicamadas:")
        print("    1. Remover componentes sobre a malha (com cuidado)")
        print("    2. Escanear camadas com raio-X (se disponível)")
        print("    3. Identificar pontos de interconexão entre camadas")
        print("    4. Isolar cada camada individualmente")
        print("    5. Cortar trilhas em todas as camadas afetadas")
        
        return True
    
    @staticmethod
    def bypass_capacitive_sensor():
        """
        Bypass de sensor capacitivo
        """
        print("[*] Bypass de sensor capacitivo:")
        print("    1. Identificar trilhas do sensor (geralmente isoladas)")
        print("    2. Aplicar fita de cobre sobre a área do sensor")
        print("    3. Conectar fita ao GND ou tensão específica")
        print("    4. Simular capacitância esperada")
        
        return True
    
    @staticmethod
    def bypass_optical_sensor():
        """
        Bypass de sensor óptico (fotoelétrico)
        """
        print("[*] Bypass de sensor óptico:")
        print("    1. Localizar LED e fototransistor")
        print("    2. Aplicar fita isolante preta sobre o caminho óptico")
        print("    3. Ou aplicar tensão constante no fototransistor")
        print("    4. Simular sinal de 'fechado'")
        
        return True

# Uso
TamperBypass.identify_tamper_mesh('pcb.jpg')
TamperBypass.bypass_single_layer_mesh()
```

### **2. Bypass de JTAG/SWD Lock**

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

class JTAGBypass:
    """
    Técnicas para reativar JTAG/SWD bloqueado
    """
    
    @staticmethod
    def locate_jtag_pads(mcu_model):
        """
        Localizar pads JTAG no chip
        """
        jtag_pins = {
            'STM32F4': 'PA13 (SWDIO), PA14 (SWCLK)',
            'STM32F1': 'PA13 (SWDIO), PA14 (SWCLK)',
            'LPC1768': 'P1.30 (SWDIO), P1.31 (SWCLK)',
            'ESP32': 'GPIO12 (MTDI), GPIO13 (MTCK)'
        }
        
        print(f"[*] Pinos JTAG para {mcu_model}: {jtag_pins.get(mcu_model, 'Desconhecido')}")
        return jtag_pins.get(mcu_model)
    
    @staticmethod
    def voltage_glitch_jtag():
        """
        Bypass de JTAG lock via voltage glitch
        """
        print("[*] Bypass de JTAG lock via voltage glitch:")
        print("    1. Aplicar undervolt durante boot")
        print("    2. Glitch faz processador pular verificação de lock")
        print("    3. JTAG permanece ativo")
        print("    4. Conectar debugger e ler memória")
        
        return True
    
    @staticmethod
    def clock_glitch_jtag():
        """
        Bypass de JTAG lock via clock glitch
        """
        print("[*] Bypass de JTAG lock via clock glitch:")
        print("    1. Injetar pulso extra de clock durante boot")
        print("    2. Verificação de lock é pulada")
        print("    3. JTAG ativo")
        
        return True
    
    @staticmethod
    def firmware_patch_jtag():
        """
        Patch de firmware via JTAG após bypass
        """
        print("[*] Patch de firmware:")
        print("    1. Ler firmware via JTAG")
        print("    2. Identificar rotina de verificação de lock")
        print("    3. Patch (NOP ou branch invertido)")
        print("    4. Gravar firmware modificado")
        print("    5. JTAG permanece ativo permanentemente")
        
        return True

# Uso
JTAGBypass.locate_jtag_pads('STM32F4')
JTAGBypass.voltage_glitch_jtag()
```

### **3. Bypass de Read-Out Protection (RDP)**

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

class RDPBypass:
    """
    Técnicas para bypass de Read-Out Protection
    """
    
    @staticmethod
    def locate_rdp_fuse(mcu):
        """
        Localizar fusível RDP
        """
        rdp_locations = {
            'STM32': 'Option bytes at 0x1FFF7800',
            'LPC': 'Flash configuration register',
            'Kinetis': 'FTFL_FSEC register'
        }
        
        print(f"[*] RDP location for {mcu}: {rdp_locations.get(mcu, 'Unknown')}")
        return rdp_locations.get(mcu)
    
    @staticmethod
    def voltage_glitch_rdp():
        """
        Bypass de RDP via voltage glitch
        """
        print("[*] Bypass de RDP via voltage glitch:")
        print("    1. Aplicar undervolt durante leitura de option bytes")
        print("    2. Glitch faz processador ler valor errado")
        print("    3. RDP aparece como desabilitado")
        print("    4. Leitura de flash permitida")
        
        return True
    
    @staticmethod
    def fault_injection_rdp():
        """
        Bypass de RDP via fault injection
        """
        print("[*] Bypass de RDP via fault injection:")
        print("    1. Interromper execução durante boot")
        print("    2. Aplicar glitch no momento da verificação RDP")
        print("    3. Verificação é pulada")
        print("    4. Acesso irrestrito à memória")
        
        return True
    
    @staticmethod
    def laser_fault_rdp():
        """
        Bypass de RDP via laser (técnica avançada)
        """
        print("[*] Bypass de RDP via laser:")
        print("    1. Decapsular o chip (remover encapsulamento)")
        print("    2. Localizar fusível RDP no die")
        print("    3. Aplicar laser pulsado para queimar fusível")
        print("    4. RDP permanentemente desabilitado")
        print("    ⚠️ Chip pode ser danificado permanentemente")
        
        return True

# Uso
RDPBypass.locate_rdp_fuse('STM32')
RDPBypass.voltage_glitch_rdp()
```

***

## 💳 **Ataques a Sistemas Embarcados**

### **Ataque a Consoles de Videogame**

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

class ConsoleTampering:
    """
    Técnicas de tampering para consoles
    """
    
    @staticmethod
    def ps4_tampering():
        """
        Ataques ao PlayStation 4
        """
        print("[*] PlayStation 4 Tampering:")
        print("    1. Identificar pontos de debug (UART/JTAG)")
        print("    2. Bypass de sensores tamper (trilhas na borda)")
        print("    3. Ler firmware da NOR flash")
        print("    4. Modificar bootloader para aceitar código não assinado")
        print("    5. Gravar firmware modificado")
        
        return True
    
    @staticmethod
    def switch_tampering():
        """
        Ataques ao Nintendo Switch
        """
        print("[*] Nintendo Switch Tampering:")
        print("    1. Explorar falha no bootROM (CVE-2018-6242)")
        print("    2. Curto-circuito no pino de recovery (RCM)")
        print("    3. Injetar payload via USB")
        print("    4. Executar código arbitrário")
        
        return True
    
    @staticmethod
    def xbox_tampering():
        """
        Ataques ao Xbox
        """
        print("[*] Xbox Tampering:")
        print("    1. Identificar pontos de teste (JTAG)")
        print("    2. Bypass de proteção de leitura")
        print("    3. Ler firmware da flash")
        print("    4. Modificar chaves de autenticação")
        
        return True

# Uso
ConsoleTampering.ps4_tampering()
```

### **Ataque a Dispositivos IoT**

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

class IOTTampering:
    """
    Técnicas de tampering para dispositivos IoT
    """
    
    @staticmethod
    def smart_camera_tampering():
        """
        Ataques a câmeras IP
        """
        print("[*] Smart Camera Tampering:")
        print("    1. Localizar porta UART (TX, RX, GND)")
        print("    2. Conectar conversor USB-UART")
        print("    3. Acessar console serial (geralmente root)")
        print("    4. Modificar firmware para remover restrições")
        
        return True
    
    @staticmethod
    def router_tampering():
        """
        Ataques a roteadores
        """
        print("[*] Router Tampering:")
        print("    1. Identificar header JTAG ou UART")
        print("    2. Ler firmware da flash SPI")
        print("    3. Modificar variáveis de boot")
        print("    4. Adicionar backdoor permanente")
        
        return True
    
    @staticmethod
    def smart_tv_tampering():
        """
        Ataques a Smart TVs
        """
        print("[*] Smart TV Tampering:")
        print("    1. Acessar porta de serviço (geralmente escondida)")
        print("    2. Bypass de proteção de região")
        print("    3. Instalar aplicativos não autorizados")
        print("    4. Remover anúncios")
        
        return True

# Uso
IOTTampering.smart_camera_tampering()
```

***

## 💰 **Ataques a POS e Terminais de Pagamento**

### **POS Ingenico iPP320**

```yaml
POS Ingenico iPP320:
  
  Identificação:
    - Processador: ARM Cortex-M3
    - Memória Flash: 512KB
    - Secure Element: AT90SC
    - Sensores tamper: Malha na borda da PCB
  
  Pontos Fracos:
    - JTAG acessível (pads sob display)
    - RDP Level 1 apenas (bypassável)
    - Sensores tamper de camada única
    - Trilhas de segurança fáceis de identificar
  
  Procedimento de Ataque:
    1. Remover display (clipes laterais)
    2. Localizar pads JTAG (TCK, TMS, TDI, TDO)
    3. Soldar fios finos (30 AWG) nos pads
    4. Conectar ST-Link/V2
    5. Aplicar voltage glitch durante boot
    6. RDP desabilitado
    7. Ler firmware completo (512KB)
    8. Extrair chaves MKS/DUKPT
  
  Resultado:
    - Terminal clonado
    - Transações fraudulentas
```

### **POS Verifone VX520**

```yaml
POS Verifone VX520:
  
  Identificação:
    - Processador: Freescale i.MX28
    - Memória Flash: NAND 128MB
    - Secure Element: AT90SC
  
  Pontos Fracos:
    - UART ativo na porta de diagnóstico
    - Bootloader permite carregar código via SD
    - Proteção de leitura fraca
  
  Procedimento de Ataque:
    1. Acessar porta UART (atrás da bateria)
    2. Conectar conversor USB-UART
    3. Interromper boot (send break)
    4. Acessar bootloader (Uboot)
    5. Carregar firmware customizado via SD
    6. Extrair chaves criptográficas
  
  Resultado:
    - Clonagem do terminal
    - Captura de transações
```

### **Script de Ataque a POS**

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

import serial
import time

class POSTampering:
    """
    Ataque a terminal de pagamento via UART
    """
    
    def __init__(self, port='/dev/ttyUSB0', baud=115200):
        self.port = port
        self.baud = baud
        self.ser = None
    
    def connect(self):
        """
        Conectar à UART do POS
        """
        try:
            self.ser = serial.Serial(self.port, self.baud, timeout=1)
            print(f"[+] Conectado ao POS via {self.port} @ {self.baud} baud")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False
    
    def interrupt_boot(self):
        """
        Interromper bootloader
        """
        print("[*] Enviando break para interromper boot...")
        self.ser.send_break()
        time.sleep(0.5)
        
        response = self.ser.read(256)
        if b'uboot' in response.lower() or b'boot' in response.lower():
            print("[+] Bootloader interrompido!")
            return True
        
        return False
    
    def read_flash(self):
        """
        Ler flash via bootloader
        """
        print("[*] Tentando ler flash...")
        
        # Comandos comuns em bootloaders
        commands = [
            'md 0x08000000 0x80000',  # STM32
            'nand read 0x80000000 0x0 0x8000000',  # i.MX
            'sf read 0x80000000 0x0 0x800000'  # SPI flash
        ]
        
        for cmd in commands:
            self.ser.write((cmd + '\n').encode())
            time.sleep(0.5)
            response = self.ser.read(4096)
            if len(response) > 0:
                print(f"[+] Dados lidos via {cmd[:20]}...")
                return response
        
        return None
    
    def extract_keys(self):
        """
        Extrair chaves do firmware
        """
        print("[*] Procurando chaves no firmware...")
        
        # Padrões de chave criptográfica
        patterns = [
            b'-----BEGIN RSA PRIVATE KEY-----',
            b'MKS',
            b'DUKPT',
            b'BDK'
        ]
        
        # Em hardware real, analisar firmware extraído
        
        return True

# Uso
# attacker = POSTampering('/dev/ttyUSB0', 115200)
# attacker.connect()
# attacker.interrupt_boot()
# attacker.read_flash()
```

***

## 🛠️ **Ferramentas e Equipamentos**

### **Ferramentas Essenciais**

| Ferramenta                   | Uso                    | Preço (R$)    | Onde Comprar          |
| ---------------------------- | ---------------------- | ------------- | --------------------- |
| **Ferro de solda fino**      | Solda de fios          | \~R$50-150    | Shopee, Mercado Livre |
| **Estação de reflow**        | Remoção de componentes | \~R$300-800   | Mercado Livre         |
| **Pistola de ar quente**     | Dessoldagem            | \~R$150-400   | Shopee, AliExpress    |
| **Lupa binocular (10x-40x)** | Inspeção               | \~R$150-400   | Shopee, AliExpress    |
| **Microscópio digital**      | Inspeção detalhada     | \~R$200-600   | Shopee, AliExpress    |
| **Multímetro**               | Teste de continuidade  | \~R$50-150    | Qualquer loja         |
| **Estilete de precisão**     | Corte de trilhas       | \~R$20-50     | Shopee, Mercado Livre |
| **Fio de solda 0.3mm**       | Reparo de trilhas      | \~R$10-30     | Qualquer loja         |
| **Pasta de solda**           | Solda de precisão      | \~R$20-50     | Shopee, AliExpress    |
| **Fluxo de solda**           | Limpeza                | \~R$10-30     | Qualquer loja         |
| **ST-Link/V2**               | Leitura de firmware    | \~R$40-80     | AliExpress, Shopee    |
| **J-Link EDU**               | Debugger profissional  | \~R$400-600   | Mouser, DigiKey       |
| **FTDI USB-UART**            | Console serial         | \~R$30-50     | AliExpress, Shopee    |
| **Total Setup Básico**       | Ferro + Multímetro     | \~R$150-300   | -                     |
| **Total Setup Profissional** | Completo               | \~R$1000-2000 | -                     |

### **Ferramentas Especializadas**

| Ferramenta                 | Uso                        | Preço (R$)    | Onde Comprar              |
| -------------------------- | -------------------------- | ------------- | ------------------------- |
| **Micromotor (Dremel)**    | Corte preciso              | \~R$200-500   | Mercado Livre             |
| **Ponteira diamantada**    | Corte de trilhas           | \~R$30-80     | Shopee, AliExpress        |
| **ChipQuik**               | Remoção de componentes SMD | \~R$50-100    | AliExpress                |
| **Laser cutter**           | Corte de precisão          | \~R$2000-5000 | Equipamento industrial    |
| **Raio-X PCB**             | Inspeção de camadas        | \~R$5000+     | Equipamento industrial    |
| **Focused Ion Beam (FIB)** | Modificação de circuito    | \~R$500.000+  | Laboratório especializado |

***

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

### **Sinais de Tampering**

```yaml
Indicadores de Violação Física:
  
  Visuais:
    - Parafusos riscados/arranhados
    - Selos de garantia violados
    - Marcas de ferramentas na carcaça
    - Carcaça com marcas de abertura
    - Trilhas cortadas ou soldadas
    - Componentes removidos/substituídos
  
  Elétricos:
    - Consumo de energia anormal
    - Tensões fora da especificação
    - Sinais de clock distorcidos
    - Ruído excessivo em trilhas
  
  Comportamentais:
    - Falhas intermitentes
    - Comportamento não documentado
    - Tempo de inicialização alterado
    - Funções de segurança desabilitadas
```

### **Proteções Anti-Tamper**

```yaml
Proteções de Hardware:
  
  Detecção de Violação:
    - Malhas tamper multicamadas
    - Sensores de tensão (voltage monitors)
    - Sensores de temperatura
    - Sensores de luz (photodiodes)
    - Sensores de proximidade
  
  Proteções Ativas:
    - Apagamento automático de chaves
    - Zeroization de memória sensível
    - Desabilitação de funcionalidades
    - Logging de tentativas de violação
  
  Proteções Passivas:
    - Encapsulamento epóxi (potting)
    - Camadas ocultas de PCB
    - Componentes sob componentes (stacked)
    - Trilhas em camadas internas
  
  Proteções de Design:
    - Geometria irregular de PCB
    - Marcas d'água em camadas
    - Componentes customizados
    - Chip-on-board (COB)
```

### **Implementação de Proteção**

```c
// tamper_protection.c

#include <stdint.h>

// Configuração de sensores tamper
void init_tamper_sensors(void) {
    // Configurar GPIOs para sensores
    // Configurar interrupções para detecção de violação
}

// Detector de violação
uint8_t detect_tamper(void) {
    // Verificar malha tamper
    if (check_tamper_mesh() != 0) {
        return 1;
    }
    
    // Verificar tensão
    if (check_voltage() < 2100 || check_voltage() > 3300) {
        return 1;
    }
    
    // Verificar temperatura
    if (check_temperature() > 85) {
        return 1;
    }
    
    return 0;
}

// Resposta a violação
void tamper_response(void) {
    // Apagar chaves criptográficas
    zeroize_keys();
    
    // Apagar memória sensível
    zeroize_sensitive_data();
    
    // Registrar evento
    log_tamper_event();
    
    // Desabilitar funcionalidades
    disable_secure_functions();
    
    // Entrar em modo de erro
    enter_error_state();
}
```

***

## 📊 **Conclusão**

### **Resumo Técnico**

```yaml
Tampering:
  ✅ Ataque físico poderoso e direto
  ✅ Bypassa todas as proteções de software
  ✅ Pode ser feito com ferramentas acessíveis
  ✅ Comum em ataques a POS, consoles, IoT

Ameaças Principais:
  - Corte de trilhas de sensores tamper
  - Bypass de JTAG/SWD lock
  - Desabilitação de proteção de leitura (RDP)
  - Extração de firmware e chaves
  - Clonagem de dispositivos seguros

Defesas:
  - Malhas tamper multicamadas
  - Encapsulamento epóxi (potting)
  - Sensores ativos de violação
  - Zeroization automática de chaves
  - Design resistente a tamper
```


---

# 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/tampering.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.