Ameaças Invisíveis, Soluções Visíveis.

Cachoeira de Exceção por Opcode Desalinhado (MOEW)

Prova de Conceito de Cachoeira SEH de 3 Estágios (Benigno, x86/Wow64)

Resumo: Esta PoC demonstra uma cascata de Tratamento de Exceção Estruturada (SEH) de 3 estágios causada por execução desalinhada deliberada em blocos de bytes brutos cuja primeira instrução válida é um div reg com divisor zero.
Cada estágio de exceção instala o próximo manipulador SEH, dispara uma nova divisão por zero desalinhada e executa uma carga benigna observável antes de restaurar a cadeia SEH original e terminar de forma limpa.

---

1. Visão Geral

MOEW (Cachoeira de Exceção por Opcode Desalinhado) é uma amostra de pesquisa defensiva que demonstra execução de múltiplos estágios controlada por exceções no Windows x86/Wow64. Ela demonstra:

• Manipulação manual da cadeia SEH via fs:[0]
• Desalinhamento deliberado em sequências de bytes artesanais (blob1, blob2, blob3)
• Manipuladores SEH encadeados por estágio
• Recursão de múltiplas falhas através de:
  • KiUserExceptionDispatcher
  • RtlDispatchException
  • Manipuladores personalizados em modo usuário
• Um caminho de término limpo que restaura a cadeia SEH original

Todas as cargas são benignas:

• Estágio 1: Abre o Notepad
• Estágio 2: Escreve um arquivo marcador em %TEMP%
• Estágio Final: Abre a Calculadora

A PoC é intencionalmente inofensiva. Nenhum dado é criptografado, modificado ou destruído.

---

2. Recursos

• Recursão SEH totalmente determinística através de 3 manipuladores em estágios
• Blocos de bytes x86 nus com múltiplos caminhos de decodificação válidos
• div desalinhado em offsets controlados (ECX/EDX/EBX = 0)
• Contador global por estágio para registro e rastreamento
• Restauração completa da cabeça SEH original (ORIGINAL_SEH)
• Rust nightly + assembly inline + funções naked
• Cargas benignas mas visíveis para telemetria e teste em depuradores

---

3. Requisitos de Ambiente

3.1 Arquitetura

• Apenas x86 (32 bits)
• Compilado com a toolchain MSVC
• Também é executado em Windows 64 bits sob WoW64

3.2 Rust Nightly

A PoC usa recursos exclusivos do nightly:

#![feature(asm_experimental_arch)]
#![feature(naked_functions)]

Instale os componentes necessários:

rustup toolchain install nightly
rustup target add i686-pc-windows-msvc --toolchain nightly

3.3 Desabilitar SAFESEH

Como a PoC instala manipuladores SEH personalizados que não estão presentes na tabela SAFESEH, o vinculador deve ser instruído a desabilitar a validação SAFESEH.

Crie .cargo/config.toml:

[target.i686-pc-windows-msvc]
rustflags = [
  "-C", "link-arg=/SAFESEH:NO",
]

---

4. Instruções de Compilação

Compile o binário:

cargo +nightly build --target i686-pc-windows-msvc --release

A saída está localizada em:

target\i686-pc-windows-msvc\release\seh_waterfall.exe

---

5. Executando a PoC

Execute:

seh_waterfall.exe

Fluxo de controle esperado:

Estágio 0 → blob1 desalinhado → Manipulador Estágio 1
Estágio 1 → blob2 desalinhado → Manipulador Estágio 2
Estágio 2 → blob3 desalinhado → Manipulador Final
Final  → restaurar SEH → sair

Artefatos visíveis:

• notepad.exe é aberto (Estágio 1)
• %TEMP%\moew_stage2.txt é criado (Estágio 2)
• calc.exe é aberto (Manipulador Final)

---

6. Detalhamento Técnico

6.1 Layout do Registro SEH

No Windows 32 bits, os registros SEH formam uma lista encadeada armazenada em fs:[0]:

#[repr(C)]
struct SehRec {
    next: *mut SehRec,
    handler: usize,
}

Cada manipulador usa a assinatura padrão SEH:

extern "system" fn handler(
    record: *mut u8,
    frame: *mut u8,
    context: *mut u8,
    dispatcher: *mut u8,
) -> i32

6.2 Estado Global

static STAGE_COUNTER: AtomicU32 = AtomicU32::new(0);
static mut ORIGINAL_SEH: *mut SehRec = std::ptr::null_mut();

Usado para:

• Contar a profundidade da recursão do manipulador
• Restaurar a cabeça SEH original no final da cachoeira

---

7. Lógica dos Estágios

Estágio 0 — Configuração Inicial do Frame

1. Salvar fs:[0] como ORIGINAL_SEH.
2. Construir um registro SEH apontando para o manipulador do Estágio 1.
3. Sobrescrever fs:[0] com este novo registro.
4. Desalinhar em blob1 + 5, que decodifica como div ecx (após definir ECX = 0).

Estágio 1 — Primeiro Manipulador SEH

1. Abrir notepad.exe.
2. Construir um registro SEH para o manipulador do Estágio 2 e encadeá-lo em cima.
3. Desalinhar em blob2 + 3 → div edx (com EDX = 0).

Estágio 2 — Segundo Manipulador SEH

1. Escrever %TEMP%\moew_stage2.txt.
2. Instalar o manipulador Final na cadeia SEH.
3. Desalinhar em blob3 + 3 → div ebx (com EBX = 0).

Manipulador Final — Terminação

1. Abrir calc.exe.
2. Restaurar ORIGINAL_SEH em fs:[0].
3. Sair do processo de forma limpa via process::exit(0).

---

8. Blobs de Falha Desalinhados

8.1 blob1

#[unsafe(naked)]
pub extern "C" fn blob1() {
    naked_asm! {
        ".byte 0xB8, 0x10, 0x00, 0x00, 0x00", // mov eax, 0x10
        ".byte 0xF7, 0xF1",                   // div ecx
        ".byte 0xC3",                         // ret
        ".byte 0x90, 0x90, 0x90",             // nop padding
    }
}

• Decodificação alinhada: mov eax, 0x10; div ecx; ret
• Desalinhado em +5: div ecx (com ECX = 0 → #DE)

8.2 blob2

#[unsafe(naked)]
pub extern "C" fn blob2() {
    naked_asm! {
        ".byte 0x55",                         // push ebp
        ".byte 0x8B, 0xEC",                   // mov ebp, esp
        ".byte 0xF7, 0xF2",                   // div edx
        ".byte 0xC3",                         // ret
        ".byte 0x90, 0x90, 0x90",             // nop padding
    }
}

• Decodificação alinhada: push ebp; mov ebp, esp; div edx; ret
• Desalinhado em +3: div edx (com EDX = 0 → #DE)

8.3 blob3

#[unsafe(naked)]
pub extern "C" fn blob3() {
    naked_asm! {
        ".byte 0x53",                         // push ebx
        ".byte 0x8B, 0xD8",                   // mov ebx, eax
        ".byte 0xF7, 0xF3",                   // div ebx
        ".byte 0xC3",                         // ret
        ".byte 0x90, 0x90, 0x90",             // nop padding
    }
}

• Decodificação alinhada: push ebx; mov ebx, eax; div ebx; ret
• Desalinhado em +3: div ebx (com EBX = 0 → #DE)

---

9. Pipeline de Exceção

Cada estágio com falha reentra no pipeline de exceção do modo usuário do Windows:

KiUserExceptionDispatcher
    → RtlDispatchException
        → Caminhada da cadeia SEH (fs:[0])
            → Manipulador MOEW

Visão típica no depurador:

seh_waterfall!blobX+offset
ntdll!KiUserExceptionDispatcher
ntdll!RtlDispatchException
seh_waterfall!stageN_handler

A cachoeira é inteiramente conduzida por falhas de hardware genuínas e despacho SEH; nenhuma exceção sintética ou falsa é usada.

---

10. Saída do Arquivo Marcador

O arquivo escrito no Estágio 2 se parece com:

MOEW Stage 2 Marker
-------------------
Este arquivo foi escrito pelo manipulador SEH do Estágio 2
como uma carga de demonstração benigna.

Sua presença em %TEMP% serve como uma prova simples e observável de que o Estágio 2 foi executado através da cadeia SEH.

---

11. Notas de Segurança

• PoC é benigna e apenas para pesquisa defensiva.
• Sem persistência, modificação de registro ou criptografia.
• Todas as exceções são capturadas e tratadas.
• A cadeia SEH original é restaurada antes da terminação.

---

12. Melhorias Futuras

Extensões potenciais incluem: