Eine eigene Funktion in ein fertiges Windows-Programm einbauen
08.11.2026. Reverse Engineering im Heimlabor: von „den Dekompilat neu kompilieren" (geht
nicht) über einen Byte-Patch bis zu echtem, selbst kompiliertem Code, der in einer fremden
.exe beim Start läuft. Mit den zwei Fallen, die Stunden gekostet hätten, wenn man sie nicht
kennt.
Rahmen. Alles hier passiert an PuTTY (MIT-Open-Source von Simon Tatham) in einer isolierten Wegwerf-VM, zum Lernen, nichts wird verteilt und nichts nachsigniert. Jede Code-Signatur wird durch eine Änderung ungültig — das ist der ehrliche Normalfall, kein Trick dagegen. Wer Fremdsoftware so verändert, bewegt sich nur im legalen Rahmen, wenn Lizenz oder Eigentum es erlauben.
Der Irrtum vorweg
Der naheliegende Wunsch lautet: „Nimm das dekompilierte Programm, ändere es und kompiliere es
wieder." Das klingt logisch, geht aber für ein reales Programm wie PuTTY nicht. Was Ghidra
(bzw. REA) ausgibt, ist C-Pseudocode zum Lesen: FUN_140001000, undefined8, erfundene
Typen, keine Header, kein Build-System. Ein Compiler nimmt das nicht an. Das ist keine
Bequemlichkeit, sondern grundsätzlich so.
Die reale Technik, die „fertiges Programm ändern" tatsächlich leistet, heißt Binär-Patching bzw. Code-Injektion: man findet im Dekompilat die Stelle, ändert die Bytes direkt in der Binärdatei oder fügt neuen Maschinencode hinzu und verdrahtet ihn. Genau diesen Weg gehen wir — in zwei Stufen.
Das Labor
Grundlage ist eine isolierte Windows-10-VM (win-re auf dem zweiten Knoten). Sie entstand als
Kopie einer alten Windows-VM, abgespeckt und in ein eigenes Netz ohne Uplink gehängt: kein
LAN, kein Internet. Ein Snapshot sauber ist der Nullpunkt — nach jeder Analyse ein
qm rollback und die Maschine ist wieder jungfräulich. Werkzeuge (x64dbg, Sysinternals,
frida-server) liegen bereit; der Windows-Defender ist in der abgeschotteten Kiste bewusst aus.
Gesteuert wird sie kopflos über den QEMU-Guest-Agent.
Die statische Analyse macht REA („Reverse Engineer Anything") in einem Container auf dem Docker-Host: er startet Ghidra headless und liefert Dekompilat, Strings, Querverweise und — für das Patchen entscheidend — die Umrechnung von Adressen in Datei-Offsets.
Stufe 1: Ein Byte-Patch (zum Warmwerden)
REA fand den Versionstext „Release 0.85" an Adresse 0x1400fa4a8 (Datei-Offset 1019048),
benutzt vom About-Dialog. Ein Patch gleicher Länge — „Release 0.85" → „Patched 0.85" (beide 12
Zeichen, NUL-Abschluss bleibt) — und fertig ist eine veränderte putty-mod.exe. REA liest im
neuen Exe den geänderten Text an genau diesem Offset, das PE parst weiter, das Programm läuft.
Die Regel beim Byte-Patch: nie länger als das Original, sonst verschiebt sich alles dahinter.
Das ist ehrlich gesagt kein „Kompilieren", nur ein Hex-Edit. Für echten neuen Code braucht es Stufe 2.
Stufe 2: Eine echte Funktion einbauen
Ziel: eine selbst in C geschriebene, mit mingw-w64 kompilierte Funktion so in putty.exe
einfügen, dass sie beim Start läuft. Der Plan:
- Funktion in C, die ihre API-Zeiger als Parameter bekommt (dann muss man die Importtabelle
nicht anfassen). Sie legt eine Marker-Datei an (
CreateFileA) und zeigt eine harmlose, selbst-erklärendeMessageBox. - Kompilieren und flach an eine feste Adresse linken, sodass die internen Verweise (die Strings) schon stimmen.
- Einen neuen PE-Abschnitt
.readdanhängen, dort die Funktion plus einen handkodierten Einsprung-Stub ablegen. Der Stub lädt die API-Zeiger aus der Importtabelle, ruft die Funktion und springt dann zum ursprünglichen Entry Point — PuTTY läuft danach normal weiter. - Den Entry Point der Exe auf den Stub umbiegen.
Die PE-Operation (Zertifikat abschneiden, Abschnitt anhängen, Header korrigieren) macht ein
kleines Python-Skript mit pefile. Statisch sah danach alles sauber aus: 11 Abschnitte, der
Entry zeigt in .readd, MessageBoxA weiter importiert, gültiges PE32+.
Falle 1: Der erste Lauf stürzt ab — ASLR
Erster Test in der VM: Absturz, Ausnahme 0xc0000005 (Speicherzugriffsfehler), und zwar
genau am ursprünglichen Entry Point 0x1400bfb24. Die Ursache steht zwischen den Zeilen der
Fehlermeldung: „Faulting module name: unknown". Das Programm liegt zur Laufzeit gar nicht an der
Adresse 0x140000000, die in der Datei steht — ASLR verschiebt es bei jedem Start an eine
zufällige Basis.
Mein Stub sprang per absoluter Adresse (movabs rax, 0x1400bfb24; jmp rax) zum Entry Point
der nicht-verschobenen Basis → ins Leere. Die RIP-relativen Teile (der Zugriff auf die
Importtabelle, die Strings) waren dagegen schon korrekt, weil sie relativ rechnen.
Lehre: In eingefügtem Code muss alles RIP-relativ sein — auch der Sprung zum Entry Point
(E9 rel32 statt absolut). Der relative Abstand zweier Punkte im selben Image ist
basis-unabhängig. Angenehmer Nebeneffekt: Dann enthält der neue Code nichts Absolutes und
braucht keine Relocation-Einträge.
Falle 2: Die Funktion läuft — aber man sieht sie nicht
Nach dem Fix: Der zweite Lauf legte die Marker-Datei an (die Funktion lief also), und der
Prozess lief danach normal als PuTTY weiter. Nur die MessageBox war nicht zu sehen. Grund ist
die Session-0-Isolation von Windows: Startet man ein Programm über den Guest-Agent, läuft es
als SYSTEM in einer Sitzung ohne sichtbaren Desktop; eine MessageBox wird dort nicht angezeigt
und kehrt einfach zurück. Kein Fehler im Code.
Der Nachweis, dass neuer Code wirklich lief, führt deshalb über etwas Desktop-Unabhängiges — eine Datei, die die Funktion anlegt. Für ein sichtbares Bild braucht es eine echte interaktive Sitzung: ein eigenes Labor-Konto mit automatischer Anmeldung, und die Exe über eine geplante Aufgabe in dieser Sitzung gestartet (nicht über den SYSTEM-Pfad). Eine Nebenhürde dabei: Beim allerersten Login hält Windows auf der OOBE-Datenschutzseite an und wartet auf einen Klick — per Richtlinie abschaltbar.
Der Beweis

Die MessageBox der nachträglich eingebauten Funktion, sichtbar auf dem Desktop — unten in der Taskleiste läuft der PuTTY-Prozess bereits weiter. Der vollständige Weg ist damit lückenlos: C-Funktion geschrieben → kompiliert → als neuer Abschnitt eingefügt → Entry Point umgebogen → läuft beim Start → und PuTTY arbeitet danach normal weiter.
Was man mitnimmt
- „Dekompilat neu kompilieren" ist ein Mythos; der echte Hebel ist Patchen/Injizieren.
- Alles RIP-relativ halten — sonst killt ASLR den eingefügten Code am ersten Sprung.
- Session-0: Ausführung über eine Datei beweisen; Sichtbares braucht eine interaktive Sitzung.
- Die Signatur ist danach ungültig. Das gehört dazu und wird nicht kaschiert.
- n=1 ist eine Demonstration, keine Garantie. Der Lauf beweist, dass der Weg funktioniert — nicht, dass jede beliebige Funktion in jedes beliebige Programm genauso glatt passt.
Die Schritte sind als wiederverwendbare Rezeptur abgelegt (compose/ghidra/win-re/addfn/) und
als Skill programm-modifizieren — damit die beiden Fallen beim nächsten Mal nicht noch einmal
Zeit kosten. Weiter geht es, wenn ein konkretes (eigenes oder offenes) Programm und eine konkrete
Funktion anstehen.