Minacce invisibili, soluzioni visibili.

Cascata di eccezioni da opcode disallineati (MOEW)

PoC di cascata SEH a 3 stadi (benigno, x86/Wow64)

TL;DR: Questo PoC dimostra una cascata di Structured Exception Handling (SEH) a 3 stadi causata da una deliberata esecuzione disallineata in blocchi di byte grezzi la cui prima istruzione valida è una div reg che genera un fault con divisore zero. Ogni stadio di eccezione installa il successivo handler SEH, innesca una nuova divisione per zero disallineata ed esegue un payload osservabile benigno prima di ripristinare la catena SEH originale e terminare in modo pulito.

---

1. Panoramica

MOEW (Misaligned Opcode Exception Waterfall) è un campione di ricerca difensiva che mostra un'esecuzione controllata multi-stadio guidata da eccezioni su Windows x86/Wow64. Dimostra:

• Manipolazione manuale della catena SEH tramite fs:[0]
• Disallineamento deliberato in sequenze di byte realizzate a mano (blob1, blob2, blob3)
• Handler SEH concatenati a stadi
• Ricorsione multi-fault attraverso:
  • KiUserExceptionDispatcher
  • RtlDispatchException
  • Handler personalizzati in spazio utente
• Un percorso di terminazione pulito che ripristina la catena SEH originale

Tutti i payload sono benigni:

• Stadio 1: Avvia Blocco note
• Stadio 2: Scrive un file marcatore in %TEMP%
• Stadio finale: Avvia Calcolatrice

Il PoC è volutamente reso innocuo. Nessun dato viene crittografato, modificato o distrutto.

---

2. Caratteristiche

• Ricorsione SEH completamente deterministica attraverso 3 handler a stadi
• Blocchi di byte x86 naked con molteplici percorsi di decodifica validi
• div disallineato a offset controllati (ECX/EDX/EBX = 0)
• Contatore globale per stadio per logging e tracing
• Completo ripristino della testa della catena SEH originale (ORIGINAL_SEH)
• Rust nightly + assembly inline + funzioni naked
• “Payload” benigni ma visibili per telemetria e test con debugger

---

3. Requisiti di Ambiente

3.1 Architettura

• Solo x86 (32 bit)
• Compilato con il toolchain MSVC
• Funziona anche su Windows 64 bit in WoW64

3.2 Rust Nightly

Il PoC usa funzionalità solo-nightly:

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

Installa i componenti necessari:

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

3.3 Disabilitare SAFESEH

Poiché il PoC installa handler SEH personalizzati che non sono presenti nella tabella SAFESEH, è necessario istruire il linker per disabilitare la validazione SAFESEH.

Crea .cargo/config.toml:

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

---

4. Istruzioni di Build

Compila il binario:

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

L'output si trova in:

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

---

5. Esecuzione del PoC

Esegui:

seh_waterfall.exe

Flusso di controllo atteso:

Stage 0 → misaligned blob1 → Stage 1 handler
Stage 1 → misaligned blob2 → Stage 2 handler
Stage 2 → misaligned blob3 → Final handler
Final  → restore SEH       → exit

Artefatti visibili:

• notepad.exe si avvia (Stadio 1)
• Viene creato %TEMP%\moew_stage2.txt (Stadio 2)
• calc.exe si avvia (handler finale)

---

6. Analisi Tecnica

6.1 Struttura dei Record SEH

Su Windows a 32 bit, i record SEH formano una lista concatenata memorizzata in fs:[0]:

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

Ogni handler usa la firma SEH standard:

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

6.2 Stato Globale

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

Usato per:

• Contare la profondità di ricorsione degli handler
• Ripristinare la testa SEH originale al termine della cascata

---

7. Logica degli Stadi

Stadio 0 — Configurazione Iniziale del Frame

1. Salva fs:[0] come ORIGINAL_SEH.
2. Costruisce un record SEH che punta all'handler dello Stadio 1.
3. Sovrascrive fs:[0] con questo nuovo record.
4. Si disallinea in blob1 + 5, che decodifica come div ecx (dopo aver impostato ECX = 0).

Stadio 1 — Primo Handler SEH

1. Avvia notepad.exe.
2. Costruisce un record SEH per l'handler dello Stadio 2 e lo concatena in cima.
3. Si disallinea in blob2 + 3 → div edx (con EDX = 0).

Stadio 2 — Secondo Handler SEH

1. Scrive %TEMP%\moew_stage2.txt.
2. Installa l'handler finale sulla catena SEH.
3. Si disallinea in blob3 + 3 → div ebx (con EBX = 0).

Handler Finale — Terminazione

1. Avvia calc.exe.
2. Ripristina ORIGINAL_SEH in fs:[0].
3. Esce dal processo in modo pulito tramite process::exit(0).

---

8. Blob di Fault Disallineati

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 allineata: mov eax, 0x10; div ecx; ret
• Disallineato a +5: div ecx (con 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 allineata: push ebp; mov ebp, esp; div edx; ret
• Disallineato a +3: div edx (con 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 allineata: push ebx; mov ebx, eax; div ebx; ret
• Disallineato a +3: div ebx (con EBX = 0 → #DE)

---

9. Pipeline delle Eccezioni

Ogni stadio in fault rientra nella pipeline delle eccezioni in modalità utente di Windows:

KiUserExceptionDispatcher
    → RtlDispatchException
        → SEH chain walk (fs:[0])
            → MOEW handler

Tipica visualizzazione nel debugger:

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

La cascata è interamente guidata da veri fault hardware e dispatch SEH; non vengono usate eccezioni sintetiche o finte.

---

10. Output del File Marcatore

Il file scritto nello Stadio 2 appare così:

MOEW Stage 2 Marker
-------------------
This file was written by the Stage 2 SEH handler
as a benign demonstration payload.

La sua presenza in %TEMP% serve come semplice prova osservabile che lo Stadio 2 è stato eseguito tramite la catena SEH.

---

11. Note di Sicurezza

• Il PoC è benigno e destinato solo alla ricerca difensiva.
• Nessuna persistenza, modifica del registro o crittografia.
• Tutte le eccezioni vengono catturate e gestite.
• La catena SEH originale viene ripristinata prima della terminazione.

---

12. Sviluppi Futuri

Le estensioni potenziali includono: