Binär-Exploitation — von Fuzz zum funktionierenden Exploit.

Korruptions-Klassen

• Stack-Buffer-Overflow. Klassisches strcpy auf Stack-Array. Verteidigungen: Stack-Canary, ASLR, NX. Noch ausnutzbar mit Info-Leak + ROP.
• Heap-Buffer-Overflow. Overflow in benachbarte Chunk-Metadata oder in benachbartes Object-Pointer/VTable. Moderne gehärtete Allocators (mimalloc, scudo, jemalloc mit Shadow-Chunks) heben die Latte.
• Use-After-Free. Freen, dann dereferenzieren. Kontrollierte Daten in den freigegebenen Slot reklamieren, Fake-VTable, Control-Flow auf nächstem virtual Call hijacken. Mitigiert durch MarkUs / GC-style Allocators in Browsers.
• Type-Confusion. Objekt als anderer Typ behandelt als sein tatsächliches Layout. Häufig in JIT-Engines; Primitive für Arbitrary R/W via Fake-Array-Length.
• Double-Free. Gleichen Chunk zweimal freen; tcache- oder Fastbin-Poisoning gibt Arbitrary Write. glibc 2.27+ hat tcache-Double-Free-Check.
• Integer-Overflow. malloc(n * sizeof(x)) wo n * sizeof(x) overflowt; kleine Allokation, große Copy.
• Format-String. printf(user_input) ohne Format. %n schreibt; %s liest. Selten in modernem Code dank Compiler-Warnings.

Fuzzing — Discovery zu Triage

• AFL++ für Grey-Box. Target mit afl-cc kompilieren; Corpus-Seed → Coverage-getriebene Mutation. ASAN-instrumentierten Build für saubereres Crash-Signal hinzufügen.
• libFuzzer für In-Process. Per-Function-Harness; schneller pro Iteration als AFL. Beste für Library-APIs.
• Honggfuzz für Kernel / Hardware-Assisted. Hardware-Perf-Counter-Coverage. Gut wenn Source-Level-Instrumentation nicht verfügbar.
• Crash-Triage.
  • ASAN-Report → Klassifikation (heap-buffer-overflow, use-after-free etc.).
  • Input minimieren — afl-tmin / libFuzzer's -minimize_crash=1.
  • Reproduzieren unter gdb / rr / Time-Travel-Debugger. rr besonders wertvoll: einmal aufzeichnen, vor und zurück gehen, um Root-Cause zu finden.
  • Kategorisieren: Control-Flow-Hijackable, Info-Leak, DoS-only. Nur die ersten zwei sind primäre Exploitation-Ziele.

Exploitation-Pipeline — Crash zu funktionierender RCE

1. Primitive etablieren. Arbitrary Read, Arbitrary Write, PC-Control, Stack-Pivot-Control, Function-Pointer-Control.
2. ASLR schlagen. Info-Leak-Primitive → libc-/Binary-Adresse leaken → Base berechnen.
3. DEP/NX schlagen. ROP-Chain. ROPgadget, ropper, one_gadget für Single-Call-Magic-Gadgets.
4. Stack-Canary schlagen. Teilt oft Low-Byte (Null auf Linux); via Partial-Overwrite leaken oder Byte für Byte bruten wenn Fork-Server.
5. CFG (Windows) / CET (Intel) schlagen.
   • CFG prüft Indirect-Calls gegen Valid-Target-Bitmap. Bypass: Valid-Target finden, das Control-Flow angreifer-günstig fortsetzt, oder Bitmap selbst angreifen.
   • CET (Shadow-Stack) detektiert ROP via Return-Mismatch. Bypass: JOP via Indirect-Jumps nicht von Shadow-Stack geschützt, oder Systeme angreifen, die Shadow-Stack nicht enforcen.
6. Payload ausführen. Shell spawnen (Linux), Reverse-TCP (Windows). Oder Registry / Token / Process für Privileg öffnen.

Windows-Internals — offensive Relevanz

• Object-Manager. Named Kernel-Objects leben im Namespace (\BaseNamedObjects, \Sessions\N). Symbolic-Link-Missbrauch: Symlink im user-kontrollierbaren Namespace auf privilegiertes Target, dann resolvt privilegierter Prozess durch.
• Token-Mechanik. SeImpersonatePrivilege + Service, der zu angreifer-kontrolliertem Named-Pipe connectet → SYSTEM-Context-Client impersonieren. PrintSpoofer, RemotePotato-Kette darauf.
• Kernel-Callbacks. EDR-Treiber registrieren Callbacks via PsSetCreateProcessNotifyRoutineEx, ObRegisterCallbacks. Aus Kernel-Exploit-Primitiv (z.B. Signed-Driver-Load) kann die Callback-Liste unhookt werden, um EDR zu blenden.
• HVCI / VBS. Hypervisor-Enforced-Code-Integrity blockt unsigned Kernel-Code-Execution. Bypass erfordert vulnerable signed Treiber, der angreifer-kontrolliertes R/W ausführt — BYOVD-Muster.