O formato Executável Portátil (PE)
O formato Portable Executable (PE) é o formato de arquivo padrão usado pelo Windows para executáveis como .exe and .dll. Foi introduzido com Windows NT (1993) e se tornou o layout unificado para ambos 32 bits e 64 bits programas.Um conhecimento sólido dos componentes internos do PE é um pré-requisito para a construção de ferramentas de segurança no Windows, incluindo mecanismos antivírus, analisadores estáticos, desempacotadores e utilitários de resposta a incidentes.
PE em resumo
Um arquivo PE típico contém:
- Cabeçalho DOS (
IMAGE_DOS_HEADER) para compatibilidade herdada e para localizar o cabeçalho NT. - Cabeçalhos NT (
IMAGE_NT_HEADERS32/64), que incluem:IMAGE_FILE_HEADERIMAGE_OPTIONAL_HEADER32/64(o nome é histórico, é efetivamente obrigatório para imagens PE)
- Tabela de seção (matriz de
IMAGE_SECTION_HEADER) - Seções como
.text,.rdata,.data,.rsrc, etc. - Diretórios de dados (importação, exportação, recursos, relocações, depuração, TLS,…) A maioria das estruturas e constantes relacionadas ao PE são declaradas em WinNT.h.
IMAGE_DOS_HEADER
IMAGE_DOS_HEADER é uma estrutura legada para compatibilidade com MS-DOS. Na prática, os dois campos mais importantes são:
e_magicAssinatura que identifica o cabeçalho do DOS. Para arquivos PE deve ser 0x5A4D que corresponde a ASCII "MZ" (IMAGE_DOS_SIGNATURE).e_lfanewDeslocamento do arquivo (do início do arquivo) até o Cabeçalhos NT (IMAGE_NT_HEADERS).
typedef struct _IMAGE_DOS_HEADER {
WORD e_magic; // 0x5A4D ("MZ")
WORD e_cblp;
WORD e_cp;
WORD e_crlc;
WORD e_cparhdr;
WORD e_minalloc;
WORD e_maxalloc;
WORD e_ss;
WORD e_sp;
WORD e_csum;
WORD e_ip;
WORD e_cs;
WORD e_lfarlc;
WORD e_ovno;
WORD e_res[4];
WORD e_oemid;
WORD e_oeminfo;
WORD e_res2[10];
DWORD e_lfanew; // offset of IMAGE_NT_HEADERS
} IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
MZ and e_lfanew
História da assinatura "MZ"
No início da década de 1980, o MS-DOS precisava de um método simples para distinguir arquivos executáveis de outros tipos de arquivos. O “número mágico” MZ foi escolhido e escrito no início dos executáveis. Hoje essa assinatura permanece como parte da compatibilidade do PE. Está armazenado em IMAGE_DOS_HEADER.e_magic as 0x5A4D.
IMAGE_NT_HEADERS (32 e 64)
Os cabeçalhos do NT foram introduzidos com Windows NT para padronizar o carregamento de executáveis. Existem duas formas:
IMAGE_NT_HEADERS32IMAGE_NT_HEADERS64Ambos contêm:Signature(deve ser "PE\0\0", também conhecido comoIMAGE_NT_SIGNATURE)IMAGE_FILE_HEADERIMAGE_OPTIONAL_HEADER32/64Documentação da Microsoft:- https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-image\_nt\_headers32
- https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-image\_nt\_headers64
typedef struct _IMAGE_NT_HEADERS32 {
DWORD Signature;
IMAGE_FILE_HEADER FileHeader;
IMAGE_OPTIONAL_HEADER32 OptionalHeader;
} IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;
typedef struct _IMAGE_NT_HEADERS64 {
DWORD Signature;
IMAGE_FILE_HEADER FileHeader;
IMAGE_OPTIONAL_HEADER64 OptionalHeader;
} IMAGE_NT_HEADERS64, *PIMAGE_NT_HEADERS64;
NT headers layout
IMAGE_FILE_HEADER
IMAGE_FILE_HEADER descreve a imagem em alto nível: arquitetura, número de seções, carimbo de data/hora e atributos. Documentação da Microsoft:
typedef struct _IMAGE_FILE_HEADER {
WORD Machine;
WORD NumberOfSections;
DWORD TimeDateStamp;
DWORD PointerToSymbolTable;
DWORD NumberOfSymbols;
WORD SizeOfOptionalHeader;
WORD Characteristics;
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
Campos principais:
MachineArquitetura alvo CPU (por exemploIMAGE_FILE_MACHINE_I386,IMAGE_FILE_MACHINE_AMD64).NumberOfSectionsContagem de cabeçalhos de seção a seguir.TimeDateStampSegundos da época UNIX. Útil para depuração, controle de versão e triagem.SizeOfOptionalHeaderTamanho da estrutura de cabeçalho opcional.CharacteristicsBandeiras como:IMAGE_FILE_EXECUTABLE_IMAGEIMAGE_FILE_DLLIMAGE_FILE_32BIT_MACHINEIMAGE_FILE_DEBUG_STRIPPED
IMAGE_OPTIONAL_HEADER (32 e 64)
Apesar do nome, este cabeçalho é essencial. Ele contém informações de layout de memória, ponto de entrada, alinhamentos, subsistema e o Diretório de dados matriz. Documentação da Microsoft:
- https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-image\_optional\_header32
- https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-image\_optional\_header64Highlights:
Magic0x10Bpara PE32 ou0x20Bpara PE32+ (64 bits).AddressOfEntryPointRVA do ponto de entrada.ImageBaseEndereço de carga preferido.SectionAlignmentandFileAlignmentAlinhamento na memória versus no disco.SizeOfImageandSizeOfHeadersTamanho da imagem na memória e tamanho total dos cabeçalhos.DataDirectory[]Ponteiros para importar tabela, exportar tabela, relocações, recursos, etc.
IMAGE_SECTION_HEADER
Um PE é dividido em sections, cada um descrito por IMAGE_SECTION_HEADER. As seções são as unidades de mapeamento fundamentais usadas pela carregadeira e pelas ferramentas. Documentação da Microsoft:
#pragma pack(push, 1)
typedef struct _IMAGE_SECTION_HEADER {
BYTE Name[IMAGE_SIZEOF_SHORT_NAME]; // 8
union {
DWORD PhysicalAddress;
DWORD VirtualSize;
} Misc;
DWORD VirtualAddress;
DWORD SizeOfRawData;
DWORD PointerToRawData;
DWORD PointerToRelocations;
DWORD PointerToLinenumbers;
WORD NumberOfRelocations;
WORD NumberOfLinenumbers;
DWORD Characteristics;
} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
#pragma pack(pop)
Nomes de seção típicos:
.textcódigo executável.rdatadados somente leitura.datadados graváveis inicializados.bssdados não inicializados (geralmente apenas virtuais).rsrcrecursos Imagens do artigo:


VirtualAddress vs PhysicalAddress (deslocamento de arquivo)
Em um PE, muitos campos são expressos como RVA (Endereço virtual relativo). RVA é um endereço relativo à base do módulo na memória. No disco, os dados são localizados por deslocamentos de arquivo.Se você precisar acessar algo no disco usando um RVA, deverá convertê-lo usando uma tradução RVA para deslocamento de arquivo (geralmente chamada rva2offset).RVA vs file offset
Importações
Quando um executável depende de funções externas (por exemplo, de user32.dll ou DLLs de terceiros), ele lista essas dependências no arquivo Diretório de importação.O carregador Windows resolve as importações no momento do carregamento e preenche o Tabela de Endereços de Importação (IAT) com ponteiros de função reais. Os compiladores normalmente geram chamadas indiretas por meio do IAT.Import table concept
IMAGE_IMPORT_DIRECTORY (tabela de diretório de importação)
O diretório de importação é uma sequência de IMAGE_IMPORT_DESCRIPTOR estruturas. Cada descritor descreve uma DLL importada.
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics; // 0 for terminating null import descriptor
DWORD OriginalFirstThunk; // RVA to unbound IAT (lookup table)
} DUMMYUNIONNAME;
DWORD TimeDateStamp;
DWORD ForwarderChain;
DWORD Name; // RVA to DLL name
DWORD FirstThunk; // RVA to IAT (addresses after binding)
} IMAGE_IMPORT_DESCRIPTOR;
Visualização do artigo:
Como funciona a chamada de importação
Chamadas típicas de saída do compilador por meio de uma célula que o carregador preenche uma vez:
; x86
call dword ptr [_cell_with_address_of_function]
; x64
call qword ptr [_cell_with_address_of_function]
IAT callO carregador só precisa escrever o endereço da função uma vez no IAT, e o código continua chamando por meio dele.
C++ analisador de tabela de importação (x86 + x64)
Abaixo está uma abordagem compacta e prática:
- Valide o cabeçalho DOS e a assinatura PE
- Detectar arquitetura de
IMAGE_FILE_HEADER.Machine - Localize seções e diretórios de dados
- Converter RVA em deslocamentos de arquivo (
rva2offset) - Caminhar
IMAGE_IMPORT_DESCRIPTORentries - Para cada função importada, detecte importação por nome versus importação por ordinal
Repositório completo: https://github.com/SToFU-Systems/DSAVE
alignUp
DWORD alignUp(DWORD value, DWORD align) {
DWORD mod = value % align;
return value + (mod ? (align - mod) : 0);
}
rva2offset
static constexpr int64_t kRvaError = -1;
int64_t rva2offset(const IMAGE_NTPE_DATA& ntpe, DWORD rva) {
try {
PIMAGE_SECTION_HEADER sec = ntpe.sectionDirectories;
// If rva is inside headers, return as-is
if (!ntpe.fileHeader->NumberOfSections || rva < sec->VirtualAddress) {
return rva;
}
for (uint32_t i = 0; i < ntpe.fileHeader->NumberOfSections; i++, sec++) {
DWORD secEnd = alignUp(sec->Misc.VirtualSize, ntpe.SecAlign) + sec->VirtualAddress;
if (sec->VirtualAddress <= rva && secEnd > rva) {
return (int64_t)rva - sec->VirtualAddress + sec->PointerToRawData;
}
}
} catch (...) {
}
return kRvaError;
}
Importe a ideia central da caminhada
// Pseudocode outline
// 1) Find DataDirectory[IMPORT].VirtualAddress
// 2) Convert RVA -> file offset
// 3) Walk IMAGE_IMPORT_DESCRIPTOR until Name == 0
// 4) For each descriptor, walk thunk table until entry == 0
// 5) If high-bit set -> ordinal, else -> name (IMAGE_IMPORT_BY_NAME)
O projeto do artigo implementa isso em um formato pronto para uso, incluindo suporte para x86 e x64.
Ferramentas usadas
- Ferramentas PE: https://github.com/petoolse/petoolsOpen-source ferramenta para manipular campos de cabeçalho PE. Suporta x86 e x64.
- WinDbg: https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/debugger-download-toolsMicrosoft depurador do sistema.
- x64dbg: https://x64dbg.com/Lightweight depurador de código aberto para Windows.
- WinHex: http://www.winhex.com/winhex/hex-editor.htmlUniversal editor hexadecimal para análise forense, recuperação e edição de dados de baixo nível.
O que vem a seguir
Próximas etapas sugeridas no artigo original:
- Construa um módulo de hash difuso
- Discuta listas negras e listas brancas
- Expanda as ferramentas de análise e análise de PE Contatos do artigo: articles@stofu.io

