Il formato PE (Portable Executable).
Il formato Portable Executable (PE) è il formato file standard utilizzato da Windows per gli eseguibili come .exe and .dll. È stato introdotto con Windows NT (1993) ed è diventato il layout unificato per entrambi 32 bit e 64 bit programmi. Una solida conoscenza degli aspetti interni di PE è un prerequisito per creare strumenti di sicurezza su Windows, inclusi motori antivirus, analizzatori statici, programmi di decompressione e utilità di risposta agli incidenti.
PE in breve
Un tipico file PE contiene:
- Intestazione DOS (
IMAGE_DOS_HEADER) per compatibilità legacy e per individuare l'intestazione NT. - Intestazioni NT (
IMAGE_NT_HEADERS32/64), che includono:IMAGE_FILE_HEADERIMAGE_OPTIONAL_HEADER32/64(il nome è storico, è effettivamente obbligatorio per le immagini PE)
- Tabella delle sezioni (serie di
IMAGE_SECTION_HEADER) - Sezioni come
.text,.rdata,.data,.rsrc, ecc - Directory di dati (importazione, esportazione, risorse, rilocazioni, debug, TLS, ...) La maggior parte delle strutture e costanti relative a PE sono dichiarate in WinNT.h.
IMAGE_DOS_HEADER
IMAGE_DOS_HEADER è una struttura legacy per la compatibilità con MS-DOS. In pratica, i due campi più importanti sono:
e_magicFirma che identifica l'intestazione DOS. Per i file PE deve essere 0x5A4D che corrisponde ad ASCII "MZ" (IMAGE_DOS_SIGNATURE).e_lfanewOffset del file (dall'inizio del file) al file Intestazioni 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
Storia della firma "MZ".
All'inizio degli anni '80, MS-DOS necessitava di un metodo semplice per distinguere i file eseguibili da altri tipi di file. Il "numero magico" MZ è stato scelto e scritto all'inizio degli eseguibili. Oggi questa firma rimane come parte della compatibilità PE. È memorizzato in IMAGE_DOS_HEADER.e_magic as 0x5A4D.
IMAGE_NT_HEADERS (32 e 64)
Le intestazioni NT sono state introdotte con Windows NT per standardizzare il caricamento degli eseguibili. Ci sono due forme:
IMAGE_NT_HEADERS32IMAGE_NT_HEADERS64Entrambi contengono:Signature(deve essere "PE\0\0", ovveroIMAGE_NT_SIGNATURE)IMAGE_FILE_HEADERIMAGE_OPTIONAL_HEADER32/64Documentazione 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 descrive l'immagine ad alto livello: architettura, numero di sezioni, timestamp e attributi. Documentazione 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;
Campi chiave:
MachineArchitettura CPU target (ad esempioIMAGE_FILE_MACHINE_I386,IMAGE_FILE_MACHINE_AMD64).NumberOfSectionsConteggio delle intestazioni di sezione che seguono.TimeDateStampSecondi dell'epoca UNIX. Utile per il debug, il controllo delle versioni, il triage.SizeOfOptionalHeaderDimensione della struttura dell'intestazione opzionale.CharacteristicsBandiere come:IMAGE_FILE_EXECUTABLE_IMAGEIMAGE_FILE_DLLIMAGE_FILE_32BIT_MACHINEIMAGE_FILE_DEBUG_STRIPPED
IMAGE_OPTIONAL_HEADER (32 e 64)
Nonostante il nome, questa intestazione è essenziale. Contiene informazioni sul layout della memoria, punto di ingresso, allineamenti, sottosistema e file DataDirectory matrice. Documentazione 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:
Magic0x10Bper PE32 o0x20Bper PE32+ (64 bit).AddressOfEntryPointRVA del punto di ingresso.ImageBaseIndirizzo di carico preferito.SectionAlignmentandFileAlignmentAllineamento in memoria vs su disco.SizeOfImageandSizeOfHeadersDimensioni dell'immagine in memoria e dimensioni totali delle intestazioni.DataDirectory[]Puntatori alla tabella di importazione, esportazione, rilocazioni, risorse, ecc.
IMAGE_SECTION_HEADER
Un PE è suddiviso in sections, ciascuno descritto da IMAGE_SECTION_HEADER. Le sezioni sono le unità di mappatura fondamentali utilizzate dal caricatore e dall'utensileria. Documentazione 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)
Nomi tipici delle sezioni:
.textcodice eseguibile.rdatadati di sola lettura.datadati scrivibili inizializzati.bssdati non inizializzati (spesso solo virtuali).rsrcrisorse Immagini dall'articolo:


Indirizzo virtuale e indirizzo fisico (offset del file)
In un PE, molti campi sono espressi come RVA (Indirizzo virtuale relativo). RVA è un indirizzo relativo alla base del modulo in memoria. Sul disco, i dati si trovano da offset dei file.Se devi accedere a qualcosa sul disco utilizzando un RVA, devi convertirlo utilizzando una traduzione RVA-to-file-offset (spesso chiamata rva2offset).RVA vs file offset
Importazioni
Quando un eseguibile dipende da funzioni esterne (ad esempio from user32.dll o DLL di terze parti), elenca tali dipendenze nel file Importa directory.Il caricatore Windows risolve le importazioni al momento del caricamento e riempie il file Tabella degli indirizzi di importazione (IAT) con puntatori a funzioni reali. I compilatori in genere generano chiamate indirette tramite IAT.Import table concept
IMAGE_IMPORT_DIRECTORY (tabella directory di importazione)
La directory di importazione è una sequenza di IMAGE_IMPORT_DESCRIPTOR strutture. Ogni descrittore descrive una DLL importata.
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;
Visualizzazione dall'articolo:
Come funziona la chiamata di importazione
Tipiche chiamate di output del compilatore attraverso una cella che il caricatore riempie una volta:
; x86
call dword ptr [_cell_with_address_of_function]
; x64
call qword ptr [_cell_with_address_of_function]
IAT callIl caricatore deve solo scrivere l'indirizzo della funzione una volta nello IAT e il codice continua a chiamare attraverso di esso.
C++ analizzatore di tabelle di importazione (x86 + x64)
Di seguito è riportato un approccio compatto e pratico:
- Convalida l'intestazione DOS e la firma PE
- Rileva l'architettura da
IMAGE_FILE_HEADER.Machine - Individuare sezioni e directory di dati
- Converti RVA in offset file (
rva2offset) - Cammina
IMAGE_IMPORT_DESCRIPTORentries - Per ogni funzione importata, rileva l'importazione per nome e l'importazione per ordinale
Archivio 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;
}
Importa l'idea principale della camminata
// 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)
Il progetto dell'articolo lo implementa in un formato pronto per l'uso, incluso il supporto x86 e x64.
Strumenti utilizzati
- Strumenti PE: https://github.com/petoolse/petoolsOpen-source strumento per manipolare i campi di intestazione PE. Supporta x86 e x64.
- WinDbg: https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/debugger-download-toolsMicrosoft debugger del sistema.
- x64dbg: https://x64dbg.com/Lightweight debugger open source per Windows.
- WinHex: http://www.winhex.com/winhex/hex-editor.htmlUniversal editor esadecimale per analisi forensi, ripristino e modifica dei dati di basso livello.
Qual è il prossimo passo?
Passaggi successivi suggeriti nell'articolo originale:
- Costruisci un modulo di hashing fuzzy
- Discutere liste nere e liste bianche
- Espandi gli strumenti relativi all'analisi e all'analisi PE. Contatti dall'articolo: articoli@stofu.io

