zig-pe

Chargeur PE réflexif écrit en Zig. Charge et exécute des fichiers PE natifs et .NET directement depuis la mémoire.

Fonctionnalités

Pipeline de chargement PE

• Analyse des en-têtes DOS et NT (PE32 et PE32+ à l'exécution)
• Mappage des sections dans la mémoire allouée
• Résolution des importations (par nom et ordinal, thunks PE32 4 octets / PE32+ 8 octets)
• Application des relocalisations de base (HIGHLOW, DIR64, ARM_MOV32, THUMB_MOV32)
• Résolution des importations différées (DataDirectory[13], format RVA moderne)
• Enregistrement des gestionnaires d'exceptions (RtlAddFunctionTable, x64/ARM64 uniquement)
• Définition des protections mémoire par section
• Invocation des callbacks TLS (DLL_PROCESS_ATTACH)
• Exécution du point d'entrée via CreateThread
• Nettoyage (désenregistrement des tables d'exceptions, libération de la mémoire)

Fonctionnalités de sécurité avancées

• Initialisation du cookie de sécurité (__security_cookie pour la sécurité de la mémoire tampon /GS)
• CFG (Control Flow Guard) – Enregistre les cibles d'appel valides via SetProcessValidCallTargets
• SxS / Contexte d'activation – Active les manifestes intégrés pour les applications GUI
• Invalidation du répertoire d'importations liées

Résolution de la table d'exportations

Fonctions utilitaires pour résoudre les exportations d'une image PE chargée :

• getExportByName(base, ntheaders, name) — résolution par nom
• getExportByOrdinal(base, ntheaders, ordinal) — résolution par ordinal

Gère automatiquement les exportations redirigées en chargeant la DLL cible (par exemple, "NTDLL.RtlAllocateHeap" se résout en la fonction réelle dans ntdll.dll).

Résolution des ensembles d'API

Résout automatiquement les ensembles d'API Windows (api-ms-win-*, ext-ms-win-*) vers leurs DLL hôtes réelles en utilisant le ApiSetMap du PEB. Cela permet de charger des PE qui importent depuis des DLL d'API virtuelles.

Fonctions utilitaires

• utils.detect_platform(buffer) — Détecte si le PE est 32 ou 64 bits
• utils.is_dotnet_assembly(ntheaders) — Vérifie si le PE est un assembly .NET
• utils.getDotNetVersion(buffer) — Extrait la chaîne de version du runtime .NET depuis les métadonnées
• utils.rvaToFileOffset(buffer, rva) — Convertit une RVA en décalage fichier brut

Compatibilité

• Exécution de binaires natifs compilés (x86, x86_64, ARM, ARM64)
• Exécution de binaires .NET compilés via hébergement CLR
• Passage d'arguments en ligne de commande aux exécutables natifs et .NET
• Validation de l'architecture (le bitness du PE doit correspondre au processus hôte)

Types de machines pris en charge

Prérequis

• Compilateur Zig (dernière version recommandée)
• Système d'exploitation Windows (le projet utilise des API spécifiques à Windows)

Construction du projet

1. Clonez le dépôt :

   root@kitploit:~

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

2. Construisez le projet :

   root@kitploit:~

   zig build
   

Options de construction

zig build -Ddotnet=false  # Désactiver le support .NET (activé par défaut)

Cibles de construction

zig build                 # Construire toutes les cibles
zig build run-putty64     # Exécuter l'exemple PE natif 64 bits
zig build run-putty32     # Exécuter l'exemple PE natif 32 bits
zig build run-dotnet      # Exécuter l'exemple d'assembly .NET
zig build test            # Exécuter les tests unitaires

Utilisation

Utilisation de base (PE intégré)

const pe = @import("pe");

pub fn main() !void {
    // Charger et exécuter un fichier PE intégré
    try pe.RunPE.init(@embedFile("bin/app.exe")).run();
}

Avec arguments en ligne de commande

const pe = @import("pe");

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

Chargement depuis un fichier

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();
}

Résolution des exportations d'un PE chargé

const pe = @import("pe");

// Après avoir chargé une DLL en mémoire...
const base: [*]const u8 = @ptrCast(loaded_base);
const ntheaders = // ... obtenir les en-têtes NT

// Résolution par nom
if (pe.getExportByName(base, ntheaders, "ExportedFunction")) |func_ptr| {
    const func: *const fn () void = @ptrCast(@alignCast(func_ptr));
    func();
}

// Résolution par ordinal
if (pe.getExportByOrdinal(base, ntheaders, 42)) |func_ptr| {
    // Utiliser le pointeur de fonction
}

Fonctionnement du passage d'arguments

• PE natifs : Les arguments sont passés en modifiant le PEB CommandLine, de sorte que GetCommandLineW() retourne les arguments fournis
• Assemblies .NET : Les arguments sont passés directement à Main(string[] args) via l'invocation CLR

Considérations de sécurité

Ce projet implique le chargement et l'exécution de code arbitraire, ce qui peut être potentiellement dangereux. N'utilisez ce chargeur qu'avec des fichiers PE de confiance et dans des environnements contrôlés. Les auteurs ne sont pas responsables de toute utilisation abusive ou des dommages causés par ce logiciel.

Contribution

Les contributions à zig-pe sont les bienvenues ! N'hésitez pas à soumettre des pull requests, à créer des issues ou à faire passer le mot.

1. Forkez le projet
2. Créez votre branche de fonctionnalité (git checkout -b feature/AmazingFeature)
3. Commitez vos modifications (git commit -m 'Ajout d'une fonctionnalité incroyable')
4. Poussez vers la branche (git push origin feature/AmazingFeature)
5. Ouvrez une pull request

Licence

Ce projet est sous licence MIT – voir le fichier LICENSE pour plus de détails.

Remerciements

• La communauté du langage de programmation Zig
• Les contributeurs à la documentation du format de fichier PE

Avertissement

Ce projet est uniquement à des fins éducatives. Assurez-vous de disposer des droits et autorisations nécessaires avant de charger et d'exécuter un fichier PE.