Analyseur de table d'importation PE

Analyseur de table d'importation PE

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_HEADER
    • IMAGE_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 :

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 exemple IMAGE_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_IMAGE
    • IMAGE_FILE_DLL
    • IMAGE_FILE_32BIT_MACHINE
    • IMAGE_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 :

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 :

  • .text code exécutable
  • .rdata données en lecture seule
  • .data données inscriptibles initialisées
  • .bss données non initialisées (souvent virtuelles uniquement)
  • .rsrc ressources Images de l'article :
  • Section header overview
  • Sections in a file
  • Section characteristics

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 :

  • OriginalFirstThunk/FirstThunk tables
  • Imported function name strings

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_DESCRIPTOR entries
  • 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

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
Retour aux blogs

Contacter

Démarrer la conversation

Quelques lignes claires suffisent. Décrivez le système, la pression et la décision bloquée. Ou écrivez directement à midgard@stofu.io.

0 / 10000
Aucun fichier choisi