zig-pe

Caricatore PE riflessivo scritto in Zig. Carica ed esegue file PE nativi e .NET direttamente dalla memoria.

Caratteristiche

Pipeline di caricamento PE

• Analizza header DOS e NT (PE32 e PE32+ a runtime)
• Mappa le sezioni nella memoria allocata
• Risolve le importazioni (per nome e ordinale, thunk PE32 a 4 byte / PE32+ a 8 byte)
• Applica rilocazioni di base (HIGHLOW, DIR64, ARM_MOV32, THUMB_MOV32)
• Risolve importazioni ritardate (DataDirectory[13], formato RVA moderno)
• Registra gestori di eccezioni (RtlAddFunctionTable, solo x64/ARM64)
• Imposta protezioni di memoria per sezione
• Richiama callback TLS (DLL_PROCESS_ATTACH)
• Esegue il punto di ingresso tramite CreateThread
• Pulizia (deregistra tabelle eccezioni, libera memoria)

Funzionalità di sicurezza avanzate

• Inizializzazione del Security Cookie (__security_cookie per la sicurezza del buffer /GS)
• CFG (Control Flow Guard) — Registra target di chiamata validi tramite SetProcessValidCallTargets
• SxS / Activation Context — Attiva manifest incorporati per applicazioni GUI
• Invalida la directory delle importazioni associate (Bound Import Directory)

Risoluzione della tabella delle esportazioni

Funzioni di utilità per risolvere le esportazioni da un'immagine PE caricata:

• getExportByName(base, ntheaders, name) — risolve per nome
• getExportByOrdinal(base, ntheaders, ordinal) — risolve per ordinale

Gestisce automaticamente le esportazioni inoltrate caricando la DLL di destinazione (ad es., "NTDLL.RtlAllocateHeap" risolve la funzione effettiva in ntdll.dll).

Risoluzione degli API Set

Risolve automaticamente gli API Set di Windows (api-ms-win-*, ext-ms-win-*) nelle loro DLL host effettive utilizzando il PEB ApiSetMap. Ciò consente di caricare PE che importano da DLL virtuali di API Set.

Funzioni di utilità

• utils.detect_platform(buffer) — Rileva se il PE è a 32 o 64 bit
• utils.is_dotnet_assembly(ntheaders) — Verifica se il PE è un assembly .NET
• utils.getDotNetVersion(buffer) — Estrae la stringa della versione del runtime .NET dai metadati
• utils.rvaToFileOffset(buffer, rva) — Converte RVA in offset file raw

Compatibilità

• Esecuzione di binari nativi compilati (x86, x86_64, ARM, ARM64)
• Esecuzione di binari .NET compilati tramite hosting CLR
• Passaggio di argomenti da riga di comando sia a eseguibili nativi che .NET
• Validazione dell'architettura (il numero di bit del PE deve corrispondere a quello del processo host)

Tipi di macchina supportati

Architettura	Codice macchina	Bitness
i386	0x014c	32-bit
AMD64	0x8664	64-bit
IA64	0x0200	64-bit
ARM (ARMNT)	0x01C4	32-bit
ARM64	0xAA64	64-bit

Prerequisiti

• Compilatore Zig (ultima versione consigliata)
• Sistema operativo Windows (il progetto utilizza API specifiche di Windows)

Compilazione del progetto

1. Clona il repository:

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

2. Compila il progetto:

   zig build
   

Opzioni di build

zig build -Ddotnet=false  # Disabilita il supporto .NET (abilitato per impostazione predefinita)

Target di build

zig build                 # Compila tutti i target
zig build run-putty64     # Esegue l'esempio PE nativo a 64 bit
zig build run-putty32     # Esegue l'esempio PE nativo a 32 bit
zig build run-dotnet      # Esegue l'esempio assembly .NET
zig build test            # Esegue i test unitari

Utilizzo

Utilizzo base (PE incorporato)

const pe = @import("pe");

pub fn main() !void {
    // Carica ed esegue un file PE incorporato
    try pe.RunPE.init(@embedFile("bin/app.exe")).run();
}

Con argomenti da riga di comando

const pe = @import("pe");

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

Caricamento da file

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

Risoluzione delle esportazioni da un PE caricato

const pe = @import("pe");

// Dopo aver caricato una DLL in memoria...
const base: [*]const u8 = @ptrCast(loaded_base);
const ntheaders = // ... ottieni gli header NT

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

// Risolvi per ordinale
if (pe.getExportByOrdinal(base, ntheaders, 42)) |func_ptr| {
    // Usa il puntatore a funzione
}

Come funziona il passaggio degli argomenti

• PE nativi: Gli argomenti vengono passati modificando il PEB CommandLine, in modo che GetCommandLineW() restituisca gli argomenti forniti
• Assembly .NET: Gli argomenti vengono passati direttamente a Main(string[] args) tramite chiamata CLR

Considerazioni sulla sicurezza

Questo progetto prevede il caricamento e l'esecuzione di codice arbitrario, che può essere potenzialmente pericoloso. Utilizza questo caricatore solo con file PE attendibili e in ambienti controllati. Gli autori non sono responsabili per eventuali usi impropri o danni causati da questo software.

Contributi

I contributi a zig-pe sono benvenuti! Sentiti libero di inviare pull request, aprire issue o diffondere la notizia.

1. Fai un fork del Progetto
2. Crea il tuo Branch per la Funzionalità (git checkout -b feature/AmazingFeature)
3. Esegui il commit delle tue Modifiche (git commit -m 'Aggiungi una funzionalità straordinaria')
4. Invia al Branch (git push origin feature/AmazingFeature)
5. Apri una Pull Request

Licenza

Questo progetto è concesso in licenza con la licenza MIT - vedi il file LICENSE per i dettagli.

Riconoscimenti

• La comunità del linguaggio di programmazione Zig
• Contributori alla documentazione del formato file PE

Disclaimer

Questo progetto ha solo scopo educativo. Assicurati di avere i diritti e le autorizzazioni necessari prima di caricare ed eseguire qualsiasi file PE.