Le format Portable Executable (PE)
Le format Portable Executable (PE) est le format de fichier standard utilisé par Windows pour les exécutables tels que .exe and .dll. Il a été introduit avec Windows NT (1993) et est devenu la mise en page unifiée pour les deux 32 bits et 64 bits programmes.Une solide compréhension des composants internes de PE est une condition préalable pour créer des outils de sécurité sur Windows, y compris des moteurs antivirus, des analyseurs statiques, des décompresseurs et des utilitaires de réponse aux incidents.
PE en un coup d'oeil
Un fichier PE typique contient :
- En-tête DOS (
IMAGE_DOS_HEADER) pour la compatibilité héritée et pour localiser l'en-tête NT. - En-têtes NT (
IMAGE_NT_HEADERS32/64), qui comprennent :IMAGE_FILE_HEADERIMAGE_OPTIONAL_HEADER32/64(le nom est historique, il est effectivement obligatoire pour les images PE)
- Tableau des sections (tableau de
IMAGE_SECTION_HEADER) - Sections comme
.text,.rdata,.data,.rsrc, etc. - Répertoires de données (importation, exportation, ressources, relocalisations, débogage, TLS, …) La plupart des structures et constantes liées au PE sont déclarées dans WinNT.h.
IMAGE_DOS_HEADER
IMAGE_DOS_HEADER est une structure héritée pour la compatibilité MS-DOS. En pratique, les deux domaines les plus importants sont :
e_magicSignature qui identifie l'en-tête DOS. Pour les fichiers PE, cela doit être 0x5A4D qui correspond à ASCII "MZ" (IMAGE_DOS_SIGNATURE).e_lfanewDécalage du fichier (du début du fichier) au En-têtes 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
Histoire de la signature "MZ"
Au début des années 1980, MS-DOS avait besoin d'une méthode simple pour distinguer les fichiers exécutables des autres types de fichiers. Le « chiffre magique » MZ a été choisie et écrite au démarrage des exécutables. Aujourd'hui, cette signature fait toujours partie de la compatibilité PE. Il est stocké dans IMAGE_DOS_HEADER.e_magic as 0x5A4D.
IMAGE_NT_HEADERS (32 et 64)
Les en-têtes NT ont été introduits avec Windows NT pour standardiser le chargement des exécutables. Il existe deux formulaires :
IMAGE_NT_HEADERS32IMAGE_NT_HEADERS64Les deux contiennent :Signature(doit être "PE\0\0", aliasIMAGE_NT_SIGNATURE)IMAGE_FILE_HEADERIMAGE_OPTIONAL_HEADER32/64Documentation 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 décrit l'image à un niveau élevé : architecture, nombre de sections, horodatage et attributs. Documentation 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;
Champs clés :
MachineArchitecture cible CPU (par exempleIMAGE_FILE_MACHINE_I386,IMAGE_FILE_MACHINE_AMD64).NumberOfSectionsNombre d'en-têtes de section qui suivent.TimeDateStampSecondes d'époque UNIX. Utile pour le débogage, la gestion des versions et le tri.SizeOfOptionalHeaderTaille de la structure d’en-tête facultative.CharacteristicsDes drapeaux tels que :IMAGE_FILE_EXECUTABLE_IMAGEIMAGE_FILE_DLLIMAGE_FILE_32BIT_MACHINEIMAGE_FILE_DEBUG_STRIPPED
IMAGE_OPTIONAL_HEADER (32 et 64)
Malgré son nom, cet en-tête est essentiel. Il contient des informations sur la disposition de la mémoire, le point d'entrée, les alignements, le sous-système et le Répertoire de données tableau. Documentation 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:
Magic0x10Bpour PE32 ou0x20Bpour PE32+ (64 bits).AddressOfEntryPointRVA du point d’entrée.ImageBaseAdresse de chargement préférée.SectionAlignmentandFileAlignmentAlignement en mémoire vs sur disque.SizeOfImageandSizeOfHeadersTaille de l’image en mémoire et taille totale des en-têtes.DataDirectory[]Pointeurs vers la table d'importation, la table d'exportation, les relocalisations, les ressources, etc.
IMAGE_SECTION_HEADER
Un PE est divisé en sections, chacun décrit par IMAGE_SECTION_HEADER. Les sections sont les unités cartographiques fondamentales utilisées par le chargeur et par les outils. Documentation 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)
Noms de section typiques :
.textcode exécutable.rdatadonnées en lecture seule.datadonnées inscriptibles initialisées.bssdonnées non initialisées (souvent virtuelles uniquement).rsrcressources Images de l'article :


VirtualAddress vs PhysicalAddress (décalage de fichier)
Dans un PE, de nombreux champs sont exprimés sous la forme RVA (Adresse virtuelle relative). RVA est une adresse relative à la base du module en mémoire. Sur le disque, les données sont localisées par décalages de fichiers.Si vous avez besoin d'accéder à quelque chose sur le disque à l'aide d'un RVA, vous devez le convertir à l'aide d'une traduction RVA en fichier-offset (souvent appelée rva2offset).RVA vs file offset
Importations
Lorsqu'un exécutable dépend de fonctions externes (par exemple de user32.dll ou des DLL tierces), il répertorie ces dépendances dans le Importer le répertoire.Le chargeur Windows résout les importations au moment du chargement et remplit le Table d'adresses d'importation (IAT) avec des pointeurs de fonction réels. Les compilateurs génèrent généralement des appels indirects via l'IAT.Import table concept
IMAGE_IMPORT_DIRECTORY (Importer la table du répertoire)
Le répertoire d'importation est une séquence de IMAGE_IMPORT_DESCRIPTOR structures. Chaque descripteur décrit une DLL importée.
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;
Visualisation de l'article :
Comment fonctionne l'appel d'importation
La sortie typique du compilateur appelle via une cellule que le chargeur remplit une fois :
; x86
call dword ptr [_cell_with_address_of_function]
; x64
call qword ptr [_cell_with_address_of_function]
IAT callLe chargeur n'a besoin d'écrire l'adresse de la fonction qu'une seule fois dans l'IAT, et le code continue d'appeler via celui-ci.
C++ analyseur de table d'importation (x86 + x64)
Vous trouverez ci-dessous une approche compacte et pratique :
- Valider l'en-tête DOS et la signature PE
- Détecter l'architecture de
IMAGE_FILE_HEADER.Machine - Localiser les sections et les répertoires de données
- Convertir RVA en décalages de fichiers (
rva2offset) - Marcher
IMAGE_IMPORT_DESCRIPTORentries - Pour chaque fonction importée, détectez l'importation par nom et l'importation par ordinal
Dépôt complet : 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;
}
Importer l'idée de base de la marche
// 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)
Le projet d'article l'implémente sous une forme prête à l'emploi, incluant la prise en charge de x86 et x64.
Outils utilisés
- Outils PE: https://github.com/petoolse/petoolsOpen-source outil pour manipuler les champs d’en-tête PE. Prend en charge x86 et x64.
- WinDbg: https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/debugger-download-toolsMicrosoft débogueur système.
- x64dbg: https://x64dbg.com/Lightweight débogueur open source pour Windows.
- WinHex: http://www.winhex.com/winhex/hex-editor.htmlUniversal éditeur hexadécimal pour l'investigation, la récupération et l'édition de données de bas niveau.
Quelle est la prochaine étape
Prochaines étapes suggérées dans l'article original :
- Construire un module de hachage flou
- Discutez des listes noires et des listes blanches
- Développez les outils autour de l'analyse syntaxique PE Contacts de l'article : articles@stofu.io

