Unsichtbare Bedrohungen, sichtbare Lösungen.

Misaligned Opcode Exception Waterfall (MOEW)

3‑stufiger SEH-Waterfall-PoC (harmlos, x86/Wow64)

TL;DR: Dieser PoC demonstriert eine 3‑stufige Kaskade der strukturierten Ausnahmebehandlung (SEH), die durch absichtliche fehlausgerichtete Ausführung in rohe Byte-Blobs verursacht wird, deren erste gültige Anweisung ein auslösendes div reg mit einem Divisor von Null ist.
Jede Ausnahmestufe installiert den nächsten SEH-Handler, löst eine neue fehlausgerichtete Division‑durch‑Null aus und führt eine harmlose, beobachtbare Nutzlast aus, bevor die ursprüngliche SEH-Kette wiederhergestellt und sauber beendet wird.

---

1. Übersicht

MOEW (Misaligned Opcode Exception Waterfall) ist eine defensive Forschungsprobe, die kontrollierte, ausnahmegetriebene mehrstufige Ausführung auf x86/Wow64-Windows demonstriert. Sie zeigt:

• Manuelle SEH-Kettenmanipulation über fs:[0]
• Absichtliche Fehlausrichtung in handgefertigte Byte-Sequenzen (blob1, blob2, blob3)
• Stufenweise verkettete SEH-Handler
• Mehrfach-Fehlerrekursion über:
  • KiUserExceptionDispatcher
  • RtlDispatchException
  • Benutzerdefinierte Benutzermodus-Handler
• Einen sauberen Beendigungspfad, der die ursprüngliche SEH-Kette wiederherstellt

Alle Nutzlasten sind harmlos:

• Stufe 1: Startet Notepad
• Stufe 2: Schreibt eine Markierungsdatei nach %TEMP%
• Endstufe: Startet den Rechner

Der PoC ist absichtlich entschärft. Es werden keine Daten verschlüsselt, verändert oder zerstört.

---

2. Features

• Vollständig deterministische SEH-Rekursion durch 3 gestufte Handler
• Nackte x86-Byte-Blobs mit mehreren gültigen Dekodierungspfaden
• Fehlausgerichtetes div an kontrollierten Offsets (ECX/EDX/EBX = 0)
• Pro Stufe ein globaler Zähler für Logging und Tracing
• Vollständige Wiederherstellung des ursprünglichen SEH-Kopfes (ORIGINAL_SEH)
• Rust Nightly + Inline-Assembly + Naked-Funktionen
• Harmlose, aber sichtbare „Nutzlasten” für Telemetrie und Debugger-Tests

---

3. Umgebungsanforderungen

3.1 Architektur

• Nur x86 (32‑Bit)
• Kompiliert mit der MSVC-Toolchain
• Läuft auch auf 64‑Bit-Windows unter WoW64

3.2 Rust Nightly

Der PoC verwendet nur in Nightly verfügbare Features:

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

Installieren Sie die erforderlichen Komponenten:

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

3.3 SAFESEH deaktivieren

Da der PoC benutzerdefinierte SEH-Handler installiert, die nicht in der SAFESEH-Tabelle enthalten sind, muss der Linker angewiesen werden, die SAFESEH-Validierung zu deaktivieren.

Erstellen Sie .cargo/config.toml:

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

---

4. Build-Anleitung

Binärdatei bauen:

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

Die Ausgabe befindet sich unter:

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

---

5. Ausführen des PoC

Ausführen:

seh_waterfall.exe

Erwarteter Kontrollfluss:

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

Sichtbare Artefakte:

• notepad.exe wird gestartet (Stufe 1)
• %TEMP%\moew_stage2.txt wird erstellt (Stufe 2)
• calc.exe wird gestartet (Endstufe)

---

6. Technische Aufschlüsselung

6.1 SEH-Record-Layout

Unter 32‑Bit-Windows bilden SEH-Records eine verkettete Liste, die unter fs:[0] gespeichert ist:

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

Jeder Handler verwendet die Standard-SEH-Signatur:

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

6.2 Globaler Zustand

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

Wird verwendet, um:

• die Rekursionstiefe des Handlers zu zählen
• den ursprünglichen SEH-Kopf am Ende des Waterfalls wiederherzustellen

---

7. Stufenlogik

Stufe 0 — Initiale Frameeinrichtung

1. fs:[0] als ORIGINAL_SEH speichern.
2. Einen SEH-Record erstellen, der auf den Stufe‑1-Handler zeigt.
3. fs:[0] mit diesem neuen Record überschreiben.
4. Fehlausrichtung in blob1 + 5, das als div ecx dekodiert (nachdem ECX = 0 gesetzt wurde).

Stufe 1 — Erster SEH-Handler

1. notepad.exe starten.
2. Einen SEH-Record für den Stufe‑2-Handler erstellen und oben in die Kette einhängen.
3. Fehlausrichtung in blob2 + 3 → div edx (mit EDX = 0).

Stufe 2 — Zweiter SEH-Handler

1. %TEMP%\moew_stage2.txt schreiben.
2. Den Endhandler in die SEH-Kette einhängen.
3. Fehlausrichtung in blob3 + 3 → div ebx (mit EBX = 0).

Endhandler — Beendigung

1. calc.exe starten.
2. ORIGINAL_SEH in fs:[0] wiederherstellen.
3. Den Prozess sauber über process::exit(0) beenden.

---

8. Fehlausgerichtete Fehler-Blobs

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
    }
}

• Ausgerichtete Dekodierung: mov eax, 0x10; div ecx; ret
• Fehlausgerichtet bei +5: div ecx (mit 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
    }
}

• Ausgerichtete Dekodierung: push ebp; mov ebp, esp; div edx; ret
• Fehlausgerichtet bei +3: div edx (mit 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
    }
}

• Ausgerichtete Dekodierung: push ebx; mov ebx, eax; div ebx; ret
• Fehlausgerichtet bei +3: div ebx (mit EBX = 0 → #DE)

---

9. Ausnahme-Pipeline

Jede ausgelöste Stufe tritt erneut in die Windows-Benutzermodus-Ausnahme-Pipeline ein:

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

Typische Debugger-Ansicht:

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

Der Waterfall wird vollständig durch echte Hardwarefehler und SEH-Dispatch angetrieben; es werden keine synthetischen oder gefälschten Ausnahmen verwendet.

---

10. Ausgabe der Markierungsdatei

Die in Stufe 2 geschriebene Datei sieht folgendermaßen aus:

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

Ihre Präsenz in %TEMP% dient als einfacher, beobachtbarer Beweis, dass Stufe 2 über die SEH-Kette ausgeführt wurde.

---

11. Sicherheitshinweise

• Der PoC ist harmlos und nur für defensive Forschung gedacht.
• Keine Persistenz, keine Registrierungsänderungen, keine Verschlüsselung.
• Alle Ausnahmen werden abgefangen und behandelt.
• Die ursprüngliche SEH-Kette wird vor der Beendigung wiederhergestellt.

---

12. Zukünftige Erweiterungen

Mögliche Erweiterungen umfassen: