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:

• Regras YARA e comportamentais para cachoeiras SEH e padrões de exceção recursivos.
• Mapeamento de sinais ETW / EDR para falhas de hardware em estágios.
• Diagramas gráficos da evolução da cadeia SEH ao longo do tempo.
• Comparação lado a lado com cadeias de exceção de malware do mundo real.

13. Código Fonte Completo

A implementação completa da PoC está disponível neste repositório (veja src/main.rs).

14. Licença

Este projeto destina-se à pesquisa defensiva e educação. Copyright <2025>

A permissão é concedida, gratuitamente, a qualquer pessoa que obtenha uma cópia deste software e arquivos de documentação associados (o “Software”), para lidar com o Software sem restrição, incluindo, sem limitação, os direitos de usar, copiar, modificar, mesclar, publicar, distribuir, sublicenciar e/ou vender cópias do Software, e permitir que pessoas a quem o Software seja fornecido o façam, sujeito às seguintes condições:

O aviso de copyright acima e este aviso de permissão devem ser incluídos em todas as cópias ou partes substanciais do Software.

O SOFTWARE É FORNECIDO “COMO ESTÁ”, SEM GARANTIA DE QUALQUER TIPO, EXPRESSA OU IMPLÍCITA, INCLUINDO, MAS NÃO SE LIMITANDO ÀS GARANTIAS DE COMERCIALIZAÇÃO, ADEQUAÇÃO A UM DETERMINADO FIM E NÃO VIOLAÇÃO. EM NENHUM CASO OS AUTORES OU DETENTORES DE DIREITOS AUTORAIS SERÃO RESPONSÁVEIS POR QUALQUER REIVINDICAÇÃO, DANOS OU OUTRA RESPONSABILIDADE, SEJA EM UMA AÇÃO DE CONTRATO, ATO ILÍCITO OU DE OUTRA FORMA, DECORRENTE DE, OU EM CONEXÃO COM O SOFTWARE OU O USO OU OUTRAS NEGOCIAÇÕES NO SOFTWARE.

15. Amostra Real vs. PoC: Corrupção SEH, Comportamento de Cachoeira e Impacto na Telemetria

15.1 Comportamento da Amostra Real: Corrupção Intencional de SEH

A amostra real do MOEW que inspirou esta PoC não restaurou fs:[0] ao final da execução.
Em vez disso, seu estágio final:

1. Sobrescreveu a cabeça SEH (fs:[0]) com NULL ou um ponteiro para memória inválida.
2. Disparou uma última exceção desalinhada, garantindo uma falha de hardware.
3. Forçou o Windows a percorrer uma cadeia SEH inválida ou truncada.
4. Fez com que RtlDispatchException encontrasse um ponteiro de manipulador inválido.
5. Resultou em uma falha onde:
   • EIP/RIP apontava para memória não pertencente a imagem (heap, pilha ou região anônima).
   • O módulo com falha não pôde ser resolvido e apareceu como unknown.
   • O caminho com falha também apareceu como unknown.
6. Produziu assinaturas do Windows Error Reporting (WER) que não eram atribuíveis a nenhum módulo carregado.
7. Registrou eventos Application Error no Visualizador de Eventos com offsets de falha sem significado.
8. Produziu telemetria EDR dominada por:
   • chamadas repetidas a KiUserExceptionDispatcher,
   • transições SEH recursivas,
   • uma falha anômala final sem atribuição de módulo.

Esta etapa destrutiva de corrupção SEH serve ao propósito anti-forense principal da amostra:
apagar a cadeia causal e produzir uma falha terminal não atribuível.

15.2 Comportamento da PoC: Restauração Limpa de SEH sem Falha Terminal

Ao contrário da amostra real, esta PoC:

• Captura a cabeça SEH original durante o Estágio 0:

  root@kitploit:~

  asm!("mov {old}, fs:[0]", old = out(reg) old_head);
  ORIGINAL_SEH = old_head;
  

• Restaura a cabeça SEH original no manipulador final:

  root@kitploit:~

  asm!("mov fs:[0], {p}", p = in(reg) ORIGINAL_SEH);
  

• Termina de forma limpa via process::exit(0) em vez de disparar uma falha não tratada.

Como resultado, a PoC:

• Não deixa uma cadeia SEH corrompida.
• Não produz uma exceção final não tratada.
• Não gera:
  • relatórios de falha WER,
  • entradas Application Error 1000 no Visualizador de Eventos,
  • assinaturas “módulo com falha: unknown”,
  • disposições de exceção inválidas,
  • ou registros SEH pendentes.

No entanto—criticamente—a PoC não elimina o comportamento de degradação de telemetria dirigida por exceção do MOEW.

15.3 Degradação de Telemetria Compartilhada pela Amostra Real e pela PoC

A PoC certamente degrada a telemetria da mesma forma fundamental:

• Ela deliberadamente dispara múltiplas falhas de hardware desalinhadas.

• Ela produz múltiplas exceções de primeira chance em rápida sucessão.

• Ela força o Windows a executar repetidamente:

  root@kitploit:~

  KiUserExceptionDispatcher
  RtlDispatchException
      → manipulador personalizado
      → blob desalinhado
      → falha de hardware
  

• Ela gera pilhas de chamadas não lineares e dominadas por exceções.

• Ela distorce a reconstrução de fluxo de controle em depuradores e EDR ao rotear a execução através de:

  • manipuladores SEH recursivos,
  • caminhos de decodificação desalinhados,
  • endereços não alinhados a funções,
  • limites parciais de instrução.

Assim, a PoC reproduz fielmente:

• o padrão de cachoeira recursiva,
• a máquina de estados dirigida por exceções,
• o comportamento de entrada por opcode desalinhado,
• e a ofuscação do fluxo de controle,

…enquanto evita a falha final destrutiva.

Isso torna a PoC ideal para instrumentação e pesquisa sem invocar a carga anti-forense completa.

15.4 Por que a PoC é Adequada para Pesquisa Defensiva

Como a PoC preserva o comportamento geral do MOEW menos a falha de corrupção SEH, ela é:

• Segura para executar repetidamente em ambientes de laboratório.
• Determinística e estável.
• Adequada para:
  • análise de pipeline EDR,
  • pesquisa de telemetria,
  • treinamento de resposta a incidentes,
  • teste de comportamento de depurador,
  • comparação lado a lado com amostras maliciosas reais.

A PoC modela a cachoeira de exceções (a essência do MOEW) enquanto remove a assinatura destrutiva final.
Ela demonstra que a degradação de telemetria surge não apenas da corrupção SEH, mas do próprio modelo de fluxo de controle dirigido por exceção.

15.5 Resumo

Esta seção formaliza as diferenças comportamentais, mantendo claro o propósito da PoC:
demonstrar a cachoeira MOEW de forma segura e adequada à pesquisa, sem a falha final anti-forense.