So verwandeln Sie Opus 5.5 in eine Reverse-Engineering-Maschine: Die komplette Anleitung in 8 Schritten

Am 8. Oktober 2026 landete ein Repository, von dem drei Monate zuvor noch niemand gehört hatte, auf Platz eins der GitHub-Trending-Liste.

Es heißt REA – Reverse Engineer Anything – und gibt deinem Agenten einen echten Disassembler an die Hand.

**Speichere das als Lesezeichen – wenn du die ausführliche Version willst: Der komplette Kurs mit 20 Lektionen dazu ist live unter**

reacourse.xyz

Es bringt dich vom leeren Terminal bis zu einem Rebuild, der seine eigenen Paritätstests besteht – jeder Befehl und jeder Prompt ist ausgeschrieben. START HIER.

Die Reaktion war in dieser Woche überall dieselbe.

Matthew Berman brachte es in drei Worten auf den Punkt, und 3,6 Millionen Menschen sahen es.

https://x.com/MatthewBerman/status/2108245653843509415

REA ist ein Open-Source-MCP-Server plus CLI, der sich in Claude Code, Codex, Cursor und Gemini CLI einklinkt.

MIT-Lizenz, gebaut von morluto, erstes Release am 12. Juli 2026 – und drei Monate später über 100.000 GitHub-Stars.

Alles läuft lokal, und jede Schlussfolgerung wird als Beobachtung, Ableitung oder Unbekanntes markiert, inklusive der Adresse oder Aufrufstelle dahinter.

Das ist der gesamte Weg von einer versiegelten Binärdatei zu einem Rebuild, der dir gehört – in acht Schritten.

Vor den Schritten: Was andere damit schon ausgeliefert haben

Nicht das Tool ist die Geschichte, sondern das, was in vier Wochen damit entstanden ist.

ArtCraft hat sieben Adobe-Apps als kostenlose Open-Source-Alternativen nachgebaut und sich dann mit WordCraft, GridCraft und DeckCraft Office vorgenommen.

Mittlerweile zwölf Apps, alle komplett neu in Rust geschrieben, nativ auf drei Plattformen – und bis auf eine laufen sie per WebAssembly auch im Browser-Tab.

Bei Spielen sind die Belege noch konkreter:

• Super Mario Sunshine bekam einen nativen PC-Port: rund 365 Agentenstunden und 17,3 Milliarden Tokens, mit Claude und Codex zusammen
• Ein Touhou-Spiel, das auf dem offiziellen REA-Blog mit Agenten rekonstruiert wurde: 697 Funktionen, 696 exakte Treffer, spielbar in etwa 12 Tagen
• Der Aegis-Authenticator (3.077 Klassen) zerlegt und neu aufgebaut, alle 133 Testfälle bestanden
• Die Sound-Pan-Funktion von DX-Ball in C nachgebaut, bestand 3.205 originale x86-Testfälle und reproduzierte alle 63 kompilierten Bytes

Beachte, was diese Liste nicht ist.

Niemand hat einen Lizenzcheck geknackt, niemand hat den Quellcode eines anderen veröffentlicht.

Jedes einzelne davon ist ein wiederhergestelltes Verhalten, dokumentiert und in neuem Code nachgebaut.

01. Das Ziel klassifizieren, bevor du etwas öffnest

Der Grund für die Verbreitung ist nicht, dass es eine Sache gut liest. Es liest fast alles – und belegt jede Behauptung, die es aufstellt.

https://x.com/RoundtableSpace/status/2109165852578992582

Diese Liste ist gleichzeitig deine erste Entscheidung. Der häufigste Weg, einen Nachmittag zu verschwenden, ist der Griff zum Disassembler, wenn das Ziel eine Electron-App ist, deren JavaScript direkt vor dir liegt.

Richte REA auf Electron, bekommst du Module, Imports und IPC-Grenzen in Sekunden – ganz ohne Engine. Bei einem nativen Mach-O- oder ELF-File öffnet sich dagegen eine Hopper-Datenbank: der tiefere, aber langsamere Weg.

Zu wissen, in welchem Fall du bist, spart Stunden – mach es also zur Aufgabe deines ersten Prompts.

1Ich möchte verstehen, wie [FUNKTION] in [APP] funktioniert, die unter [ABSOLUTER PFAD] liegt.
2    Sag mir zuerst, um welche Art von Ziel es sich handelt (nativ, Electron/JS, .NET, Go, APK, WASM)
3    und wähle das passende REA-Tool, um es zu öffnen. Beginne noch keine tiefe Analyse.
4    Fasse es dann in einem Absatz zusammen: Womit es gebaut wurde, wie groß es ist, wo du
5    zuerst nach [FUNKTION] suchen würdest. Halte Beobachtungen, Ableitungen und Unbekanntes getrennt.

Was fast niemand erwähnt: Viele Unity-Spiele liefern ihre Logik als .NET aus, und REA liest .NET ohne zusätzliche Engine.

Genau deshalb geht ein gekauftes Steam-Spiel in einer halben Stunde von der Binärdatei zu bearbeitbarem C#.

Und jede Electron-App auf deinem Rechner ist sofort lesbar, ohne sie überhaupt zu starten:

1# wo das JavaScript liegt
2macOS:   /Applications/<App>.app/Contents/Resources/app.asar
3Windows: C:\Users\<du>\AppData\Local\Programs\<App>\resources\app.asar
4    npx -y rea-agents@latest analyze-javascript-application /absoluter/pfad/zur/app --json

02. In fünf Minuten installieren, dann eine Engine hinzufügen

Was hier funktioniert, ist kein cleverer Prompt. Es ist eine echte Disassembly-Engine, die an den Agenten angebunden ist – genau so beschrieb es ein Entwickler.

https://x.com/techNmak/status/2108431092462338178

Das Setup registriert den MCP-Server bei deinem Agenten und installiert den passenden Workflow-Skill.

Es zeigt jede Änderung an, bevor etwas geschrieben wird, und sichert alles, was es anfasst.

node -v # Node 22.19+, 24.11+ oder 26+. Die Versionen 23 und 25 werden nicht unterstützt

1npx rea-agents@latest setup          # registriert den MCP-Server, fragt vor dem Schreiben
2npm install --global rea-agents      # der kurze rea-Befehl, für immer
3rea --help
4# starte den Agenten neu, dann prüfen. doctor prüft nur, es ändert nie etwas
5npx -y rea-agents@latest doctor --client claude_code --json

Der Neustart ist wichtiger, als es klingt: Eine Terminalsitzung muss frisch gestartet werden, und Desktop-Apps müssen komplett beendet werden, weil das Schließen des Fensters nicht reicht.

Füge danach nur für das eine Engine hinzu, was du wirklich lesen willst:

Eine Datei lohnt es sich vor deinem ersten echten Ziel zu schreiben: Hausregeln in claude-md.

Analysiere nur, was dir gehört, markiere jede Behauptung als Beobachtung, Ableitung oder Unbekanntes, zitiere die Adresse dahinter und lass ein wiederhergestelltes Verhalten niemals als erledigt gelten, ohne dass ein Test besteht.

1# native Programme und Spiele: Ghidra 12.1.x und JDK 21 oder neuer
2    export GHIDRA_INSTALL_DIR=/absoluter/pfad/zu/ghidra_12.1.4_PUBLIC
3    export JAVA_HOME=/absoluter/pfad/zu/jdk-21
4    npx -y rea-agents@latest doctor --provider ghidra --json
5
6    # Android-Apps: JDK 17+ und jadx-headless-mcp 0.7.1
7    export REA_JADX_MCP_JAR=/absoluter/pfad/jadx-headless-mcp-0.7.1-all.jar
8    rea inspect-android-package /pfad/App.apk
9
10    # Smart-Contract-Bytecode, vorerst Linux x64
11    rea inspect-evm-interface ./runtime.hex hex --json

03. Recon: Die Karte kommt vor dem Code

Öffne noch keine einzige Funktion.

Ein Befehl verrät dir, auf welcher Maschine die Binärdatei läuft, wie viele Funktionen darin stecken und welcher lesbare Text darin verborgen ist.

Dieser Text ist der schnellste Hinweis, den du den ganzen Tag bekommst: Endpunkte, Fehlermeldungen und Funktionsnamen beschreiben die App, bevor du irgendeine Logik liest.

1rea.open_binary        { path: "/Applications/Target.app/Contents/MacOS/Target" }
2rea.binary_overview    {}
3  arch:        arm64
4  functions:   1.284 identifiziert
5  entry:       _main @ 0x1000051c0
6
7rea.search             { query: "http" }
8  0x10004a2c0  "https://api.target.app/v3/sync"
9  0x10004a300  "Authorization: Bearer "
10
11rea.xrefs              { address: "0x100012ab0" }
12  147 Referenzen  ->  Core-Konfigurationslader, wird überall aufgerufen

REA zählt, wie oft jede Funktion aufgerufen wird, und diese Zahl ist die Cross-Reference-Anzahl.

Eine Funktion, die 147 Mal aufgerufen wird, ist die Architektur der App; eine, die zweimal aufgerufen wird, ist ein Helfer, der warten kann.

Sortiere nach dieser Zahl und arbeite dich nach unten durch – niemals in Dateireihenfolge, denn Dateireihenfolge ist der Grund, warum Leute ein Wochenende in einer Binärdatei verlieren, in der nur vier interessante Funktionen steckten.

04. Eine Funktion dekompilieren, dann Opus alles darin benennen lassen

Ein Dekompiler verwandelt rohe Maschinenbefehle zurück in etwas, das C ähnelt.

Das Ergebnis ist grob: Namen wie var_28, Type-Casts überall, verschachtelte Verzweigungen – und grob ist völlig okay, denn lesbar ist alles, was das Modell braucht.

1# eine Funktion nach Adresse, als JSON zum Speichern und Wiederverwenden
2rea decompile /pfad/zu/Target 0x100012ab0 --provider hopper --json > fn_config.json
3
4# oder nach Name finden und ihren Referenzen folgen
5rea function /pfad/zu/Target parseConfig --provider hopper --json
6rea xrefs    /pfad/zu/Target 0x100012ab0 --provider hopper --json

Gib diese Ausgabe dann an Opus 5.5 und lass es den Teil übernehmen, den der Disassembler nicht kann:

1Hier ist dekompilierter Pseudocode aus einer Funktion mit 147 Cross-References.
2
31. Benenne jede Variable basierend auf ihrer Verwendung um und erkläre den Zweck in einem Satz.
42. Liste die Datenstrukturen auf, die sie liest und schreibt, und benenne das Muster, dem sie folgt.
53. Schreibe sie als sauberen, idiomatischen Code in der Sprache um, die die Aufrufkonventionen nahelegen.
64. Markiere fehlende Fehlerbehandlung, Eingabevalidierung oder Sicherheitsprüfungen.
7
8Denke mit Aufwand „xhigh“ nach, bevor du antwortest. Markiere alles, worüber du unsicher bist.

Opus 5.5 liefert fünf Aufwandstufen: low, medium, high, xhigh und max.

Medium inspiziert und navigiert, high annotiert gewöhnliche Funktionen, max ist für obfuskierten Code und komplexe Zeigerarithmetik.

Der Aufwand ist der wichtigste Qualitätsregler in dieser Pipeline, und die meisten lassen ihn auf Standard und geben dann dem Modell die Schuld.

Die Dekompilierung zeigt dir, was der Code tut, das Modell liefert dir das Warum – und die Namen, um ihn neu aufzubauen.

05. Obfuskation: Knacken, was sich lohnt, den Rest budgetieren

Manche Apps sind genau dafür gebaut, dir Widerstand zu leisten: Logik durcheinandergewürfelt, Strings verschlüsselt, falsche Verzweigungen nur eingebaut, um deine Aufmerksamkeit zu verschwenden.

Das ist der eine Bereich, in dem selbst das beste Modell kämpft – und es gibt gemessene Zahlen dazu.

Elastic Security Labs ließ Claude Opus in 20 Aufgaben auf den Tigress-Scrambler los, und zwei Erkenntnisse fallen direkt heraus.

Ein gescheiterter Versuch kostet etwa doppelt so viel wie ein erfolgreicher, weil das Modell weiter drückt, bevor es aufgibt. Und mehrschichtige Obfuskation kam auf null Treffer – sie stumpf abzuarbeiten ist also der teuerste Weg, nichts zu lernen.

Die praktische Regel lautet: ein Budget pro Funktion, nicht pro Sitzung.

Entferne zuerst den Ballast, denn ein kostenloses Tool namens Caveman beseitigt etwa 75 % des dekompilierten Mülls, sodass das Modell seine Aufmerksamkeit auf echte Logik verwendet.

1Diese Funktion sieht obfuskiert aus. Arbeite mit maximalem Aufwand.
2
31. Identifiziere die vorhandenen Techniken (Control-Flow-Flattening, opake Prädikate,
4   toter Code, String-Verschlüsselung, Function Splitting) und zeige jeweils darauf.
52. Löse sie auf: Entferne tote Zweige, werte opake Prädikate aus, entflache das
6   Dispatching, entschlüssele Inline-Strings, falls der Schlüssel wiederherstellbar ist. Zeige, was übrig bleibt.
73. Bewerte die Zuversicht auf einer Skala von 1–10. Unter 6 benenne die unsicheren Teile und welchen Kontext es bräuchte,
8   um sie zu klären. Rate nicht still vor dich hin.

06. Der Schwarm: ein Controller, viele Worker

Ein einzelner Chat kann 500 Funktionen nicht sauber lesen.

Er vergisst, was er vor vierzig Funktionen gesehen hat, benennt denselben Struct auf drei verschiedene Arten und beginnt leise, sich selbst zu widersprechen.

Die Lösung ist nicht mehr Kontext, sondern eine Rollenaufteilung: ein Controller, der Arbeit verteilt, und Worker, die jeweils eine Funktion übernehmen und dann stoppen.

1Du bist ein Reverse-Engineering-Controller. Die Funktionskarte steht in functions.json
2(Adresse, Name, Größe, xref_count).
3
41. Cluster Funktionen nach Nähe im Call-Graph; sortiere Cluster nach Xref-Anzahl.
52. Weise jeden Cluster einem Worker zu. Analysiere niemals selbst eine Funktion.
63. Injiziere bereits aufgelöste Structs in jedes Briefing, damit die Namen konsistent bleiben.
74. Zuversicht unter 6 bekommt einen zweiten Durchlauf mit Kontext aus aufgelösten Nachbarn.
85. Verfolge den kumulierten Token-Verbrauch und melde ihn nach jedem Cluster.
9
10Du bist ein Worker. Du erhältst eine dekompilierte Funktion und die bisher aufgelösten Structs.
11Gib exakt zurück: Adresse, Zweck, Zuversicht (1–10), structs_used, structs_new,
12clean_source, flags. Verwende bestehende Struct-Namen weiter, erfinde niemals einen zweiten Namen für
13einen Struct, den dir der Controller bereits gegeben hat. Nur eine Funktion. Stoppe, wenn du fertig bist.

REA liefert außerdem geführte Workflows direkt im MCP-Server mit, die die meisten nie öffnen:

• - investigate_feature – eine Funktion von der Entdeckung bis zu den exakten Funktionen nachverfolgen
• - compare_application_versions – zwei Releases vergleichen und sehen, was sich wirklich geändert hat
• - verify_reconstruction – deinen Rebuild gegen die gespeicherten Belege prüfen
• - audit_residual_unknowns – auflisten, was noch unbewiesen ist

07. Clean Room: Die Mauer zwischen zwei Kontexten ist das Produkt

Ein Clean-Room-Rebuild bedeutet, dass du kopierst, was die App tut, und niemals den Code darin.

Machst du es richtig, gehört das, was du auslieferst, komplett dir. Machst du es falsch, trägst du das Urheberrecht eines anderen in deinem eigenen Repository.

Das ist eine 40 Jahre alte Methode, keine Erfindung von 2026.

In den frühen 80ern baute Compaq das IBM-BIOS auf diese Weise für etwa 1 Million Dollar nach – der einzige Grund, warum PCs anderer Marken existieren.

1992 entschied das Gericht in Sega v. Accolade, dass das Zerlegen von Code Fair Use sein kann, wenn es der einzige Weg ist, seine Funktionsweise zu verstehen. Und im Jahr 2000 verlor Sony den Fall Sony v. Connectix mit 0:3, weil der fertige Emulator keinen einzigen Byte von Sonys Code enthielt.

Die andere Seite der Linie ist genauso klar: 2011 einigte sich George Hotz mit Sony und verpflichtete sich aufzuhören, nachdem der PS3-Root-Key öffentlich geworden war.

Vier Regeln halten dich auf der sicheren Seite, und das ArtCraft-Team prüft bei jedem Build automatisch alle vier:

• - Beobachten, niemals kopieren. Das Ziel als Blackbox ausführen, nur dessen eigenes Fenster screenshoten, niemals seinen Code in dein Projekt pasten
• - Spezifikationen, keine Quellen. Dateiformate stammen aus öffentlichen Standards (OOXML ist ECMA-376 / ISO 29500, dazu die veröffentlichten RTF- und ODF-Specs), niemals aus dem Lesen des Parsers eines Konkurrenten
• - Nur eigene Assets. Jedes Icon, jeder Font, jedes Template und jeder Sound wird im Code gezeichnet, ist gemeinfrei oder offen lizenziert, mit einer Zeile in einer Attributionsdatei
• - Die beiden Aufgaben trennen. Ein Agent stellt das Verhalten wieder her und schreibt die Spec, ein anderer Kontext implementiert ausschließlich nach dieser Spec

Die letzte Regel ist die, die Leute überspringen – und sie ist die eigentliche Grenze.

Dein untersuchender Agent ist definitionsgemäß kontaminiert, weil er die Dekompilierung gelesen hat. Dein bauender Agent darf das nicht.

1Schreibe anhand der abgeschlossenen Analyse eine Clean-Room-Spezifikation für eine Neuimplementierung.
2
3Beschreibe NUR DAS VERHALTEN: jede öffentliche Schnittstelle, das Datenmodell, jede nutzersichtbare
4Funktion als testbare Anforderung, die gelesenen und geschriebenen Dateiformate, die Fehlerbehandlung.
5
6Füge KEINE Adressen, Offsets, dekompilierte Variablennamen, Assembler oder irgendetwas
7aus dem Original Kopiertes ein. Ein Entwickler, der die Binärdatei nie gesehen hat, muss
8allein aus diesem Dokument eine kompatible Version implementieren können.
9
10Abschnitte: Architektur, Datenmodell, Öffentliche API, Dateiformate, Testfälle.

Nach einer Beschreibung zu arbeiten, ist nicht nur rechtliche Absicherung.

Es erlaubt dir, die richtige Entscheidung für deine eigene Sprache zu treffen, statt Entscheidungen zu erben, die jemand vor zwei Jahrzehnten getroffen hat – weshalb WordCraft stellenweise schneller ist als Word.

08. Parität prüfen, dann über MCP ausliefern

Du hattest nie den Originalquellcode, also kannst du nicht Zeile für Zeile diffen.

Du vergleichst Verhalten: dieselben Inputs in beide Builds, dieselben Outputs zurück.

1Baue einen Verhaltens-Test-Harness, der die originale Binärdatei und meinen Rebuild vergleicht.
2
3Generiere 50 Inputs: 30 normal, 10 Edge-Cases (leer, maximale Größe, Unicode), 10 Fehlerfälle
4(fehlerhaft formatiert, korrupt). Jage jeden durch beide, vergleiche wo möglich Byte für Byte
5und andernfalls semantisch. Melde Trefferquote, Abweichungen und einen Schweregrad für jede
6(kosmetisch / verhaltensbezogen / kritisch). Speichere in report.md.

„Ich glaube, es stimmt überein“ ist kein Beweis, eine Trefferquote schon – und dieser Report ist das Überzeugendste, was du an den Anfang eines Release-Posts setzen kannst.

Liefere den Rebuild dann so aus, wie REA und die Craft-Apps es getan haben: als MCP-Server, damit der Agent der nächsten Person dein Tool genauso steuern kann, wie du REA gesteuert hast.

Gib jeder Funktion einen klaren Namen und eine Ein-Zeilen-Installation, und jede Aktion wird zu einem benannten Befehl, den ein Klick, ein Shortcut und ein Agent identisch auslösen.

1claude mcp add wordcraft -- wordcraft-cli mcp
2
3> Öffne report.docx, setze jede Überschrift auf 14pt fett, exportiere als PDF
4  ok  select.all-headings -> 12 ausgewählt
5  ok  format.font-size 14 . format.bold
6  ok  export report.pdf (markierbarer Text, Lesezeichen behalten)

Die Grenzen und die fünf Fehler, die ein Wochenende kosten

REA kommt nicht an den Server heran, denn es liest, was auf deinem Rechner liegt – und Code, der auf den Servern eines Unternehmens läuft, wurde dir nie ausgeliefert.

Dekompilierter Code ist eine Rekonstruktion, nicht das Original – genau deshalb existiert Schritt 08.

Gestrippte C++-Binaries bleiben deutlich härter als Unity-.NET-Spiele, und kommerzielle Engines brauchen weiterhin echte Lizenzen.

• - Einen Disassembler auf eine Electron-App anzusetzen, wenn das JavaScript direkt da liegt
• - Die ganze Binärdatei zu dumpen, bevor man eine Zusammenfassung liest – das begräbt die Logik und treibt die Kosten hoch
• - Funktionen in Dateireihenfolge zu lesen statt nach Cross-Reference-Anzahl
• - Dem Modell zu erlauben, Code in deinen Rebuild zu kopieren, was den Clean Room mit einem Paste zerstört
• - Ohne Paritätsreport auszuliefern

Die ehrliche Linie zur Rechtslage, nachdem die Hälfte von X eine Woche lang wegen Piraterie geschrien hat: Eine App auf dem eigenen Computer zu lesen ist Lernen, eine Funktion anhand ihres Verhaltens neu aufzubauen ist so, wie die Branche seit den 80ern arbeitet – und Code zu kopieren oder bezahlpflichtige Features zu knacken, ist der Teil, für den du verklagt wirst.

Studiere das Original, liefere dein Eigenes aus.

Hinter jedem dieser acht Schritte steckt eine Lektion unter

reacourse.xyz , mit den exakten Prompts, den Fehlermustern und den Stellen, an denen das hier nicht mehr funktioniert.

Closed Source bedeutete früher: Du wirst es nie erfahren.

Jetzt bedeutet es: Zeig mir die Belege.

Die meisten werden weiterhin monatlich für ein Feature bezahlen, das sie an einem Nachmittag verstehen und an einem Wochenende nachbauen könnten.

Die wenigen, die lernen, Software zu lesen, werden bauen, was immer sie wollen.

Folge mir und abonniere meinen Telegram-Kanal:

https://t.me/+75nMf005jRpjMDU1