游戏修改器制作教程六：hook的各种姿势

傷城~ 2022-08-18 12:10 615阅读 0赞

本教程面向有C\\C++基础的人，最好还要懂一些Windows编程知识  
代码一律用Visual Studio 2013编译，如果你还在用VC6请趁早丢掉它...  
写这个教程只是为了让玩家更好地体验所爱的单机游戏，顺便学到些逆向知识，我不会用网络游戏做示范，请自重

在第二章介绍了hook机制，本章要自己实现hook，实现调用某个函数时我们能截获、修改、取消这次调用

hook大概分两种，一种是修改函数代码跳转到钩子过程(inline hook)，另一种是修改地址表指向钩子过程(IAT hook、SSDT hook、虚函数表hook)

### inline hook ###

inline hook就是修改函数代码跳转到钩子过程，就像第三章里CE注入代码那样  
可以把目标函数开头的代码修改成jmp或call指令实现，不过用jmp才能取消调用

#### 完整的inline hook例程： ####

#### 结果 ####

![20151218115102321][]

#### 为了不影响原函数调用，functionB改成这样 ####

int functionB(int arg)
    {
    	printf("调用了functionB，arg = %d\n", arg);
    	// 此时functionA被hook了，不unhook就调用会再跳转到functionB最后栈溢出
    	unhook();
    	int ret = functionA(456); // 参数可自己改变
    	// 恢复hook
    	hook();
    	return ret;
    }

结果

![20151218122954210][]

### IAT hook ###

IAT hook是一种修改地址表实现的hook

什么是IAT？这里要补充一些PE文件的知识  
IAT是导入地址表(Import Address Table)，储存着其他模块(DLL)的函数指针  
跟IAT相关的有导入表（不要和IAT弄混），储存着导入函数的信息（比如函数名）  
一个PE文件被加载时系统会根据导入表加载这个文件需要的模块，并修改IAT中的函数指针

程序要调用其他模块的函数时就要查IAT然后CALL表中的函数地址，所以只要修改IAT中的函数地址不用修改代码就能实现hook了  
比如调用MessageBoxA的代码：  
![20151218124232282][]

其中0x00F59158就是IAT中的地址，储存着MessageBoxA的指针

本章重点不是PE文件和导入表的结构所以只要复制代码运行就好

#### IAT hook的完整例程： ####

#include <Windows.h>
    
    
    void** findImportAddress(HANDLE hookModule, LPCSTR moduleName, LPCSTR functionName)
    {
    	// 被hook的模块基址
    	uintptr_t hookModuleBase = (uintptr_t)hookModule;
    	PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)hookModuleBase;
    	PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)(hookModuleBase + dosHeader->e_lfanew);
    	// 导入表
    	PIMAGE_IMPORT_DESCRIPTOR importTable = (PIMAGE_IMPORT_DESCRIPTOR)(hookModuleBase
    		+ ntHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
    
    
    	// 遍历导入的模块
    	for (; importTable->Characteristics != 0; importTable++)
    	{
    		// 不是函数所在模块
    		if (_stricmp((LPCSTR)(hookModuleBase + importTable->Name), moduleName) != 0)
    			continue;
    
    
    		PIMAGE_THUNK_DATA info = (PIMAGE_THUNK_DATA)(hookModuleBase + importTable->OriginalFirstThunk);
    		void** iat = (void**)(hookModuleBase + importTable->FirstThunk);
    
    
    		// 遍历导入的函数
    		for (; info->u1.AddressOfData != 0; info++, iat++)
    		{
    			if ((info->u1.Ordinal & IMAGE_ORDINAL_FLAG) == 0) // 是用函数名导入的
    			{
    				PIMAGE_IMPORT_BY_NAME name = (PIMAGE_IMPORT_BY_NAME)(hookModuleBase + info->u1.AddressOfData);
    				if (strcmp((LPCSTR)name->Name, functionName) == 0)
    					return iat;
    			}
    		}
    
    
    		return NULL; // 没找到要hook的函数
    	}
    
    
    	return NULL; // 没找到要hook的模块
    }
    
    
    BOOL hookIAT(HANDLE hookModule, LPCSTR moduleName, LPCSTR functionName, void* hookFunction, void** oldAddress)
    {
    	void** address = findImportAddress(hookModule, moduleName, functionName);
    	if (address == NULL)
    		return FALSE;
    
    
    	// 保存原函数地址
    	if (oldAddress != NULL)
    		*oldAddress = *address;
    
    
    	// 修改IAT中地址为hookFunction
    	DWORD oldProtect, oldProtect2;
    	VirtualProtect(address, sizeof(DWORD), PAGE_READWRITE, &oldProtect);
    	*address = hookFunction;
    	VirtualProtect(address, sizeof(DWORD), oldProtect, &oldProtect2);
    
    
    	return TRUE;
    }
    
    
    BOOL unhookIAT(HANDLE hookModule, LPCSTR moduleName, LPCSTR functionName)
    {
    	// 取原函数地址
    	void* oldAddress = GetProcAddress(GetModuleHandleA(moduleName), functionName);
    	if (oldAddress == NULL)
    		return FALSE;
    
    
    	// 修改回原函数地址
    	return hookIAT(hookModule, moduleName, functionName, oldAddress, NULL);
    }
    
    
    
    
    // MessageBoxA的函数指针类型
    typedef int (WINAPI* MessageBoxAType)(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType);
    
    
    // 原函数地址
    MessageBoxAType RealMessageBoxA = NULL;
    
    
    int WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
    {
    	printf("截获到MessageBoxA调用，lpText = %s\n", lpText);
    	return RealMessageBoxA(hWnd, "被截获了！", lpCaption, uType);
    }
    
    
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	MessageBoxA(NULL, "Hello world1!", "", MB_OK);
    
    
    	hookIAT(GetModuleHandle(NULL), "user32.dll", "MessageBoxA", MyMessageBoxA, (void**)&RealMessageBoxA);
    	MessageBoxA(NULL, "Hello world2!", "", MB_OK);
    
    
    	unhookIAT(GetModuleHandle(NULL), "user32.dll", "MessageBoxA");
    	MessageBoxA(NULL, "Hello world3!", "", MB_OK);
    
    
    	return 0;
    }

#### 结果 ####

![20151218143254013][]

这种hook的优点就是调用原函数时不用unhook了，缺点是不能截获全部的调用（比如用GetProcAddress获取函数指针再调用）

### 高级一点的inline hook ###

前面的inline hook调用原函数时要unhook，这样看起来比较蠢而且多线程同时调用时会漏  
这里有一种办法不用unhook，不过有很多限制，不推荐使用  
测试中64位版因为MessageBoxA原代码用了相对地址，复制后相对地址变了导致崩溃

#include <Windows.h>
    
    
    #pragma pack(push)
    // 修改内存对齐，保证JmpCode不被无效数据填充
    #pragma pack(1)
    #ifndef _WIN64
    // 32位版，JMP XXXXXXXX
    struct JmpCode
    {
    private:
    	const BYTE jmp; // JMP指令的机器码，近跳转为E9，可跳至同一个段的范围内的地址
    	DWORD address; // 相对地址 = 目标地址 - 下一条指令地址 = 目标地址 - 当前地址 - JMP指令长度
    
    
    
    
    public:
    	JmpCode(DWORD srcAddr, DWORD dstAddr)
    		: jmp(0xE9)
    	{
    		setAddress(srcAddr, dstAddr);
    	}
    
    
    
    
    	void setAddress(DWORD srcAddr, DWORD dstAddr)
    	{
    		address = dstAddr - srcAddr - sizeof(JmpCode); // JMP指令长度 = sizeof(JmpCode) = 5
    	}
    };
    #else
    // 64位版，JMP QWORD PTR [XXXXXXXXXXXXXXXX]，64位JMP不能直接用操作数，需要存到变量或寄存器里
    struct JmpCode
    {
    private:
    	BYTE jmp[6]; // JMP指令的机器码
    	uintptr_t address; // 绝对地址
    
    
    
    
    public:
    	JmpCode(uintptr_t srcAddr, uintptr_t dstAddr)
    	{
    		static const BYTE JMP[] = { 0xFF, 0x25, 0x00, 0x00, 0x00, 0x00 };
    		memcpy(jmp, JMP, sizeof(jmp));
    		setAddress(srcAddr, dstAddr);
    	}
    
    
    
    
    	void setAddress(uintptr_t srcAddr, uintptr_t dstAddr)
    	{
    		address = dstAddr;
    	}
    };
    #endif
    #pragma pack(pop)
    
    
    
    
    // hookLength至少要有sizeof(JmpCode)，要保证originalFunction开头前hookLength个字节是完整的指令
    void hook(void* originalFunction, void* hookFunction, void** newFunction, SIZE_T hookLength = sizeof(JmpCode))
    {
    	// 改变虚拟内存保护，使originalFunction开头可写，用WriteProcessMemory写内存的话好像不用改保护
    	DWORD oldProtect, oldProtect2;
    	VirtualProtect(originalFunction, hookLength, PAGE_EXECUTE_READWRITE, &oldProtect);
    
    
    	// 保存originalFunction开头的指令，这里假设了originalFunction开头前hookLength个字节是完整的指令，如果截断了会出错
    	// 更好的办法是用反汇编引擎判断开头前几个字节是完整指令
    	// 另外如果原代码可能跳转到这几个字节之间也会出错，所以这个方法有局限性
    	void* newFunctionCode = VirtualAlloc(NULL, hookLength + sizeof(JmpCode), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    	// 保存originalFunction开头前hookLength个字节
    	memcpy(newFunctionCode, originalFunction, hookLength);
    	// 从newFunctionCode开头第hookLength + 1字节跳到originalFunction开头第hookLength + 1字节的指令
    	JmpCode code((uintptr_t)newFunctionCode + hookLength, (uintptr_t)originalFunction + hookLength);
    	memcpy((BYTE*)newFunctionCode + hookLength, &code, sizeof(code));
    	*newFunction = newFunctionCode;
    
    
    	// 从originalFunction开头跳到hookFunction开头的指令
    	code.setAddress((uintptr_t)originalFunction, (uintptr_t)hookFunction);
    	// 修改originalFunction开头的指令
    	memcpy(originalFunction, &code, sizeof(code));
    
    
    	// 恢复虚拟内存保护
    	VirtualProtect(originalFunction, hookLength, oldProtect, &oldProtect2);
    }
    
    
    void unhook(void* originalFunction, void** newFunction, SIZE_T hookLength = sizeof(JmpCode))
    {
    	// 改变虚拟内存保护，使originalFunction开头可写
    	DWORD oldProtect, oldProtect2;
    	VirtualProtect(originalFunction, hookLength, PAGE_EXECUTE_READWRITE, &oldProtect);
    	// 恢复originalFunction开头的指令
    	memcpy(originalFunction, *newFunction, hookLength);
    	// 恢复虚拟内存保护
    	VirtualProtect(originalFunction, hookLength, oldProtect, &oldProtect2);
    
    
    	// 释放newFunction
    	VirtualFree(*newFunction, 0, MEM_RELEASE);
    	*newFunction = NULL;
    }
    
    
    
    
    // MessageBoxA的函数指针类型
    typedef int (WINAPI* MessageBoxAType)(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType);
    
    
    // 新的MessageBoxA入口，执行完MessageBoxA开头5字节代码后跳到MessageBoxA开头第6个字节
    MessageBoxAType NewMessageBoxA = NULL;
    
    
    int WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
    {
    	printf("截获到MessageBoxA调用，lpText = %s\n", lpText);
    	return NewMessageBoxA(hWnd, "被截获了！", lpCaption, uType);
    }
    
    
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	//void* MessageBoxAAddress = GetProcAddress(GetModuleHandle(_T("user32.dll")), "MessageBoxA"); // 这个是查目标模块EAT
    	void* MessageBoxAAddress = MessageBoxA; // 这个是查本模块IAT
    
    
    	MessageBoxA(NULL, "Hello world1!", "", MB_OK);
    
    
    	hook(MessageBoxAAddress, MyMessageBoxA, (void**)&NewMessageBoxA);
    	MessageBoxA(NULL, "Hello world2!", "", MB_OK);
    
    
    	unhook(MessageBoxAAddress, (void**)&NewMessageBoxA);
    	MessageBoxA(NULL, "Hello world3!", "", MB_OK);
    
    
    	return 0;
    }

结果同上

当然学hook技术不是为了hook自身进程的，下一章讲怎么hook其他进程

[20151218115102321]: /images/20220731/90c7dc0559704af483ad1120746692e1.png
[20151218122954210]: /images/20220731/5e81533798664e878b58edb33e511d1c.png
[20151218124232282]: /images/20220731/00071c3703364f13b2ba5c6e77460688.png
[20151218143254013]: /images/20220731/9baeadc8982441e2bdabd252702aaa05.png