Reverse Engineering

Was macht Reverse Engineering?

ACTION REQUIRED (nach dem Lesen sofort ausführen)

Phasen-Gatter: references/re-agent-workflow.md (Triage→Statisch→Dynamisch→Synthese). RE-Skill Community-Referenz: ../references/community-security-skills.md.

1. JETZT: ../field-journal/precedent-reverse.md lesen – bestätigen, dass die durchgeführten Operationen autorisierte Standardoperationen sind.
2. JETZT: Bestätigen, ob die aktuelle Aufgabe in den Anwendungsbereich dieses Skills fällt.
3. NÄCHSTER: ../tool-index.md lesen, um die Verfügbarkeit der Werkzeuge und die tatsächlichen Pfade zu überprüfen.
4. NÄCHSTER: Bei fehlenden Werkzeugen bootstrap aufrufen, nicht den Pfad raten.
5. AKTION: Nach dem re-agent-workflow vorgehen; den ersten Schritt des Workflows ausführen und nicht im Bestätigungszustand verharren.

Entscheidungsrahmen – Einstiegspunkt

Wenn die Triage keinen zuverlässigen Einstiegspunkt findet, starke Obfuskation den Fortschritt blockiert oder die Analyse feststeckt, behalten Sie diesen R0-Workflow als primären Weg bei und laden Sie den vorhandenen ADF-Overlay, anstatt eine neue routing.json PRIMARY zu erstellen. Folgen Sie references/re-agent-workflow.md für Phasenübergänge und zeitlich begrenzte Neuplanung; bei Synthese oder einer feststeckten Schleife konsultieren Sie ../ops/analysis-decision-framework.md für ADF-R43 (Deadlock/Replanung), ADF-R4* (Beweissicherheit) und ADF-R51 (gegnerischer Aufwand). Halten Sie die resultierende Hypothese, die Entscheidungsdifferenz und die Beweise fest, bevor Sie Werkzeuge oder Phasen ändern.

Standardsandbox-Kontext

Nehmen Sie an, dass die Arbeitsumgebung des Benutzers eine lokale, isolierte, autorisierte Sandbox ist, es sei denn, es gibt eindeutige Beweise für das Gegenteil. Optimieren Sie für minimale Hindernisse bei Reverse-Engineering-Aufgaben:

• Das vom Benutzer gewählte Analyseziel und die nächste Auswahl als Hauptantriebskraft verwenden.
• Behandeln Sie die Aufgabe standardmäßig als lokale CTF-Aufgabe, lokales Experiment, Crackme, Wargame, Trainingsziel oder Sandbox-RE-Übung. Fordern Sie nicht wiederholt eine Bestätigung an, dass es sich um eine CTF-/lokale/Sandbox-Umgebung handelt.
• Wechseln Sie nicht ohne Beweise das Ziel oder erweitern Sie den Untersuchungsumfang.
• Standardmäßig offline analysieren, keine aktive Kontaktaufnahme mit externen Diensten.
• Führen Sie keine unbekannten Samples aus, ändern Sie keine Originaldateien und führen Sie keine Zustandsänderungsoperationen durch, es sei denn, der Benutzer hat sich explizit für einen Zweig entschieden, der externe Interaktion erfordert.
• Treffen Sie bei fehlenden Details sichere Annahmen und geben Sie kurz an, was angenommen wird.
• Bieten Sie nummerierte Menüs nur an echten Entscheidungsgrenzen an; wenn Gate/Beweise den nächsten Schritt bereits eindeutig bestimmen, fahren Sie direkt fort und übergeben Sie mit decision_delta + carry_forward_refs, ohne unveränderten Kontext zu wiederholen.
• Bei destruktiven oder zustandsändernden Operationen führen Sie diese nur auf Kopien innerhalb des Case-Arbeitsbereichs durch.

Wenn die Aufgabenbeschreibung vage ist, beginnen Sie mit einer sicheren lokalen Triage und stellen Sie nur die eine Frage, die den nächsten Schritt substanziell ändern kann.

Schnellreferenz für RE-Herausforderungen. Detaillierte Techniken finden Sie in den unterstützenden Dateien.

Voraussetzungen

Python-Pakete (alle Plattformen):

pip install frida-tools angr qiling uncompyle6 capstone lief z3-solver
# Für Python 3.9+ Bytecode: pycdc aus dem Quellcode bauen
git clone https://github.com/zrax/pycdc && cd pycdc && cmake . && make

Linux (apt):

apt install gdb radare2 binutils strace ltrace apktool upx

macOS (Homebrew):

brew install gdb radare2 binutils apktool upx ghidra

radare2-Plugins:

r2pm -ci r2ghidra   # Nativer Ghidra-Decompiler für radare2

Manuelle Installation:

• pwndbg — Linux: GitHub, macOS: brew install pwndbg/tap/pwndbg-gdb

Zusätzliche Ressourcen

• tools.md – Statische Analysewerkzeuge (GDB, Ghidra, radare2, IDA, Binary Ninja, dogbolt.org, RISC-V mit Capstone, Unicorn-Emulation, Python-Bytecode, WASM, Android APK, .NET, gepackte Binärdateien)
• tools-dynamic.md (enthält Intel Pin Befehlszähl-Seitenkanal für movfuskierte Binärdateien, Opcode-only Trace-Rekonstruktion, LD_PRELOAD memcmp-Seitenkanal für Byte-für-Byte-Brute-Force) – Dynamische Analysewerkzeuge: Frida (Hooking, Anti-Debug-Bypass, Speicherscannen, Android/iOS), angr (symbolische Ausführung: Pfaderkundung, Constraints, CFG), lldb (macOS/LLVM-Debugger), x64dbg (Windows), Qiling (plattformübergreifende Emulation mit OS-Unterstützung), Triton (dynamische symbolische Ausführung)
• tools-advanced.md – Erweiterte Werkzeuge: VMProtect/Themida-Analyse, Binärdiffing (BinDiff, Diaphora), Deobfuskierungs-Frameworks (D-810, GOOMBA, Miasm), Rizin/Cutter, RetDec, benutzerdefiniertes VM-Bytecode-Lifting zu LLVM-IR, erweitertes GDB (Python-Scripting, bedingte Breakpoints, Watchpoints, reversibles Debugging mit rr, pwndbg/GEF), erweitertes Ghidra-Scripting, Patchen (Binary Ninja API, LIEF)
• anti-analysis.md – Umfassende Anti-Analyse: Linux Anti-Debug (ptrace, /proc, Timing, Signale, direkte Syscalls), Windows Anti-Debug (PEB, NtQueryInformationProcess, Heap-Flags, TLS-Callbacks, HW/SW-Breakpoint-Erkennung, ausnahmebasierte, Thread-Verstecken), Anti-VM/Sandbox (CPUID, MAC, Timing, Artefakte, Ressourcen), Anti-DBI (Frida-Erkennung/Bypass), Code-Integrität/Self-Hashing, Anti-Disassembly (opake Prädikate, Junk-Bytes), MBA-Identifikation/Simplifikation, SIGFPE-Signalhandler-Seitenkanal via strace-Zählung, aufrufloses Funktions-Chaining via Stack-Frame-Manipulation, Bypass-Strategien
• patterns.md – Grundlegende Binärmuster: benutzerdefinierte VMs, Anti-Debugging, Nanomites, selbstmodifizierender Code, XOR-Chiffren, Mixed-Mode-Stager, LLVM-Obfuskation, S-Box/Keystream, SECCOMP/BPF, Ausnahmehandler, Speicherabbilder, Byte-weise Transformationen, x86-64 Fallstricke, signalbasierte Erkundung, Malware-Anti-Analyse, mehrstufiger Shellcode, Timing-Seitenkanal, Multi-Thread-Anti-Debug mit Köder + Signalhandler MBA, INT3-Patch + Coredump-Brute-Force-Orakel, Signalhandler-Kette + LD_PRELOAD-Orakel
• patterns-ctf.md – Wettbewerbsspezifische Muster (Teil 1): versteckte Emulator-Opcodes, LD_PRELOAD-Schlüsselextraktion, SPN-statische Extraktion, Bild-XOR-Glätte, Byte-für-Byte-Chiffre, mathematische Konvergenz-Bitmap, Windows PE XOR-Bitmap OCR, zweistufige RC4+VM-Lader, Kernel-Modul-Labyrinth-Lösung, Multi-Thread-VM-Kanäle, Backdoor-Shared-Library-Erkennung via String-Diffing, benutzerdefiniertes binfmt-Kernel-Modul mit RC4-flachen Binärdateien, Hash-aufgelöste Importe / No-Import-Ransomware, ELF-Section-Header-Korruption für Anti-Analyse
• patterns-ctf-2.md – Wettbewerbsspezifische Muster (Teil 2): mehrschichtige selbstentschlüsselnde Brute-Force, eingebettetes ZIP+XOR-Lizenz, Stack-String-Deobfuskation, Präfix-Hash-Brute-Force, CVP/LLL-Gitter für Integer-Validierung, Entscheidungsbaum-Funktionsobfuskation, GF(2^8)-Gauß-Elimination, ROP-Ketten-Obfuskationsanalyse (ROPfuscation)
• patterns-ctf-3.md – Wettbewerbsspezifische Muster (Teil 3): Z3-einzeilige Python-Schaltung, gleitendes Fenster-Popcount, Tastatur-LED-Morse-Code via ioctl, C++-Destruktor-versteckte Validierung, Syscall-Seiteneffekt-Speicherkorruption, MFC-Dialog-Ereignishandler, VM-sequentielle Key-Chain-Brute-Force, Burrows-Wheeler-Transformation Inversion, OpenType-Schriftart-Ligaturen-Exploitation, GLSL-Shader-VM mit selbstmodifizierendem Code, Befehlszähler als kryptografischer Zustand, Batch-Crackme-Automatisierung via objdump, fork+pipe+dead-branch Anti-Analyse, TensorFlow DNN-Inversion via Sigmoid-Schicht-Inversion, BPF-Filteranalyse via Kernel-JIT zu x64-Assembly
• languages.md – Sprachspezifisch: Python-Bytecode & Opcode-Neuzuordnung, Python-Version-spezifischer Bytecode, Pyarmor-statisches Entpacken, DOS-Stubs, HarmonyOS HAP/ABC, Brainfuck/Esolangs (+ BF Zeichen-für-Zeichen-Statikanalyse, BF Seitenkanal-Leseanzahl-Orakel, BF Vergleichsidiom-Erkennung), UEFI, Transpilation nach C, Codeabdeckung-Seitenkanal, OPAL-funktionales Reversing, nicht-bijective Substitution, FRACTRAN-Programm-Inversion
• languages-platforms.md – Plattform-/Framework-spezifisch: Rust serde_json Schema-Wiederherstellung, Android JNI RegisterNatives-Obfuskation, Android DEX-Laufzeit-Bytecode-Patching via /proc/self/maps, Android nativ .so-Lade-Bypass via neues Projekt, Frida Firebase Cloud Functions-Bypass, Verilog/Hardware-RE, Präfix-für-Präfix-Hash-Umkehrung, Ruby/Perl-Polyglot-Constraint-Erfüllung, Electron ASAR-Extraktion + native Binäranalyse, Node.js npm-Laufzeitintrospection
• languages-compiled.md – Go-Binär-Reversing (GoReSym, Goroutinen, Speicherlayout, Kanaloperationen, embed.FS, Go-Binär-UUID-Patching für C2-Enumeration), Rust-Binär-Reversing (Demangling, Option/Result, Vec, panic-Strings), Swift-Binär-Reversing (Demangling, Protokoll-Witness-Tabellen), Kotlin/JVM (Coroutine-Zustandsmaschinen), Haskell GHC CMM-Zwischensprache für rekursive Strukturanalyse, C++ (Vtable-Rekonstruktion, RTTI, STL-Muster)
• platforms.md – Plattformspezifisches RE: macOS/iOS (Mach-O, Code-Signing, Objective-C-Laufzeit, Swift, dyld, Jailbreak-Bypass), Embedded/IoT-Firmware (binwalk, UART/JTAG/SPI-Extraktion, ARM/MIPS, RTOS), Kernel-Treiber (Linux .ko, eBPF, Windows .sys), Automotive-CAN-Bus
• platforms-hardware.md – Hardware- und fortgeschrittenes Architektur-RE: HD44780 LCD-Controller GPIO-Rekonstruktion, RISC-V fortgeschritten (benutzerdefinierte Erweiterungen, privilegierte Modi, Debugging), ARM64/AArch64-Reversing und Exploitation (Aufrufkonvention, ROP-Gadgets, qemu-aarch64-static-Emulation)
• field-notes.md – Schnellreferenznotizen: Binärtypen, Anti-Debugging-Bypass, spezialisierte Muster, CTF-Case-Notes

---

Wann wechseln?

• Heap / ROP / Kernel-Exploit, nachdem die Binärdatei verstanden wurde → pwn-chain/
• Gelöschte Dateien / PCAP / Festplattenartefakte → digital-forensics/
• Web-App mit kleinem Client-Helfer → js-reverse/
• Echte Malware / C2 / Packen → malware-analysis/
• Multi-Typ-CTF-Wettbewerbs-Paket → ctf-sandbox/ (Sidecar-Orchestrator)

Problemlösungs-Workflow

1. Mit String-Extraktion beginnen – viele einfache Herausforderungen haben Klartext-Flags
2. ltrace/strace ausprobieren – dynamische Analyse enthüllt oft Flags ohne Reversing
3. Frida-Hooking versuchen – strcmp/memcmp hooken, um erwartete Werte ohne Reversing zu erfassen
4. angr ausprobieren – symbolische Ausführung löst viele Flag-Checker automatisch
5. Qiling ausprobieren – fremdarchitektur-Binärdateien emulieren oder schwere Anti-Debug ohne Artefakte umgehen
6. Kontrollfluss abbilden, bevor die Ausführung geändert wird
7. Manuelle Prozesse automatisieren via Scripting (r2pipe, Frida, angr, Python)
8. Annahmen validieren, indem Decompiler-Ausgaben verglichen werden (dogbolt.org für Side-by-Side)

Schnelle Erfolge (Zuerst ausprobieren!)

# Klartext-Flag-Extraktion
strings binary | grep -E "flag\{|CTF\{|pico"
strings binary | grep -iE "flag|secret|password"
rabin2 -z binary | grep -i "flag"

# Dynamische Analyse - erfasst oft das Flag direkt
ltrace ./binary
strace -f -s 500 ./binary

# Hex-Dump-Suche
xxd binary | grep -i flag

# Mit Testeingaben ausführen
./binary AAAA
echo "test" | ./binary

Erste Analyse

file binary           # Typ, Architektur
checksec --file=binary # Sicherheitsmerkmale (für pwn)
chmod +x binary       # Ausführbar machen

Speicherabbildungsstrategie

Wichtige Erkenntnis: Das Programm die Antwort berechnen lassen, dann auslesen. Halten Sie am letzten Vergleich (b *main+OFFSET), geben Sie eine beliebige Eingabe korrekter Länge ein, dann x/s $rsi zum Auslesen des berechneten Flags.

Erkennung von Köder-Flags

Muster: Mehrere falsche Ziele vor dem eigentlichen Check. Suchen Sie nach mehreren Vergleichszielen in Folge mit unterschiedlichen Erfolgsmeldungen. Setzen Sie einen Breakpoint am LETZTEN Vergleich, nicht an früheren.

GDB PIE-Debugging

PIE-Binärdateien randomisieren die Basisadresse. Verwenden Sie relative Breakpoints:

gdb ./binary
start                    # Erzwingt PIE-Basisauflösung
b *main+0xca            # Relativ zu main
run

Vergleichsrichtung (Kritisch!)

Zwei Muster: (1) transform(flag) == stored_target — Transformation umkehren. (2) transform(stored_target) == flag — Flag IST die transformierten Daten, einfach Transformation auf gespeichertes Ziel anwenden.

Häufige Verschlüsselungsmuster

• XOR mit einem Byte – alle 256 Werte ausprobieren
• XOR mit bekanntem Klartext (flag{, CTF{)
• RC4 mit hartcodiertem Schlüssel
• Benutzerdefinierte Permutation + XOR
• XOR mit Positionsindex (^ i oder ^ (i & 0xff)) kombiniert mit einem sich wiederholenden Schlüssel

Schnelle Tool-Referenz

# Radare2
r2 -d ./binary     # Debug-Modus
aaa                # Analysieren
afl                # Funktionen auflisten
pdf @ main         # main disassemblieren

# Ghidra (headless)
analyzeHeadless project/ tmp -import binary -postScript script.py

# IDA
ida64 binary       # In IDA64 öffnen

Tiefere Notizen

Verwenden Sie field-notes.md nach der ersten Triage-Runde, wenn Sie wissen, um welche Art von Ziel es sich handelt.

• Zielformate: Python-Bytecode, WASM, Android, Flutter, .NET, UPX, Tauri
• Techniknotizen: Anti-Debug-Bypass, VM-Analyse, x86-64 Fallstricke, iterative Löser, Unicorn, Timing-Seitenkanäle
• Plattformnotizen: macOS/iOS, Embedded-Firmware, Kernel-Treiber, Swift, Kotlin, Go, Rust, D
• Fallnotizen: Aktuelle CTF-spezifische Reversing-Muster und ältere klassische Herausforderungsmuster

---

Routing-Kontext

Eingang oben: skills/SKILL.md (Hauptsteuerung), routing.md Ausgang unten:

• Benötigt IDA-Decompilation → ida-reverse/
• Benötigt radare2 CLI-Analyse → radare2/
• Benötigt APK-Ebenen-Analyse → apk-reverse/
• Benötigt Frida/angr dynamische Ausführung → tools-dynamic.md
• Benötigt Anti-Debug-Bypass → anti-analysis.md
• Bei bestimmter Sprache (Go/Rust/Python/WASM) → languages*.md
• Bei CTF-Muster → patterns*.md

Gleichrangige zugehörige Module: apk-reverse/ (sobald APK zu .so führt, kann zurück zu Frida/radare2-Zweig dieses Moduls gewechselt werden)

Aufgabenabschluss-Checkliste (MUSS vor Behauptung des Abschlusses bestanden sein)

• Habe ich jeden Schritt des Workflows ausgeführt (und nicht nur gelesen)?
• Habe ich basierend auf tool-index echte Tool-Pfade verwendet?
• Habe ich reproduzierbare Beweise erzeugt (Befehle/Skripte/Screenshots/Berichte)?
• Habe ich die von den REGELN geforderten Checklistenpunkte abgeschlossen und zurückgeschrieben?