zig-pe

Carregador de PE reflexivo escrito em Zig. Carrega e executa arquivos PE nativos e .NET diretamente da memória.

Funcionalidades

Pipeline de Carregamento de PE

• Analisar cabeçalhos DOS e NT (PE32 e PE32+ em tempo de execução)
• Mapear seções na memória alocada
• Resolver importações (por nome e ordinal, thunks de 4 bytes PE32 / 8 bytes PE32+)
• Aplicar realocações de base (HIGHLOW, DIR64, ARM_MOV32, THUMB_MOV32)
• Resolver importações atrasadas (DataDirectory[13], formato RVA moderno)
• Registrar manipuladores de exceção (RtlAddFunctionTable, apenas x64/ARM64)
• Definir proteções de memória por seção
• Invocar callbacks TLS (DLL_PROCESS_ATTACH)
• Executar ponto de entrada via CreateThread
• Limpeza (desregistrar tabelas de exceção, liberar memória)

Recursos Avançados de Segurança

• Inicialização de Security Cookie (__security_cookie para segurança de buffer /GS)
• CFG (Control Flow Guard) - Registra alvos de chamada válidos via SetProcessValidCallTargets
• SxS / Contexto de Ativação - Ativa manifestos incorporados para aplicações GUI
• Invalidação do Diretório de Importação Limitada

Resolução da Tabela de Exportação

Funções utilitárias para resolver exportações de uma imagem PE carregada:

• getExportByName(base, ntheaders, name) — resolver por nome
• getExportByOrdinal(base, ntheaders, ordinal) — resolver por ordinal

Lida automaticamente com exportações encaminhadas carregando a DLL alvo (ex.: "NTDLL.RtlAllocateHeap" resolve para a função real em ntdll.dll).

Resolução de API Set

Resolve automaticamente conjuntos de API do Windows (api-ms-win-*, ext-ms-win-*) para suas DLLs host reais usando o PEB ApiSetMap. Isso permite carregar PEs que importam de DLLs virtuais de conjuntos de API.

Funções Utilitárias

• utils.detect_platform(buffer) — Detectar se PE é 32 ou 64 bits
• utils.is_dotnet_assembly(ntheaders) — Verificar se PE é um assembly .NET
• utils.getDotNetVersion(buffer) — Extrair string de versão do runtime .NET dos metadados
• utils.rvaToFileOffset(buffer, rva) — Converter RVA para offset de arquivo bruto

Compatibilidade

• Execução de binário nativo compilado (x86, x86_64, ARM, ARM64)
• Execução de binário .NET compilado via hospedagem CLR
• Passagem de argumentos de linha de comando para executáveis nativos e .NET
• Validação de arquitetura (bitness do PE deve corresponder ao processo host)

Tipos de Máquina Suportados

Arquitetura	Código da Máquina	Bits
i386	0x014c	32-bit
AMD64	0x8664	64-bit
IA64	0x0200	64-bit
ARM (ARMNT)	0x01C4	32-bit
ARM64	0xAA64	64-bit

Pré-requisitos

• Compilador Zig (versão mais recente recomendada)
• Sistema Operacional Windows (o projeto usa APIs específicas do Windows)

Compilando o Projeto

1. Clone o repositório:

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

2. Compile o projeto:

   zig build
   

Opções de Compilação

zig build -Ddotnet=false  # Disable .NET support (enabled by default)

Alvos de Compilação

zig build                 # Build all targets
zig build run-putty64     # Run 64-bit native PE example
zig build run-putty32     # Run 32-bit native PE example
zig build run-dotnet      # Run .NET assembly example
zig build test            # Run unit tests

Uso

Uso Básico (PE Incorporado)

const pe = @import("pe");

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

Com Argumentos de Linha de Comando

const pe = @import("pe");

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

Carregando de Arquivo

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

Resolvendo Exportações de PE Carregado

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
}

Como Funciona a Passagem de Argumentos

• PEs Nativos: Os argumentos são passados através de patch no PEB CommandLine, para que GetCommandLineW() retorne os argumentos fornecidos
• Assemblies .NET: Os argumentos são passados diretamente para Main(string[] args) via invocação do CLR

Considerações de Segurança

Este projeto envolve carregar e executar código arbitrário, o que pode ser potencialmente perigoso. Use este carregador apenas com arquivos PE confiáveis e em ambientes controlados. Os autores não são responsáveis por qualquer uso indevido ou dano causado por este software.

Contribuindo

Contribuições para zig-pe são bem-vindas! Sinta-se à vontade para enviar pull requests, criar issues ou divulgar.

1. Faça um Fork do Projeto
2. Crie sua Branch de Funcionalidade (git checkout -b feature/AmazingFeature)
3. Faça Commit das suas Alterações (git commit -m 'Add some AmazingFeature')
4. Faça Push para a Branch (git push origin feature/AmazingFeature)
5. Abra um Pull Request

Licença

Este projeto está licenciado sob a Licença MIT - consulte o arquivo LICENSE para detalhes.

Agradecimentos

• A comunidade da linguagem de programação Zig
• Contribuidores para a documentação do formato de arquivo PE

Aviso Legal

Este projeto é apenas para fins educacionais. Certifique-se de ter os direitos e permissões necessários antes de carregar e executar qualquer arquivo PE.