# Power Fault

## 📑 **Índice**

1. [Fundamentos do Ataque Físico a PCB](#-fundamentos-do-ataque-físico-a-pcb)
2. [Corte de Trilhas (Trace Cutting)](#-corte-de-trilhas-trace-cutting)
3. [Desabilitação de Hardening Físico](#-desabilitação-de-hardening-físico)
4. [Ataques a Máquinas de Cartão (POS)](#-ataques-a-máquinas-de-cartão-pos)
5. [Equipamentos e Ferramentas](#-equipamentos-e-ferramentas)
6. [Técnicas Avançadas](#-técnicas-avançadas)
7. [Detecção e Prevenção](#-detecção-e-prevenção)
8. [Custos e Onde Comprar](#-custos-e-onde-comprar)

***

## 🔍 **Fundamentos do Ataque Físico a PCB**

### **O que é Ataque Físico a PCB?**

O ataque físico a Placas de Circuito Impresso (PCB) envolve a manipulação direta do hardware para contornar mecanismos de segurança. Isso inclui o **corte de trilhas** (trace cutting) para interromper sinais críticos, a **desabilitação de sensores de tamper** e a **manipulação de componentes** para bypassar proteções. Esta é uma técnica clássica em ataques a terminais de pagamento (POS), caixas eletrônicos, consoles de jogos e dispositivos de segurança.

### **Contexto Histórico**

```yaml
Evolução dos Ataques Físicos:
  1980s: Primeiros ataques a fliperamas (créditos grátis)
  1990s: Ataques a consoles de videogame (modchips)
  2000s: Ataques a decodificadores de TV por assinatura
  2010s: Ataques a terminais POS e ATMs
  2015: Descoberta de falhas em chips de segurança
  2020: Ataques a dispositivos IoT e hardware seguro
  2024: Técnicas avançadas de micro-soldagem e bypass

Motivação:
  ✅ Bypass de proteções de software (impossível via código)
  ✅ Extração de chaves criptográficas
  ✅ Obtenção de créditos/prêmios grátis
  ✅ Clonagem de dispositivos seguros
```

### **Por que Atacar o Hardware?**

```yaml
Limitações do Ataque por Software:
  - Firmware protegido contra leitura (RDP)
  - Bootloaders assinados criptograficamente
  - Criptografia forte nas comunicações
  - Atualizações OTA bloqueadas

Vantagens do Ataque Físico:
  - Bypassa todas as proteções de software
  - Acesso direto a barramentos e sinais
  - Possibilidade de ler memória protegida
  - Pode ser feito com ferramentas simples
```

***

## ✂️ **Corte de Trilhas (Trace Cutting)**

### **O que são Trilhas de PCB?**

Trilhas são as "estradas" de cobre que conectam componentes em uma placa de circuito impresso. Cada trilha transporta sinais elétricos entre processadores, memórias, sensores e outros componentes. Cortar uma trilha interrompe permanentemente essa conexão, podendo desabilitar proteções ou permitir injeção de sinais maliciosos.

```mermaid
graph TD
    subgraph "PCB Normal"
        A[Processador] === B[Memória Flash]
        A === C[Sensor Tamper]
        A === D[Interface de Debug]
    end
    
    subgraph "Após Corte de Trilhas"
        A[Processador] -.-x B[Memória Flash]
        A -.-x C[Sensor Tamper]
        A --> D[Interface de Debug]
    end
```

### **Trilhas Comuns para Ataque**

| Componente                    | Trilha Alvo          | Efeito do Corte                  |
| ----------------------------- | -------------------- | -------------------------------- |
| **Sensor Tamper**             | Sinal de saída       | Desabilita detecção de violação  |
| **JTAG/SWD**                  | Pinos de debug       | Permite acesso à depuração       |
| **Proteção de Leitura (RDP)** | Fusível de segurança | Permite leitura de firmware      |
| **Boot Select**               | Pino de modo de boot | Força boot em modo inseguro      |
| **Clock**                     | Sinal de clock       | Permite glitch de clock          |
| **Reset**                     | Linha de reset       | Impede resets de segurança       |
| **Power Monitoring**          | Sinal de BOR         | Desabilita detecção de undervolt |
| **Comunicação Segura**        | Linhas I²C/SPI       | Permite sniffing/injeção         |

### **Técnicas de Corte de Trilhas**

#### **1. Corte Manual com Estilete/Laser**

```yaml
Ferramentas Necessárias:
  - Estilete de precisão (lâmina #11)
  - Lupa de aumento (10x-40x)
  - Multímetro (teste de continuidade)
  - Iluminação adequada (LED ring light)

Procedimento:
  1. Identificar a trilha alvo (datasheet + inspeção)
  2. Marcar o ponto de corte com caneta fina
  3. Raspar a máscara de solda (se necessário)
  4. Cortar a trilha com movimento controlado
  5. Verificar continuidade com multímetro
  6. Testar funcionalidade do dispositivo

Riscos:
  - Cortar trilha errada (danifica dispositivo)
  - Danificar componentes adjacentes
  - Criar curtos com trilhas próximas
```

#### **2. Corte com Ferramentas Especializadas**

```yaml
Ferramentas Avançadas:
  - Micromotores (Dremel) com ponta diamantada
  - Cortador a laser (PCB laser cutter)
  - Microssolda para desfazer cortes
  - Ponteiras de fibra óptica (corte fino)

Vantagens:
  - Cortes mais precisos
  - Menor dano a componentes
  - Possibilidade de reparo (re-soldagem)
```

### **Corte de Trilha de Sensor Tamper (Passo a Passo)**

```python
# trace_cutting_guide.py - Guia para corte de trilha de tamper

class TamperBypass:
    """
    Bypass de sensor tamper via corte de trilha
    Comum em terminais POS e ATMs
    """
    
    @staticmethod
    def locate_tamper_traces(pcb_image):
        """
        Localizar trilhas de tamper na PCB
        """
        # Características de trilhas de tamper:
        # - Trilhas muito finas (0.1-0.2mm)
        # - Padrão de zigue-zague ou malha
        # - Conectadas a um pino específico do processador
        # - Geralmente em bordas da placa
        
        print("[*] Procurando trilhas de tamper...")
        print("    - Trilhas finas em padrão de malha")
        print("    - Conectadas a pino de interrupção")
        print("    - Ao redor de componentes sensíveis")
        
        # Simular localização
        tamper_traces = [
            {'location': 'Edge of PCB', 'width': '0.15mm'},
            {'location': 'Under security IC', 'width': '0.1mm'}
        ]
        
        return tamper_traces
    
    @staticmethod
    def cut_tamper_trace(trace_location):
        """
        Realizar corte da trilha de tamper
        """
        print(f"[*] Cortando trilha em {trace_location}")
        print("    1. Remover máscara de solda (se necessário)")
        print("    2. Realizar corte com estilete de precisão")
        print("    3. Verificar isolamento com multímetro")
        print("    4. Testar se tamper foi desabilitado")
        
        return True
    
    @staticmethod
    def bypass_tamper_simulation():
        """
        Simular bypass de tamper em POS
        """
        print("\n=== BYPASS DE SENSOR TAMPER ===")
        
        # Antes do corte
        print("\n[ANTES] Sensor tamper ativo:")
        print("   - Qualquer tentativa de abertura destrói chaves")
        print("   - Memória de segurança é apagada")
        print("   - Dispositivo entra em modo de erro")
        
        # Após o corte
        print("\n[APÓS CORTE] Sensor tamper desabilitado:")
        print("   - Placa pode ser aberta sem consequências")
        print("   - Memória de segurança permanece intacta")
        print("   - Acesso a chaves criptográficas possível")
        
        return True

# Uso
# TamperBypass.locate_tamper_traces('pcb_back.jpg')
# TamperBypass.cut_tamper_trace('Edge of PCB')
```

***

## 🛡️ **Desabilitação de Hardening Físico**

### **Tipos de Hardening Físico**

```yaml
Hardening Físico Comum em POS:
  
  Camadas Epóxi/Conformal Coating:
    - Resina que cobre componentes
    - Dificulta acesso a trilhas/pinos
    - Pode ser removida quimicamente
  
  Sensores Tamper (Malha):
    - Trilhas finas que detectam violação
    - Quando rompidas, apagam chaves
    - Localizadas sob componentes críticos
  
  Potting (Encapsulamento):
    - Resina preenchendo toda a cavidade
    - Extremamente difícil de remover
    - Requer ácidos ou aquecimento
  
  Chips Seguros (Secure Element):
    - Proteções internas anti-tamper
    - Sensores de tensão, temperatura, luz
    - Glitch detection
  
  Camadas Ocultas de PCB:
    - Trilhas em camadas internas
    - Inacessíveis sem decapagem
    - Protegem sinais críticos
```

### **Remoção de Camadas Protetivas**

```yaml
Remoção de Conformal Coating:
  
  Química:
    - Acetona (para coating acrílico)
    - Diclorometano (para poliuretano)
    - N-Metil-2-pirrolidona (NMP)
    - Aplicar com pincel ou imersão
  
  Mecânica:
    - Escovação suave (escova de cerdas macias)
    - Jato de bicarbonato (micro-abrasão)
    - Laser (remoção precisa)
  
  Térmica:
    - Aquecimento localizado (80-120°C)
    - Coating amolece e pode ser raspado
    - Cuidado para não danificar componentes

Remoção de Potting (Epóxi):
  - Aquecimento (150-200°C) + remoção mecânica
  - Ácido nítrico concentrado (muito perigoso)
  - Ferramentas rotativas (Dremel) com cuidado
```

### **Bypass de Malha Tamper**

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

class TamperMeshBypass:
    """
    Técnicas para bypass de malha tamper
    """
    
    @staticmethod
    def identify_mesh_type(pcb):
        """
        Identificar tipo de malha tamper
        """
        mesh_types = {
            'single_layer': 'Uma camada de trilhas finas',
            'multi_layer': 'Múltiplas camadas interconectadas',
            'active_mesh': 'Malha com corrente monitorada',
            'capacitive': 'Detecta proximidade (não contato)'
        }
        
        # Determinar tipo baseado na inspeção
        return 'single_layer'
    
    @staticmethod
    def bypass_single_layer_mesh():
        """
        Bypass de malha de camada única
        """
        print("[*] Bypass de malha de camada única:")
        print("    1. Identificar pontos de entrada/saída da malha")
        print("    2. Cortar trilhas próximas ao conector")
        print("    3. Aplicar tensão constante no pino de monitoramento")
        print("    4. Simular sinal 'OK' para o processador")
        
        return True
    
    @staticmethod
    def bypass_multi_layer_mesh():
        """
        Bypass de malha multicamadas
        """
        print("[*] Bypass de malha multicamadas:")
        print("    1. Remover componentes sobre a malha")
        print("    2. Escanear camadas com raio-X")
        print("    3. Identificar pontos de interconexão")
        print("    4. Isolar cada camada individualmente")
        print("    5. Aplicar sinais de bypass em todas")
        
        return True
    
    @staticmethod
    def inject_fake_tamper_signal(processor_pin):
        """
        Injetar sinal falso de tamper
        """
        print(f"[*] Injetando sinal falso no pino {processor_pin}")
        print("    - Sinal normalmente é HIGH (não violado)")
        print("    - Quando violado, vai LOW")
        print("    - Aplicar tensão constante (3.3V) no pino")
        
        return True

# Uso
# TamperMeshBypass.bypass_single_layer_mesh()
```

### **Desabilitação de Proteção de Leitura (RDP)**

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

class RDPBypass:
    """
    Bypass de Read-Out Protection (RDP)
    Comum em microcontroladores STM32
    """
    
    @staticmethod
    def locate_rdp_fuse(mcu_model):
        """
        Localizar fusível RDP no chip
        """
        rdp_locations = {
            'STM32F4': 'Option bytes at 0x1FFF7800',
            'STM32F1': 'Option bytes at 0x1FFFF800',
            'STM32L4': 'Option bytes at 0x1FFF7800'
        }
        
        return rdp_locations.get(mcu_model, 'Unknown')
    
    @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/skippada")
        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")
        
        return True
```

***

## 💳 **Ataques a Máquinas de Cartão (POS)**

### **Visão Geral do Ataque a POS**

```mermaid
graph TD
    subgraph "Terminal POS"
        A[Processador Principal] --- B[Memória Flash]
        A --- C[Display]
        A --- D[Teclado]
        A --- E[Leitor de Cartão]
        A --- F[Modem/Internet]
        A --- G[SRAM/Bateria]
    end
    
    subgraph "Pontos de Ataque"
        H[Corte Trilha Tamper] --> A
        I[Corte Trilha RDP] --> B
        J[Glitch Alimentação] --> A
        K[Sondagem SPI/I²C] --> E
    end
```

### **POS Atingidos por Ataques Físicos**

```yaml
Modelos de POS Vulneráveis:
  - Ingenico iPP320, iPP350, iWL250
  - Verifone VX520, VX680, VX820
  - PAX S80, S90, D210
  - Gertec GPOS X5, GPOS X7
  - Positivo POS-700

Vulnerabilidades Exploradas:
  - Sensores tamper ineficazes
  - Trilhas de segurança fáceis de identificar
  - RDP desabilitado ou bypassável
  - Bootloader sem proteção
```

### **Passo a Passo do Ataque a POS**

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

class POSPhysicalAttack:
    """
    Ataque físico a terminal de pagamento
    """
    
    @staticmethod
    def disassemble_pos():
        """
        Desmontagem do terminal
        """
        print("[1] DESMONTAGEM DO POS")
        print("    - Remover parafusos (geralmente Torx T6/T8)")
        print("    - Utilizar espátula para abrir clipes")
        print("    - Cuidado com sensores tamper")
        print("    - Identificar localização do sensor de abertura")
        
        return True
    
    @staticmethod
    def identify_critical_components():
        """
        Identificar componentes críticos
        """
        print("[2] IDENTIFICAÇÃO DE COMPONENTES")
        print("    Componentes principais:")
        print("    - Processador principal (geralmente ARM Cortex)")
        print("    - Memória Flash (Winbond, Macronix, etc.)")
        print("    - Secure Element (chip de segurança)")
        print("    - SRAM com bateria backup")
        print("    - Sensores tamper (malha/metais)")
        
        return True
    
    @staticmethod
    def bypass_tamper_sensors():
        """
        Bypass de sensores tamper
        """
        print("[3] BYPASS DE SENSORES TAMPER")
        print("    Método 1: Corte de trilhas")
        print("      - Localizar trilhas da malha tamper")
        print("      - Cortar antes do conector do processador")
        print("      - Aplicar tensão constante nos pinos")
        
        print("\n    Método 2: Simulação de sinal")
        print("      - Identificar pino de monitoramento")
        print("      - Aplicar 3.3V constante")
        print("      - Processador acredita que tamper está OK")
        
        print("\n    Método 3: Bypass óptico")
        print("      - Sensor fotoelétrico pode ser enganado")
        print("      - Aplicar fita isolante/cola escura")
        
        return True
    
    @staticmethod
    def extract_firmware():
        """
        Extração de firmware
        """
        print("[4] EXTRAÇÃO DE FIRMWARE")
        print("    Opção A: Leitura via JTAG/SWD")
        print("      - Localizar pontos JTAG na PCB")
        print("      - Conectar debugger (J-Link, ST-Link)")
        print("      - Ler memória flash")
        
        print("\n    Opção B: Dessoldagem da flash")
        print("      - Remover chip de memória flash")
        print("      - Usar programador universal")
        print("      - Ler conteúdo")
        
        print("\n    Opção C: Bypass de RDP")
        print("      - Aplicar voltage glitch")
        print("      - Desabilitar proteção de leitura")
        print("      - Ler via debugger")
        
        return True
    
    @staticmethod
    def extract_keys():
        """
        Extração de chaves criptográficas
        """
        print("[5] EXTRAÇÃO DE CHAVES")
        print("    Chave MKS (Master Key):")
        print("      - Armazenada no Secure Element")
        print("      - Pode ser extraída via power analysis")
        print("      - Ou via fault injection durante operação")
        
        print("\n    Chave DUKPT (derivadas):")
        print("      - Armazenadas em SRAM com bateria")
        print("      - Aplicar cold boot attack")
        print("      - Congelar SRAM e ler rapidamente")
        
        return True
    
    @staticmethod
    def clone_pos():
        """
        Clonagem do terminal
        """
        print("[6] CLONAGEM DO POS")
        print("    - Copiar firmware extraído")
        print("    - Programar novo chip flash")
        print("    - Copiar chaves extraídas")
        print("    - Terminal clonado pronto para uso")
        
        return True

# Executar simulação
POSPhysicalAttack.disassemble_pos()
POSPhysicalAttack.identify_critical_components()
POSPhysicalAttack.bypass_tamper_sensors()
POSPhysicalAttack.extract_firmware()
POSPhysicalAttack.extract_keys()
POSPhysicalAttack.clone_pos()
```

### **Caso Real: Ataque a POS Ingenico iPP320**

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

***

## 🛠️ **Equipamentos e Ferramentas**

### **Ferramentas Essenciais**

| Ferramenta                   | Uso                   | Preço (R$)   | Onde Comprar          |
| ---------------------------- | --------------------- | ------------ | --------------------- |
| **Estilete de precisão**     | Corte de trilhas      | \~R$20-50    | Shopee, Mercado Livre |
| **Lupa binocular (10x-40x)** | Inspeção              | \~R$150-400  | Shopee, AliExpress    |
| **Multímetro digital**       | Teste continuidade    | \~R$50-150   | Qualquer loja         |
| **Ferro de solda fino**      | Reparo/solda          | \~R$50-150   | 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    |
| **ST-Link/V2**               | Leitura de firmware   | \~R$40-80    | AliExpress, Shopee    |
| **J-Link EDU**               | Debugger profissional | \~R$400-600  | Mouser, DigiKey       |
| **Raspberry Pi Pico**        | Glitch generator      | \~R$35-50    | Shopee, AliExpress    |
| **Total Setup Básico**       | -                     | \~R$200-400  | -                     |
| **Total Setup Profissional** | -                     | \~R$800-1500 | -                     |

### **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     |
| **Estação de reflow**   | Remoção de componentes | \~R$300-800   | Mercado Livre          |
| **ChipWhisperer**       | Glitch + SCA           | \~R$2500-3500 | newae.com              |
| **Raio-X PCB**          | Inspeção de camadas    | \~R$5000+     | Equipamento industrial |

***

## 🔬 **Técnicas Avançadas**

### **Micro-Soldagem para Reparo de Trilhas Cortadas**

```python
# trace_repair.py

class TraceRepair:
    """
    Reparo de trilhas cortadas (para bypass de segurança)
    """
    
    @staticmethod
    def repair_with_wire(trace_gap, wire_gauge=36):
        """
        Reparo com fio de cobre
        """
        print("[*] Reparo de trilha com fio:")
        print(f"    1. Limpar área do corte (álcool isopropílico)")
        print(f"    2. Aplicar fluxo de solda")
        print(f"    3. Soldar fio AWG{wire_gauge} em um dos lados")
        print(f"    4. Moldar fio para alcançar o outro lado")
        print(f"    5. Soldar segundo ponto")
        print(f"    6. Verificar continuidade")
        
        return True
    
    @staticmethod
    def repair_with_conductive_paint():
        """
        Reparo com tinta condutiva
        """
        print("[*] Reparo de trilha com tinta condutiva:")
        print("    1. Limpar área do corte")
        print("    2. Aplicar tinta condutiva sobre o gap")
        print("    3. Aguardar secagem (15-30 minutos)")
        print("    4. Testar continuidade")
        print("    5. Aplicar camada isolante")
        
        return True
```

### **Criação de Pontos de Acesso (Debug Pads)**

```python
# debug_pad_creation.py

class DebugPadCreation:
    """
    Criação de pontos de acesso para depuração
    """
    
    @staticmethod
    def create_jtag_pads(mcu_pins):
        """
        Criar pads para acesso JTAG
        """
        print("[*] Criando pads JTAG:")
        print(f"    Pinos JTAG: {mcu_pins}")
        print("    1. Localizar trilhas dos pinos JTAG")
        print("    2. Remover máscara de solda (se necessário)")
        print("    3. Soldar fios finos (AWG30) nos pontos")
        print("    4. Conectar a header 2.54mm")
        print("    5. Fixar com cola quente")
        
        return True
    
    @staticmethod
    def create_uart_pads(tx_pin, rx_pin):
        """
        Criar pads para console UART
        """
        print(f"[*] Criando pads UART (TX={tx_pin}, RX={rx_pin})")
        print("    1. Localizar trilhas TX/RX do processador")
        print("    2. Soldar fios nos pontos")
        print("    3. Conectar a conversor FTDI")
        print("    4. Testar comunicação")
        
        return True
```

***

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

### **Como Fabricantes Protegem os POS**

```yaml
Proteções Modernas em POS:
  
  Hardware:
    - Malhas tamper em múltiplas camadas
    - Sensores de tensão, temperatura, luz
    - Encapsulamento epóxi (potting)
    - Chips com proteções ativas
  
  Firmware:
    - Secure boot com cadeia de confiança
    - Atualizações assinadas criptograficamente
    - Detecção de violação de integridade
    - Apagamento automático de chaves
  
  Design:
    - Trilhas em camadas internas
    - Componentes sob componentes (stacked)
    - Geometria irregular de PCB
    - Marcas d'água em camadas
```

### **Verificação de Integridade de Hardware**

```python
# hardware_integrity_check.py

class HardwareIntegrityCheck:
    """
    Verificação de integridade de hardware
    """
    
    @staticmethod
    def check_trace_continuity(test_points):
        """
        Verificar continuidade de trilhas críticas
        """
        print("[*] Verificando continuidade de trilhas...")
        
        for point in test_points:
            # Medir resistência
            # Verificar se há cortes
            pass
        
        return True
    
    @staticmethod
    def check_tamper_mesh():
        """
        Verificar integridade da malha tamper
        """
        print("[*] Verificando malha tamper...")
        print("    - Testar continuidade entre pontos")
        print("    - Verificar resistência esperada")
        print("    - Detectar curtos ou abertos")
        
        return True
    
    @staticmethod
    def check_rdp_status():
        """
        Verificar status de proteção de leitura
        """
        print("[*] Verificando RDP status...")
        print("    - RDP Level 0: Desprotegido")
        print("    - RDP Level 1: Protegido (leitura bloqueada)")
        print("    - RDP Level 2: Irreversível")
        
        return True
```

***

## 📊 **Conclusão**

### **Resumo Técnico**

```yaml
Ataque Físico a PCB:
  ✅ Técnica poderosa que bypassa proteções de software
  ✅ Acessível com ferramentas de baixo custo
  ✅ Comum em ataques a terminais POS
  ✅ Requer conhecimento de eletrônica

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

Defesas:
  - Malhas tamper multicamadas
  - Encapsulamento epóxi
  - Sensores ativos de violação
  - Verificação contínua de integridade
```


---

# 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/power-fault.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.