← zur Übersicht

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:

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.

RE-Studio nach dem Upload: mobile Oberfläche mit den drei Reitern und der Dateiliste

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:

Dekompilat von matepath.exe: entry, die Startup-Initialisierung und _guard_dispatch_icall

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.txt und 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:

Die vom lokalen Modell geschriebene C-Funktion im Review-Feld, vor dem Injizieren

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.

Ergebnis: matepath-mod.exe mit neuem Abschnitt, Entry-Point-RVA und OEP

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:

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.

Die injizierte MessageBox auf dem Desktop der isolierten win-re-VM

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.

← zur Übersicht