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_HEADERIMAGE_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:
IMAGE_NT_HEADERS32IMAGE_NT_HEADERS64Beide enthalten:Signature(muss sein „PE\0\0“, auch bekannt alsIMAGE_NT_SIGNATURE)IMAGE_FILE_HEADERIMAGE_OPTIONAL_HEADER32/64Microsoft-Dokumentation:- 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 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. BIMAGE_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_IMAGEIMAGE_FILE_DLLIMAGE_FILE_32BIT_MACHINEIMAGE_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:
- 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:
Magic0x10Bfür PE32 oder0x20Bfür PE32+ (64-Bit).AddressOfEntryPointRVA des Einstiegspunkts.ImageBaseBevorzugte Ladeadresse.SectionAlignmentandFileAlignmentAusrichtung im Speicher vs. auf der Festplatte.SizeOfImageandSizeOfHeadersBildgröße im Arbeitsspeicher und Gesamtgröße der Header.DataDirectory[]Zeiger auf Importtabelle, Exporttabelle, Verschiebungen, Ressourcen usw.
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:
.textausführbarer Code.rdataschreibgeschützte Daten.datainitialisierte beschreibbare Daten.bssnicht initialisierte Daten (oft nur virtuell).rsrcRessourcen Bilder aus dem Artikel:


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:
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_DESCRIPTORentries - 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
- PE-Tools: https://github.com/petoolse/petoolsOpen-source Tool zum Bearbeiten von PE-Header-Feldern. Unterstützt x86 und x64.
- WinDbg: https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/debugger-download-toolsMicrosoft System-Debugger.
- x64dbg: https://x64dbg.com/Lightweight Open-Source-Debugger für Windows.
- WinHex: http://www.winhex.com/winhex/hex-editor.htmlUniversal Hex-Editor für Forensik, Wiederherstellung und einfache Datenbearbeitung.
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

