Themabewertung:
  • 0 Bewertung(en) - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Reverse Engineering der NLT III (mit KI)
#67
Hallo zusammen,

hier ein "Kochrezept", wie die Sternenschweif, Schatten über Riva und die Schicksalsklinge rekonstruiert wurden. Davon kann man garantiert viel verwenden.

Das Ziel: Am Ende steht C/C++-Quelltext, aus dem der damalige Compiler wieder exakt dieselbe EXE baut, bis auf die letzte Prüfsumme (MD5 bytegleich). Erst dann weiß man sicher, dass alles stimmt, und kann Fehler beheben, ohne neue einzubauen.


=== Schritt 0: Vorbereiten ===

- Original-EXE sichern und ihre Prüfsumme (MD5) notieren. Daran wird alles gemessen.
- Du brauchst: den Original-Compiler, DOSBox, Python, Ghidra und Zugang zu mehreren KI-Modellen (nicht notwendiger Weise verschiedene Anbieter, aber jeden Fall verschiedene Leistungsklassen, weil es dann günstiger wird vom "token-verbrauch" her, einfache Funktionen lassen sich auch mit einfachen Modellen berechnen, je größer die Funktion, desto schwieriger ist sie zu lösen).
- Original-Spieldateien und den Compiler nie mit hochladen. Veröffentlicht werden nur eigene Quelltexte und Werkzeuge.


=== Schritt 1: Den Original-Compiler finden ===

- Herausfinden, mit welchem Compiler und welcher Version das Spiel gebaut wurde (bei uns Borland C++ 3.1 und Watcom C/C++ 10.6). Hinweise stecken im Startcode, in den Bibliotheksfunktionen und in Text-Resten in der EXE.
- Kleine Testprogramme übersetzen und vergleichen, bis Version und Compiler-Schalter Bit für Bit passen.
- Den Compiler in einem Emulator laufen lassen, damit ein Durchlauf nur Sekunden dauert. So werden tausende Versuche bezahlbar.
- Falle: Eine Nachbarversion oder ein anderer Linker erzeugt fast gleichen, aber eben nicht identischen Code.


=== Schritt 2: Das Programm zerlegen ===

- Mit Ghidra das Programm erkunden: Wo fangen Funktionen an, wer ruft wen auf, welche Texte und Daten gibt es.
- Die EXE in Assembler umwandeln, der wieder exakt dieselbe EXE ergibt. Das ist die Ausgangsbasis.
- In Einheiten (die ursprünglichen Quelltextdateien) und Funktionen schneiden. Handgeschriebenen Assembler und fremde Bibliotheken als feste Blöcke stehen lassen.
- Fertig, wenn die Basis wieder die Original-Prüfsumme ergibt.


=== Schritt 3: Der Richter ===

Das Wichtigste überhaupt: Keine KI bewertet ihr eigenes Ergebnis. Bewertet wird nur vom echten Compiler.

- Pförtner: Vor dem Übersetzen wird geprüft, ob geschummelt wird (eingebetteter Assembler, rohe Bytes). Das wird sofort abgewiesen.
- Richter: Der Original-Compiler übersetzt, ein Vergleich zählt, wie viele Maschinenbefehle noch vom Original abweichen.
- Ratsche: Eine neue Fassung wird nur übernommen, wenn sie wirklich besser ist. Es geht nie zurück.
- Falle: Den Berichten der KI glauben. Es zählt nur, was der Richter misst.


=== Schritt 4: Arbeit nach Funktionsgröße verteilen ===

- Erster Durchgang: Ghidra liefert für jede Funktion eine erste C-Fassung, eine KI (bei uns Claude) bessert sie nach, kleine Varianten werden automatisch durchprobiert. Damit fällt schon fast die Hälfte, vor allem die kleinen Funktionen.
- Kleine Funktionen: Schnelle, günstige Modelle und automatische Varianten-Werkzeuge reichen meistens.
- Mittlere Funktionen: Suchwellen mit mehreren verschiedenen KI-Modellen.
- Große Funktionen: Blind neu schreiben lassen (Schritt 5), dann mischen und übermalen (Schritt 6). Hier brauchen die Modelle Zeit, keine Eile.
- Fast fertige Funktionen, bei denen nur noch Register oder Stapelplätze vertauscht sind: Nicht mehr raten, sondern den Compiler nachrechnen (Schritt 8).
- Wird eine Funktion besser, dürfen alle Werkzeuge sie wieder neu probieren.


=== Schritt 5: Blind neu schreiben ===

- Bei festgefahrenen Funktionen alten Quelltext, Ghidra-Fassung und alte Notizen wegwerfen. Die halten die KI in derselben Sackgasse fest.
- Mehrere verschiedene Modellfamilien parallel aus dem reinen Assembler neu schreiben lassen. Als einziges Werkzeug bekommen sie den Richter.
- Abwechselnd einzelne Verbote geben ("diesmal ohne switch"), damit nicht alle denselben Denkfehler machen.
- Jede übersetzte Zwischenfassung aufheben, die braucht der Mischer.
- Falle: Immer dasselbe Modell nehmen. Es macht an derselben Stelle immer wieder denselben Fehler.


=== Schritt 6: Mischen und Übermalen ===

- Mischer: Aus vielen Fassungen werden die jeweils passenden Stücke ausgeschnitten und zusammengesetzt. Es reicht, wenn irgendein Modell ein Stück richtig hat.
- Übermalen (Layern): Alles, was stimmt, wird eingefroren. Nur die eine kaputte Stelle wird von verschiedenen Modellen neu geschrieben.
- Blinder Fleck oder Wachs: Scheitern nur manche Modelle an einer Stelle, nimmt man ein anderes. Scheitern alle an derselben Stelle, obwohl der Ablauf schon stimmt, hilft kein Raten mehr. Dann weiter mit Schritt 8.


=== Schritt 7: Abschauen und Durchprobieren ===

- Schwestern: Ähnliche, schon gelöste Funktionen suchen und als Vorlage mitgeben. Damals wurde viel kopiert.
- Mustersuche: Für ein kurzes Stück Assembler in allen gelösten Funktionen nachsehen, welcher Quelltext genau das erzeugt hat.
- Mutator: Kleinigkeiten automatisch durchprobieren (Reihenfolge der Variablen, Typumwandlungen, Klammern).
- Gibt es Demo- oder Debug-Fassungen des Spiels, sieht man dort manchmal Hilfsfunktionen, die in der fertigen EXE verschmolzen sind. Nur mit zwei unabhängigen Belegen zuordnen.


=== Schritt 8: Den Compiler nachrechnen ===

Am Ende bleiben Funktionen, bei denen der Code stimmt, aber Register oder Stapelplätze vertauscht sind.

- Im Emulator nachsehen, wie der Compiler intern entscheidet. Watcom 10.6 zum Beispiel sortiert Variablen mit einem instabilen Sortierverfahren, da entscheiden Kleinigkeiten wie die Reihenfolge der Deklarationen.
- Diese Sortierung nachbauen und rückwärts ausrechnen, welche Reihenfolge nötig ist.
- Unbenutzte Hilfsvariablen ("Geistervariablen") lenken die Sortierung, ohne Code zu erzeugen. Hinterher so viele wie möglich wieder wegrechnen.


=== Schritt 9: Alles zusammenbauen ===

- Alle Einheiten übersetzen und zur ganzen EXE linken. Erst wenn die Prüfsumme stimmt, ist es bewiesen.
- Falle: Bei uns passte jede Funktion einzeln, trotzdem zeigten noch einige Aufrufe auf die falsche Nachbarfunktion. Das sieht man nur im Gesamtbau.


=== Schritt 10: Aufräumen ===

- Reihenfolge: erst gemeinsame Header und Typen, dann die Suchkrücken entfernen, zum Schluss Kommentare.
- Nach jedem Schritt muss die EXE weiter identisch sein.


=== Schritt 11: Fehler beheben ===

- Fehlerfunde der KI immer von einer zweiten, unabhängigen Instanz am Code gegenprüfen lassen. Bei uns war fast die Hälfte falscher Alarm.
- Gefundene Fehler auch in kopierten Zwillingsfunktionen suchen.
- Jede Korrektur hinter einen Schalter setzen. Ohne Schalter muss weiterhin exakt die Original-EXE herauskommen.


=== Schritt 12: Die reparierte EXE prüfen ===

- Sobald Korrekturen Funktionen länger oder kürzer machen, verschiebt sich der ganze restliche Code. Dann alle Zeiger und Sprungziele automatisch prüfen.
- Stürzt sie ab: Die Korrekturen halbieren und eingrenzen, bis man die schuldige findet.
- Zwei Fallen bei uns: Der Compiler legte zwei gleich gewordene Funktionen auf dieselbe Adresse, und im erhaltenen Assembler gab es feste Sprünge, die nach dem Verschieben ins Leere gingen.
- Am Ende im Spiel selbst testen.


=== Schritt 13: Veröffentlichen ===

- Bau-Paket: Quelltexte und ein Skript, das mit dem eigenen Compiler die EXE baut.
- Patch für Spieler: macht aus der eigenen Original-EXE die reparierte Fassung und enthält selbst kein einziges Original-Byte.
- Vor dem Hochladen prüfen, dass keine Original-Dateien und keine persönlichen Pfade dabei sind.


=== Schritt 14: Die KI-Agenten führen ===

- Kurze, klare Aufträge. Lange Akten voller alter Fehlversuche machen die Ergebnisse schlechter.
- Den Agenten Zeit geben: "Hör erst auf, wenn die Funktion gleich ist."
- Berichte immer nachmessen.
- Gelerntes knapp weitergeben, nicht ganze Protokolle.


=== Checkliste ===

- Prüfsumme der Original-EXE gesichert
- Compiler und Schalter gefunden, Emulator läuft
- Basis ergibt wieder die Original-EXE
- Richter, Pförtner und Ratsche laufen
- Erster Durchgang mit Ghidra und KI gemacht
- Kleine, mittlere und große Funktionen auf die passenden Wege verteilt
- Festgefahrene blind neu geschrieben, gemischt und übermalt
- Letzte Register-Dreher nachgerechnet
- Gesamtbau ergibt die Original-Prüfsumme
- Aufgeräumt, EXE weiter identisch
- Fehler gegengeprüft und hinter Schaltern
- Reparierte EXE geprüft und im Spiel getestet
- Bau-Paket und Patch ohne Original-Bytes veröffentlicht

Viel Spaß beim Nachkochen!

FREIE TOOLS von mir und den KI'-Modellen Claude Opus, Fable und Astra und Gemini
https://github.com/MeowMuhMuhCow/byte-ex...mp-toolkit
Zitieren


Nachrichten in diesem Thema
RE: Reverse Engineering der NLT III (mit KI) - von MiauKuh - Vor 9 Stunden
RE: Reverse Engineering der NLT II - von Wetzer - 05.11.2026, 19:41
RE: Reverse Engineering der NLT II - von Shihan - 05.11.2026, 15:00



Benutzer, die gerade dieses Thema anschauen: 4 Gast/Gäste