Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
Ferramentas/GitHubGitHub/iss4cf0ng/ironpe
Forensia de MemóriaExploraçãoEngenharia ReversaShellcodeAnálise de BináriosAprendizado e EducaçãoDesenvolvimento de PayloadsExploração de Binários
GitHubiss4cf0ng/ironpe

IronPE

Carregador manual de PE do Windows baseado em Rust que mapeia e executa executáveis x86/x64 da memória, demonstrando o comportamento interno do carregador e a estrutura PE para pesquisa educacional.

Ver Repositório
124194há 6 mesesRevisado pelo Kitploit

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar
Site

IronPE - Carregador manual de PE do Windows mínimo escrito em Rust.

Implementação de Carregador de PE em Rust / Mapeamento Manual

status language license Release

IronPE é um carregador manual de PE do Windows mínimo escrito em Rust para arquivos PE x86 e x64.

Este projeto é uma reimplementação em Rust do meu projeto anterior dotNetPELoader, que implementava um carregador manual de PE em C#.

O objetivo do IronPE é explorar como o Windows carrega Executáveis Portáteis internamente e demonstrar como esse processo pode ser implementado em Rust.


Waaaahhhhhhh!

Se você achar este projeto útil ou informativo, uma ⭐ seria apreciada!

Aviso Legal

Este projeto é destinado apenas para fins educacionais e de pesquisa.

Ele foi projetado para ajudar a entender:

  • Internos do PE do Windows
  • Técnicas de carregamento manual
  • Conceitos de engenharia reversa

Funcionalidades

  • Carregamento manual de PE
  • Mapeamento de seções
  • Realocações de base
  • Resolução de importações
  • Executar PE a partir da memória
  • Suporte a PE x86 e x64

Contexto

Este projeto foi inspirado pela minha implementação anterior:

  • dotNetPELoader (C#)

Naquele projeto, implementei um carregador de PE usando .NET e WinAPI.
O IronPE reescreve o mesmo conceito em Rust, que oferece melhor segurança de memória enquanto ainda permite acesso de baixo nível à API do Windows.

O propósito deste projeto é educacional, para entender melhor:

  • Estrutura do arquivo PE
  • Comportamento do carregador do Windows
  • Técnicas de mapeamento manual de PE

Como Funciona

O IronPE executa os seguintes passos para executar um arquivo PE a partir da memória:

  1. Ler o arquivo PE na memória
  2. Analisar os cabeçalhos PE
  3. Alocar memória usando VirtualAlloc
  4. Copiar cabeçalhos e seções do PE
  5. Aplicar realocações de base
  6. Resolver importações usando LoadLibrary e GetProcAddress
  7. Transferir a execução para o Ponto de Entrada Original (OEP)

Este processo imita o comportamento do carregador de PE do Windows.

Um PE x64 não pode ser carregado por um carregador x86, e vice-versa.

Compilar

Requisitos:

  • Rust (cargo, rustc)
  • Windows

Compilar o projeto:

root@kitploit:~
cd IronPE
build.bat

Uso

root@kitploit:~
IronPE.exe --coffee
IronPE.exe --x86 <x86_pe_file>
IronPE.exe --x64 <x64_pe_file>

Exemplo:

root@kitploit:~
IronPE.exe --x86 Win32\mimikatz.exe
IronPE.exe --x64 x64\mimikatz.exe

Demonstração (Executando mimikatz)

x86


x64


Arquitetura do Carregador e PE Incompatíveis (Erro)

Baixar ferramenta