Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
zig-pe — Reflektierender PE-Lader, geschrieben in Zig. Lädt native und .NET PE-Dateien direkt aus dem Speicher und führt sie aus. | Kitploit
Tools/GitHubGitHub/thoxy67/zig-pe
ExploitationPost-ExploitationPenetrationstestsRed TeamingPayload-EntwicklungBinary-Exploitation
GitHubthoxy67/zig-pe

zig-pe

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

Repository anzeigen
6775vor 6 MonatenVon Kitploit geprüft

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

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

    ArchitekturMaschinencodeBitness
    i3860x014c32-Bit
    AMD640x866464-Bit
    IA640x020064-Bit
    ARM (ARMNT)0x01C432-Bit
    ARM640xAA6464-Bit

    Voraussetzungen

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

    Erstellen des Projekts

    1. Klonen Sie das Repository:

      root@kitploit:~
      git clone https://github.com/Thoxy67/zig-pe.git
      cd zig-pe
      
    2. Erstellen Sie das Projekt:

      root@kitploit:~
      zig build
      

    Build-Optionen

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

    Build-Ziele

    root@kitploit:~
    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)

    root@kitploit:~
    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

    root@kitploit:~
    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

    root@kitploit:~
    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

    root@kitploit:~
    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.

    Tool herunterladen