zig-pe

Reflektiver PE-Lader geschrieben in Zig. Lädt und führt native und .NET PE-Dateien direkt aus dem Speicher aus.

Funktionen

PE-Ladepipeline

• DOS- und NT-Header parsen (PE32 und PE32+ zur Laufzeit)
• Abschnitte in zugewiesenen Speicher abbilden
• Importe auflösen (Name und Ordinal, PE32 4-Byte / PE32+ 8-Byte Thunks)
• Basisrelokationen anwenden (HIGHLOW, DIR64, ARM_MOV32, THUMB_MOV32)
• Verzögerte Importe auflösen (DataDirectory[13], modernes RVA-Format)
• Ausnahmehandler registrieren (RtlAddFunctionTable, nur x64/ARM64)
• Speicherschutz pro Abschnitt setzen
• TLS-Callbacks aufrufen (DLL_PROCESS_ATTACH)
• Einstiegspunkt über CreateThread ausführen
• Bereinigung (Ausnahmetabellen abmelden, Speicher freigeben)

Erweiterte Sicherheitsfunktionen

• Sicherheits-Cookie-Initialisierung (__security_cookie für /GS-Puffersicherheit)
• CFG (Control Flow Guard) - Registriert gültige Aufrufziele über SetProcessValidCallTargets
• SxS / Aktivierungskontext - Aktiviert eingebettete Manifeste für GUI-Anwendungen
• Ungültigmachung des gebundenen Importverzeichnisses

Exporttabellenauflösung

Hilfsfunktionen zum Auflösen von Exporten aus einem geladenen PE-Image:

• getExportByName(base, ntheaders, name) — nach Name auflösen
• getExportByOrdinal(base, ntheaders, ordinal) — nach Ordinal auflösen

Behandelt weitergeleitete Exporte automatisch, indem die Ziel-DLL geladen wird (z.B. "NTDLL.RtlAllocateHeap" wird zur tatsächlichen Funktion in ntdll.dll aufgelöst).

API-Set-Auflösung

Löst automatisch Windows-API-Sets (api-ms-win-*, ext-ms-win-*) zu ihren tatsächlichen Host-DLLs auf, unter Verwendung der PEB ApiSetMap. Dies ermöglicht das Laden von PEs, die aus virtuellen API-Set-DLLs importieren.

Hilfsfunktionen

• utils.detect_platform(buffer) — Erkennt, ob PE 32-Bit oder 64-Bit ist
• utils.is_dotnet_assembly(ntheaders) — Überprüft, ob PE eine .NET-Assembly ist
• utils.getDotNetVersion(buffer) — Extrahiert die .NET-Laufzeitversionszeichenfolge aus Metadaten
• utils.rvaToFileOffset(buffer, rva) — Konvertiert RVA in rohen Dateioffset

Kompatibilität

• Ausführung nativ kompilierter Binärdateien (x86, x86_64, ARM, ARM64)
• Ausführung .NET-kompilierter Binärdateien über CLR-Hosting
• Übergabe von Befehlszeilenargumenten an native und .NET-Ausführungsdateien
• Architekturvalidierung (PE-Bitness muss mit dem Host-Prozess übereinstimmen)

Unterstützte Maschinentypen

Architektur	Maschinencode	Bitness
i386	0x014c	32-Bit
AMD64	0x8664	64-Bit
IA64	0x0200	64-Bit
ARM (ARMNT)	0x01C4	32-Bit
ARM64	0xAA64	64-Bit

Voraussetzungen

• Zig-Compiler (aktuelle Version empfohlen)
• Windows-Betriebssystem (das Projekt verwendet Windows-spezifische APIs)

Erstellen des Projekts

1. Klonen Sie das Repository:

   git clone https://github.com/Thoxy67/zig-pe.git
   cd zig-pe
   

2. Erstellen Sie das Projekt:

   zig build
   

Build-Optionen

zig build -Ddotnet=false  # .NET-Unterstützung deaktivieren (standardmäßig aktiviert)

Build-Ziele

zig build                 # Alle Ziele erstellen
zig build run-putty64     # 64-Bit natives PE-Beispiel ausführen
zig build run-putty32     # 32-Bit natives PE-Beispiel ausführen
zig build run-dotnet      # .NET-Assembly-Beispiel ausführen
zig build test            # Komponententests ausführen

Verwendung

Grundlegende Verwendung (Eingebettetes PE)

const pe = @import("pe");

pub fn main() !void {
    // Load and execute an embedded PE file
    try pe.RunPE.init(@embedFile("bin/app.exe")).run();
}

Mit Befehlszeilenargumenten

const pe = @import("pe");

pub fn main() !void {
    var loader = pe.RunPE.init(@embedFile("bin/app.exe"));
    try loader.runWithArgs(&.{ "arg1", "arg2", "arg3" });
}

Laden aus Datei

const std = @import("std");
const pe = @import("pe");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    const file_content = try std.fs.cwd().readFileAlloc(
        allocator,
        "path/to/executable.exe",
        std.math.maxInt(usize),
    );
    defer allocator.free(file_content);

    try pe.RunPE.init(file_content).run();
}

Auflösen von Exporten aus geladenem PE

const pe = @import("pe");

// After loading a DLL into memory...
const base: [*]const u8 = @ptrCast(loaded_base);
const ntheaders = // ... get NT headers

// Resolve by name
if (pe.getExportByName(base, ntheaders, "ExportedFunction")) |func_ptr| {
    const func: *const fn () void = @ptrCast(@alignCast(func_ptr));
    func();
}

// Resolve by ordinal
if (pe.getExportByOrdinal(base, ntheaders, 42)) |func_ptr| {
    // Use the function pointer
}

Wie die Argumentübergabe funktioniert

• Native PEs: Argumente werden durch Patchen der PEB-Befehlszeile übergeben, sodass GetCommandLineW() die bereitgestellten Argumente zurückgibt
• .NET-Assemblys: Argumente werden direkt an Main(string[] args) über CLR-Aufruf übergeben

Sicherheitshinweise

Dieses Projekt beinhaltet das Laden und Ausführen von beliebigem Code, was potenziell gefährlich sein kann. Verwenden Sie diesen Lader nur mit vertrauenswürdigen PE-Dateien und in kontrollierten Umgebungen. Die Autoren übernehmen keine Verantwortung für Missbrauch oder Schäden, die durch diese Software verursacht werden.

Mitwirken

Beiträge zu zig-pe sind willkommen! Zögern Sie nicht, Pull-Requests einzureichen, Issues zu erstellen oder die Nachricht zu verbreiten.

1. Forken Sie das Projekt
2. Erstellen Sie Ihren Feature-Branch (git checkout -b feature/AmazingFeature)
3. Committen Sie Ihre Änderungen (git commit -m 'Add some AmazingFeature')
4. Pushen Sie zum Branch (git push origin feature/AmazingFeature)
5. Öffnen Sie einen Pull-Request

Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert - siehe die Datei LICENSE für Details.

Danksagungen

• Die Community der Programmiersprache Zig
• Beitragende zur Dokumentation des PE-Dateiformats

Haftungsausschluss

Dieses Projekt dient nur zu Bildungszwecken. Stellen Sie sicher, dass Sie die notwendigen Rechte und Berechtigungen haben, bevor Sie eine PE-Datei laden und ausführen.