PE-Importtabellenparser

PE-Importtabellenparser

Das Portable Executable (PE)-Format

Das Portable Executable (PE)-Format ist das Standarddateiformat, das von Windows für ausführbare Dateien wie verwendet wird .exe and .dll. Es wurde mit eingeführt Windows NT (1993) und wurde zum einheitlichen Layout für beide 32-Bit und 64-Bit Programme. Ein solides Verständnis der PE-Interna ist eine Voraussetzung für die Entwicklung von Sicherheitstools auf Windows, einschließlich Antiviren-Engines, statischen Analyseprogrammen, Entpackern und Dienstprogrammen zur Reaktion auf Vorfälle.

PE auf einen Blick

Eine typische PE-Datei enthält:

  • DOS-Header (IMAGE_DOS_HEADER) für Legacy-Kompatibilität und zum Auffinden des NT-Headers.
  • NT-Header (IMAGE_NT_HEADERS32/64), zu denen gehören:
    • IMAGE_FILE_HEADER
    • IMAGE_OPTIONAL_HEADER32/64 (Der Name ist historisch, er ist für PE-Bilder praktisch obligatorisch)
  • Abschnittstabelle (Anordnung von IMAGE_SECTION_HEADER)
  • Abschnitte wie z.B .text, .rdata, .data, .rsrcusw
  • Datenverzeichnisse (Import, Export, Ressourcen, Verschiebungen, Debug, TLS, …) Die meisten PE-bezogenen Strukturen und Konstanten werden in deklariert WinNT.h.

IMAGE_DOS_HEADER

IMAGE_DOS_HEADER ist eine Legacy-Struktur für MS-DOS-Kompatibilität. In der Praxis sind die beiden wichtigsten Bereiche:

  • e_magicSignatur, die den DOS-Header identifiziert. Für PE-Dateien muss dies der Fall sein 0x5A4D was ASCII entspricht „MZ“ (IMAGE_DOS_SIGNATURE).
  • e_lfanewDateioffset (vom Anfang der Datei) zum NT-Header (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

Geschichte der Signatur „MZ“.

In den frühen 1980er Jahren benötigte MS-DOS eine einfache Methode, um ausführbare Dateien von anderen Dateitypen zu unterscheiden. Die „magische Zahl“ MZ wurde zu Beginn der ausführbaren Dateien ausgewählt und geschrieben. Heute bleibt diese Signatur Teil der PE-Kompatibilität. Es ist darin gespeichert IMAGE_DOS_HEADER.e_magic as 0x5A4D.

IMAGE_NT_HEADERS (32 und 64)

Die NT-Header wurden mit Windows NT eingeführt, um das Laden ausführbarer Dateien zu standardisieren. Es gibt zwei Formen:

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 beschreibt das Bild auf einer hohen Ebene: Architektur, Anzahl der Abschnitte, Zeitstempel und Attribute. Microsoft-Dokumentation:

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;

Schlüsselfelder:

  • MachineZielarchitektur CPU (z. B IMAGE_FILE_MACHINE_I386, IMAGE_FILE_MACHINE_AMD64).
  • NumberOfSectionsAnzahl der folgenden Abschnittsüberschriften.
  • TimeDateStampSekunden der UNIX-Epoche. Nützlich für Debugging, Versionierung und Triage.
  • SizeOfOptionalHeaderGröße der optionalen Header-Struktur.
  • CharacteristicsFlaggen wie:
    • IMAGE_FILE_EXECUTABLE_IMAGE
    • IMAGE_FILE_DLL
    • IMAGE_FILE_32BIT_MACHINE
    • IMAGE_FILE_DEBUG_STRIPPED

IMAGE_OPTIONAL_HEADER (32 und 64)

Trotz des Namens ist dieser Header wichtig. Es enthält Informationen zum Speicherlayout, zum Einstiegspunkt, zu Ausrichtungen, zum Subsystem usw Datenverzeichnis Array. Microsoft-Dokumentation:

IMAGE_SECTION_HEADER

Ein PE ist aufgeteilt in sections, jeweils beschrieben von IMAGE_SECTION_HEADER. Abschnitte sind die grundlegenden Zuordnungseinheiten, die vom Lader und von den Werkzeugen verwendet werden. Microsoft-Dokumentation:

#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 Abschnittsnamen:

  • .text ausführbarer Code
  • .rdata schreibgeschützte Daten
  • .data initialisierte beschreibbare Daten
  • .bss nicht initialisierte Daten (oft nur virtuell)
  • .rsrc Ressourcen Bilder aus dem Artikel:
  • Section header overview
  • Sections in a file
  • Section characteristics

VirtualAddress vs. PhysicalAddress (Dateioffset)

In einem PE werden viele Felder ausgedrückt als RVA (Relative virtuelle Adresse). RVA ist eine Adresse relativ zur Modulbasis im Speicher. Auf der Festplatte befinden sich die Daten nach Dateioffsets.Wenn Sie mit einem RVA auf etwas auf der Festplatte zugreifen müssen, müssen Sie es mithilfe einer RVA-zu-Datei-Offset-Übersetzung (oft als „RVA-zu-Datei-Offset-Übersetzung“ bezeichnet) konvertieren rva2offset).RVA vs file offset

Importe

Wenn eine ausführbare Datei von externen Funktionen abhängt (z. B. von user32.dll oder DLLs von Drittanbietern), listet es diese Abhängigkeiten im auf Verzeichnis importieren.Der Windows-Loader löst Importe zur Ladezeit auf und füllt die Adresstabelle importieren (IAT) mit tatsächlichen Funktionszeigern. Compiler generieren normalerweise indirekte Aufrufe über das IAT.Import table concept

IMAGE_IMPORT_DIRECTORY (Verzeichnistabelle importieren)

Das Importverzeichnis ist eine Folge von IMAGE_IMPORT_DESCRIPTOR Strukturen. Jeder Deskriptor beschreibt eine importierte 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;

Visualisierung aus dem Artikel:

  • OriginalFirstThunk/FirstThunk tables
  • Imported function name strings

So funktioniert der Importaufruf

Typische Compiler-Ausgabeaufrufe über eine Zelle, die der Loader einmal füllt:

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

IAT callDer Loader muss die Funktionsadresse nur einmal in den IAT schreiben und der Code ruft ihn weiterhin auf.

C++ Tabellenparser importieren (x86 + x64)

Nachfolgend ein kompakter, praktischer Ansatz:

  • Validieren Sie den DOS-Header und die PE-Signatur
  • Architektur erkennen von IMAGE_FILE_HEADER.Machine
  • Suchen Sie nach Abschnitten und Datenverzeichnissen
  • Konvertieren Sie RVA in Dateioffsets (rva2offset)
  • Gehen IMAGE_IMPORT_DESCRIPTOR entries
  • Erkennen Sie für jede importierte Funktion den Import nach Namen und den Import nach Ordinalzahl

Vollständiges Repository: 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;
}

Kernidee des Spaziergangs importieren

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

Das Artikelprojekt implementiert dies in einer gebrauchsfertigen Form, einschließlich x86- und x64-Unterstützung.

Verwendete Werkzeuge

Was kommt als nächstes?

Nächste Schritte im Originalartikel vorgeschlagen:

  • Erstellen Sie ein Fuzzy-Hashing-Modul
  • Besprechen Sie Blacklists und Whitelists
  • Erweitern Sie die Tools rund um PE-Parsing und -Analyse. Kontakte aus dem Artikel: Articles@stofu.io
Zurück zu Blogs

Kontakt

Gespräch starten

Ein paar klare Zeilen reichen. Beschreiben Sie das System, den Druck und die Entscheidung, die feststeckt. Oder schreiben Sie direkt an midgard@stofu.io.

0 / 10000
Keine Datei ausgewählt