0x1 前言

本篇文章是Windows PE学习的下篇,讲述Windows PE中的导入、重定位,以及用C++实现一个PE Parser,PE导入主要分为三部分:导入目录表(Import Directory Table)、导入查询表(Import Lookup Table)、导入地址表(Import Address Table),这三部分都位于.idata(导入数据节)中,然后会讲述PE重定位是什么,它在哪里,如何进行重定位,最后实现的PE Parser可以解析32位PE和64位PE,解析部分如下

  • DOS Header
  • Rich Header
  • NT Headers
  • Data Directory
  • Section Headers
  • Import Table
  • Relocation Table

0x2 导入目录表(Import Directory Table)

导入目录表是从.idata节起始地址开始的一段特殊数据,它是一个IMAGE_IMPORT_DESCRIPTOR结构体数组,数组中的每个成员对应一个需要导入的DLL,它没有固定大小,数组中最后一个成员的所有值被置为0,来表示导入目录表的结尾,IMAGE_IMPORT_DESCRIPTOR的定义如下

typedef struct _IMAGE_IMPORT_DESCRIPTOR {
    union {
        DWORD   Characteristics;
        DWORD   OriginalFirstThunk;
    } DUMMYUNIONNAME;
    DWORD   TimeDateStamp;
    DWORD   ForwarderChain;
    DWORD   Name;
    DWORD   FirstThunk;
} IMAGE_IMPORT_DESCRIPTOR;
typedef IMAGE_IMPORT_DESCRIPTOR UNALIGNED *PIMAGE_IMPORT_DESCRIPTOR;

OriginalFirstThunk:是导入查询表的RVA
TimeDateStamp:如果没使用绑定导入,这个字段值为0,如果使用绑定导入,这个字段值为-1,如果开始没使用绑定导入,后面发生绑定导入,那时间戳会被更新为DLL的时间戳,当使用绑定导入时,这个字段的值始终为-1,此时DLL的真实时间戳位于绑定导入目录表IMAGE_BOUND_IMPORT_DESCRIPTOR中(这段看不懂也没关系,后面会介绍绑定导入,可以再回过头来看)
ForwarderChain:第一个转发链引用的索引,转发链是负责DLL转发的,当一个DLL想要转发它的一些导出函数到另外一个DLL
Name:包含要导入DLL的名字的ASCII字符串的RVA
FirstThunk:导入地址表的RVA

绑定导入(Bound Imports)

绑定导入的含义是提前计算要导入函数的地址,在编译阶段由链接器计算和写入到绑定导入数据目录表

绑定导入本质是一种优化机制,它减少了PE文件载入内存后,PE Loader解析函数地址并填充到IAT的时间,但是如果提前计算的地址不等于实际地址(DLL版本更新了),那PE Loader还是需要重新计算函数地址,并写入IAT

在讨论IMAGE_IMPORT_DESCRIPTOR.TimeDateStamp的时候,提到了当使用绑定导入的时候,日期时间戳设置为-1,实际上DLL的日期时间戳可以在绑定导入数据目录的IMAGE_BOUND_IMPORT_DESCRIPTOR中发现

绑定导入数据目录(Bound Import Data Directory)

绑定导入数据目录和导入目录表类似,只不过它里面的信息是关于绑定导入,它是一个IMAGE_BOUND_IMPORT_DESCRIPTOR结构体数组,同样最后一个成员的全部值为0,其中IMAGE_BOUND_IMPORT_DESCRIPTOR的定义如下

typedef struct _IMAGE_BOUND_IMPORT_DESCRIPTOR {
    DWORD   TimeDateStamp;
    WORD    OffsetModuleName;
    WORD    NumberOfModuleForwarderRefs;
// Array of zero or more IMAGE_BOUND_FORWARDER_REF follows
} IMAGE_BOUND_IMPORT_DESCRIPTOR,  *PIMAGE_BOUND_IMPORT_DESCRIPTOR;

TimeDateStamp:被导入DLL的时间戳
OffsetModuleName:包含要导入DLL的名字的ASCII字符串的RVA,它是相对于IMAGE_BOUND_IMPORT_DESCRIPTOR起始地址的RVA
NumberOfModuleForwarderRefs:紧随这个结构体之后下一个结构体IMAGE_BOUND_FORWARDER_REF的数量,IMAGE_BOUND_FORWARDER_REF是一个几乎等同于IMAGE_BOUND_IMPORT_DESCRIPTOR的结构体,唯一的区别是最后一个成员是被保留的

0x3 导入查询表(Import Lookup Table)

导入查询表,也叫导入名称表

每一个要导入的DLL都有一个导入查询表,IMAGE_IMPORT_DESCRIPTOR.OriginalFirstThunk中的值就是对应DLL的导入查询表的RVA

导入查询表的本质是对DLL中用到的函数的引用,它告诉PE Loader,DLL中的哪些函数是被用到的

导入查询表是一个4字节的数组(对于32位PE),或者8字节的数组(对于64位PE),最后一个成员值为0表示导入查询表的结束

64位数字(8字节)中,每一位的含义如下:

  • 最后一位(32位PE中是Bit 31,64位PE中是Bit 63):称为序号名称标志位,它指定了是通过名字还是通过序号导入函数
  • Bits 0-15(序号名称标志位为1):如果序号名称标志位为1的话,则Bits 0-15装的是16位的序号,用这个序号来导入函数,Bits 16-30(Bits 16-62)值为0
  • Bits 0-30(序号名称标志位为0):如果序号名称标志位为0的话,则Bits 0-30(Bits 0-62)装的是函数名称表的RVA

其中函数名称表是一个结构体,定义在winnt.h中,定义如下

typedef struct _IMAGE_IMPORT_BY_NAME {
    WORD    Hint;
    CHAR   Name[1];
} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;
  • Hint:一个2字节的数字用来查找函数,这个数字首先作为DLL导出函数名称表的索引,如果查找失败,那么会在DLL导出函数名称表执行二分搜索
  • Name:包含要导入函数的名称,以Null结尾

0x4 导入地址表(Import Address Table)

在PE文件中IAT完全等于导入查询表,不同的地方在于,PE文件载入内存时,IAT中的地址被绑定导入数据目录中的地址覆盖

梳理一下,PE Loader在解析的时候,首先通过NT Headers -> PE Optional Header -> Data Directory[IMAGE_DIRECTORY_ENTRY_IMPORT]来找到导入目录表的地址

然后通过IMAGE_IMPORT_DESCRIPTOR -> OriginalFirstThunk找到ILT的地址,通过IMAGE_IMPORT_DESCRIPTOR -> FirstThunk找到IAT的地址,PE文件载入到内存前,IAT等于ILT,PE文件载入内存后,PE Loader会使用实际地址覆盖IAT中的地址

如果在编译期间使用了绑定导入,就会有绑定导入数据目录,PE文件载入时无需重新计算实际地址,直接使用绑定导入数据目录中的地址替换,没使用绑定导入的话,就需要PE文件载入时计算

我们看一个实际PE文件的导入部分,这个PE文件没有.idata(导入节)

可以看到导入了哪些DLL,以及每个DLL导入了哪些函数,上述图片中IAT不等于ILT是因为链接器启用了IAT分离优化,将IAT和ILT放在不同节区,IAT因为后期会写入放在.data节,ILT是只读的放在.rdata节,不管它们是否相等,作用是不变的

  • ILT负责“记录要导入的函数”
  • IAT负责“存储函数的真实地址(加载后)”

0x5 基址重定位

重定位是什么

PE文件在编译时,编译器会假设PE文件载入内存时的基地址是IMAGE_OPTIONAL_HEADER.ImageBase,然后根据这个基址计算后得出一些硬编码地址,但由于ASLR等安全机制,PE文件在载入内存时,几乎不会使用ImageBase这个基址,这个时候,硬编码那些地址就无效了,所以需要重定位

全部硬编码的地址被集中在一个区域,这个区域称为重定位表,上一篇文章讲述了,PE Option Header->Data Directory[BASERELOC]就负责指向重定位表,并且重定位表位于.reloc节中

举个小例子演示一下

int test = 2;
int* testPtr = &test;

在编译时,假设PE在内存的基地址是0x1000,然后test的偏移地址是0x100,那么test在内存中的地址就是0x1100,testPtr的值也就是0x1100,然后当PE实际载入到内存后,基地址变成了0x4000,这个时候重定位需要做的是,0x1100 + (0x2000 - 0x1000) = 0x2100,重定位修复后,testPtr的值变为0x2100

重定位表

.reloc节本质不是一个结构体,而是由多个紧密相邻的重定位块组成的(需要注意,这里的紧密相邻需要遵循4字节对齐,就是起始地址需要是4或者4的整数倍),最后一个重定位块是空块,表示重定位表的结束,每个重定位块对应一个4KB页面,其中每个重定位块的结构是一个重定位块头 + 多个重定位块项,重定位块头是一个结构体,定义如下

typedef struct _IMAGE_BASE_RELOCATION {
    DWORD   VirtualAddress;
    DWORD   SizeOfBlock;
} IMAGE_BASE_RELOCATION;
typedef IMAGE_BASE_RELOCATION UNALIGNED * PIMAGE_BASE_RELOCATION;

VirtualAddress:表示指向的4KB页面的起始地址
SizeOfBlock:表示当前重定位块的大小

每个重定位块项对应一个需要修改的硬编码地址,所以有几个重定位块项,要看这个4KB页面有几个硬编码地址,重定位块项是WORD类型,也就是2字节,16位,其中高4位用来表示这个硬编码地址的重定位类型(比如最常见的IMAGE_REL_BASED_HIGHLOW,表示“修正32位地址”),低12位用来寻址,4KB=4096字节=2的12次幂,所以用12位来寻址刚好可以覆盖4KB大小

需要重定位修复的地址 = PE基址 + VirtualAddress + 低12位的地址

下图所示是一个实际PE文件的重定位表,可以看到它有2个重定位块,拿第一个重定位块来说,它指向的页面偏移地址是0x5000,那个页面中需要重定位的块项数是0x3A,重定位块本身的大小是0x7C

重定位块头固定是8字节,7C(124) - 8 = 116,每个重定位块项占2个字节,所以重定位块项的数量是 116 / 2 = 58(3A)

0x6 PE Parser Readme

  1. 以二进制形式读取一个PE文件
  2. 通过校验DOS头中的Signature和NT头中的Signature这两个固定值,判断它是否有效的PE文件
  3. 通过PE可选头中的字段判断它是32位PE还是64位PE
  4. 解析下列结构
  • DOS Header
  • Rich Header
  • NT Headers
  • Section Headers
  • Import Data Directory
  • Relocation Data Directory
  1. 输出下列信息
  • 文件名和类型
  • DOS头中的签名以及PE文件的实际起始地址
  • 富有头中的每一项
  • PE文件Signature
  • PE文件头中节的数量、PE可选头的大小
  • PE可选头中代码节的大小、初始化数据节的大小、未初始化数据节的大小、入口点的地址、代码节的起始RVA、期望的映像基址、节对齐、文件对齐、映像文件大小、各类头的大小
  • 数据目录中每一项的名字、RVA、大小
  • 节头中节的名字、节在文件中的起始地址和大小、节在内存中的起始地址和大小、节的属性
  • 导入表中每个DLL的名字、ILT和IAT、是否使用绑定导入、使用名称还是需要搜索函数、函数名称表的RVA
  • 重定位表中每个块对应的页面RVA、块大小、块项的数量

0x7 整理用到的结构体

代码实现中会用到定义在winnt.h中的类型、常量、结构体,整理后放到winntdef.h中,代码如下

typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef unsigned long DWORD;
typedef unsigned long long QWORD;
typedef unsigned long LONG;
typedef __int64 LONGLONG;
typedef unsigned __int64 ULONGLONG;

#define ___IMAGE_NT_OPTIONAL_HDR32_MAGIC       0x10b
#define ___IMAGE_NT_OPTIONAL_HDR64_MAGIC       0x20b
#define ___IMAGE_NUMBEROF_DIRECTORY_ENTRIES    16
#define ___IMAGE_DOS_SIGNATURE                 0x5A4D

#define ___IMAGE_DIRECTORY_ENTRY_EXPORT          0
#define ___IMAGE_DIRECTORY_ENTRY_IMPORT          1
#define ___IMAGE_DIRECTORY_ENTRY_RESOURCE        2
#define ___IMAGE_DIRECTORY_ENTRY_EXCEPTION       3
#define ___IMAGE_DIRECTORY_ENTRY_SECURITY        4
#define ___IMAGE_DIRECTORY_ENTRY_BASERELOC       5
#define ___IMAGE_DIRECTORY_ENTRY_DEBUG           6
#define ___IMAGE_DIRECTORY_ENTRY_ARCHITECTURE    7
#define ___IMAGE_DIRECTORY_ENTRY_GLOBALPTR       8
#define ___IMAGE_DIRECTORY_ENTRY_TLS             9
#define ___IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG    10
#define ___IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT   11
#define ___IMAGE_DIRECTORY_ENTRY_IAT            12
#define ___IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT   13
#define ___IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14

#define ___IMAGE_SIZEOF_SHORT_NAME              8
#define ___IMAGE_SIZEOF_SECTION_HEADER          40

typedef struct __IMAGE_DOS_HEADER {
    WORD   e_magic;
    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];
    LONG   e_lfanew;
} ___IMAGE_DOS_HEADER, * ___PIMAGE_DOS_HEADER;

typedef struct __IMAGE_DATA_DIRECTORY {
    DWORD   VirtualAddress;
    DWORD   Size;
} ___IMAGE_DATA_DIRECTORY, * ___PIMAGE_DATA_DIRECTORY;


typedef struct __IMAGE_OPTIONAL_HEADER {
    WORD    Magic;
    BYTE    MajorLinkerVersion;
    BYTE    MinorLinkerVersion;
    DWORD   SizeOfCode;
    DWORD   SizeOfInitializedData;
    DWORD   SizeOfUninitializedData;
    DWORD   AddressOfEntryPoint;
    DWORD   BaseOfCode;
    DWORD   BaseOfData;
    DWORD   ImageBase;
    DWORD   SectionAlignment;
    DWORD   FileAlignment;
    WORD    MajorOperatingSystemVersion;
    WORD    MinorOperatingSystemVersion;
    WORD    MajorImageVersion;
    WORD    MinorImageVersion;
    WORD    MajorSubsystemVersion;
    WORD    MinorSubsystemVersion;
    DWORD   Win32VersionValue;
    DWORD   SizeOfImage;
    DWORD   SizeOfHeaders;
    DWORD   CheckSum;
    WORD    Subsystem;
    WORD    DllCharacteristics;
    DWORD   SizeOfStackReserve;
    DWORD   SizeOfStackCommit;
    DWORD   SizeOfHeapReserve;
    DWORD   SizeOfHeapCommit;
    DWORD   LoaderFlags;
    DWORD   NumberOfRvaAndSizes;
    ___IMAGE_DATA_DIRECTORY DataDirectory[___IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} ___IMAGE_OPTIONAL_HEADER32, * ___PIMAGE_OPTIONAL_HEADER32;

typedef struct __IMAGE_OPTIONAL_HEADER64 {
    WORD        Magic;
    BYTE        MajorLinkerVersion;
    BYTE        MinorLinkerVersion;
    DWORD       SizeOfCode;
    DWORD       SizeOfInitializedData;
    DWORD       SizeOfUninitializedData;
    DWORD       AddressOfEntryPoint;
    DWORD       BaseOfCode;
    ULONGLONG   ImageBase;
    DWORD       SectionAlignment;
    DWORD       FileAlignment;
    WORD        MajorOperatingSystemVersion;
    WORD        MinorOperatingSystemVersion;
    WORD        MajorImageVersion;
    WORD        MinorImageVersion;
    WORD        MajorSubsystemVersion;
    WORD        MinorSubsystemVersion;
    DWORD       Win32VersionValue;
    DWORD       SizeOfImage;
    DWORD       SizeOfHeaders;
    DWORD       CheckSum;
    WORD        Subsystem;
    WORD        DllCharacteristics;
    ULONGLONG   SizeOfStackReserve;
    ULONGLONG   SizeOfStackCommit;
    ULONGLONG   SizeOfHeapReserve;
    ULONGLONG   SizeOfHeapCommit;
    DWORD       LoaderFlags;
    DWORD       NumberOfRvaAndSizes;
    ___IMAGE_DATA_DIRECTORY DataDirectory[___IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} ___IMAGE_OPTIONAL_HEADER64, * ___PIMAGE_OPTIONAL_HEADER64;

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;

typedef struct __IMAGE_NT_HEADERS64 {
    DWORD Signature;
    ___IMAGE_FILE_HEADER FileHeader;
    ___IMAGE_OPTIONAL_HEADER64 OptionalHeader;
} ___IMAGE_NT_HEADERS64, * ___PIMAGE_NT_HEADERS64;

typedef struct __IMAGE_NT_HEADERS {
    DWORD Signature;
    ___IMAGE_FILE_HEADER FileHeader;
    ___IMAGE_OPTIONAL_HEADER32 OptionalHeader;
} ___IMAGE_NT_HEADERS32, * ___PIMAGE_NT_HEADERS32;

typedef struct __IMAGE_IMPORT_DESCRIPTOR {
    union {
        DWORD   Characteristics;
        DWORD   OriginalFirstThunk;
    } DUMMYUNIONNAME;
    DWORD   TimeDateStamp;
    DWORD   ForwarderChain;
    DWORD   Name;
    DWORD   FirstThunk;
} ___IMAGE_IMPORT_DESCRIPTOR, * ___PIMAGE_IMPORT_DESCRIPTOR;

typedef struct __IMAGE_IMPORT_BY_NAME {
    WORD    Hint;
    char   Name[100];
} ___IMAGE_IMPORT_BY_NAME, * ___PIMAGE_IMPORT_BY_NAME;

typedef struct __IMAGE_BASE_RELOCATION {
    DWORD   VirtualAddress;
    DWORD   SizeOfBlock;
} ___IMAGE_BASE_RELOCATION, * ___PIMAGE_BASE_RELOCATION;

typedef struct __IMAGE_SECTION_HEADER {
    BYTE    Name[___IMAGE_SIZEOF_SHORT_NAME];
    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;

0x8 自定义结构体

自定义一些结构体,方便解析PE文件,放到PEFILE_CUSTOM_STRUCTS.h中

#pragma once
#include "winntdef.h"

typedef struct __RICH_HEADER_INFO {
    int size;
    char* ptrToBuffer;
    int entries;
} RICH_HEADER_INFO, * PRICH_HEADER_INFO;

typedef struct __RICH_HEADER_ENTRY {
    WORD  prodID;
    WORD  buildID;
    DWORD useCount;
} RICH_HEADER_ENTRY, * PRICH_HEADER_ENTRY;

typedef struct __RICH_HEADER {
    PRICH_HEADER_ENTRY entries;
} RICH_HEADER, * PRICH_HEADER;

typedef struct __ILT_ENTRY_64 {
    union {
        DWORD ORDINAL : 16;
        DWORD HINT_NAME_TABE : 32;
    } FIELD_2;
    DWORD ORDINAL_NAME_FLAG : 1;
} ILT_ENTRY_64, * PILT_ENTRY_64;

typedef struct __ILT_ENTRY_32 {
    union {
        DWORD ORDINAL : 16;
        DWORD HINT_NAME_TABE : 32;
        DWORD ORDINAL_NAME_FLAG : 1;
    } FIELD_1;
} ILT_ENTRY_32, * PILT_ENTRY_32;

typedef struct __BASE_RELOC_ENTRY {
    WORD OFFSET : 12;
    WORD TYPE : 4;
} BASE_RELOC_ENTRY, * PBASE_RELOC_ENTRY;

0x9 代码实现

整理逻辑是PE-Parser.cpp调用PEFILE,PEFILE根据PE文件是32位还是64位,传给PE32FILE还是PE64FILE,定义在.h文件中,实现在.cpp文件中

PE-Parser.cpp

#include <iostream>
#include <fstream>
#include "PEFILE.h"

int main(int argc, char* argv[])
{
    if (argc != 2) {
        printf("Usage: %s [path to executable]\n", argv[0]);
        return 1;
    }

    FILE* PpeFile;
    fopen_s(&PpeFile, argv[1], "rb");

    if (PpeFile == NULL) {
        printf("Can't open file.\n");
        return 1;
    }

    if (INITPARSE(PpeFile) == 1) {
        exit(1);
    }
    else if (INITPARSE(PpeFile) == 32) {
        PE32FILE PeFile_1(argv[1], PpeFile);
        PeFile_1.PrintInfo();
        fclose(PpeFile);
        exit(0);
    }
    else if (INITPARSE(PpeFile) == 64) {
        PE64FILE PeFile_1(argv[1], PpeFile);
        PeFile_1.PrintInfo();
        fclose(PpeFile);
        exit(0);
    }

    return 0;
}

PEFILE.h

#pragma once
#include "PE32FILE.h"
#include "PE64FILE.h"

int INITPARSE(FILE* PpeFile);

PEFILE.cpp

#include "PEFILE.h"

// INITIAL PARSE //

int INITPARSE(FILE* PpeFile) {
    ___IMAGE_DOS_HEADER TMP_DOS_HEADER;
    WORD PEFILE_TYPE;

    fseek(PpeFile, 0, SEEK_SET);
    fread(&TMP_DOS_HEADER, sizeof(___IMAGE_DOS_HEADER), 1, PpeFile);

    if (TMP_DOS_HEADER.e_magic != ___IMAGE_DOS_SIGNATURE) {
        printf("Error. Not a PE file.\n");
        return 1;
    }

    fseek(PpeFile, (TMP_DOS_HEADER.e_lfanew + sizeof(DWORD) + sizeof(___IMAGE_FILE_HEADER)), SEEK_SET);
    fread(&PEFILE_TYPE, sizeof(WORD), 1, PpeFile);

    if (PEFILE_TYPE == ___IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
        return 32;
    }
    else if (PEFILE_TYPE == ___IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
        return 64;
    }
    else {
        printf("Error while parsing IMAGE_OPTIONAL_HEADER.Magic. Unknown Type.\n");
        return 1;
    }

}

PE32FILE.h

#pragma once
#include "winntdef.h"
#include "PEFILE_CUSTOM_STRUCTS.h"
#include <string>

class PE32FILE
{
public:
    PE32FILE(char* _NAME, FILE* Ppefile);

    void PrintInfo();

private:
    char* NAME;
    FILE* Ppefile;
    int _import_directory_count, _import_directory_size;
    int _basreloc_directory_count;

    // HEADERS
    ___IMAGE_DOS_HEADER     PEFILE_DOS_HEADER;
    ___IMAGE_NT_HEADERS32   PEFILE_NT_HEADERS;

    // DOS HEADER
    DWORD PEFILE_DOS_HEADER_EMAGIC;
    LONG  PEFILE_DOS_HEADER_LFANEW;

    // RICH HEADER
    RICH_HEADER_INFO PEFILE_RICH_HEADER_INFO;
    RICH_HEADER PEFILE_RICH_HEADER;

    // NT_HEADERS.Signature
    DWORD PEFILE_NT_HEADERS_SIGNATURE;

    // NT_HEADERS.FileHeader
    WORD PEFILE_NT_HEADERS_FILE_HEADER_MACHINE;
    WORD PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS;
    WORD PEFILE_NT_HEADERS_FILE_HEADER_SIZEOF_OPTIONAL_HEADER;

    // NT_HEADERS.OptionalHeader
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_MAGIC;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_CODE;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_INITIALIZED_DATA;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_UNINITIALIZED_DATA;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_ADDRESSOF_ENTRYPOINT;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_BASEOF_CODE;
    ULONGLONG PEFILE_NT_HEADERS_OPTIONAL_HEADER_IMAGEBASE;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SECTION_ALIGNMENT;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_FILE_ALIGNMENT;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_IMAGE;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_HEADERS;

    ___IMAGE_DATA_DIRECTORY PEFILE_EXPORT_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_IMPORT_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_RESOURCE_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_EXCEPTION_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_SECURITY_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_BASERELOC_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_DEBUG_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_ARCHITECTURE_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_GLOBALPTR_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_TLS_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_LOAD_CONFIG_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_BOUND_IMPORT_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_IAT_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_DELAY_IMPORT_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_COM_DESCRIPTOR_DIRECTORY;

    // SECTION HEADERS
    ___PIMAGE_SECTION_HEADER PEFILE_SECTION_HEADERS;

    // IMPORT TABLE
    ___PIMAGE_IMPORT_DESCRIPTOR PEFILE_IMPORT_TABLE;

    // BASE RELOCATION TABLE
    ___PIMAGE_BASE_RELOCATION PEFILE_BASERELOC_TABLE;

    // FUNCTIONS

    // ADDRESS RESOLVERS
    int  locate(DWORD VA);
    DWORD resolve(DWORD VA, int index);

    // PARSERS
    void ParseFile();
    void ParseDOSHeader();
    void ParseNTHeaders();
    void ParseSectionHeaders();
    void ParseImportDirectory();
    void ParseBaseReloc();
    void ParseRichHeader();

    // PRINT INFO
    void PrintFileInfo();
    void PrintDOSHeaderInfo();
    void PrintRichHeaderInfo();
    void PrintNTHeadersInfo();
    void PrintSectionHeadersInfo();
    void PrintImportTableInfo();
    void PrintBaseRelocationsInfo();
};

PE32FILE.cpp

#include "PE32FILE.h"

// CONSTRUCTOR
PE32FILE::PE32FILE(char* _NAME, FILE* _Ppefile) {

    NAME = _NAME;
    Ppefile = _Ppefile;

    ParseFile();

}

// ADDRESS RESOLVERS
int PE32FILE::locate(DWORD VA) {

    int index;

    for (int i = 0; i < PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS; i++) {
        if (VA >= PEFILE_SECTION_HEADERS[i].VirtualAddress
            && VA < (PEFILE_SECTION_HEADERS[i].VirtualAddress + PEFILE_SECTION_HEADERS[i].Misc.VirtualSize)) {
            index = i;
            break;
        }
    }
    return index;

}

DWORD PE32FILE::resolve(DWORD VA, int index) {

    return (VA - PEFILE_SECTION_HEADERS[index].VirtualAddress) + PEFILE_SECTION_HEADERS[index].PointerToRawData;

}

// PARSERS
void PE32FILE::ParseDOSHeader() {

    fseek(Ppefile, 0, SEEK_SET);
    fread(&PEFILE_DOS_HEADER, sizeof(___IMAGE_DOS_HEADER), 1, Ppefile);

    PEFILE_DOS_HEADER_EMAGIC = PEFILE_DOS_HEADER.e_magic;
    PEFILE_DOS_HEADER_LFANEW = PEFILE_DOS_HEADER.e_lfanew;

}

void PE32FILE::ParseNTHeaders() {

    fseek(Ppefile, PEFILE_DOS_HEADER.e_lfanew, SEEK_SET);
    fread(&PEFILE_NT_HEADERS, sizeof(PEFILE_NT_HEADERS), 1, Ppefile);

    PEFILE_NT_HEADERS_SIGNATURE = PEFILE_NT_HEADERS.Signature;

    PEFILE_NT_HEADERS_FILE_HEADER_MACHINE = PEFILE_NT_HEADERS.FileHeader.Machine;
    PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS = PEFILE_NT_HEADERS.FileHeader.NumberOfSections;
    PEFILE_NT_HEADERS_FILE_HEADER_SIZEOF_OPTIONAL_HEADER = PEFILE_NT_HEADERS.FileHeader.SizeOfOptionalHeader;

    PEFILE_NT_HEADERS_OPTIONAL_HEADER_MAGIC = PEFILE_NT_HEADERS.OptionalHeader.Magic;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_CODE = PEFILE_NT_HEADERS.OptionalHeader.SizeOfCode;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_INITIALIZED_DATA = PEFILE_NT_HEADERS.OptionalHeader.SizeOfInitializedData;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_UNINITIALIZED_DATA = PEFILE_NT_HEADERS.OptionalHeader.SizeOfUninitializedData;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_ADDRESSOF_ENTRYPOINT = PEFILE_NT_HEADERS.OptionalHeader.AddressOfEntryPoint;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_BASEOF_CODE = PEFILE_NT_HEADERS.OptionalHeader.BaseOfCode;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_IMAGEBASE = PEFILE_NT_HEADERS.OptionalHeader.ImageBase;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SECTION_ALIGNMENT = PEFILE_NT_HEADERS.OptionalHeader.SectionAlignment;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_FILE_ALIGNMENT = PEFILE_NT_HEADERS.OptionalHeader.FileAlignment;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_IMAGE = PEFILE_NT_HEADERS.OptionalHeader.SizeOfImage;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_HEADERS = PEFILE_NT_HEADERS.OptionalHeader.SizeOfHeaders;

    PEFILE_EXPORT_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_EXPORT];
    PEFILE_IMPORT_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_IMPORT];
    PEFILE_RESOURCE_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_RESOURCE];
    PEFILE_EXCEPTION_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_EXCEPTION];
    PEFILE_SECURITY_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_SECURITY];
    PEFILE_BASERELOC_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_BASERELOC];
    PEFILE_DEBUG_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_DEBUG];
    PEFILE_ARCHITECTURE_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_ARCHITECTURE];
    PEFILE_GLOBALPTR_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_GLOBALPTR];
    PEFILE_TLS_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_TLS];
    PEFILE_LOAD_CONFIG_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG];
    PEFILE_BOUND_IMPORT_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT];
    PEFILE_IAT_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_IAT];
    PEFILE_DELAY_IMPORT_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT];
    PEFILE_COM_DESCRIPTOR_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR];

}

void PE32FILE::ParseSectionHeaders() {

    PEFILE_SECTION_HEADERS = new ___IMAGE_SECTION_HEADER[PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS];
    for (int i = 0; i < PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS; i++) {
        int offset = (PEFILE_DOS_HEADER.e_lfanew + sizeof(PEFILE_NT_HEADERS)) + (i * ___IMAGE_SIZEOF_SECTION_HEADER);
        fseek(Ppefile, offset, SEEK_SET);
        fread(&PEFILE_SECTION_HEADERS[i], ___IMAGE_SIZEOF_SECTION_HEADER, 1, Ppefile);
    }

}

void PE32FILE::ParseImportDirectory() {

    DWORD _import_directory_address = resolve(PEFILE_IMPORT_DIRECTORY.VirtualAddress, locate(PEFILE_IMPORT_DIRECTORY.VirtualAddress));
    _import_directory_count = 0;

    while (true) {
        ___IMAGE_IMPORT_DESCRIPTOR tmp;
        int offset = (_import_directory_count * sizeof(___IMAGE_IMPORT_DESCRIPTOR)) + _import_directory_address;
        fseek(Ppefile, offset, SEEK_SET);
        fread(&tmp, sizeof(___IMAGE_IMPORT_DESCRIPTOR), 1, Ppefile);

        if (tmp.Name == 0x00000000 && tmp.FirstThunk == 0x00000000) {
            _import_directory_count -= 1;
            _import_directory_size = _import_directory_count * sizeof(___IMAGE_IMPORT_DESCRIPTOR);
            break;
        }

        _import_directory_count++;
    }

    PEFILE_IMPORT_TABLE = new ___IMAGE_IMPORT_DESCRIPTOR[_import_directory_count];

    for (int i = 0; i < _import_directory_count; i++) {
        int offset = (i * sizeof(___IMAGE_IMPORT_DESCRIPTOR)) + _import_directory_address;
        fseek(Ppefile, offset, SEEK_SET);
        fread(&PEFILE_IMPORT_TABLE[i], sizeof(___IMAGE_IMPORT_DESCRIPTOR), 1, Ppefile);
    }

}

void PE32FILE::ParseBaseReloc() {

    DWORD _basereloc_directory_address = resolve(PEFILE_BASERELOC_DIRECTORY.VirtualAddress, locate(PEFILE_BASERELOC_DIRECTORY.VirtualAddress));
    _basreloc_directory_count = 0;
    int _basereloc_size_counter = 0;

    while (true) {
        ___IMAGE_BASE_RELOCATION tmp;

        int offset = (_basereloc_size_counter + _basereloc_directory_address);

        fseek(Ppefile, offset, SEEK_SET);
        fread(&tmp, sizeof(___IMAGE_BASE_RELOCATION), 1, Ppefile);

        if (tmp.VirtualAddress == 0x00000000 &&
            tmp.SizeOfBlock == 0x00000000) {
            break;
        }

        _basreloc_directory_count++;
        _basereloc_size_counter += tmp.SizeOfBlock;
    }

    PEFILE_BASERELOC_TABLE = new ___IMAGE_BASE_RELOCATION[_basreloc_directory_count];

    _basereloc_size_counter = 0;

    for (int i = 0; i < _basreloc_directory_count; i++) {
        int offset = _basereloc_directory_address + _basereloc_size_counter;
        fseek(Ppefile, offset, SEEK_SET);
        fread(&PEFILE_BASERELOC_TABLE[i], sizeof(___IMAGE_BASE_RELOCATION), 1, Ppefile);
        _basereloc_size_counter += PEFILE_BASERELOC_TABLE[i].SizeOfBlock;
    }

}

void PE32FILE::ParseRichHeader() {

    char* dataPtr = new char[PEFILE_DOS_HEADER_LFANEW];
    fseek(Ppefile, 0, SEEK_SET);
    fread(dataPtr, PEFILE_DOS_HEADER_LFANEW, 1, Ppefile);

    int index_ = 0;

    for (int i = 0; i <= PEFILE_DOS_HEADER_LFANEW; i++) {
        if (dataPtr[i] == 0x52 && dataPtr[i + 1] == 0x69) {
            index_ = i;
            break;
        }
    }

    if (index_ == 0) {
        printf("Error while parsing Rich Header.");
        PEFILE_RICH_HEADER_INFO.entries = 0;
        return;
    }

    char key[4];
    memcpy(key, dataPtr + (index_ + 4), 4);

    int indexpointer = index_ - 4;
    int RichHeaderSize = 0;

    while (true) {
        char tmpchar[4];
        memcpy(tmpchar, dataPtr + indexpointer, 4);

        for (int i = 0; i < 4; i++) {
            tmpchar[i] = tmpchar[i] ^ key[i];
        }

        indexpointer -= 4;
        RichHeaderSize += 4;

        if (tmpchar[1] = 0x61 && tmpchar[0] == 0x44) {
            break;
        }
    }

    char* RichHeaderPtr = new char[RichHeaderSize];
    memcpy(RichHeaderPtr, dataPtr + (index_ - RichHeaderSize), RichHeaderSize);

    for (int i = 0; i < RichHeaderSize; i += 4) {

        for (int x = 0; x < 4; x++) {
            RichHeaderPtr[i + x] = RichHeaderPtr[i + x] ^ key[x];
        }

    }

    PEFILE_RICH_HEADER_INFO.size = RichHeaderSize;
    PEFILE_RICH_HEADER_INFO.ptrToBuffer = RichHeaderPtr;
    PEFILE_RICH_HEADER_INFO.entries = (RichHeaderSize - 16) / 8;

    delete[] dataPtr;

    PEFILE_RICH_HEADER.entries = new RICH_HEADER_ENTRY[PEFILE_RICH_HEADER_INFO.entries];

    for (int i = 16; i < RichHeaderSize; i += 8) {
        WORD PRODID = (uint16_t)((unsigned char)RichHeaderPtr[i + 3] << 8) | (unsigned char)RichHeaderPtr[i + 2];
        WORD BUILDID = (uint16_t)((unsigned char)RichHeaderPtr[i + 1] << 8) | (unsigned char)RichHeaderPtr[i];
        DWORD USECOUNT = (uint32_t)((unsigned char)RichHeaderPtr[i + 7] << 24) | (unsigned char)RichHeaderPtr[i + 6] << 16 | (unsigned char)RichHeaderPtr[i + 5] << 8 | (unsigned char)RichHeaderPtr[i + 4];
        PEFILE_RICH_HEADER.entries[(i / 8) - 2] = {
            PRODID,
            BUILDID,
            USECOUNT
        };

        if (i + 8 >= RichHeaderSize) {
            PEFILE_RICH_HEADER.entries[(i / 8) - 1] = { 0x0000, 0x0000, 0x00000000 };
        }

    }

    delete[] PEFILE_RICH_HEADER_INFO.ptrToBuffer;

}

// PRINT INFO
void PE32FILE::PrintFileInfo() {

    printf(" FILE: %s\n", NAME);
    printf(" TYPE: 0x%X (PE32)\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_MAGIC);

}

void PE32FILE::PrintDOSHeaderInfo() {

    printf(" DOS HEADER:\n");
    printf(" -----------\n\n");

    printf(" Magic: 0x%X\n", PEFILE_DOS_HEADER_EMAGIC);
    printf(" File address of new exe header: 0x%X\n", PEFILE_DOS_HEADER_LFANEW);

}

void PE32FILE::PrintRichHeaderInfo() {

    printf(" RICH HEADER:\n");
    printf(" ------------\n\n");

    for (int i = 0; i < PEFILE_RICH_HEADER_INFO.entries; i++) {
        printf(" 0x%X 0x%X 0x%X: %d.%d.%d\n",
            PEFILE_RICH_HEADER.entries[i].buildID,
            PEFILE_RICH_HEADER.entries[i].prodID,
            PEFILE_RICH_HEADER.entries[i].useCount,
            PEFILE_RICH_HEADER.entries[i].buildID,
            PEFILE_RICH_HEADER.entries[i].prodID,
            PEFILE_RICH_HEADER.entries[i].useCount);
    }

}

void PE32FILE::PrintNTHeadersInfo() {

    printf(" NT HEADERS:\n");
    printf(" -----------\n\n");

    printf(" PE Signature: 0x%X\n", PEFILE_NT_HEADERS_SIGNATURE);

    printf("\n File Header:\n\n");
    printf("   Machine: 0x%X\n", PEFILE_NT_HEADERS_FILE_HEADER_MACHINE);
    printf("   Number of sections: 0x%X\n", PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS);
    printf("   Size of optional header: 0x%X\n", PEFILE_NT_HEADERS_FILE_HEADER_SIZEOF_OPTIONAL_HEADER);

    printf("\n Optional Header:\n\n");
    printf("   Magic: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_MAGIC);
    printf("   Size of code section: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_CODE);
    printf("   Size of initialized data: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_INITIALIZED_DATA);
    printf("   Size of uninitialized data: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_UNINITIALIZED_DATA);
    printf("   Address of entry point: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_ADDRESSOF_ENTRYPOINT);
    printf("   RVA of start of code section: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_BASEOF_CODE);
    printf("   Desired image base: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_IMAGEBASE);
    printf("   Section alignment: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SECTION_ALIGNMENT);
    printf("   File alignment: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_FILE_ALIGNMENT);
    printf("   Size of image: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_IMAGE);
    printf("   Size of headers: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_HEADERS);

    printf("\n Data Directories:\n");
    printf("\n   * Export Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_EXPORT_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_EXPORT_DIRECTORY.Size);

    printf("\n   * Import Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_IMPORT_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_IMPORT_DIRECTORY.Size);

    printf("\n   * Resource Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_RESOURCE_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_RESOURCE_DIRECTORY.Size);

    printf("\n   * Exception Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_EXCEPTION_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_EXCEPTION_DIRECTORY.Size);

    printf("\n   * Security Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_SECURITY_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_SECURITY_DIRECTORY.Size);

    printf("\n   * Base Relocation Table:\n");
    printf("       RVA: 0x%X\n", PEFILE_BASERELOC_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_BASERELOC_DIRECTORY.Size);

    printf("\n   * Debug Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_DEBUG_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_DEBUG_DIRECTORY.Size);

    printf("\n   * Architecture Specific Data:\n");
    printf("       RVA: 0x%X\n", PEFILE_ARCHITECTURE_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_ARCHITECTURE_DIRECTORY.Size);

    printf("\n   * RVA of GlobalPtr:\n");
    printf("       RVA: 0x%X\n", PEFILE_GLOBALPTR_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_GLOBALPTR_DIRECTORY.Size);

    printf("\n   * TLS Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_TLS_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_TLS_DIRECTORY.Size);

    printf("\n   * Load Configuration Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_LOAD_CONFIG_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_LOAD_CONFIG_DIRECTORY.Size);

    printf("\n   * Bound Import Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_BOUND_IMPORT_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_BOUND_IMPORT_DIRECTORY.Size);

    printf("\n   * Import Address Table:\n");
    printf("       RVA: 0x%X\n", PEFILE_IAT_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_IAT_DIRECTORY.Size);

    printf("\n   * Delay Load Import Descriptors:\n");
    printf("       RVA: 0x%X\n", PEFILE_DELAY_IMPORT_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_DELAY_IMPORT_DIRECTORY.Size);

    printf("\n   * COM Runtime Descriptor:\n");
    printf("       RVA: 0x%X\n", PEFILE_COM_DESCRIPTOR_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_COM_DESCRIPTOR_DIRECTORY.Size);

}

void PE32FILE::PrintSectionHeadersInfo() {

    printf(" SECTION HEADERS:\n");
    printf(" ----------------\n\n");

    for (int i = 0; i < PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS; i++) {
        printf("   * %.8s:\n", PEFILE_SECTION_HEADERS[i].Name);
        printf("        VirtualAddress: 0x%X\n", PEFILE_SECTION_HEADERS[i].VirtualAddress);
        printf("        VirtualSize: 0x%X\n", PEFILE_SECTION_HEADERS[i].Misc.VirtualSize);
        printf("        PointerToRawData: 0x%X\n", PEFILE_SECTION_HEADERS[i].PointerToRawData);
        printf("        SizeOfRawData: 0x%X\n", PEFILE_SECTION_HEADERS[i].SizeOfRawData);
        printf("        Characteristics: 0x%X\n\n", PEFILE_SECTION_HEADERS[i].Characteristics);
    }

}

void PE32FILE::PrintImportTableInfo() {

    printf(" IMPORT TABLE:\n");
    printf(" ----------------\n\n");

    for (int i = 0; i < _import_directory_count; i++) {
        DWORD NameAddr = resolve(PEFILE_IMPORT_TABLE[i].Name, locate(PEFILE_IMPORT_TABLE[i].Name));
        int NameSize = 0;

        while (true) {
            char tmp;
            fseek(Ppefile, (NameAddr + NameSize), SEEK_SET);
            fread(&tmp, sizeof(char), 1, Ppefile);

            if (tmp == 0x00) {
                break;
            }

            NameSize++;
        }

        char* Name = new char[NameSize + 2];
        fseek(Ppefile, NameAddr, SEEK_SET);
        fread(Name, (NameSize * sizeof(char)) + 1, 1, Ppefile);
        printf("   * %s:\n", Name);
        delete[] Name;

        printf("       ILT RVA: 0x%X\n", PEFILE_IMPORT_TABLE[i].DUMMYUNIONNAME.OriginalFirstThunk);
        printf("       IAT RVA: 0x%X\n", PEFILE_IMPORT_TABLE[i].FirstThunk);

        if (PEFILE_IMPORT_TABLE[i].TimeDateStamp == 0) {
            printf("       Bound: FALSE\n");
        }
        else if (PEFILE_IMPORT_TABLE[i].TimeDateStamp == -1) {
            printf("       Bound: TRUE\n");
        }

        printf("\n");

        DWORD ILTAddr = resolve(PEFILE_IMPORT_TABLE[i].DUMMYUNIONNAME.OriginalFirstThunk, locate(PEFILE_IMPORT_TABLE[i].DUMMYUNIONNAME.OriginalFirstThunk));
        int entrycounter = 0;

        while (true) {

            ILT_ENTRY_32 entry;

            fseek(Ppefile, (ILTAddr + (entrycounter * sizeof(DWORD))), SEEK_SET);
            fread(&entry, sizeof(ILT_ENTRY_32), 1, Ppefile);

            BYTE flag = entry.FIELD_1.ORDINAL_NAME_FLAG;
            DWORD HintRVA = 0x0;
            WORD ordinal = 0x0;

            if (flag == 0x0) {
                HintRVA = entry.FIELD_1.HINT_NAME_TABE;
            }
            else if (flag == 0x01) {
                ordinal = entry.FIELD_1.ORDINAL;
            }

            if (flag == 0x0 && HintRVA == 0x0 && ordinal == 0x0) {
                break;
            }

            printf("\n       Entry:\n");

            if (flag == 0x0) {
                ___IMAGE_IMPORT_BY_NAME hint;

                DWORD HintAddr = resolve(HintRVA, locate(HintRVA));
                fseek(Ppefile, HintAddr, SEEK_SET);
                fread(&hint, sizeof(___IMAGE_IMPORT_BY_NAME), 1, Ppefile);
                printf("         Name: %s\n", hint.Name);
                printf("         Hint RVA: 0x%X\n", HintRVA);
                printf("         Hint: 0x%X\n", hint.Hint);
            }
            else if (flag == 1) {
                printf("         Ordinal: 0x%X\n", ordinal);
            }

            entrycounter++;
        }

        printf("\n   ----------------------\n\n");

    }

}

void PE32FILE::PrintBaseRelocationsInfo() {

    printf(" BASE RELOCATIONS TABLE:\n");
    printf(" -----------------------\n");

    int szCounter = sizeof(___IMAGE_BASE_RELOCATION);

    for (int i = 0; i < _basreloc_directory_count; i++) {

        DWORD PAGERVA, BLOCKSIZE, BASE_RELOC_ADDR;
        int ENTRIES;

        BASE_RELOC_ADDR = resolve(PEFILE_BASERELOC_DIRECTORY.VirtualAddress, locate(PEFILE_BASERELOC_DIRECTORY.VirtualAddress));
        PAGERVA = PEFILE_BASERELOC_TABLE[i].VirtualAddress;
        BLOCKSIZE = PEFILE_BASERELOC_TABLE[i].SizeOfBlock;
        ENTRIES = (BLOCKSIZE - sizeof(___IMAGE_BASE_RELOCATION)) / sizeof(WORD);

        printf("\n   Block 0x%X: \n", i);
        printf("     Page RVA: 0x%X\n", PAGERVA);
        printf("     Block size: 0x%X\n", BLOCKSIZE);
        printf("     Number of entries: 0x%X\n", ENTRIES);
        printf("\n     Entries:\n");

        for (int i = 0; i < ENTRIES; i++) {

            BASE_RELOC_ENTRY entry;

            int offset = (BASE_RELOC_ADDR + szCounter + (i * sizeof(WORD)));

            fseek(Ppefile, offset, SEEK_SET);
            fread(&entry, sizeof(WORD), 1, Ppefile);

            printf("\n       * Value: 0x%X\n", entry);
            printf("         Relocation Type: 0x%X\n", entry.TYPE);
            printf("         Offset: 0x%X\n", entry.OFFSET);

        }
        printf("\n   ----------------------\n\n");
        szCounter += BLOCKSIZE;
    }

}

// MAIN
void PE32FILE::ParseFile() {

    // PARSE DOS HEADER
    ParseDOSHeader();

    // PARSE RICH HEADER
    ParseRichHeader();

    //PARSE NT HEADERS
    ParseNTHeaders();

    // PARSE SECTION HEADERS
    ParseSectionHeaders();

    // PARSE IMPORT DIRECTORY
    ParseImportDirectory();

    // PARSE BASE RELOCATIONS
    ParseBaseReloc();

}

void PE32FILE::PrintInfo() {

    printf("\n\n");

    PrintFileInfo();
    printf("\n ----------------------------------\n\n");

    PrintDOSHeaderInfo();
    printf("\n ----------------------------------\n\n");

    PrintRichHeaderInfo();
    printf("\n ----------------------------------\n\n");

    PrintNTHeadersInfo();
    printf("\n ----------------------------------\n\n");

    PrintSectionHeadersInfo();
    printf("\n ----------------------------------\n\n");

    PrintImportTableInfo();
    printf("\n ----------------------------------\n\n");

    PrintBaseRelocationsInfo();
    printf("\n ----------------------------------\n\n");

    return;

}

PE64FILE.h

#pragma once
#include "winntdef.h"
#include "PEFILE_CUSTOM_STRUCTS.h"
#include <string>

class PE64FILE
{
public:
    PE64FILE(char* _NAME, FILE* Ppefile);

    void PrintInfo();

private:
    char* NAME;
    FILE* Ppefile;
    int _import_directory_count, _import_directory_size;
    int _basreloc_directory_count;

    // HEADERS
    ___IMAGE_DOS_HEADER     PEFILE_DOS_HEADER;
    ___IMAGE_NT_HEADERS64   PEFILE_NT_HEADERS;

    // DOS HEADER
    DWORD PEFILE_DOS_HEADER_EMAGIC;
    LONG  PEFILE_DOS_HEADER_LFANEW;

    // RICH HEADER
    RICH_HEADER_INFO PEFILE_RICH_HEADER_INFO;
    RICH_HEADER PEFILE_RICH_HEADER;

    // NT_HEADERS.Signature
    DWORD PEFILE_NT_HEADERS_SIGNATURE;

    // NT_HEADERS.FileHeader
    WORD PEFILE_NT_HEADERS_FILE_HEADER_MACHINE;
    WORD PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS;
    WORD PEFILE_NT_HEADERS_FILE_HEADER_SIZEOF_OPTIONAL_HEADER;

    // NT_HEADERS.OptionalHeader
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_MAGIC;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_CODE;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_INITIALIZED_DATA;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_UNINITIALIZED_DATA;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_ADDRESSOF_ENTRYPOINT;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_BASEOF_CODE;
    ULONGLONG PEFILE_NT_HEADERS_OPTIONAL_HEADER_IMAGEBASE;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SECTION_ALIGNMENT;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_FILE_ALIGNMENT;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_IMAGE;
    DWORD PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_HEADERS;

    ___IMAGE_DATA_DIRECTORY PEFILE_EXPORT_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_IMPORT_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_RESOURCE_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_EXCEPTION_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_SECURITY_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_BASERELOC_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_DEBUG_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_ARCHITECTURE_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_GLOBALPTR_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_TLS_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_LOAD_CONFIG_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_BOUND_IMPORT_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_IAT_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_DELAY_IMPORT_DIRECTORY;
    ___IMAGE_DATA_DIRECTORY PEFILE_COM_DESCRIPTOR_DIRECTORY;

    // SECTION HEADERS
    ___PIMAGE_SECTION_HEADER PEFILE_SECTION_HEADERS;

    // IMPORT TABLE
    ___PIMAGE_IMPORT_DESCRIPTOR PEFILE_IMPORT_TABLE;

    // BASE RELOCATION TABLE
    ___PIMAGE_BASE_RELOCATION PEFILE_BASERELOC_TABLE;

    // FUNCTIONS

    // ADDRESS RESOLVERS
    int  locate(DWORD VA);
    DWORD resolve(DWORD VA, int index);

    // PARSERS
    void ParseFile();
    void ParseDOSHeader();
    void ParseNTHeaders();
    void ParseSectionHeaders();
    void ParseImportDirectory();
    void ParseBaseReloc();
    void ParseRichHeader();

    // PRINT INFO
    void PrintFileInfo();
    void PrintDOSHeaderInfo();
    void PrintRichHeaderInfo();
    void PrintNTHeadersInfo();
    void PrintSectionHeadersInfo();
    void PrintImportTableInfo();
    void PrintBaseRelocationsInfo();
};

PE64FILE.cpp

#include "PE64FILE.h"

// CONSTRUCTOR
PE64FILE::PE64FILE(char* _NAME, FILE* _Ppefile) {

    NAME = _NAME;
    Ppefile = _Ppefile;

    ParseFile();

}

// ADDRESS RESOLVERS
int PE64FILE::locate(DWORD VA) {

    int index;

    for (int i = 0; i < PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS; i++) {
        if (VA >= PEFILE_SECTION_HEADERS[i].VirtualAddress
            && VA < (PEFILE_SECTION_HEADERS[i].VirtualAddress + PEFILE_SECTION_HEADERS[i].Misc.VirtualSize)) {
            index = i;
            break;
        }
    }
    return index;
}

DWORD PE64FILE::resolve(DWORD VA, int index) {

    return (VA - PEFILE_SECTION_HEADERS[index].VirtualAddress) + PEFILE_SECTION_HEADERS[index].PointerToRawData;

}

// PARSERS
void PE64FILE::ParseDOSHeader() {

    fseek(Ppefile, 0, SEEK_SET);
    fread(&PEFILE_DOS_HEADER, sizeof(___IMAGE_DOS_HEADER), 1, Ppefile);

    PEFILE_DOS_HEADER_EMAGIC = PEFILE_DOS_HEADER.e_magic;
    PEFILE_DOS_HEADER_LFANEW = PEFILE_DOS_HEADER.e_lfanew;

}

void PE64FILE::ParseNTHeaders() {

    fseek(Ppefile, PEFILE_DOS_HEADER.e_lfanew, SEEK_SET);
    fread(&PEFILE_NT_HEADERS, sizeof(PEFILE_NT_HEADERS), 1, Ppefile);

    PEFILE_NT_HEADERS_SIGNATURE = PEFILE_NT_HEADERS.Signature;

    PEFILE_NT_HEADERS_FILE_HEADER_MACHINE = PEFILE_NT_HEADERS.FileHeader.Machine;
    PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS = PEFILE_NT_HEADERS.FileHeader.NumberOfSections;
    PEFILE_NT_HEADERS_FILE_HEADER_SIZEOF_OPTIONAL_HEADER = PEFILE_NT_HEADERS.FileHeader.SizeOfOptionalHeader;

    PEFILE_NT_HEADERS_OPTIONAL_HEADER_MAGIC = PEFILE_NT_HEADERS.OptionalHeader.Magic;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_CODE = PEFILE_NT_HEADERS.OptionalHeader.SizeOfCode;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_INITIALIZED_DATA = PEFILE_NT_HEADERS.OptionalHeader.SizeOfInitializedData;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_UNINITIALIZED_DATA = PEFILE_NT_HEADERS.OptionalHeader.SizeOfUninitializedData;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_ADDRESSOF_ENTRYPOINT = PEFILE_NT_HEADERS.OptionalHeader.AddressOfEntryPoint;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_BASEOF_CODE = PEFILE_NT_HEADERS.OptionalHeader.BaseOfCode;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_IMAGEBASE = PEFILE_NT_HEADERS.OptionalHeader.ImageBase;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SECTION_ALIGNMENT = PEFILE_NT_HEADERS.OptionalHeader.SectionAlignment;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_FILE_ALIGNMENT = PEFILE_NT_HEADERS.OptionalHeader.FileAlignment;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_IMAGE = PEFILE_NT_HEADERS.OptionalHeader.SizeOfImage;
    PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_HEADERS = PEFILE_NT_HEADERS.OptionalHeader.SizeOfHeaders;

    PEFILE_EXPORT_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_EXPORT];
    PEFILE_IMPORT_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_IMPORT];
    PEFILE_RESOURCE_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_RESOURCE];
    PEFILE_EXCEPTION_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_EXCEPTION];
    PEFILE_SECURITY_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_SECURITY];
    PEFILE_BASERELOC_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_BASERELOC];
    PEFILE_DEBUG_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_DEBUG];
    PEFILE_ARCHITECTURE_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_ARCHITECTURE];
    PEFILE_GLOBALPTR_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_GLOBALPTR];
    PEFILE_TLS_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_TLS];
    PEFILE_LOAD_CONFIG_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG];
    PEFILE_BOUND_IMPORT_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT];
    PEFILE_IAT_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_IAT];
    PEFILE_DELAY_IMPORT_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT];
    PEFILE_COM_DESCRIPTOR_DIRECTORY = PEFILE_NT_HEADERS.OptionalHeader.DataDirectory[___IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR];

}

void PE64FILE::ParseSectionHeaders() {

    PEFILE_SECTION_HEADERS = new ___IMAGE_SECTION_HEADER[PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS];
    for (int i = 0; i < PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS; i++) {
        int offset = (PEFILE_DOS_HEADER.e_lfanew + sizeof(PEFILE_NT_HEADERS)) + (i * ___IMAGE_SIZEOF_SECTION_HEADER);
        fseek(Ppefile, offset, SEEK_SET);
        fread(&PEFILE_SECTION_HEADERS[i], ___IMAGE_SIZEOF_SECTION_HEADER, 1, Ppefile);
    }

}

void PE64FILE::ParseImportDirectory() {

    DWORD _import_directory_address = resolve(PEFILE_IMPORT_DIRECTORY.VirtualAddress, locate(PEFILE_IMPORT_DIRECTORY.VirtualAddress));
    _import_directory_count = 0;

    while (true) {
        ___IMAGE_IMPORT_DESCRIPTOR tmp;
        int offset = (_import_directory_count * sizeof(___IMAGE_IMPORT_DESCRIPTOR)) + _import_directory_address;
        fseek(Ppefile, offset, SEEK_SET);
        fread(&tmp, sizeof(___IMAGE_IMPORT_DESCRIPTOR), 1, Ppefile);

        if (tmp.Name == 0x00000000 && tmp.FirstThunk == 0x00000000) {
            _import_directory_count -= 1;
            _import_directory_size = _import_directory_count * sizeof(___IMAGE_IMPORT_DESCRIPTOR);
            break;
        }

        _import_directory_count++;
    }

    PEFILE_IMPORT_TABLE = new ___IMAGE_IMPORT_DESCRIPTOR[_import_directory_count];

    for (int i = 0; i < _import_directory_count; i++) {
        int offset = (i * sizeof(___IMAGE_IMPORT_DESCRIPTOR)) + _import_directory_address;
        fseek(Ppefile, offset, SEEK_SET);
        fread(&PEFILE_IMPORT_TABLE[i], sizeof(___IMAGE_IMPORT_DESCRIPTOR), 1, Ppefile);
    }

}

void PE64FILE::ParseBaseReloc() {

    DWORD _basereloc_directory_address = resolve(PEFILE_BASERELOC_DIRECTORY.VirtualAddress, locate(PEFILE_BASERELOC_DIRECTORY.VirtualAddress));
    _basreloc_directory_count = 0;
    int _basereloc_size_counter = 0;

    while (true) {
        ___IMAGE_BASE_RELOCATION tmp;

        int offset = (_basereloc_size_counter + _basereloc_directory_address);

        fseek(Ppefile, offset, SEEK_SET);
        fread(&tmp, sizeof(___IMAGE_BASE_RELOCATION), 1, Ppefile);

        if (tmp.VirtualAddress == 0x00000000 &&
            tmp.SizeOfBlock == 0x00000000) {
            break;
        }

        _basreloc_directory_count++;
        _basereloc_size_counter += tmp.SizeOfBlock;
    }

    PEFILE_BASERELOC_TABLE = new ___IMAGE_BASE_RELOCATION[_basreloc_directory_count];

    _basereloc_size_counter = 0;

    for (int i = 0; i < _basreloc_directory_count; i++) {
        int offset = _basereloc_directory_address + _basereloc_size_counter;
        fseek(Ppefile, offset, SEEK_SET);
        fread(&PEFILE_BASERELOC_TABLE[i], sizeof(___IMAGE_BASE_RELOCATION), 1, Ppefile);
        _basereloc_size_counter += PEFILE_BASERELOC_TABLE[i].SizeOfBlock;
    }

}

void PE64FILE::ParseRichHeader() {

    char* dataPtr = new char[PEFILE_DOS_HEADER_LFANEW];
    fseek(Ppefile, 0, SEEK_SET);
    fread(dataPtr, PEFILE_DOS_HEADER_LFANEW, 1, Ppefile);

    int index_ = 0;

    for (int i = 0; i <= PEFILE_DOS_HEADER_LFANEW; i++) {
        if (dataPtr[i] == 0x52 && dataPtr[i + 1] == 0x69) {
            index_ = i;
            break;
        }
    }

    if (index_ == 0) {
        printf("Error while parsing Rich Header.");
        PEFILE_RICH_HEADER_INFO.entries = 0;
        return;
    }

    char key[4];
    memcpy(key, dataPtr + (index_ + 4), 4);

    int indexpointer = index_ - 4;
    int RichHeaderSize = 0;

    while (true) {
        char tmpchar[4];
        memcpy(tmpchar, dataPtr + indexpointer, 4);

        for (int i = 0; i < 4; i++) {
            tmpchar[i] = tmpchar[i] ^ key[i];
        }

        indexpointer -= 4;
        RichHeaderSize += 4;

        if (tmpchar[1] = 0x61 && tmpchar[0] == 0x44) {
            break;
        }
    }

    char* RichHeaderPtr = new char[RichHeaderSize];
    memcpy(RichHeaderPtr, dataPtr + (index_ - RichHeaderSize), RichHeaderSize);

    for (int i = 0; i < RichHeaderSize; i += 4) {

        for (int x = 0; x < 4; x++) {
            RichHeaderPtr[i + x] = RichHeaderPtr[i + x] ^ key[x];
        }

    }

    PEFILE_RICH_HEADER_INFO.size = RichHeaderSize;
    PEFILE_RICH_HEADER_INFO.ptrToBuffer = RichHeaderPtr;
    PEFILE_RICH_HEADER_INFO.entries = (RichHeaderSize - 16) / 8;

    delete[] dataPtr;

    PEFILE_RICH_HEADER.entries = new RICH_HEADER_ENTRY[PEFILE_RICH_HEADER_INFO.entries];

    for (int i = 16; i < RichHeaderSize; i += 8) {
        WORD PRODID = (uint16_t)((unsigned char)RichHeaderPtr[i + 3] << 8) | (unsigned char)RichHeaderPtr[i + 2];
        WORD BUILDID = (uint16_t)((unsigned char)RichHeaderPtr[i + 1] << 8) | (unsigned char)RichHeaderPtr[i];
        DWORD USECOUNT = (uint32_t)((unsigned char)RichHeaderPtr[i + 7] << 24) | (unsigned char)RichHeaderPtr[i + 6] << 16 | (unsigned char)RichHeaderPtr[i + 5] << 8 | (unsigned char)RichHeaderPtr[i + 4];
        PEFILE_RICH_HEADER.entries[(i / 8) - 2] = {
            PRODID,
            BUILDID,
            USECOUNT
        };

        if (i + 8 >= RichHeaderSize) {
            PEFILE_RICH_HEADER.entries[(i / 8) - 1] = { 0x0000, 0x0000, 0x00000000 };
        }

    }

    delete[] PEFILE_RICH_HEADER_INFO.ptrToBuffer;

}

// PRINT INFO
void PE64FILE::PrintFileInfo() {

    printf(" FILE: %s\n", NAME);
    printf(" TYPE: 0x%X (PE32+)\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_MAGIC);

}

void PE64FILE::PrintDOSHeaderInfo() {

    printf(" DOS HEADER:\n");
    printf(" -----------\n\n");

    printf(" Magic: 0x%X\n", PEFILE_DOS_HEADER_EMAGIC);
    printf(" File address of new exe header: 0x%X\n", PEFILE_DOS_HEADER_LFANEW);

}

void PE64FILE::PrintRichHeaderInfo() {

    printf(" RICH HEADER:\n");
    printf(" ------------\n\n");

    for (int i = 0; i < PEFILE_RICH_HEADER_INFO.entries; i++) {
        printf(" 0x%X 0x%X 0x%X: %d.%d.%d\n",
            PEFILE_RICH_HEADER.entries[i].buildID,
            PEFILE_RICH_HEADER.entries[i].prodID,
            PEFILE_RICH_HEADER.entries[i].useCount,
            PEFILE_RICH_HEADER.entries[i].buildID,
            PEFILE_RICH_HEADER.entries[i].prodID,
            PEFILE_RICH_HEADER.entries[i].useCount);
    }

}

void PE64FILE::PrintNTHeadersInfo() {

    printf(" NT HEADERS:\n");
    printf(" -----------\n\n");

    printf(" PE Signature: 0x%X\n", PEFILE_NT_HEADERS_SIGNATURE);

    printf("\n File Header:\n\n");
    printf("   Machine: 0x%X\n", PEFILE_NT_HEADERS_FILE_HEADER_MACHINE);
    printf("   Number of sections: 0x%X\n", PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS);
    printf("   Size of optional header: 0x%X\n", PEFILE_NT_HEADERS_FILE_HEADER_SIZEOF_OPTIONAL_HEADER);

    printf("\n Optional Header:\n\n");
    printf("   Magic: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_MAGIC);
    printf("   Size of code section: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_CODE);
    printf("   Size of initialized data: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_INITIALIZED_DATA);
    printf("   Size of uninitialized data: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_UNINITIALIZED_DATA);
    printf("   Address of entry point: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_ADDRESSOF_ENTRYPOINT);
    printf("   RVA of start of code section: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_BASEOF_CODE);
    printf("   Desired image base: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_IMAGEBASE);
    printf("   Section alignment: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SECTION_ALIGNMENT);
    printf("   File alignment: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_FILE_ALIGNMENT);
    printf("   Size of image: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_IMAGE);
    printf("   Size of headers: 0x%X\n", PEFILE_NT_HEADERS_OPTIONAL_HEADER_SIZEOF_HEADERS);

    printf("\n Data Directories:\n");
    printf("\n   * Export Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_EXPORT_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_EXPORT_DIRECTORY.Size);

    printf("\n   * Import Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_IMPORT_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_IMPORT_DIRECTORY.Size);

    printf("\n   * Resource Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_RESOURCE_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_RESOURCE_DIRECTORY.Size);

    printf("\n   * Exception Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_EXCEPTION_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_EXCEPTION_DIRECTORY.Size);

    printf("\n   * Security Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_SECURITY_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_SECURITY_DIRECTORY.Size);

    printf("\n   * Base Relocation Table:\n");
    printf("       RVA: 0x%X\n", PEFILE_BASERELOC_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_BASERELOC_DIRECTORY.Size);

    printf("\n   * Debug Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_DEBUG_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_DEBUG_DIRECTORY.Size);

    printf("\n   * Architecture Specific Data:\n");
    printf("       RVA: 0x%X\n", PEFILE_ARCHITECTURE_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_ARCHITECTURE_DIRECTORY.Size);

    printf("\n   * RVA of GlobalPtr:\n");
    printf("       RVA: 0x%X\n", PEFILE_GLOBALPTR_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_GLOBALPTR_DIRECTORY.Size);

    printf("\n   * TLS Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_TLS_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_TLS_DIRECTORY.Size);

    printf("\n   * Load Configuration Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_LOAD_CONFIG_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_LOAD_CONFIG_DIRECTORY.Size);

    printf("\n   * Bound Import Directory:\n");
    printf("       RVA: 0x%X\n", PEFILE_BOUND_IMPORT_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_BOUND_IMPORT_DIRECTORY.Size);

    printf("\n   * Import Address Table:\n");
    printf("       RVA: 0x%X\n", PEFILE_IAT_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_IAT_DIRECTORY.Size);

    printf("\n   * Delay Load Import Descriptors:\n");
    printf("       RVA: 0x%X\n", PEFILE_DELAY_IMPORT_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_DELAY_IMPORT_DIRECTORY.Size);

    printf("\n   * COM Runtime Descriptor:\n");
    printf("       RVA: 0x%X\n", PEFILE_COM_DESCRIPTOR_DIRECTORY.VirtualAddress);
    printf("       Size: 0x%X\n", PEFILE_COM_DESCRIPTOR_DIRECTORY.Size);

}

void PE64FILE::PrintSectionHeadersInfo() {

    printf(" SECTION HEADERS:\n");
    printf(" ----------------\n\n");

    for (int i = 0; i < PEFILE_NT_HEADERS_FILE_HEADER_NUMBER0F_SECTIONS; i++) {
        printf("   * %.8s:\n", PEFILE_SECTION_HEADERS[i].Name);
        printf("        VirtualAddress: 0x%X\n", PEFILE_SECTION_HEADERS[i].VirtualAddress);
        printf("        VirtualSize: 0x%X\n", PEFILE_SECTION_HEADERS[i].Misc.VirtualSize);
        printf("        PointerToRawData: 0x%X\n", PEFILE_SECTION_HEADERS[i].PointerToRawData);
        printf("        SizeOfRawData: 0x%X\n", PEFILE_SECTION_HEADERS[i].SizeOfRawData);
        printf("        Characteristics: 0x%X\n\n", PEFILE_SECTION_HEADERS[i].Characteristics);
    }

}

void PE64FILE::PrintImportTableInfo() {

    printf(" IMPORT TABLE:\n");
    printf(" ----------------\n\n");

    for (int i = 0; i < _import_directory_count; i++) {
        DWORD NameAddr = resolve(PEFILE_IMPORT_TABLE[i].Name, locate(PEFILE_IMPORT_TABLE[i].Name));
        int NameSize = 0;

        while (true) {
            char tmp;
            fseek(Ppefile, (NameAddr + NameSize), SEEK_SET);
            fread(&tmp, sizeof(char), 1, Ppefile);

            if (tmp == 0x00) {
                break;
            }

            NameSize++;
        }

        char* Name = new char[NameSize + 2];
        fseek(Ppefile, NameAddr, SEEK_SET);
        fread(Name, (NameSize * sizeof(char)) + 1, 1, Ppefile);
        printf("   * %s:\n", Name);
        delete[] Name;

        printf("       ILT RVA: 0x%X\n", PEFILE_IMPORT_TABLE[i].DUMMYUNIONNAME.OriginalFirstThunk);
        printf("       IAT RVA: 0x%X\n", PEFILE_IMPORT_TABLE[i].FirstThunk);

        if (PEFILE_IMPORT_TABLE[i].TimeDateStamp == 0) {
            printf("       Bound: FALSE\n");
        }
        else if (PEFILE_IMPORT_TABLE[i].TimeDateStamp == -1) {
            printf("       Bound: TRUE\n");
        }

        printf("\n");

        DWORD ILTAddr = resolve(PEFILE_IMPORT_TABLE[i].DUMMYUNIONNAME.OriginalFirstThunk, locate(PEFILE_IMPORT_TABLE[i].DUMMYUNIONNAME.OriginalFirstThunk));
        int entrycounter = 0;

        while (true) {

            ILT_ENTRY_64 entry;

            fseek(Ppefile, (ILTAddr + (entrycounter * sizeof(QWORD))), SEEK_SET);
            fread(&entry, sizeof(ILT_ENTRY_64), 1, Ppefile);

            BYTE flag = entry.ORDINAL_NAME_FLAG;
            DWORD HintRVA = 0x0;
            WORD ordinal = 0x0;

            if (flag == 0x0) {
                HintRVA = entry.FIELD_2.HINT_NAME_TABE;
            }
            else if (flag == 0x01) {
                ordinal = entry.FIELD_2.ORDINAL;
            }

            if (flag == 0x0 && HintRVA == 0x0 && ordinal == 0x0) {
                break;
            }

            printf("\n       Entry:\n");

            if (flag == 0x0) {
                ___IMAGE_IMPORT_BY_NAME hint;

                DWORD HintAddr = resolve(HintRVA, locate(HintRVA));
                fseek(Ppefile, HintAddr, SEEK_SET);
                fread(&hint, sizeof(___IMAGE_IMPORT_BY_NAME), 1, Ppefile);
                printf("         Name: %s\n", hint.Name);
                printf("         Hint RVA: 0x%X\n", HintRVA);
                printf("         Hint: 0x%X\n", hint.Hint);
            }
            else if (flag == 1) {
                printf("         Ordinal: 0x%X\n", ordinal);
            }

            entrycounter++;
        }

        printf("\n   ----------------------\n\n");

    }

}

void PE64FILE::PrintBaseRelocationsInfo() {

    printf(" BASE RELOCATIONS TABLE:\n");
    printf(" -----------------------\n");

    int szCounter = sizeof(___IMAGE_BASE_RELOCATION);

    for (int i = 0; i < _basreloc_directory_count; i++) {

        DWORD PAGERVA, BLOCKSIZE, BASE_RELOC_ADDR;
        int ENTRIES;

        BASE_RELOC_ADDR = resolve(PEFILE_BASERELOC_DIRECTORY.VirtualAddress, locate(PEFILE_BASERELOC_DIRECTORY.VirtualAddress));
        PAGERVA = PEFILE_BASERELOC_TABLE[i].VirtualAddress;
        BLOCKSIZE = PEFILE_BASERELOC_TABLE[i].SizeOfBlock;
        ENTRIES = (BLOCKSIZE - sizeof(___IMAGE_BASE_RELOCATION)) / sizeof(WORD);

        printf("\n   Block 0x%X: \n", i);
        printf("     Page RVA: 0x%X\n", PAGERVA);
        printf("     Block size: 0x%X\n", BLOCKSIZE);
        printf("     Number of entries: 0x%X\n", ENTRIES);
        printf("\n     Entries:\n");

        for (int i = 0; i < ENTRIES; i++) {

            BASE_RELOC_ENTRY entry;

            int offset = (BASE_RELOC_ADDR + szCounter + (i * sizeof(WORD)));

            fseek(Ppefile, offset, SEEK_SET);
            fread(&entry, sizeof(WORD), 1, Ppefile);

            printf("\n       * Value: 0x%X\n", entry);
            printf("         Relocation Type: 0x%X\n", entry.TYPE);
            printf("         Offset: 0x%X\n", entry.OFFSET);

        }
        printf("\n   ----------------------\n\n");
        szCounter += BLOCKSIZE;
    }

}

// MAIN
void PE64FILE::ParseFile() {

    // PARSE DOS HEADER
    ParseDOSHeader();

    // PARSE RICH HEADER
    ParseRichHeader();

    //PARSE NT HEADERS
    ParseNTHeaders();

    // PARSE SECTION HEADERS
    ParseSectionHeaders();

    // PARSE IMPORT DIRECTORY
    ParseImportDirectory();

    // PARSE BASE RELOCATIONS
    ParseBaseReloc();

}

void PE64FILE::PrintInfo() {

    printf("\n\n");

    PrintFileInfo();
    printf("\n ----------------------------------\n\n");

    PrintDOSHeaderInfo();
    printf("\n ----------------------------------\n\n");

    PrintRichHeaderInfo();
    printf("\n ----------------------------------\n\n");

    PrintNTHeadersInfo();
    printf("\n ----------------------------------\n\n");

    PrintSectionHeadersInfo();
    printf("\n ----------------------------------\n\n");

    PrintImportTableInfo();
    printf("\n ----------------------------------\n\n");

    PrintBaseRelocationsInfo();
    printf("\n ----------------------------------\n\n");

    return;

}

最终效果如下

代码放到:https://github.com/ybdt/evasion-hub/tree/master/Misc-Tool/03-PE-Parser