PE格式：分析IatHook并实现

Ring 3层的 IAT HOOK 和 EAT HOOK 其原理是通过替换IAT表中函数的原始地址从而实现Hook的，与普通的 InlineHook 不太一样 IAT Hook 需要充分理解PE文件的结构才能完成 Hook，接下来将具体分析 IAT Hook 的实现原理，并编写一个DLL注入文件，实现 IAT Hook 。

在早些年系统中运行的都是DOS应用，所以DOS头结构就是在那个年代产生的，那时候还没有PE结构的概念，不过软件行业发展到今天DOS头部分的功能已经无意义了，但为了最大的兼容性微软还是保留了DOS文件头，有些软件在识别程序是不是可执行文件的时候通常会读取PE文件的前两个字节来判断是不是MZ。

上图就是PE文件中的DOS部分，典型的DOS开头ASCII字符串MZ幻数，MZ是Mark Zbikowski的缩写，Mark Zbikowski是MS-DOS的主要开发者之一，很显然这个人给微软做出了巨大的贡献。

在DOS格式部分我们只需要关注标红部分，标红部分是一个偏移值000000F8h该偏移值指向了PE文件中的标绿部分00004550指向PE字符串的位置，此外标黄部分为DOS提示信息，当我们在DOS模式下执行一个可执行文件时会弹出This program cannot be run in DOS mode.提示信息。

上图中在PE字符串开头位置向后偏移1字节，就能看到黄色的014C此处代表的是机器类别的十六进制表示形式，在向后偏移1个字节是紫色的0006代表的是程序中的区段数，继续向后偏移1字节会看到蓝色的5DB93874此处是一个时间戳，代表的是自1970年1月1日至当前时间的总秒数，继续向后可看到灰色的000C此处代表的是链接器的具体版本。

上图中我们以PE字符串为单位向后偏移36字节，即可看到文件偏移为120处的内容，此处的内容是我们要重点研究的对象。

在文件FOA偏移为120的位置，可以看到标红色的地址0001121C此处代表的是程序装入内存后的入口点(虚拟地址)，而紧随其后的橙色部分00001000就是代码段的基址，其后的粉色部分是数据段基址，在数据基址向后偏移1字节可看到紫色的00400000此处就是程序的建议装入地址，如果编译器没有开启基址随机化的话，此处默认就是00400000，开启随机化后建议装入地址与实际地址将不符合。

继续向下文件FOA偏移为130的位置，第一处浅蓝色部分00001000为区段之间的对齐值，深蓝色部分00002000为文件对其值。

上面只简单的介绍了PE结构的基本内容，在PE结构的开头我们知道了区段的数量是6个，接着我们可以在PE字符串向下偏移244个字节的位置就能够找到区段块，区块内容如下：

上图可以看到，我分别用不同的颜色标注了这六个不同的区段，区段的开头一般以.xxx为标识符其所对应的机器码是2E，其中每个区块分别占用40个字节的存储空间。

我们以.text节为例子，解释下不同块的含义，第一处绿色的位置就是区段名称该名称总长度限制在8字节以内，第二处深红色标签为虚拟大小，第三处深紫色标签为虚拟偏移，第四处蓝色标签为实际大小，第五处绿色标签为区段的属性，其它的节区属性与此相同，此处就不再赘述了。

接着继续看一下导入表，导出表，基址重定位表，IAT表，这些表位于PE字符串向后偏移116个字节的位置，如下我已经将重要的字段备注了颜色：

首先第一处浅红色部分就是导出表的地址与大小，默认情况下只有DLL文件才会导出函数所以此处为零，第二处深红色位置为导入表地址而后面的黄色部分则为导入表的大小，继续向下第三处浅蓝色部分则为资源表地址与大小，第四处棕色部分就是基址重定位表的地址，默认情况下只有DLL文件才会重定位，最下方的蓝色部分是IAT表的地址，后面的黄色为IAT表的大小。

此时我们重点关注一下导入表RVA地址 0001A1E0 我们通过该地址计算一下导入表对应到文件中的位置。

计算公式：FOA = 导入RVA表地址 - 虚拟偏移 + 实际偏移 = > 0001A1E0 - 11000 + 400 = 95E0

通过计算可得知，导入表位置对应到文件中的位置是0x95E0，我们直接跟随过去但此时你会惊奇的发现这里全部都是0，这是因为Windows装载器在加载时会动态的获取第三方函数的地址并自动的填充到这些位置处，我们并没有运行EXE文件所以也就不会填充，为了方便演示，我们将程序拖入x64dbg让其运行起来，然后来看一个重要的结构。

typedef struct _IMAGE_IMPORT_DESCRIPTOR {
    union {
        DWORD   Characteristics;
        DWORD   OriginalFirstThunk;    // 指向导入表名称的RVA
    } DUMMYUNIONNAME;
    DWORD   TimeDateStamp;           // 默认为0（非重点）
    DWORD   ForwarderChain;          // 默认为0（非重点）
    DWORD   Name;                       // 指向DLL名字的RVA
    DWORD   FirstThunk;               // 导入地址表IAT的RVA
} IMAGE_IMPORT_DESCRIPTOR;

该IMAGE_IMPORT_DESCRIPTOR 导入表结构的大小为4*5 = 20个字节的空间，导入表结构结束的位置通常会通过使用一串连续的4*5个0表示结束，接下来我们将从后向前逐一分析这个数据结构所对应到程序中的位置。

通过上面对导入表的分析我们知道了导入表RVA地址为 0001A1E0 此时我们还知道ImageBase地址是00400000两个地址相加即可得到导入表的虚拟VA地址0041a1e0，此时我们可以直接通过x64dbg的数据窗口定位到0041a1e0可看到如下地址组合，结合IMAGE_IMPORT_DESCRIPTOR结构来分析。

如上所示，可以看到该程序一共有3个导入结构分别是红紫黄色部分，最后是一串零结尾的字符串，标志着导入表的结束，我们以第1段红色部分为例，最后一个地址偏移0001A15C对应的就是导入表中的FirstThunk字段，我们将其加上ImageBase地址，定位过去发现该地址刚好是LoadIconW的函数地址，那么我们有理由相信紧随其后的地址应该是下一个外部函数的地址，而事实也正是如此。

接着我们继续来分析IMAGE_IMPORT_DESCRIPTOR 导入结构中的Name字段，其对应的是第一张图中的红色部分0001A54A将该偏移与基址00400000相加后直接定位过去，可以看到0041A54A对应的字符串正是USER32.dll动态链接库，而后面会有两个00标志着字符串的结束。

最后我们来分析IMAGE_IMPORT_DESCRIPTOR中最复杂的一个字段OriginalFirstThunk 为什么说它复杂呢？是因为他的内部并不是一个数值而是嵌套了另一个结构体 IMAGE_THUNK_DATA ，我们先来看一下微软对该结构的定义：

typedef struct _IMAGE_THUNK_DATA32 {
    union {
        DWORD ForwarderString;      // PBYTE 
        DWORD Function;                  // PDWORD
        DWORD Ordinal;                     // 序号
        DWORD AddressOfData;        // 指向 PIMAGE_IMPORT_BY_NAME
    } u1;
} IMAGE_THUNK_DATA32;
typedef IMAGE_THUNK_DATA32 * PIMAGE_THUNK_DATA32;

接着来找到OriginalFirstThunk字段在内存中的位置，由第一张图可知，图中的标红部分第一个四字节0001A38C 就是它丫的！我们加上基址00400000然后直接怼过去，并结合上方的结构定义研究一下！

该结构中我们需要关注AddressOfData结构成员，该成员中的数据最高位（红色）如果为1(去掉1)说明是函数的导出序号，而如果最高位为0则说明是一个指向IMAGE_IMPROT_BY_NAME结构(导入表)的RVA（蓝色）地址，此处因为我们找的是导入表所以最高位全部为零。

我们以上图中的第一个RVA地址0001A53E与基址相加，来看下该AddressOfData字段中所指向的内容是什么。

上图黄色部分是编译器生成的，而蓝色部分则为LoadIconW字符串与FirstThunk中的0041A15C地址指针是相互对应的，而最后面的00则表明字符串的结束，对比以下结构声明就很好理解了。

typedef struct _IMAGE_IMPORT_BY_NAME {
    WORD    Hint;       // 编译器生成的
    CHAR   Name[1];  // 函数名称，以0结尾的字符串
} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;

为了能更加充分的理解，我用Excel画了一张图，如下所示：

如上图IMAGE_IMPORT_DESCRIPTO导入表结构中的FirstThunk和OriginalFirstThunk分别指向两个相同的IMAGE_THUNK_DATA结构，其中内存INT(Improt Name Table)表中存储的就是导入函数的名称，而IAT(Improt Address Table)表中存放的是导入函数的地址，他们都共同指向IMAGE_IMPORT_BY_NAME结构，而之所以使用两份IMAGE_THUNK_DATA结构，是为了最后还可以留下一份备份数据用来反过来查询地址所对应的导入函数名，看了这张图再结合上面的实验相信你已经理解了！

一个 DLL 文件对应一个 IMAGE_IMPORT_DESCRIPTOR 结构，而一个 DLL 文件中有多个函数，那么需要使用两个循环来进行枚举。外层循环枚举所有的 DLL，而内层循环枚举所导入的该 DLL 的所有函数名及函数地址。

#include <windows.h>
#include <Dbghelp.h>
#include <stdio.h>

#pragma comment (lib, "Dbghelp")

int main(int argc, char* argv[])
{
	HANDLE hFile = CreateFile(L"c://1.exe", GENERIC_READ, FILE_SHARE_READ, 
		NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY | SEC_IMAGE, 0, 0, 0);
	LPVOID lpBase = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
	PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)lpBase;
	if (pDosHdr->e_magic != IMAGE_DOS_SIGNATURE)
	{
		UnmapViewOfFile(lpBase);
		return -1;
	}

	PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)((DWORD)lpBase + pDosHdr->e_lfanew);
	if (pNtHdr->Signature != IMAGE_NT_SIGNATURE)
	{
		return -1;
	}

	DWORD dwNum = 0;
	PIMAGE_IMPORT_DESCRIPTOR pImpDes = (PIMAGE_IMPORT_DESCRIPTOR)
	ImageDirectoryEntryToData(lpBase, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &dwNum);

	PIMAGE_IMPORT_DESCRIPTOR pTmpImpDes = pImpDes;
	while (pTmpImpDes->Name)
	{
		printf("[*] 链接库名称: %s \n", (DWORD)lpBase + (DWORD)pTmpImpDes->Name);
		PIMAGE_THUNK_DATA thunk = (PIMAGE_THUNK_DATA)(pTmpImpDes->FirstThunk + (DWORD)lpBase);

		int index = 0;
		while (thunk->u1.Function)
		{
			if (thunk->u1.Ordinal & IMAGE_ORDINAL_FLAG)
			{
				printf("导入序号: %08X \r\n", thunk->u1.Ordinal & 0xFFFF);
			}
			else
			{
				PIMAGE_IMPORT_BY_NAME pImName = (PIMAGE_IMPORT_BY_NAME)thunk->u1.Function;
				printf("函数名称: %-30s \t", (DWORD)lpBase + pImName->Name);
				DWORD dwAddr = (DWORD)((DWORD *)((DWORD)pNtHdr->OptionalHeader.ImageBase 
					+ pTmpImpDes->FirstThunk) + index);
				printf("导入地址: 0x%08x \r\n", dwAddr);
			}
			thunk++; index++;
		}
		pTmpImpDes++;
	}

	system("pause");
	return 0;
}

经过了上面对导入表的学习，接着我们就来通过代码的方式实现劫持MessageBox函数：

1.首先需要编写一个DLL文件，在DLL文件中找出MessageBox的原函数地址。
2.接着通过代码的方式找到DOS/NT/FILE-Optional头偏移地址。
3.通过DataDirectory[1]数组得到导入表的起始RVA并与ImageBase基址相加得到VA。
4.循环遍历导入表中的IAT表，找到与MessageBox地址相同的4字节位置。
5.找到后通过VirtualProtect设置内存属性可读写，并将自己的函数地址写入到目标IAT表中。
6.没有找到的话直接pFirstThunk++循环遍历后面的4字节位置，直到找到为止。

知道了流程，编写并理解代码就变得非常简单了，代码如下，你可以自行注入到进程中测试效果。

#include <stdio.h>
#include <Windows.h>

typedef int(WINAPI *pfMessageBoxA)(HWND, LPCSTR, LPCSTR, UINT);
pfMessageBoxA OldMessageBoxA = NULL;

int WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
{
	return OldMessageBoxA(hWnd, "hello lyshark", lpCaption, uType);
}

PIMAGE_NT_HEADERS GetLocalNtHead()
{
	DWORD dwTemp = NULL;
	PIMAGE_DOS_HEADER pDosHead = NULL;
	PIMAGE_NT_HEADERS pNtHead = NULL;
	HMODULE ImageBase = GetModuleHandle(NULL);                              // 取自身ImageBase
	pDosHead = (PIMAGE_DOS_HEADER)(DWORD)ImageBase;                         // 取pDosHead地址
	dwTemp = (DWORD)pDosHead + (DWORD)pDosHead->e_lfanew;
	pNtHead = (PIMAGE_NT_HEADERS)dwTemp;                                    // 取出NtHead头地址
	return pNtHead;
}

void IATHook()
{
	PVOID pFuncAddress = NULL;
	pFuncAddress = GetProcAddress(GetModuleHandleA("user32.dll"), "MessageBoxA");  // 取Hook函数地址
	OldMessageBoxA = (pfMessageBoxA)pFuncAddress;                                  // 保存原函数指针
	PIMAGE_NT_HEADERS pNtHead = GetLocalNtHead();                                  // 获取到程序自身NtHead
	PIMAGE_FILE_HEADER pFileHead = (PIMAGE_FILE_HEADER)&pNtHead->FileHeader;
	PIMAGE_OPTIONAL_HEADER pOpHead = (PIMAGE_OPTIONAL_HEADER)&pNtHead->OptionalHeader;

	DWORD dwInputTable = pOpHead->DataDirectory[1].VirtualAddress;    // 找出导入表偏移
	DWORD dwTemp = (DWORD)GetModuleHandle(NULL) + dwInputTable;
	PIMAGE_IMPORT_DESCRIPTOR   pImport = (PIMAGE_IMPORT_DESCRIPTOR)dwTemp;
	PIMAGE_IMPORT_DESCRIPTOR   pCurrent = pImport;
	DWORD *pFirstThunk; //导入表子表,IAT存储函数地址表.

	//遍历导入表
	while (pCurrent->Characteristics && pCurrent->FirstThunk != NULL)
	{
		dwTemp = pCurrent->FirstThunk + (DWORD)GetModuleHandle(NULL);// 找到内存中的导入表
		pFirstThunk = (DWORD *)dwTemp;                               // 赋值 pFirstThunk
		while (*(DWORD*)pFirstThunk != NULL)                         // 不为NULl说明没有结束
		{
			if (*(DWORD*)pFirstThunk == (DWORD)OldMessageBoxA)       // 相等说明正是我们想要的地址
			{
				DWORD oldProtected;
				VirtualProtect(pFirstThunk, 0x1000, PAGE_EXECUTE_READWRITE, &oldProtected);  // 开启写权限
				dwTemp = (DWORD)MyMessageBoxA;
				// 将MyMessageBox地址拷贝替换
				memcpy(pFirstThunk, (DWORD *)&dwTemp, 4);
				VirtualProtect(pFirstThunk, 0x1000, oldProtected, &oldProtected);            // 关闭写保护
			}
			pFirstThunk++; // 继续递增循环
		}
		pCurrent++;        // 每次是加1个导入表结构.
	}
}
BOOL APIENTRY DllMain(HMODULE hModule,DWORD  ul_reason_for_call,LPVOID lpReserved)
{
	IATHook();
	return TRUE;
}

EAT Hook就是针对于导出表的Hook挂钩技术，与IAT不同的是它存放的不是函数地址，而是导出函数地址的偏移，使用时需要加上指定Dll的模块基地址，当Hook挂钩之后，所有试图通过输出表获取函数地址的行为都会受到影响，EATHook并不会直接生效，他只能影响Hook之后对该函数地址的获取。EAT Hook的流程如下:

1.首先获取到DOS头，并加上偏移得到NT头，再通过Nt头得到数据目录表基地址。
2.数据目录表中的第0个成员指向导出表的首地址，直接拿到导出表的虚拟地址。
3.循环查找导出表的导出函数是否与我们的函数名称一致，一致则取出导出函数地址。
4.设置导出函数位置读写属性，将新的导出函数地址写入到该位置

代码如下所示:

#include <windows.h>
#include <cstdio>
#include <tchar.h>

BOOL EATHook(LPCTSTR szDllName, LPCTSTR szFunName, LPVOID NewFun)
{
	DWORD addr = 0, index = 0,dwProtect=0;
	HMODULE DllBase = LoadLibrary(szDllName);
	if (NULL == DllBase)
		return(FALSE);

	// 1.首先得到Dos头，NT头，数据目录表
	PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)DllBase;
	// PIMAGE_OPTIONAL_HEADER pOptHeader = (PIMAGE_OPTIONAL_HEADER)((PBYTE)DllBase + pDosHeader->e_lfanew + 24);
	PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)((DWORD)pDosHeader + pDosHeader->e_lfanew);
	PIMAGE_OPTIONAL_HEADER pOptHeader = (PIMAGE_OPTIONAL_HEADER)(&pNtHeader->OptionalHeader);

	// 2.得到导出表的虚拟地址
	PIMAGE_EXPORT_DIRECTORY pExpDes = (PIMAGE_EXPORT_DIRECTORY)
		((PBYTE)DllBase + pOptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

	// 3.获取导出表的函数地址，函数名称，函数序号
	PULONG pAddressOfFunctions = (PULONG)((PBYTE)DllBase + pExpDes->AddressOfFunctions);
	PULONG pAddressOfNames = (PULONG)((PBYTE)DllBase + pExpDes->AddressOfNames);
	PUSHORT pAddressOfNameOrdinals = (PUSHORT)((PBYTE)DllBase + pExpDes->AddressOfNameOrdinals);

	// 4.循环查找
	for (int i = 0; i < pExpDes->NumberOfNames; ++i)
	{
		index = pAddressOfNameOrdinals[i];
		LPCTSTR pFuncName = (LPTSTR)((PBYTE)DllBase + pAddressOfNames[i]);
		if (!_tcscmp((LPCTSTR)pFuncName, szFunName))
		{
			addr = pAddressOfFunctions[index];
			break;
		}
	}

	// 5.设置导出函数位置读写属性，将新的导出函数地址写入到该位置
	VirtualProtect(&pAddressOfFunctions[index], 0x1000, PAGE_READWRITE, &dwProtect);
	pAddressOfFunctions[index] = (DWORD)NewFun - (DWORD)DllBase;
	WriteProcessMemory(GetCurrentProcess(), &pAddressOfFunctions[index], 
		(LPCVOID)((DWORD)NewFun - (DWORD)DllBase), sizeof(NewFun), &dwProtect);
	return(TRUE);
}

int __stdcall MyMessageBox(HWND hWnd,LPCTSTR lpText,LPCTSTR lpCaption,UINT uType)
{
	printf("hello lyshark \n");
	return(0);
}

typedef int (WINAPI* LPFNMESSAGEBOX)(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType);

int main(int argc,char *argv[])
{
	// 对MessageBoxA进行Eat Hook
	EATHook("USER32.dll", "MessageBoxA", MyMessageBox);

	// 模拟下次调用后就是执行我们的Hook代码
	LoadLibrary("USER32.dll");
	HMODULE hDll = GetModuleHandle("USER32.dll");
	LPFNMESSAGEBOX lpMessageBox = (LPFNMESSAGEBOX)GetProcAddress(hDll, "MessageBoxA");
	lpMessageBox(NULL, "Hello, EAT Hook", "Info", MB_OK);
	return(0);
}