PE Header + Resource Directory unter 64 Bit auslesen?

[Zacherl]

Hey,

ich habe mir eine Unit geschrieben, die die PE Header eine EXE Datei ausliest und die Sections parst. Dies funktioniert wunderbar, sowohl mit 32 als auch mit 64 Bit EXEn. Weitergehend habe ich die Unit jetzt so erweitert, dass ich die Resourcen, die sich in der .rsrc Section befinden manuell auslesen kann. Die Strukturen dazu habe ich in einem offiziellen Dokument von Microsoft gefunden.

http://www.microsoft.com/whdc/system...re/PECOFF.mspx

Wenn ich meinen Code an einer 32 Bit EXE ausprobiere, so klappt alles wunderbar. Lese ich jetzt eine 64 Bit EXE ein, so gibt es schon Probleme beim Auslesen der ersten Resource Directory Struktur. Die Felder im Record enthalten unsinnige Werte und dies obwohl der anhand der PE Header ermittelte Begin der Resource Table korrekt zu sein scheint.

Meine Fragen:
:?: Gibt es Unterschiede zwischen den Resource Sturkturen? (Der PE Header selbst unterscheidet sich ja nicht sichtbar bei 32 und 64 Bit Dateien)
:?: Wenn ja, wie erkenne ich eine 64 Bit EXE direkt am PE Header?

Könnte mir vorstellen, dass in der 64 Bit EXE die Integer Typen einfach doppelt so groß sind, was ja auch einer der Unterschiede zwischen 32 und 64 Bit Code ist.

Gruß Zacherl

[Muetze1]

Von wegen Erkennung ob 32 oder 64 Bit EXE:

16 Bit Modul: NE16 Header
32 Bit Modul: PE32 Header
64 Bit Modul: PE32+ Header

Zitat:

Zitat von MSDN

The addition of 64-bit Windows required just a few modifications to the PE format. This new format is called PE32+. No new fields were added, and only one field in the PE format was deleted. The remaining changes are simply the widening of certain fields from 32 bits to 64 bits. In most of these cases, you can write code that simply works with both 32 and 64-bit PE files.

MSDN

The IMAGE_NT_HEADERS structure is the primary location where specifics of the PE file are stored. Its offset is given by the e_lfanew field in the IMAGE_DOS_HEADER at the beginning of the file. There are actually two versions of the IMAGE_NT_HEADER structure, one for 32-bit executables and the other for 64-bit versions. The differences are so minor that I'll consider them to be the same for the purposes of this discussion. The only correct, Microsoft-approved way of differentiating between the two formats is via the value of the Magic field in the IMAGE_OPTIONAL_HEADER (described shortly).

Beide Quotes aus dem 2. Link.

Im Detail: IMAGE_FILE_XXX Struktur, erstes Wort: "MACHINE"

Code:

The target CPU for this executable. Common values are:

IMAGE_FILE_MACHINE_I386    0x014c // Intel 386
IMAGE_FILE_MACHINE_IA64    0x0200 // Intel 64

Siehe letzter Link.

/EDIT: Noch was: Jeder Section Header hat nochmal eine entsprechende Magic:

Auch wieder das 1. Word:

Zitat:

Zitat von Structures: IMAGE_SECTION_HEADER

A signature WORD, identifying what type of header this is. The two most common values are IMAGE_NT_OPTIONAL_HDR32_MAGIC 0x10b and IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b.

Siehe letzter Link.

Some Info:
* MSDN: Peering Inside the PE: A Tour of the Win32 Portable Executable File Format
* An In-Depth Look into the Win32 Portable Executable File Format
* Under the hood
* Structures

[mr_emre_d]

zum Erkennen, ob 32 oder 64 Bit:
[msdn]http://msdn.microsoft.com/en-us/library/aa364819(VS.85).aspx[/msdn]

[Zacherl]

Ah danke euch, damit kann ich jetzt zumindest mal zwischen 64 Bit und 32 Bit differenzieren :)

Also das Ermitteln des IMAGE_DIRECTORY_ENTRY_RESOURCE Directories funktioniert schonmal. Doch dann hängt es an den verwendeten Strukturen, mit denen ich die Resourcen auslese. Momentan verwende ich folgende:

Code:

typedef struct _IMAGE_RESOURCE_DIRECTORY 
{
DWORD   Characteristics; // Not important to resource retrieval.
DWORD   TimeDateStamp;   // Not important to resource retrieval.
WORD    MajorVersion;    // Not important to resource retrieval.
WORD    MinorVersion;    // Not important to resource retrieval.
WORD    NumberOfNamedEntries;
WORD    NumberOfIdEntries;
//  IMAGE_RESOURCE_DIRECTORY_ENTRY DirectoryEntries[];
} 
IMAGE_RESOURCE_DIRECTORY, *PIMAGE_RESOURCE_DIRECTORY;

typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY 
{
DWORD Name;
DWORD OffsetToData;
}
IMAGE_RESOURCE_DIRECTORY_ENTRY, *PIMAGE_RESOURCE_DIRECTORY_ENTRY;

typedef struct _IMAGE_RESOURCE_DIR_STRING_U 
{
WORD    Length;        // Number of Unicode characters in string
WCHAR   NameString[1]; // Length Unicode characters
}
IMAGE_RESOURCE_DIR_STRING_U, *PIMAGE_RESOURCE_DIR_STRING_U;

typedef struct _IMAGE_RESOURCE_DATA_ENTRY 
{
DWORD   OffsetToData;
DWORD   Size;
DWORD   CodePage; // Possibly important to resource retrieval.
DWORD   Reserved; // Not important to resource retrieval.
}
IMAGE_RESOURCE_DATA_ENTRY, *PIMAGE_RESOURCE_DATA_ENTRY;

Ändert sich im Vergleich zur 32 Bit EXE irgendwas an der Größe der WORD und DWORD Felder? Ist die einzige Erklärung die mir spontan einfällt, außer, dass die Strukturen für 64 Bit EXEn komplett geändert wurden, was ich mir aber irgendwie auch nicht vorstelle kann.

Gruß Zacherl

[mr_emre_d]

Könnte es sein, dass bei dieser Struktur etwas fehlt ?

Ich hatte nämlich vor einiger Zeit mal einen PE-Crypter für mich geschrieben und da
hatte ich das auch durchgenommen.
Bei mir sah das ca so aus

Delphi-Quellcode:

  TResource_Directory_Table = packed record
    Resource_Flags        : Cardinal;
    Time_Data_Stamp       : Cardinal;
    Major_Version         : Word;
    Minor_Version         : Word;
    Name_Entry            : Word;
    ID_Entry              : Word;
    Resource_Dir_Entries  : Cardinal;
  end;

EDIT:
Was vlt noch hilfreich sein könnte:
Das Format für die 64 Bit Executables nennt sich pe32+ oder einfach nur pe+!
pe+

MfG

[Zacherl]

Bei deiner Struktur ist ja lediglich das Resource_Dir_Entries hinzugekommen. Bei mir enthalten allerdings schon die ersten Felder total unsinnige Werte. Ich prüfe jetzt mal, ob das doch daran liegen könnte, dass mein IMAGE_OPTIONAL_HEADER für 32 Bit und nicht für 64 Bit ausgelegt ist.

€dit: Unglaublich ^^ Da habe ich tatsächlich an der falschen Stelle gesucht. Mit einer Deklaration des ImageOptionalHeaders nach folgender Art konnte ich problemlos 64 Bit EXEn öffnen:

Delphi-Quellcode:

DllCharacteristics: Word;
    SizeOfStackReserve: DWORD;
    X1: DWORD;
    SizeOfStackCommit: DWORD;
    X2: DWORD;
    SizeOfHeapReserve: DWORD;
    X3: DWORD;
    SizeOfHeapCommit: DWORD;
    X4: DWORD;
    LoaderFlags: DWORD;
    NumberOfRvaAndSizes: DWORD;
    DataDirectory: packed array[0..IMAGE_NUMBEROF_DIRECTORY_ENTRIES-1] of TImageDataDirectory;

Jetzt muss ich das ganze nur noch anhand der Erkennungsmethode dynamisch machen und es ist perfekt :)

Danke euch!