Eine Werkbank fürs Reverse Engineering — und ein lokales Modell, das die eingebaute Funktion selbst schreibt
09.11.2026. Letzte Woche habe ich einem fertigen Windows-Programm von Hand eine eigene Funktion eingebaut (dazu der vorige Artikel). Diese Woche steckt derselbe Weg in einer einzigen Weboberfläche — und den heiklen Teil, die C-Funktion, tippt nicht mehr ich, sondern ein lokales Sprachmodell auf der Heim-GPU. Hier der komplette Durchlauf an einem echten Open-Source-Programm, inklusive der zwei Fehler, die mir das Modell dabei erst sichtbar gemacht hat.
Rahmen. Alles passiert an eigener oder quelloffener Software in einem isolierten Heimlabor, zum Lernen. Das Zielprogramm unten ist BSD-lizenziert. Nichts wird verteilt, nichts nachsigniert — jede Code-Signatur wird durch eine Änderung ungültig, das ist der ehrliche Normalfall. Die eingefügte Funktion ist harmlos und sichtbar (eine Marker-Datei und ein Hinweisfenster), kein verstecktes Verhalten, kein Netz, keine Persistenz. Wer Fremdsoftware so verändert, bleibt nur im legalen Rahmen, wenn Lizenz oder Eigentum es erlauben.
Von drei Werkzeugen zu einer Werkbank
Beim letzten Mal war Reverse Engineering im Heimlabor noch ein Flickenteppich aus Befehlen: eine Datei hochladen, sie mit einer Tool-Kette dekompilieren, dann in einem Werkzeug-Container Code kompilieren und injizieren. Das wollte ich in einer bedienbaren, handytauglichen Oberfläche haben. Herausgekommen ist RE-Studio — lokal gehostet, hinter SSO, mit drei Reitern:
- Upload — Binärdateien (und Archive) in den Arbeitsordner legen.
- Dekompilieren — die Hauptfunktionen eines Programms als lesbaren Pseudocode holen.
- PE-Werkstatt — eine neue Funktion vom lokalen Modell schreiben lassen, mit MinGW
kompilieren und in die
.exeinjizieren.
Kein Clouddienst ist beteiligt: Das Modell läuft über einen eigenen Router auf der Gaming-GPU im Keller, die Analyse macht ein Ghidra/REA-Container, und die Oberfläche ist schlichtes, serverseitiges Python. Für diesen Durchlauf habe ich die ganze Oberfläche mit Playwright ferngesteuert und bei jedem Schritt einen Screenshot gezogen — die seht ihr hier.
Das Versuchsobjekt: ein echtes Windows-UI-Programm
Als Ziel wollte ich kein Spielzeug, sondern ein reales Programm. Die Wahl fiel auf
matepath.exe, den Datei-Browser-Begleiter aus der quelloffenen Notepad4-Suite (BSD-Lizenz),
x64, rund 285 KB — ein ganz normales Windows-UI-Programm, aus dem offiziellen GitHub-Release geladen.

Schritt 1 + 2: Hochladen und dekompilieren
Der Upload ist unspektakulär — Datei reinziehen, fertig. Interessanter ist das Dekompilieren.
RE-Studio schickt ein tool-fähiges Modell durch eine kurze, feste Kette: Programm öffnen → die
Startfunktion suchen → ihren Pseudocode holen → der echten main folgen. Das Ergebnis ist kein
Maschinencode-Kauderwelsch, sondern lesbares C:

Man erkennt sauber den Einsprung (entry), die typische MSVC-Startup-Initialisierung
(GetSystemTimeAsFileTime, GetCurrentProcessId, QueryPerformanceCounter — das Security-Cookie)
und den Control-Flow-Guard. Drei Prozeduren, dann Schluss: Die Kette bricht von selbst ab, sobald
das Modell anfängt, dieselbe Funktion ein zweites Mal anzufordern. Das klingt banal, war aber eine
echte Reparatur — dazu gleich mehr.
Schritt 3: Das Modell schreibt die Funktion
Jetzt der eigentliche Clou. In der PE-Werkstatt beschreibe ich in Alltagssprache, was die neue Funktion tun soll:
„Schreibe beim Programmstart eine kleine Marker-Datei nach
C:\Samples\matepath-addfn.txtund zeige danach eine sichtbare MessageBox, die bestätigt, dass diese Funktion nachträglich per RE-Studio eingefügt wurde."
Das lokale Modell (qwen2.5-coder:14b) schreibt daraufhin eine vollständige C-Funktion — und zwar
nicht irgendeine, sondern eine, die exakt zu den Schnittstellen passt, die genau dieses Programm
anbietet:

void addfn(CreateFileW_t CreateFileW, WriteFile_t WriteFile,
CloseHandle_t CloseHandle, MessageBoxExW_t MessageBoxExW) {
const void *filePath = L"C:\\Samples\\matepath-addfn.txt";
const void *message = L"matepath-mod: Diese Funktion wurde nachtraeglich per RE-Studio eingefuegt.";
const void *title = L"matepath-mod";
void *h = CreateFileW(filePath, 0x40000000, 0, 0, 2, 0x80, 0);
if (h != (void *)-1) {
unsigned written;
WriteFile(h, message, 68, &written, 0);
CloseHandle(h);
}
MessageBoxExW(0, message, title, 0, 0);
}
Die Funktion bekommt ihre Windows-API-Zeiger als Parameter (dazu unten mehr) und benutzt sie wie
echten Code. Wichtig: Es gibt einen Review-Schritt. Das Modell schlägt vor, ich lese nach — und
erst dann geht es weiter. Ein Klick auf Kompilieren & injizieren ruft MinGW, hängt die Funktion
als neuen Abschnitt .readd an und biegt den Entry-Point auf einen kleinen Einsprung-Stub um, der
die Funktion aufruft und dann ins Original springt.

Heraus kommt matepath-mod.exe: ein neuer Code-Abschnitt, der umgebogene Entry-Point, dazu das
fertige Testkommando für die isolierte Windows-VM.
Die eigentliche Geschichte: was unterwegs kaputt war
Ein Demo-Video wäre jetzt zu Ende. Spannend wird es aber erst dort, wo das echte Programm meine Werkzeuge an die Wand gefahren hat.
1. Der feste API-Kontrakt scheitert an echten Programmen. Mein erster Entwurf band die injizierte
Funktion fest an CreateFileA + MessageBoxA — die ASCII-Varianten. Das funktioniert an PuTTY. An
matepath.exe nicht: Reale Windows-UI-Programme sind Unicode und importieren CreateFileW,
MessageBoxExW — und oft gar kein MessageBoxA. Die Lösung war, den Kontrakt zu verallgemeinern:
RE-Studio liest jetzt die Import-Tabelle, wählt aus einem kuratierten, bewusst harmlosen API-Katalog
(Datei anlegen/schreiben/schließen, ein sichtbares/hörbares Signal) automatisch eine sinnvolle Kombi
aus und baut die passenden C-typedefs, die Funktionssignatur und den Prompt dynamisch — inklusive
Hinweis, dass die W-Funktionen Wide-Strings (L"...") brauchen. Deshalb hat das Modell oben ganz von
selbst CreateFileW und MessageBoxExW mit L"..." benutzt.
2. Ein winziges Testprogramm deckte zwei echte Bugs auf. Bevor matepath überhaupt dran war, habe
ich an einem selbst mit MinGW gebauten hello.exe getestet — und prompt zwei Fehler gefunden, die an
PuTTY nie aufgefallen wären:
- Die Platzprüfung im Header nahm das Minimum über alle Abschnitte. MinGW-Programme haben aber
.bss- und Debug-Abschnitte ohne Rohdaten (Dateioffset 0) — die zogen das Minimum auf 0 und ließen die Injektion fälschlich mit „kein Platz" abbrechen, obwohl reichlich Platz war. Fix: nur Abschnitte mit echten Rohdaten zählen. - Der PE-Chirurg meldet Grenzfälle über einen Mechanismus, den der Webserver nicht abfing — der Bearbeitungs-Thread starb daraufhin ohne Antwort (die Verbindung brach einfach ab). Fix: sauber abfangen und als lesbaren Fehler zurückgeben.
3. Das Modell drehte Leerrunden. Beim Dekompilieren fragte es nach dem ersten Treffer immer wieder dieselbe Funktion an — bis zur Rundenobergrenze. Jetzt bricht die Kette deterministisch ab, sobald eine schon dekompilierte Funktion erneut angefragt wird. Aus zwölf Runden wurden vier.
Keiner dieser drei Punkte stand in einer Spezifikation. Sie sind aufgetaucht, weil ich das Ganze an echtem Material ausprobiert habe — und genau das ist der Grund, warum solche Durchläufe sich lohnen.
Der sichtbare Beweis
Reden ist billig — also habe ich matepath-mod.exe in der isolierten Windows-VM gestartet. Und da
ist sie: die vom lokalen Modell geschriebene, nachträglich eingefügte Funktion läuft beim Start und
zeigt ihr Fenster, bevor das eigentliche Programm hochkommt.

Parallel liegt die Marker-Datei C:\Samples\matepath-addfn.txt auf der Platte — mit genau dem
(Unicode-)Text, den die Funktion hineinschreibt. Damit ist die ganze Kette belegt: dekompiliert,
Funktion vom Modell geschrieben, kompiliert, injiziert und sichtbar ausgeführt.
Ehrlichkeit zum Schluss
Ein paar Dinge gehören trotzdem gesagt. Die VM ist bewusst abgeschottet (kein Netz, Wegwerf- Snapshot), die injizierte Funktion ist harmlos und sichtbar, nichts wird verteilt, und die Signatur der Datei ist nun ungültig — das ist der ehrliche Normalfall, kein Trick dagegen. Und eine gelungene Demonstration an einem Programm ist kein Robustheitsnachweis: n=1 bleibt n=1. Dass es hier an einem echten, fremden (wenn auch quelloffenen) Unicode-Programm auf Anhieb lief, ist ein gutes Zeichen — mehr aber auch nicht. Der Reiz bleibt, wie weit man mit einem lokalen Modell und etwas Klebstoff kommt, ganz ohne Cloud.
Und das Wichtigste bleibt der Rahmen von oben: offene oder eigene Software, isoliertes Labor, harmlose und sichtbare Funktion, nichts wird verteilt. So ist das ein Lernwerkzeug — und ein ziemlich schönes Beispiel dafür, wie weit man mit einem lokalen Modell und etwas Klebstoff kommt, ganz ohne Cloud.