如何通过4.2 Inline Hook技术实现高效代码钩子？

本文共计2923个文字，预计阅读时间需要12分钟。

InlineHook是一种计算机安全编程技术，其原理是在计算机程序执行期间拦截、修改和增强现有函数的功能。它通过钩子函数（也称为回调函数）捕获程序执行过程中的事件，进而对程序行为进行控制。

InlineHook 是一种计算机安全编程技术，其原理是在计算机程序执行期间进行拦截、修改、增强现有函数功能。它使用钩子函数（也可以称为回调函数）来截获程序执行的各种事件，并在事件发生前或后进行自定义处理，从而控制或增强程序行为。Hook技术常被用于系统加速、功能增强、开发等领域。本章将重点讲解Hook是如何实现的，并手动封装实现自己的Hook挂钩模板。

x32 Inline Hook

对于4.1中所提到的Hook方法还是过于复杂，我们可以将上述代码定义为MyHook类，构造函数用来初始化，析构函数用来恢复钩子，在Hook()成员函数中完成了3项工作，首先是获得了被HOOK函数的函数地址，接下来是保存了被HOOK函数的前5字节，最后是用构造好的跳转指令来修改被HOOK函数的前5字节的内容。

如下封装中实现了三个类内函数，其中Hook()用于开始Hook函数，此函数接收三个参数，参数1为需要Hook的动态链接库名，参数2为需要挂钩的函数名，参数3为自定以中转函数地址，其中UnHook()用于恢复函数挂钩，最后的ReHook()用于重新挂钩，以下是该类提供的功能的简要摘要：

• m_pfnRig：成员变量，在挂接之前存储原始函数地址。
• m_bOldBytes：成员变量，用于存储函数入口代码的原始5个字节。
• m_bNewBytes：成员变量，用于存储将替换原始函数代码的内联钩子代码。
• Hook（）：成员函数，通过将函数入口代码的前5个字节替换为JMP指令，将控制流重定向到指定的钩子函数，从而在指定的模块中钩子指定的函数。此函数返回一个BOOL，指示挂钩是否成功。
• UnHook（）：成员函数，用于删除钩子并恢复原始函数代码。此函数返回一个BOOL，指示解除挂钩是否成功。
• ReHook（）：成员函数，它使用之前存储的钩子代码重新钩子之前未钩子的函数。此函数返回一个BOOL，指示重新挂钩是否成功。

// 自己封装的Hook组件 class MyHook { public: PROC m_pfnOrig; // 保存函数地址 BYTE m_bOldBytes[5]; // 保存函数入口代码 BYTE m_bNewBytes[5]; // 保存Inlie Hook代码 public: // 构造函数 MyHook() { m_pfnOrig = NULL; ZeroMemory(m_bOldBytes, 5); ZeroMemory(m_bNewBytes, 5); } // 析构函数清理现场 ~MyHook() { UnHook(); m_pfnOrig = NULL; ZeroMemory(m_bOldBytes, 5); ZeroMemory(m_bNewBytes, 5); } // 开始挂钩 BOOL Hook(LPSTR pszModuleName, LPSTR pszFuncName, PROC pfnHookFunc) { BOOL bRet = FALSE; // 获取指定模块中函数的地址 m_pfnOrig = (PROC)GetProcAddress(GetModuleHandleA(pszModuleName), pszFuncName); if (m_pfnOrig != NULL) { // 保存该地址处 5 字节的内容 DWORD dwNum = 0; ReadProcessMemory(GetCurrentProcess(), m_pfnOrig, m_bOldBytes, 5, &dwNum); // 构造 JMP 指令 m_bNewBytes[0] = '\xe9'; // jmp Opcode // pfnHookFunc 是 HOOK 后的目标地址 // m_pfnOrig 是原来的地址 // 5 是指令长度 *(DWORD*)(m_bNewBytes + 1) = (DWORD)pfnHookFunc - (DWORD)m_pfnOrig - 5; // 将构造好的地址写入该地址处 WriteProcessMemory(GetCurrentProcess(), m_pfnOrig, m_bNewBytes, 5, &dwNum); bRet = TRUE; } return bRet; } // 取消挂钩 BOOL UnHook() { if (m_pfnOrig != 0) { DWORD dwNum = 0; WriteProcessMemory(GetCurrentProcess(), m_pfnOrig, m_bOldBytes, 5, &dwNum); } return TRUE; } // 重新挂钩 BOOL ReHook() { BOOL bRet = FALSE; if (m_pfnOrig != 0) { DWORD dwNum = 0; WriteProcessMemory(GetCurrentProcess(), m_pfnOrig, m_bNewBytes, 5, &dwNum); bRet = TRUE; } return bRet; } };

同样我们以替换自身弹窗为例子具体讲解一下该库如何使用，如下代码中首先我们自定义一个MyMessageBoxA函数，该函数的原型读者可通过微软官方文档获取，以下是MessageBoxA函数的原型（函数声明）：

int MessageBoxA( HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType );

其中，参数的含义如下：

• hWnd: 指向包含消息框的窗口的句柄，通常为父窗口的句柄。可以设为NULL，表示没有父窗口。
• lpText: 指向要显示的消息文本的字符串指针。
• lpCaption: 指向要显示在消息框标题栏上的字符串指针，通常用于指定消息框的标题。
• uType: 用于指定消息框的按钮和图标样式，可以使用预定义的常量值进行设置，如MB_OK、MB_YESNO等。

有了函数原型声明部分读者则可以自己实现一个MyMessageBoxA函数，需注意参数传递必须与原函数保持一致，在自定以函数内部我们首先通过MsgHook.UnHook();恢复之前的钩子，并调用原函数实现功能替换，当调用结束后记得使用MsgHook.ReHook();重新挂钩恢复钩子。

// 定义全局类 MyHook MsgHook; // 定义自定义Hook函数 int WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) { // 先来恢复Hook 之所以要恢复是因为我们需要调用原始的MsgBox弹窗 MsgHook.UnHook(); MessageBoxA(hWnd, "hi hook api", lpCaption, uType); // 弹窗完成后重新Hook MsgHook.ReHook(); return 0; }

在主函数中我们通过调用MsgHook.Hook()函数，挂钩住user32.dll模块内的MessageBoxA函数，并将该函数请求转发到MyMessageBoxA上面做处理，当此时调用MessageBoxA时读者可观察弹出提示是否为我们所期望的，最后通过MsgHook.UnHook();用于解除钩子；

// 调用Hook组件 int main(int argc, char* argv[]) { // 开始Hook MsgHook.Hook((char *)"user32.dll", (char *)"MessageBoxA", (PROC)MyMessageBoxA); // 调用函数 MessageBoxA(NULL, "hello lyshark", "Msg", MB_OK); // 结束Hook MsgHook.UnHook(); return 0; }

读者可自行运行上述代码，当尝试调用MessageBox函数并传入hello lyshark参数时，输出的结果却变成了hi hook api如下图所示，则说明内联挂钩生效了。

x64 Inline Hook

32位钩子的封装实现详细读者已经能够理解了，接着我们来实现64位钩子的封装，64位与32位系统之间无论从寻址方式，还是语法规则都与x32架构有着本质的不同，由于64位编译器无法直接内嵌汇编代码，导致我们只能调用C库函数内嵌机器码来实现Hook的中转。

首先实现去MessageBox弹窗，由于64位编译器无法直接内嵌汇编代码，所以在我们需要Hook时只能将跳转机器码以二进制字节方式写死在程序里，如下代码是一段去弹窗演示案例。

#include <stdio.h> #include <Windows.h> BYTE OldCode[12] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; BYTE HookCode[12] = { 0x48, 0xB8, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xFF, 0xE0 }; DWORD_PTR base; // 自己实现中转函数 int WINAPI MyMessageBoxW(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) { return 1; } int main(int argc,char * argv[]) { HMODULE hwnd = GetModuleHandle(TEXT("user32.dll")); DWORD_PTR base = (DWORD_PTR)GetProcAddress(hwnd, "MessageBoxW"); DWORD OldProtect; if (VirtualProtect((LPVOID)base, 12, PAGE_EXECUTE_READWRITE, &OldProtect)) { memcpy(OldCode, (LPVOID)base, 12); // 拷贝原始机器码指令 *(PINT64)(HookCode + 2) = (INT64)&MyMessageBoxW; // 填充90为指定跳转地址 } memcpy((LPVOID)base, &HookCode, sizeof(HookCode)); // 拷贝Hook机器指令 MessageBoxW(NULL, L"hello lyshark", NULL, NULL); return 0; }

接着我们在上面代码的基础上继续进行完善，添加恢复钩子的功能，该功能时必须要有的，因为我们还是需要调用原始的弹窗代码，所以要在调用时进行暂时恢复，调用结束后再继续Hook挂钩。

#include <stdio.h> #include <Windows.h> void Hook(); void UnHook(); BYTE Ori_Code[12] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; BYTE HookCode[12] = { 0x48, 0xB8, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xFF, 0xE0 }; /* Hook 机器码的原理如下所示 MOV RAX, 0x9090909090909090 JMP RAX */ // 定义函数指针 static int (WINAPI *OldMessageBoxW)(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) = MessageBoxW; // 执行自己的弹窗 int WINAPI MyMessageBoxW(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) { UnHook(); // 恢复Hook int ret = OldMessageBoxW(hWnd, TEXT("Hook Inject"), lpCaption, uType); // 调用原函数 Hook(); // 继续hook return ret; } // 开始Hook void Hook() { DWORD OldProtect; if (VirtualProtect(OldMessageBoxW, 12, PAGE_EXECUTE_READWRITE, &OldProtect)) { memcpy(Ori_Code, OldMessageBoxW, 12); // 拷贝原始机器码指令 *(PINT64)(HookCode + 2) = (INT64)&MyMessageBoxW; // 填充90为指定跳转地址 } memcpy(OldMessageBoxW, &HookCode, sizeof(HookCode)); // 拷贝Hook机器指令 } // 结束Hook void UnHook() { memcpy(OldMessageBoxW, &Ori_Code, sizeof(Ori_Code)); // 恢复hook原始代码 } int main(int argc, char *argv []) { Hook(); MessageBoxW(NULL, TEXT("hello lyshark"), TEXT("MsgBox"), MB_OK); UnHook(); MessageBoxW(NULL, TEXT("hello lyshark"), TEXT("MsgBox"), MB_OK); return 0; }

将上面所写的代码进行函数化封装，实现一个完整的钩子处理程序。代码如下所示。

#include <stdio.h> #include <Windows.h> BYTE OldCode[12] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; BYTE HookCode[12] = { 0x48, 0xB8, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xFF, 0xE0 }; void Hook(LPCWSTR lpModule, LPCSTR lpFuncName, LPVOID lpFunction) { DWORD_PTR FuncAddress = (UINT64)GetProcAddress(GetModuleHandle(lpModule), lpFuncName); DWORD OldProtect = 0; if (VirtualProtect((LPVOID)FuncAddress, 12, PAGE_EXECUTE_READWRITE, &OldProtect)) { memcpy(OldCode, (LPVOID)FuncAddress, 12); // 拷贝原始机器码指令 *(PINT64)(HookCode + 2) = (UINT64)lpFunction; // 填充90为指定跳转地址 } memcpy((LPVOID)FuncAddress, &HookCode, sizeof(HookCode)); // 拷贝Hook机器指令 VirtualProtect((LPVOID)FuncAddress, 12, OldProtect, &OldProtect); } void UnHook(LPCWSTR lpModule, LPCSTR lpFuncName) { DWORD OldProtect = 0; UINT64 FuncAddress = (UINT64)GetProcAddress(GetModuleHandle(lpModule), lpFuncName); if (VirtualProtect((LPVOID)FuncAddress, 12, PAGE_EXECUTE_READWRITE, &OldProtect)) { memcpy((LPVOID)FuncAddress, OldCode, sizeof(OldCode)); } VirtualProtect((LPVOID)FuncAddress, 12, OldProtect, &OldProtect); } int WINAPI MyMessageBoxW(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) { // 首先恢复Hook代码 UnHook(L"user32.dll", "MessageBoxW"); int ret = MessageBoxW(0, L"hello lyshark", lpCaption, uType); // 调用结束后,再次挂钩 Hook(L"user32.dll", "MessageBoxW", (PROC)MyMessageBoxW); return ret; } bool APIENTRY DllMain(HANDLE handle, DWORD dword, LPVOID lpvoid) { switch (dword) { case DLL_PROCESS_ATTACH: Hook(L"user32.dll", "MessageBoxW", (PROC)MyMessageBoxW); break; case DLL_PROCESS_DETACH: UnHook(L"user32.dll", "MessageBoxW"); break; } return true; }

上方的代码还是基于过程化的案例，为了能更加通用，我们将其封装成MyHook类，这样后期可以直接引入项目调用了。

#include <iostream> #include <Windows.h> class MyHook { public: FARPROC m_pfnOrig; // 保存函数地址 BYTE m_bOldBytes[12]; // 保存函数入口代码 BYTE m_bNewBytes[12]; // 保存Inlie Hook代码 public: // 构造函数 MyHook() { BYTE OldCode[12] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; BYTE NewCode[12] = { 0x48, 0xB8, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xFF, 0xE0 }; RtlMoveMemory(MyHook::m_bNewBytes, NewCode, 12); memset(MyHook::m_bOldBytes, 0, 12); m_pfnOrig = NULL; } // 析构函数 ~MyHook() { m_pfnOrig = NULL; ZeroMemory(MyHook::m_bNewBytes, 12); ZeroMemory(MyHook::m_bOldBytes, 12); } // 开始挂钩 BOOL Hook(LPCWSTR lpModule, LPCSTR lpFuncName, LPVOID lpFunction) { DWORD_PTR FuncAddress = (UINT64)GetProcAddress(GetModuleHandle(lpModule), lpFuncName); DWORD OldProtect = 0; if (VirtualProtect((LPVOID)FuncAddress, 12, PAGE_EXECUTE_READWRITE, &OldProtect)) { memcpy(m_bOldBytes, (LPVOID)FuncAddress, 12); // 拷贝原始机器码指令 *(PINT64)(MyHook::m_bNewBytes + 2) = (UINT64)lpFunction; // 填充90为指定跳转地址 } memcpy((LPVOID)FuncAddress, &m_bNewBytes, sizeof(m_bNewBytes)); // 拷贝Hook机器指令 VirtualProtect((LPVOID)FuncAddress, 12, OldProtect, &OldProtect); return TRUE; } // 结束挂钩 BOOL UnHook(LPCWSTR lpModule, LPCSTR lpFuncName) { DWORD OldProtect = 0; UINT64 FuncAddress = (UINT64)GetProcAddress(GetModuleHandle(lpModule), lpFuncName); if (VirtualProtect((LPVOID)FuncAddress, 12, PAGE_EXECUTE_READWRITE, &OldProtect)) { memcpy((LPVOID)FuncAddress, m_bOldBytes, sizeof(m_bOldBytes)); } VirtualProtect((LPVOID)FuncAddress, 12, OldProtect, &OldProtect); return TRUE; } }; // 定义全局类 MyHook MsgHook; // 自己实现中转函数 int WINAPI MyMessageBoxW(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) { // 首先恢复Hook代码 MsgHook.UnHook(L"user32.dll", "MessageBoxW"); int ret = MessageBoxW(0, L"hi hook api", lpCaption, uType); // 调用结束后,再次挂钩 MsgHook.Hook(L"user32.dll", "MessageBoxW", (PROC)MyMessageBoxW); return ret; } int main(int argc, char* argv[]) { // 开始Hook MsgHook.Hook(L"user32.dll", "MessageBoxW", (PROC)MyMessageBoxW); MessageBoxW(NULL, L"hello lyshark", L"Msg", MB_OK); // 结束Hook MsgHook.UnHook(L"user32.dll", "MessageBoxW"); return 0; }

读者可自行运行上述代码，当尝试调用MessageBox函数并传入hello lyshark参数时，输出的结果却变成了hi hook api如下图所示，则说明内联挂钩生效了。

本文作者： 王瑞 本文链接： www.lyshark.com/post/ad20f53e.html 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！