PE-importtabelparser

PE-importtabelparser

Het Portable Executable (PE)-formaat

Het Portable Executable (PE)-formaat is het standaardbestandsformaat dat door Windows wordt gebruikt voor uitvoerbare bestanden zoals .exe and .dll. Het werd geïntroduceerd met Windows NT (1993) en werd de uniforme lay-out voor beide 32-bits en 64-bits programma's. Een goed begrip van PE-internals is een voorwaarde voor het bouwen van beveiligingstools op Windows, inclusief antivirus-engines, statische analysers, uitpakprogramma's en hulpprogramma's voor incidentrespons.

PE in één oogopslag

Een typisch PE-bestand bevat:

  • DOS-header (IMAGE_DOS_HEADER) voor oudere compatibiliteit en voor het lokaliseren van de NT-header.
  • NT-headers (IMAGE_NT_HEADERS32/64), waaronder:
    • IMAGE_FILE_HEADER
    • IMAGE_OPTIONAL_HEADER32/64 (de naam is historisch, deze is feitelijk verplicht voor PE-afbeeldingen)
  • Sectie tafel (reeks van IMAGE_SECTION_HEADER)
  • Secties zoals .text, .rdata, .data, .rsrcenz
  • Gegevensmappen (importeren, exporteren, bronnen, verhuizingen, debuggen, TLS, …) De meeste PE-gerelateerde structuren en constanten worden gedeclareerd in WinNT.h.

IMAGE_DOS_HEADER

IMAGE_DOS_HEADER is een oudere structuur voor MS-DOS-compatibiliteit. In de praktijk zijn de twee belangrijkste velden:

  • e_magicHandtekening die de DOS-header identificeert. Voor PE-bestanden moet dit zo zijn 0x5A4D wat overeenkomt met ASCII "MZ" (IMAGE_DOS_SIGNATURE).
  • e_lfanewBestandsoffset (vanaf het begin van het bestand) tot de NT-headers (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

Geschiedenis van de "MZ" -handtekening

Begin jaren tachtig had MS-DOS een eenvoudige methode nodig om uitvoerbare bestanden te onderscheiden van andere bestandstypen. Het "magische getal" MZ werd gekozen en geschreven aan het begin van uitvoerbare bestanden. Tegenwoordig blijft deze handtekening onderdeel van PE-compatibiliteit. Het wordt erin opgeslagen IMAGE_DOS_HEADER.e_magic as 0x5A4D.

IMAGE_NT_HEADERS (32 en 64)

De NT-headers zijn geïntroduceerd met Windows NT om het laden van uitvoerbare bestanden te standaardiseren. Er zijn twee vormen:

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 beschrijft de afbeelding op een hoog niveau: architectuur, aantal secties, tijdstempel en attributen. Microsoft-documentatie:

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;

Belangrijkste velden:

  • MachineTarget CPU-architectuur (bijvoorbeeld IMAGE_FILE_MACHINE_I386, IMAGE_FILE_MACHINE_AMD64).
  • NumberOfSectionsAantal sectiekoppen die volgen.
  • TimeDateStampUNIX-epochseconden. Handig voor foutopsporing, versiebeheer en triage.
  • SizeOfOptionalHeaderGrootte van de optionele headerstructuur.
  • CharacteristicsVlaggen zoals:
    • IMAGE_FILE_EXECUTABLE_IMAGE
    • IMAGE_FILE_DLL
    • IMAGE_FILE_32BIT_MACHINE
    • IMAGE_FILE_DEBUG_STRIPPED

IMAGE_OPTIONAL_HEADER (32 en 64)

Ondanks de naam is deze header essentieel. Het bevat informatie over de geheugenindeling, het toegangspunt, de uitlijningen, het subsysteem en de GegevensDirectory reeks. Microsoft-documentatie:

IMAGE_SECTION_HEADER

Een PE wordt opgesplitst in sections, elk beschreven door IMAGE_SECTION_HEADER. Secties zijn de fundamentele kaarteenheden die door de lader en door de gereedschappen worden gebruikt. Microsoft-documentatie:

#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)

Typische sectienamen:

  • .text uitvoerbare code
  • .rdata alleen-lezen gegevens
  • .data geïnitialiseerde schrijfbare gegevens
  • .bss niet-geïnitialiseerde gegevens (vaak alleen virtueel)
  • .rsrc bronnen Afbeeldingen uit het artikel:
  • Section header overview
  • Sections in a file
  • Section characteristics

VirtualAddress versus PhysicalAddress (bestandsverschuiving)

In een PE worden veel velden uitgedrukt als RVA (Relatief virtueel adres). RVA is een adres relatief aan de modulebasis in het geheugen. Op schijf worden gegevens gelokaliseerd door bestandscompensaties.Als u toegang wilt krijgen tot iets op schijf met behulp van een RVA, moet u het converteren met behulp van een RVA-naar-bestand-offset-vertaling (vaak rva2offset).RVA vs file offset

Importeert

Wanneer een uitvoerbaar bestand afhankelijk is van externe functies (bijvoorbeeld from user32.dll of DLL's van derden), worden deze afhankelijkheden vermeld in de Directory importeren.De Windows-lader lost de import op tijdens het laden en vult de Adrestabel importeren (IAT) met daadwerkelijke functieaanwijzingen. Compilers genereren doorgaans indirecte oproepen via de IAT.Import table concept

IMAGE_IMPORT_DIRECTORY (directorytabel importeren)

De importdirectory is een reeks van IMAGE_IMPORT_DESCRIPTOR structuren. Elke descriptor beschrijft één geïmporteerde DLL.

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;

Visualisatie uit het artikel:

  • OriginalFirstThunk/FirstThunk tables
  • Imported function name strings

Hoe de importoproep werkt

Typische compileruitvoer wordt aangeroepen via een cel die de lader één keer vult:

; x86
call dword ptr [_cell_with_address_of_function]
; x64
call qword ptr [_cell_with_address_of_function]

IAT callDe lader hoeft het functieadres slechts één keer in de IAT te schrijven en de code blijft erdoorheen bellen.

C++ tabelparser importeren (x86 + x64)

Hieronder vindt u een compacte, praktische aanpak:

  • Valideer de DOS-header en PE-handtekening
  • Detecteer architectuur van IMAGE_FILE_HEADER.Machine
  • Zoek secties en gegevensmappen
  • Converteer RVA naar bestandsoffsets (rva2offset)
  • Loop IMAGE_IMPORT_DESCRIPTOR entries
  • Detecteer voor elke geïmporteerde functie import op naam versus import op rangtelwoord

Volledige opslagplaats: 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;
}

Importeer het kernidee van de wandeling

// 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)

Het artikelproject implementeert dit in een kant-en-klare vorm, inclusief zowel x86- als x64-ondersteuning.

Gebruikt gereedschap

Wat is het volgende

Volgende stappen voorgesteld in het originele artikel:

  • Bouw een fuzzy hashing-module
  • Bespreek zwarte lijsten en witte lijsten
  • Breid de tooling rond PE-parsering en -analyse uit. Contacten uit het artikel: artikelen@stofu.io
Terug naar Blogs

Contact

Begin het gesprek

Een paar heldere regels zijn genoeg. Beschrijf het systeem, de druk en de beslissing die vastzit. Of mail direct naar midgard@stofu.io.

0 / 10000
Geen bestand gekozen