> For the complete documentation index, see [llms.txt](https://0xmorte.gitbook.io/bibliadopentestbr/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/hardware/componentes/exploracao-de-mosfets.md).

# Exploracao de MOSFETs

> *"O gate de um MOSFET é um capacitor. O atacante decide se carrega ou descarrega."*

## 📋 ÍNDICE

1. [Fundamentos de MOSFETs](#1-fundamentos-de-mosfets)
2. [Injeção no Gate (Fault Injection)](#2-injeção-no-gate-fault-injection)
3. [Exploração de Gate Flutuante](#3-exploração-de-gate-flutuante)
4. [Condução de Diodo Corporal](#4-condução-de-diodo-corporal)
5. [Indução de Shoot-Through](#5-indução-de-shoot-through)
6. [Abuso de Ruptura por Avalanche](#6-abuso-de-ruptura-por-avalanche)
7. [Circuitos Injetores de Carga](#7-circuitos-injetores-de-carga)
8. [Equipamentos e Instrumentação](#8-equipamentos-e-instrumentação)
9. [Contramedidas e Proteções](#9-contramedidas-e-proteções)
10. [Referências Rápidas](#10-referências-rápidas)

***

## 1. FUNDAMENTOS DE MOSFETS

### 1.1 Conceito

MOSFETs (Metal-Oxide-Semiconductor Field-Effect Transistors) são componentes fundamentais em fontes chaveadas, drivers de motor, conversores DC-DC e circuitos de potência. A exploração física permite controlar ou danificar esses dispositivos, comprometendo sistemas inteiros.

```yaml
MOSFET_EXPLOITATION:
  Definição: "Manipulação física de MOSFETs para controle de potência ou indução de falhas"

  TIPOS_DE_MOSFET:
    - Canal N (NMOS): Mais comum, tensão positiva no gate para ligar
    - Canal P (PMOS): Tensão negativa no gate para ligar
    - Logic-level: Vth baixo (1-2.5V), compatível com MCU 3.3V/5V
    - Standard: Vth mais alto (2-4V), requer driver de gate

  PARÂMETROS_CRÍTICOS:
    - Vth (Threshold Voltage): Tensão mínima para condução
    - Rds(on): Resistência em condução (mΩ)
    - Ciss: Capacitância de entrada (gate)
    - V_BR(DSS): Tensão de ruptura dreno-source
    - E_AS: Energia de avalanche suportável

  MITRE ATT&CK:
    - Tactic: Impact, Execution
    - T0872: Hardware Fault Injection
    - T0810: Manipulate System State
```

### 1.2 Arquitetura do MOSFET

```mermaid
graph TD
    subgraph "Símbolo NMOS"
        A[Dreno (D)] --> B[Canal]
        B --> C[Source (S)]
        D[Gate (G)] -.-> B
    end
    
    subgraph "Componentes Internos"
        E[Canal condutivo] --> F[Rds(on)]
        G[Diodo Corporal] --> H[D-S intrínseco]
        I[Ciss] --> J[Capacitância gate-source]
    end
    
    subgraph "Regiões de Operação"
        K[Corte: V_GS < Vth] --> L[ID ≈ 0]
        M[Linear/Saturação] --> N[ID controlado por V_GS]
        O[Avalanche] --> P[V_DS > V_BR(DSS)]
    end
    
    style D fill:#f66,stroke:#333,stroke-width:2px
    style G fill:#ff9,stroke:#333,stroke-width:2px
```

### 1.3 Comparação de MOSFETs Comuns

| Modelo      | Tipo       | V\_DS max | ID max | Rds(on) | Vth    | Ciss   | Aplicação         | Vulnerabilidade |
| ----------- | ---------- | --------- | ------ | ------- | ------ | ------ | ----------------- | --------------- |
| **IRFZ44N** | NMOS       | 55V       | 49A    | 17.5mΩ  | 2-4V   | 1470pF | Buck converter    | Gate flutuante  |
| **IRLZ44N** | Logic NMOS | 55V       | 47A    | 22mΩ    | 1-2V   | 1470pF | MCU direct drive  | Injeção gate    |
| **IRF530N** | NMOS       | 100V      | 17A    | 110mΩ   | 2-4V   | 640pF  | Flyback converter | Avalanche       |
| **IRF4905** | PMOS       | 55V       | 42A    | 20mΩ    | -2-4V  | 3400pF | High-side switch  | Inversão        |
| **2N7000**  | Small NMOS | 60V       | 200mA  | 5Ω      | 0.8-3V | 50pF   | Sinal, nível      | Gate flutuante  |

⚠️ **Alerta Ofensivo:** O gate do MOSFET é um capacitor de alta impedância. Sem resistor pull-down, ele pode flutuar e ligar/desligar aleatoriamente devido a campos eletromagnéticos ambiente.

***

## 2. INJEÇÃO NO GATE (FAULT INJECTION)

### 2.1 Princípio de Funcionamento

A injeção de tensão no gate permite forçar o MOSFET a conduzir (LIGADO) ou bloquear (DESLIGADO) independente do circuito de controle.

```yaml
GATE_INJECTION:
  Princípio: "Aplicação de tensão externa no gate para controlar o MOSFET"

  MÉTODO_1_FORÇAR_LIGADO:
    Circuito: Fonte +3.3V/5V → R_100Ω → Gate
    Condição: V_GS > Vth (2-4V para standard, 1-2.5V para logic-level)
    Efeito: MOSFET conduz independente do driver original

  MÉTODO_2_FORÇAR_DESLIGADO:
    Circuito: Curto Gate-Source (jumper ou probe)
    Efeito: C_iss descarregado, V_GS = 0V → MOSFET desliga

  VARIANTE_EMFI:
    Método: Sonda EM próxima à trilha do gate
    Efeito: Tensão induzida modula V_GS
    Aplicação: Glitching em chaveamento de potência
```

### 2.2 Circuito de Injeção

```bash
#!/bin/bash
# gate_injection.sh - Circuito de injeção no gate

echo "=== Injeção no Gate do MOSFET ==="

# 1. Método 1 - Forçar LIGADO
echo "[*] Forçando MOSFET a LIGAR:"
echo "    Conectar: Fonte +3.3V → Resistor 100Ω → Gate"
echo "    Source → GND da fonte externa"
echo "    V_GS aplicada ≈ 3.3V (para logic-level) ou 5V (standard)"
echo "    Resultado: MOSFET conduz independente do circuito"

# 2. Método 2 - Forçar DESLIGADO
echo -e "\n[*] Forçando MOSFET a DESLIGAR:"
echo "    Conectar: Gate → Source (jumper ou probe)"
echo "    C_iss descarrega, V_GS = 0V"
echo "    Resultado: MOSFET bloqueia corrente"

# 3. Método 3 - Glitch via injeção pulsada
echo -e "\n[*] Glitch via injeção pulsada:"
echo "    Gerar pulso 10-100µs na faixa de Vth"
echo "    MOSFET conduz apenas durante o pulso"
echo "    Aplicação: interrupção temporária de carga"

# 4. Cálculo do resistor de gate
echo -e "\n[*] Cálculo do resistor de gate:"
echo "    R_g = (V_in - V_GS) / I_g"
echo "    Exemplo: V_in=5V, V_GS=3V, I_g=20mA"
echo "    R_g = (5-3)/0.02 = 100Ω"
echo ""
echo "    Para pulsos curtos, resistor pode ser menor (10-47Ω)"

echo -e "\n[!] Use resistor limitador para não danificar o gate"
```

### 2.3 Script de Controle de Injeção (Arduino)

```cpp
// gate_injection_control.ino - Controle de injeção no gate
// APENAS AMBIENTE AUTORIZADO

const int GATE_PIN = 9;      // PWM output para gate
const int TRIGGER_PIN = 2;   // Trigger externo
const float V_TH = 2.5;      // Tensão de threshold do MOSFET (V)
const float V_MAX = 5.0;     // Tensão máxima de gate

void setup() {
  pinMode(GATE_PIN, OUTPUT);
  pinMode(TRIGGER_PIN, INPUT);
  analogWriteResolution(8);   // 0-255
}

void setGateVoltage(float voltage) {
  // voltage: 0-V_MAX volts
  int duty = (voltage / V_MAX) * 255;
  analogWrite(GATE_PIN, duty);
}

void pulseGate(float voltage, float duration_ms) {
  setGateVoltage(voltage);
  delay(duration_ms);
  setGateVoltage(0);
}

void rampGate(float start_v, float end_v, float duration_ms) {
  int steps = 50;
  float step_v = (end_v - start_v) / steps;
  float step_time = duration_ms / steps;
  
  for (int i = 0; i <= steps; i++) {
    float v = start_v + i * step_v;
    setGateVoltage(v);
    delay(step_time);
  }
}

void loop() {
  // Esperar trigger (ex: borda de clock)
  if (digitalRead(TRIGGER_PIN) == HIGH) {
    // Aplicar glitch durante a chaveamento
    pulseGate(V_TH + 1.0, 10);  // 10ms pulse above threshold
    
    delay(100);  // Debounce
  }
}
```

***

## 3. EXPLORAÇÃO DE GATE FLUTUANTE

### 3.1 Princípio de Funcionamento

O gate de um MOSFET é um capacitor de alta impedância (Ciss). Sem resistor pull-down, a tensão do gate é indefinida e pode ser carregada por campos eletromagnéticos ambiente.

```yaml
FLOATING_GATE:
  Princípio: "Gate sem caminho DC para source → comportamento indefinido"

  FÍSICA_DO_FENÔMENO:
    - Ciss = 500-5000 pF (capacitância gate-source)
    - Corrente de fuga < 100 nA
    - Impedância DC > 10 MΩ
    - Tempo de retenção de carga: segundos a minutos

  FONTES_DE_CARGA:
    - Campos eletromagnéticos ambiente (redes elétricas, RF)
    - ESD (toque humano, plásticos)
    - Acoplamento capacitivo de trilhas adjacentes
    - Sondas de osciloscópio/multímetro

  EFEITOS_PRÁTICOS:
    - MOSFET liga/desliga aleatoriamente
    - Comportamento depende da temperatura e umidade
    - Falhas intermitentes difíceis de diagnosticar
```

### 3.2 Teste de Gate Flutuante

```bash
#!/bin/bash
# floating_gate_test.sh - Teste de gate flutuante

echo "=== Teste de Gate Flutuante ==="

# 1. Identificar gates sem pull-down
echo "[*] Identificando possíveis gates flutuantes:"
echo "    - MOSFETs sem resistor entre gate e source"
echo "    - Drivers com saída tri-state"
echo "    - Conectores desconectados"

# 2. Teste de sensibilidade
echo -e "\n[*] Teste de sensibilidade:"
echo "    1. Medir V_GS com multímetro (alta impedância)"
echo "    2. Aproximar mão da trilha do gate"
echo "    3. Observar variação em V_GS"
echo "    Se varia > 0.5V → gate provavelmente flutuante"

# 3. Teste com carga ESD
echo -e "\n[*] Teste com carga ESD:"
echo "    Esfregar caneta plástica ou balão no cabelo"
echo "    Aproximar do gate (não tocar!)"
echo "    Se MOSFET ligar → gate flutuante"

# 4. Teste com fonte RF
echo -e "\n[*] Teste com fonte RF:"
echo "    Aproximar rádio portátil (transmitindo)"
echo "    Observar comportamento do MOSFET"

# 5. Medição de impedância
echo -e "\n[*] Medindo impedância do gate:"
echo "    Desconectar gate do circuito"
echo "    Medir resistência entre gate e source"
echo "    Leitura OL (circuito aberto) → gate flutuante"

echo -e "\n[!] Contramedida: Adicionar resistor 10kΩ-100kΩ entre gate e source"
```

### 3.3 Script de Detecção (Python)

```python
#!/usr/bin/env python3
"""
floating_gate_detector.py - Detector de gate flutuante
APENAS AMBIENTE AUTORIZADO
"""

import time
import numpy as np
import matplotlib.pyplot as plt

class FloatingGateDetector:
    """Detecta gate flutuante por variação de tensão"""
    
    def __init__(self, adc_channel=0, sample_rate=100):
        self.adc_channel = adc_channel
        self.sample_rate = sample_rate
        self.voltages = []
    
    def read_voltage(self):
        """Lê tensão do gate via ADC"""
        # Simulação - substituir por leitura real
        import random
        import math
        
        # Simular flutuação de gate flutuante
        noise = random.uniform(-0.5, 0.5)
        drift = math.sin(time.time() / 10) * 0.3
        return 1.5 + noise + drift
    
    def measure(self, duration=10):
        """Mede tensão do gate por período de tempo"""
        print(f"[*] Medindo tensão do gate por {duration}s...")
        
        samples = int(duration * self.sample_rate)
        
        for _ in range(samples):
            v = self.read_voltage()
            self.voltages.append(v)
            time.sleep(1/self.sample_rate)
        
        return np.array(self.voltages)
    
    def analyze(self, voltages):
        """Analisa estabilidade da tensão"""
        mean_v = np.mean(voltages)
        std_v = np.std(voltages)
        peak_peak = np.ptp(voltages)
        
        print(f"\n[*] Análise do sinal:")
        print(f"    Média: {mean_v:.2f}V")
        print(f"    Desvio padrão: {std_v:.3f}V")
        print(f"    Pico a pico: {peak_peak:.2f}V")
        
        # Critério de detecção
        if std_v > 0.1:
            print("[!] ALTA VARIABILIDADE - Gate provavelmente flutuante!")
            return True
        elif peak_peak > 0.5:
            print("[!] GRANDE VARIAÇÃO - Possível gate flutuante")
            return True
        else:
            print("[✓] Tensão estável - Gate provavelmente fixo")
            return False
    
    def plot_results(self):
        """Plota variação da tensão"""
        if not self.voltages:
            return
        
        plt.figure(figsize=(12, 6))
        t = np.arange(len(self.voltages)) / self.sample_rate
        
        plt.plot(t, self.voltages)
        plt.axhline(y=np.mean(self.voltages), color='r', linestyle='--', label='Média')
        plt.fill_between(t, 
                         np.mean(self.voltages) - np.std(self.voltages),
                         np.mean(self.voltages) + np.std(self.voltages),
                         alpha=0.3, label='±1σ')
        plt.xlabel('Tempo (s)')
        plt.ylabel('Tensão do Gate (V)')
        plt.title('Estabilidade do Gate do MOSFET')
        plt.legend()
        plt.grid(True)
        plt.savefig('gate_stability.png')
        plt.show()

# Exemplo de uso
detector = FloatingGateDetector()
voltages = detector.measure(duration=30)
is_floating = detector.analyze(voltages)
detector.plot_results()

if is_floating:
    print("\n[!] Recomendação: Adicionar resistor pull-down de 10kΩ-100kΩ")
```

***

## 4. CONDUÇÃO DE DIODO CORPORAL

### 4.1 Princípio de Funcionamento

Todo MOSFET de potência tem um diodo corporal intrínseco entre dreno e source. Este diodo conduz quando a tensão dreno-source é negativa (V\_DS < 0).

```yaml
BODY_DIODE:
  Princípio: "Diodo intrínseco entre dreno e source presente em todos MOSFETs"

  CARACTERÍSTICAS:
    - Catodo no dreno (para NMOS)
    - Anodo no source (para NMOS)
    - Queda direta: 0.5-0.8V
    - Tempo de recuperação: 50-200ns
    - Corrente máxima: igual ao ID do MOSFET

  APLICAÇÕES_EM_PONTE_H:
    - Frenagem regenerativa de motores
    - Condução durante dead-time
    - Bypass de MOSFET desligado

  VANTAGENS_OFENSIVAS:
    - Condução mesmo com MOSFET desligado
    - Permite caminho de corrente não intencional
    - Pode causar realimentação de tensão
```

### 4.2 Teste do Diodo Corporal

```bash
#!/bin/bash
# body_diode_test.sh - Teste do diodo corporal

echo "=== Teste do Diodo Corporal ==="

# 1. Identificação dos terminais
echo "[*] Identificando diodo corporal:"
echo "    NMOS: Catodo no Dreno, Anodo no Source"
echo "    PMOS: Catodo no Source, Anodo no Dreno"

# 2. Teste com multímetro
echo -e "\n[*] Teste com multímetro (modo diodo):"
echo "    Ponteira vermelha → Dreno"
echo "    Ponteira preta → Source"
echo "    Leitura esperada: 0.5-0.8V (diodo conduzindo)"
echo ""
echo "    Ponteira vermelha → Source"
echo "    Ponteira preta → Dreno"
echo "    Leitura esperada: OL (diodo bloqueado)"

# 3. Consequências em ponte H
echo -e "\n[*] Consequências em ponte H:"
echo "    High-side OFF, Low-side OFF"
echo "    Corrente pode fluir via diodo corporal do high-side"
echo "    Efeito: frenagem não intencional do motor"

# 4. Medição de corrente reversa
echo -e "\n[*] Medindo corrente reversa:"
echo "    Aplicar tensão negativa entre D e S"
echo "    Medir corrente com amperímetro em série"
echo "    I_reversa = (V_applied - V_f) / R_load"

echo -e "\n[!] Diodo corporal útil para frenagem mas pode causar realimentação"
```

### 4.3 Script de Simulação (Python)

```python
#!/usr/bin/env python3
"""
body_diode_simulation.py - Simulação de diodo corporal
APENAS AMBIENTE AUTORIZADO
"""

import numpy as np
import matplotlib.pyplot as plt

class BodyDiodeSimulation:
    """Simula comportamento do diodo corporal do MOSFET"""
    
    def __init__(self, v_f=0.6, r_d=0.1, c_j=50e-12):
        """
        v_f: tensão direta (V)
        r_d: resistência dinâmica (Ω)
        c_j: capacitância de junção (F)
        """
        self.v_f = v_f
        self.r_d = r_d
        self.c_j = c_j
    
    def forward_current(self, v_ds):
        """Corrente direta do diodo"""
        if v_ds > self.v_f:
            return (v_ds - self.v_f) / self.r_d
        return 0
    
    def reverse_current(self, v_ds):
        """Corrente reversa (fuga)"""
        if v_ds < 0:
            return -self.c_j * abs(v_ds) / 1e-6  # Aproximação
        return 0
    
    def simulate_h_bridge(self, v_bus, pwm_duty, dead_time_us=1):
        """Simula ponte H com diodos corporais"""
        t = np.linspace(0, 10e-3, 10000)  # 10ms
        t_period = 1 / 20000  # 20kHz PWM
        t_on = t_period * pwm_duty
        t_dead = dead_time_us * 1e-6
        
        current = np.zeros_like(t)
        
        for i, ts in enumerate(t):
            phase = ts % t_period
            
            if phase < t_on:
                # High-side ON, Low-side OFF
                # Corrente via MOSFET high-side
                current[i] = v_bus / 10  # Simulação
            elif phase < t_on + t_dead:
                # Dead-time: ambos OFF
                # Corrente via diodo corporal
                current[i] = self.forward_current(0.7)
            else:
                # High-side OFF, Low-side ON
                current[i] = 0
        
        return t, current
    
    def plot_characteristics(self):
        """Plota características do diodo"""
        v_ds = np.linspace(-2, 2, 500)
        i_f = [self.forward_current(v) for v in v_ds]
        i_r = [self.reverse_current(v) for v in v_ds]
        i_total = np.array(i_f) + np.array(i_r)
        
        plt.figure(figsize=(10, 6))
        plt.plot(v_ds, i_total * 1000)
        plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)
        plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)
        plt.xlabel('Tensão Dreno-Source (V)')
        plt.ylabel('Corrente (mA)')
        plt.title('Característica do Diodo Corporal')
        plt.grid(True)
        
        # Destacar região de condução
        plt.fill_between([0.6, 2], [0, 0], [300, 300], alpha=0.3, label='Condução direta')
        plt.fill_between([-2, 0], [0, 0], [0.1, 0.1], alpha=0.3, label='Fuga reversa')
        plt.legend()
        
        plt.savefig('body_diode_characteristic.png')
        plt.show()

# Exemplo de uso
sim = BodyDiodeSimulation(v_f=0.65, r_d=0.05)
sim.plot_characteristics()

# Simular ponte H
t, current = sim.simulate_h_bridge(v_bus=24, pwm_duty=0.5)

plt.figure(figsize=(12, 4))
plt.plot(t*1000, current)
plt.xlabel('Tempo (ms)')
plt.ylabel('Corrente (A)')
plt.title('Ponte H - Condução via Diodo Corporal')
plt.grid(True)
plt.savefig('h_bridge_body_diode.png')
plt.show()
```

***

## 5. INDUÇÃO DE SHOOT-THROUGH

### 5.1 Princípio de Funcionamento

Shoot-through ocorre quando ambos os MOSFETs de uma meia-ponte conduzem simultaneamente, criando um curto-circuito da alimentação para o terra.

```yaml
SHOOT_THROUGH:
  Princípio: "Ligação simultânea de high-side e low-side MOSFETs"

  CAUSAS:
    - Dead-time insuficiente
    - Glitch no driver de gate
    - Injeção externa durante dead-time
    - Falha no circuito de bootstrap

  EFEITOS:
    - Corrente de curto-circuito (centenas de amperes)
    - Queda de tensão na alimentação (brownout)
    - Superaquecimento dos MOSFETs
    - Falha catastrófica (curto permanente)

  EQUIPAMENTO_NECESSÁRIO:
    - Gerador de pulso (rise time < 10ns)
    - Acoplamento capacitivo (1-10pF)
    - Osciloscópio de alta velocidade
```

### 5.2 Circuito de Indução

```bash
#!/bin/bash
# shoot_through_inducer.sh - Circuito para indução de shoot-through

echo "=== Indução de Shoot-Through ==="

# 1. Identificação do dead-time
echo "[*] Medindo dead-time:"
echo "    Osciloscópio: Probe CH1 = High-side gate"
echo "                  Probe CH2 = Low-side gate"
echo "    Medir tempo entre desligamento de um e ligação do outro"

# 2. Circuito de injeção
echo -e "\n[*] Circuito injetor capacitivo:"
echo ""
echo "  ┌──────────┐"
echo "  │ Gerador  │── C_1pF ──┬── Saída do driver de gate"
echo "  │ de pulso │           │"
echo "  │ 10-100ns │          ─┴── GND"
echo "  │ rise<10ns│"
echo "  └──────────┘"
echo ""

# 3. Parâmetros de injeção
echo -e "\n[*] Parâmetros de injeção:"
echo "    Largura do pulso: 10-100 ns"
echo "    Amplitude: 2-5V (adicional ao sinal do driver)"
echo "    Fase: durante o dead-time (ambos gates em 0V)"

# 4. Efeitos esperados
echo -e "\n[*] Efeitos esperados:"
echo "    ⚠️ Pico de corrente (centenas de amperes)"
echo "    ⚠️ Queda de tensão V_BUS (brownout)"
echo "    ⚠️ Possível reset do microcontrolador"
echo "    ⚠️ MOSFETs podem falhar em curto"

# 5. Medição de corrente
echo -e "\n[*] Medindo corrente de shoot-through:"
echo "    Sonda de corrente (alta largura de banda)"
echo "    Posicionar entre fonte e capacitor de desacoplamento"
echo "    I_peak pode exceder 100A"

echo -e "\n[!] ATENÇÃO: Pode danificar MOSFETs e fonte"
```

### 5.3 Script de Medição (Python)

```python
#!/usr/bin/env python3
"""
shoot_through_detector.py - Detector de shoot-through
APENAS AMBIENTE AUTORIZADO
"""

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

class ShootThroughDetector:
    """Detecta eventos de shoot-through via análise de corrente"""
    
    def __init__(self, sample_rate=10e6):  # 10 MHz
        self.sample_rate = sample_rate
    
    def generate_shoot_through(self, duration_us=100, peak_current=50):
        """Simula corrente de shoot-through"""
        t = np.linspace(0, duration_us * 1e-6, int(self.sample_rate * duration_us * 1e-6))
        
        # Pulso de corrente
        current = np.zeros_like(t)
        width = 20  # ns
        idx = int(30e-6 * self.sample_rate)  # 30us delay
        pulse_idx = int(width * 1e-9 * self.sample_rate)
        
        if idx + pulse_idx < len(current):
            current[idx:idx+pulse_idx] = peak_current
        
        # Adicionar ruído
        current += np.random.normal(0, 0.5, len(t))
        
        return t, current
    
    def detect_shoot_through(self, current, threshold=10):
        """Detecta picos de corrente indicando shoot-through"""
        peaks, properties = signal.find_peaks(current, height=threshold)
        
        if len(peaks) > 0:
            print(f"[!] Detectados {len(peaks)} picos de corrente")
            for peak in peaks[:5]:
                print(f"    Pico em {peak/self.sample_rate*1e6:.1f}µs: {current[peak]:.1f}A")
            return peaks
        else:
            print("[✓] Nenhum pico de corrente detectado")
            return []
    
    def analyze_voltage_drop(self, v_bus, threshold=0.2):
        """Analisa queda na tensão de barramento"""
        v_nominal = np.mean(v_bus[:100])
        v_min = np.min(v_bus)
        v_drop = (v_nominal - v_min) / v_nominal
        
        if v_drop > threshold:
            print(f"[!] Queda de tensão significativa: {v_drop*100:.1f}%")
            return True
        return False
    
    def plot_shoot_through(self, current, v_bus=None):
        """Plota evento de shoot-through"""
        t = np.arange(len(current)) / self.sample_rate * 1e6
        
        fig, axes = plt.subplots(2 if v_bus is not None else 1, 
                                 1, figsize=(12, 8))
        
        if v_bus is not None:
            ax1, ax2 = axes
        else:
            ax1 = axes
        
        ax1.plot(t[:5000], current[:5000])
        ax1.set_ylabel('Corrente (A)')
        ax1.set_xlabel('Tempo (µs)')
        ax1.set_title('Corrente durante Shoot-Through')
        ax1.grid(True)
        
        if v_bus is not None:
            ax2.plot(t[:5000], v_bus[:5000])
            ax2.set_ylabel('Tensão V_BUS (V)')
            ax2.set_xlabel('Tempo (µs)')
            ax2.set_title('Queda de Tensão')
            ax2.grid(True)
        
        plt.tight_layout()
        plt.savefig('shoot_through_event.png')
        plt.show()

# Exemplo de uso
detector = ShootThroughDetector(sample_rate=10_000_000)

# Simular evento
t, current = detector.generate_shoot_through(duration_us=100, peak_current=150)
peaks = detector.detect_shoot_through(current, threshold=50)

# Simular queda de tensão
v_bus = 24 - current * 0.05  # Queda proporcional
detector.analyze_voltage_drop(v_bus)

detector.plot_shoot_through(current, v_bus)
```

***

## 6. ABUSO DE RUPTURA POR AVALANCHE

### 6.1 Princípio de Funcionamento

A ruptura por avalanche ocorre quando a tensão dreno-source excede V\_BR(DSS), fazendo o MOSFET conduzir na região de ruptura. Operar repetitivamente nesta região pode destruir o dispositivo.

```yaml
AVALANCHE_ABUSE:
  Princípio: "Forçar MOSFET a operar em região de avalanche para degradá-lo"

  PARÂMETROS_CRÍTICOS:
    - V_BR(DSS): Tensão de ruptura típica (ex: 55V, 100V)
    - E_AS: Energia de avalanche suportável (mJ)
    - I_AS: Corrente de avalanche máxima
    - T_j(max): Temperatura máxima de junção (150-175°C)

  MÉTODOS:
    - Remover snubber/flyback
    - Aumentar corrente da carga indutiva
    - Operar com duty cycle maior
    - Sobretensão na alimentação

  EFEITOS:
    - Degradação gradual do Rds(on)
    - Aumento da corrente de fuga
    - Falha final em curto-circuito
    - Destruição catastrófica
```

### 6.2 Teste de Avalanche

```bash
#!/bin/bash
# avalanche_test.sh - Teste de ruptura por avalanche

echo "=== Teste de Ruptura por Avalanche ==="

# 1. Identificar V_BR(DSS)
echo "[*] Identificando tensão de ruptura:"
echo "    Consultar datasheet do MOSFET"
echo "    Exemplos: IRFZ44N = 55V, IRF530N = 100V"
echo "    Medir com fonte de alta tensão + resistor limitador"

# 2. Método de indução
echo -e "\n[*] Induzindo avalanche:"
echo "    1. Remover diodo flyback da carga indutiva"
echo "    2. Aumentar corrente do indutor (carga)"
echo "    3. Desligar MOSFET rapidamente"
echo "    V_DS = V_in + L * dI/dt (pode exceder V_BR(DSS))"

# 3. Cálculo da energia de avalanche
echo -e "\n[*] Cálculo da energia de avalanche:"
echo "    E_AS = ½ * L * I^2 * (V_BR / (V_BR - V_in))"
echo ""
echo "    Exemplo: L=100µH, I=5A, V_BR=60V, V_in=12V"
echo "    E_AS = 0.5 * 100e-6 * 25 * (60/(60-12))"
echo "    E_AS = 0.5 * 0.0025 * 1.25 = 1.56mJ"

# 4. Monitoramento de avalanche
echo -e "\n[*] Monitorando evento de avalanche:"
echo "    Osciloscópio: V_DS (alta tensão)"
echo "    Escala: 50V/div"
echo "    Trigger: rising edge, 60V"
echo "    Capturar single shot"

# 5. Sinais de degradação
echo -e "\n[*] Sinais de degradação por avalanche:"
echo "    Aumento da corrente de fuga I_DSS"
echo "    Aumento do Rds(on) (MOSFET aquece mais)"
echo "    Ruído no gate durante chaveamento"

echo -e "\n[!] Operação repetitiva em avalanche destrói o MOSFET"
```

### 6.3 Script de Simulação de Avalanche

```python
#!/usr/bin/env python3
"""
avalanche_simulation.py - Simulação de ruptura por avalanche
APENAS AMBIENTE AUTORIZADO
"""

import numpy as np
import matplotlib.pyplot as plt

class AvalancheSimulation:
    """Simula eventos de avalanche em MOSFET"""
    
    def __init__(self, v_br=60, l=100e-6, i_load=5, v_in=12):
        """
        v_br: tensão de ruptura (V)
        l: indutância da carga (H)
        i_load: corrente de carga (A)
        v_in: tensão de alimentação (V)
        """
        self.v_br = v_br
        self.l = l
        self.i_load = i_load
        self.v_in = v_in
    
    def calculate_avalanche_energy(self):
        """Calcula energia dissipada em avalanche"""
        e_as = 0.5 * self.l * self.i_load**2 * (self.v_br / (self.v_br - self.v_in))
        return e_as
    
    def simulate_avalanche(self, time_window_us=10):
        """Simula tensão durante avalanche"""
        t = np.linspace(0, time_window_us * 1e-6, 10000)
        
        # Tensão durante desligamento
        v_ds = np.zeros_like(t)
        
        # Fase 1: Transição linear
        idx_on = int(0.1e-6 * len(t) / (time_window_us * 1e-6))
        v_ds[:idx_on] = self.v_in
        
        # Fase 2: Pico de avalanche
        idx_peak = idx_on + int(0.5e-6 * len(t) / (time_window_us * 1e-6))
        v_ds[idx_on:idx_peak] = np.linspace(self.v_in, self.v_br * 1.2, idx_peak - idx_on)
        
        # Fase 3: Queda após avalanche
        v_ds[idx_peak:] = self.v_br * np.exp(-(t[idx_peak:] - t[idx_peak]) / 1e-6)
        
        return t, v_ds
    
    def plot_avalanche(self):
        """Plota evento de avalanche"""
        t, v_ds = self.simulate_avalanche()
        
        fig, axes = plt.subplots(2, 1, figsize=(12, 8))
        
        # Tensão
        axes[0].plot(t * 1e6, v_ds)
        axes[0].axhline(y=self.v_br, color='r', linestyle='--', label=f'V_BR({self.v_br}V)')
        axes[0].set_ylabel('V_DS (V)')
        axes[0].set_xlabel('Tempo (µs)')
        axes[0].set_title('Evento de Avalanche')
        axes[0].legend()
        axes[0].grid(True)
        
        # Energia
        e_as = self.calculate_avalanche_energy()
        axes[1].bar(['E_AS calculada'], [e_as * 1000])
        axes[1].axhline(y=5, color='r', linestyle='--', label='E_AS típica (5mJ)')
        axes[1].set_ylabel('Energia (mJ)')
        axes[1].set_title('Energia de Avalanche')
        axes[1].legend()
        
        plt.tight_layout()
        plt.savefig('avalanche_event.png')
        plt.show()
        
        print(f"[!] Energia de avalanche: {e_as*1000:.2f}mJ")
        if e_as * 1000 > 5:
            print("[!] Excede E_AS típica - MOSFET pode falhar!")

# Exemplo de uso
sim = AvalancheSimulation(v_br=60, l=100e-6, i_load=8, v_in=24)
sim.plot_avalanche()
```

***

## 7. CIRCUITOS INJETORES DE CARGA

### 7.1 Circuito com Timer 555

```bash
#!/bin/bash
# charge_injector_555.sh - Circuito injetor com 555

echo "=== Circuito Injetor de Carga com 555 ==="

# 1. Esquema do circuito
cat << 'EOF' > /tmp/555_circuit.txt
Circuito injetor de carga no gate:

  ┌──────────────┐
  │     555      │
  │   Timer      │
  │  (astable)   │
  │  1-10 MHz    │
  └──────┬───────┘
         │
         │ R_100Ω
         │
         ├── C_couple (1-10 pF) ──┬── Probe tip (gate)
         │                         │
         └── GND ──────────────────┴── Garras jacaré
EOF

cat /tmp/555_circuit.txt

# 2. Cálculo da frequência
echo -e "\n[*] Cálculo da frequência (astable 555):"
echo "    f = 1.44 / ((R1 + 2×R2) × C)"
echo "    Exemplo: R1=1k, R2=10k, C=1nF"
echo "    f = 1.44 / ((1000 + 20000) × 1e-9) = 68.6 kHz"

# 3. Parâmetros de acoplamento
echo -e "\n[*] Acoplamento capacitivo:"
echo "    C_couple = 1-10 pF (dois fios trançados)"
echo "    Impedância a 1MHz: Xc = 1/(2π × 1e6 × 1e-12) = 159 kΩ"
echo "    Tensão induzida no gate: V_g ≈ V_555 × C_couple / C_iss"

# 4. Aplicações
echo -e "\n[*] Aplicações:"
echo "    - Glitching em chaveamento"
echo "    - Injeção de falhas"
echo "    - Teste de imunidade"

echo -e "\n[!] Eficácia depende do layout da PCB"
```

### 7.2 Script de Controle (Arduino)

```cpp
// charge_injector_control.ino - Controle de injetor de carga
// APENAS AMBIENTE AUTORIZADO

const int INJECTOR_PIN = 9;
const int TRIGGER_PIN = 2;

// Parâmetros do injetor
const int PULSE_WIDTH_US = 10;      // 10 microsegundos
const int PULSE_VOLTAGE = 5;        // 5V (PWM duty 100%)

void setup() {
  pinMode(INJECTOR_PIN, OUTPUT);
  pinMode(TRIGGER_PIN, INPUT);
  digitalWrite(INJECTOR_PIN, LOW);
}

void inject_pulse() {
  digitalWrite(INJECTOR_PIN, HIGH);
  delayMicroseconds(PULSE_WIDTH_US);
  digitalWrite(INJECTOR_PIN, LOW);
}

void inject_burst(int num_pulses, int period_us) {
  for (int i = 0; i < num_pulses; i++) {
    inject_pulse();
    delayMicroseconds(period_us);
  }
}

void loop() {
  // Aguardar trigger
  if (digitalRead(TRIGGER_PIN) == HIGH) {
    // Pulso único
    inject_pulse();
    
    delay(100);  // Debounce
  }
}
```

***

## 8. EQUIPAMENTOS E INSTRUMENTAÇÃO

### 8.1 Equipamentos Necessários

```yaml
EQUIPAMENTOS_BÁSICOS:
  Multímetro:
    - Modo diodo (teste diodo corporal)
    - Medição de continuidade
    - Custo: R$ 50-200

  Osciloscópio:
    - Largura de banda: 100 MHz+
    - Pontas de prova: 10×, 100 MHz
    - Amostragem: 1 GS/s
    - Custo: R$ 2.000-10.000

  Fonte de bancada:
    - Tensão: 0-30V
    - Corrente: 0-5A
    - Custo: R$ 300-1.000

  Ferramentas manuais:
    - Pontas de prova finas (SMD)
    - Jumper wires
    - Resistor assortment (10Ω-100kΩ)
    - Capacitores (1pF-10µF)

EQUIPAMENTOS_AVANÇADOS:
  - Gerador de pulso (rise time < 10ns)
  - Sonda de corrente (alta largura de banda)
  - Gerador de funções (1-100 MHz)
  - Câmera térmica (para detectar pontos quentes)
```

### 8.2 Script de Teste de MOSFET

```bash
#!/bin/bash
# mosfet_tester.sh - Teste completo de MOSFET

echo "=== Teste Completo de MOSFET ==="

# 1. Teste do diodo corporal
echo "[*] Teste do diodo corporal:"
echo "    Multímetro modo diodo"
echo "    Dreno (+), Source (-) → {0.5-0.8V}"
echo "    Source (+), Dreno (-) → OL"

# 2. Teste de gate
echo -e "\n[*] Teste de gate:"
echo "    Gate (+), Source (-): medir capacitância"
echo "    Gate (-), Source (+): OL (alta impedância)"

# 3. Teste de chaveamento (V_GS > Vth)
echo -e "\n[*] Teste de chaveamento:"
echo "    Aplicar 3.3V/5V entre Gate e Source"
echo "    Medir resistência entre Dreno e Source"
echo "    Rds(on) esperada: 10-100 mΩ"

# 4. Teste de ruptura
echo -e "\n[*] Teste de ruptura (cuidado!):"
echo "    Aplicar tensão crescente entre Dreno e Source"
echo "    Gate curto com Source"
echo "    Medir corrente de fuga I_DSS"
echo "    Ruptura: corrente aumenta abruptamente"

echo -e "\n[!] MOSFET aprovado se passar todos os testes"
```

***

## 9. CONTRAMEDIDAS E PROTEÇÕES

### 9.1 Proteções de Hardware

```yaml
PROTEÇÕES_HARDWARE:
  Gate Protection:
    - Resistor pull-down (10kΩ-100kΩ) entre gate e source
    - Diodo Zener (12-15V) gate-source (protege contra ESD)
    - Resistor de gate em série (10-100Ω)

  Snubber Protection:
    - Snubber RC entre dreno e source (para cargas indutivas)
    - Diodo flyback em paralelo com carga
    - Varistor (MOV) para surtos

  Thermal Protection:
    - Sensor de temperatura no dissipador
    - Desligamento térmico (thermal shutdown)
    - Dissipador dimensionado adequadamente

  Layout:
    - Trilhas curtas para gate
    - Plano de terra contínuo
    - Desacoplamento próximo ao MOSFET
```

### 9.2 Proteções de Software

```python
#!/usr/bin/env python3
"""
mosfet_protections.py - Proteções de software
APENAS AMBIENTE AUTORIZADO
"""

import time
import threading

class MOSFETProtection:
    """Implementa proteções para MOSFETs"""
    
    def __init__(self, thermal_sensor=None, current_sensor=None):
        self.thermal_sensor = thermal_sensor
        self.current_sensor = current_sensor
        self.shutdown_flag = False
    
    def check_temperature(self, max_temp=85):
        """Monitora temperatura do MOSFET"""
        if self.thermal_sensor:
            temp = self.thermal_sensor.read()
            if temp > max_temp:
                print(f"[!] Temperatura excessiva: {temp}°C")
                self.shutdown()
                return False
        return True
    
    def check_current(self, max_current=10):
        """Monitora corrente no MOSFET"""
        if self.current_sensor:
            current = self.current_sensor.read()
            if current > max_current:
                print(f"[!] Corrente excessiva: {current}A")
                self.shutdown()
                return False
        return True
    
    def shoot_through_prevention(self, 
                                 high_side_pin, low_side_pin,
                                 dead_time_us=100):
        """Previne shoot-through com dead-time programável"""
        # Desligar ambos
        self.set_gate(high_side_pin, False)
        self.set_gate(low_side_pin, False)
        
        # Aguardar dead-time
        time.sleep(dead_time_us / 1_000_000)
        
        # Ligar o desejado
        return True
    
    def soft_start(self, duty_cycle_start=0.1, ramp_time_s=1):
        """Soft start para evitar picos de corrente"""
        steps = 100
        step_time = ramp_time_s / steps
        
        for i in range(steps + 1):
            duty = duty_cycle_start * i / steps
            self.set_pwm_duty(duty)
            time.sleep(step_time)
    
    def shutdown(self):
        """Desligamento de emergência"""
        self.shutdown_flag = True
        # Desligar todos MOSFETs
        print("[!] Desligamento de emergência ativado")
        # self.disable_all_outputs()

# Exemplo de uso
protection = MOSFETProtection()

# Verificações periódicas
while not protection.shutdown_flag:
    protection.check_temperature()
    protection.check_current()
    time.sleep(0.1)
```

### 9.3 Checklist de Hardening

```bash
#!/bin/bash
# mosfet_hardening.sh - Checklist de proteção

echo "=== MOSFET Hardening Checklist ==="
echo ""

echo "[ ] Resistor pull-down gate-source (10kΩ-100kΩ)"
echo "[ ] Resistor de gate em série (10-100Ω)"
echo "[ ] Diodo Zener gate-source (12-15V)"
echo "[ ] Snubber RC dreno-source"
echo "[ ] Diodo flyback em cargas indutivas"
echo "[ ] Sensor de temperatura no dissipador"
echo "[ ] Fusível de ação rápida em série"
echo "[ ] Dead-time adequado em pontes H"
echo "[ ] Soft start para evitar picos"
echo "[ ] Monitoramento de corrente"
echo "[ ] Dissipador dimensionado corretamente"

echo -e "\n[!] Protections increase cost but prevent failure"
```

***

## 10. REFERÊNCIAS RÁPIDAS

### 10.1 Comandos Rápidos

| Ação                       | Medição/Setup                                |
| -------------------------- | -------------------------------------------- |
| **Testar diodo corporal**  | Multímetro modo diodo D→S: 0.5-0.8V, S→D: OL |
| **Medir Vth**              | Aumentar V\_GS até condução (\~mA)           |
| **Testar gate flutuante**  | Aproximar mão → variação >0.5V               |
| **Medir Ciss**             | Capacitância gate-source (500-5000pF)        |
| **Detectar shoot-through** | Sonda de corrente, picos >10× normal         |
| **Medir avalanche**        | Osciloscópio, V\_DS > V\_BR(DSS)             |

### 10.2 Resumo Técnico

```yaml
MOSFET_EXPLOITATION_RESUMO:

  Técnicas_Comprovadas:
    - Injeção no gate: ✅ Forçar LIGADO/DESLIGADO
    - Gate flutuante: ✅ Exploração de alta impedância
    - Diodo corporal: ✅ Condução mesmo desligado
    - Shoot-through: ✅ Curto via dead-time
    - Avalanche: ✅ Degradação por sobretensão

  Componentes_Vulneráveis:
    - IRFZ44N (padrão)
    - IRLZ44N (logic-level)
    - IRF530N (flyback)
    - 2N7000 (sinal)

  Equipamentos_Necessários:
    - Multímetro com modo diodo
    - Osciloscópio 100MHz+
    - Fonte de bancada
    - Resistores/capacitores

  Mitigações:
    - Resistor pull-down gate
    - Snubber RC
    - Diodo flyback
    - Dead-time adequado
    - Monitoramento térmico
```

### 10.3 Cross-References

| Técnica Relacionada          | Aplicação                |
| ---------------------------- | ------------------------ |
| **Op-Amp Exploitation**      | Drivers de gate          |
| **Diode Exploitation**       | Flyback, snubber         |
| **Hardware Fault Injection** | Glitch via gate          |
| **Power Analysis**           | Consumo do MOSFET        |
| **PCB Probing**              | Acesso a trilhas de gate |

***

## 📅 METADADOS FINAIS

```yaml
versão: 1.0
data_publicação: 2026-06-08
categoria: Hardware Security - MOSFET Exploitation

tags:
  - mosfet
  - hardware-hacking
  - gate-injection
  - floating-gate
  - shoot-through
  - avalanche
  - power-electronics
  - T0872

changelog:
  - v1.0: Documentação completa de exploração de MOSFETs
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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/componentes/exploracao-de-mosfets.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.