这一期主要分享Hook中的Trampoline（蹦床）技术，这个相当于是Detour的进化版。Trampoline的最大的优势是解决Detour调用被Hook函数带来的无限递归问题。
一，技术介绍
Trampoline和Detour的区别
1.Dertour（转向）
结合上一期内容Detour是拦截目标函数并把代码重定向到自己的函数（Hook函数）当中。比如当程序正常调用一个目标函数时实际上执行的是被我们修改后的指令，通过插入的Jmp指令让CPU跳转到我们的代码。本质就是拦截和重定向目标函数。
举例：汽车正常形式的一条公路上，我们设立了个路障（拦截）和指示牌（转向），强制让所有车开往我们指定的一条小路（Hook函数）上。
2.Trampoline（蹦床）
跟Detour不同的是，在实行Detour之前先备份被窃取的字节（原始指令），再分配一块内存空间（Trampoline空间）存放原始指令。在这原始指令后面紧接着一个Jmp指令用来跳转回被窃取的字节之后的位置，继续执行原始函数的剩余部分。这样就达到了备份原始指令的目的，我们先通过Detour跳转到我们的Hook函数执行想要的功能逻辑（如果Hook函数当中我们需要调用原始指令的话直接调用Trampoline的地址就行了）。执行完Hook函数之后CPU会跳转到Trampoline，Trampoline会执行之前备份好的原始指令，然后通过Trampoline中的Jmp指令跳转回原始函数继续执行。本质上可以在自己的函数当中可以随意调用原函数避免出现递归循环问题。
举例：跟上面的公路举例中，在设置的路障旁边修建一条匝道（Trampoline），这个匝道包含被我们通过路障覆盖掉的原始公路的一部分（备份原始指令），匝道的尽头就是原始公路路障后面的部分。当车进入我们的小路（Hook函数）后，必须经过我们新修建的匝道（Trampoline）才能会到主公路的后面部分继续行驶。
二，Hook函数（Trampoline）
1.函数的定义
首先是函数的声明，跟Detour创建的Hook函数一样需要三个参数。分别是想要拦截的目标函数地址，指向我们自定义的Hook函数的地址，需要被窃取的字节长度：
1
| void * TrampolineHook(void * toHook, void * ourFunct, int len);
|
第一步跟之前一样先判断被窃取的字节长度是否小于5个字节，是的话就没有办法完整的写入Detour所需要的跳转指令返回NULL表示失败：
1
| if (len < 5) return NULL;
|
之后可以为存放 Trampoline 代码分配一个新的内存空间，这里通过调用 Windows API 函数 VirtualAlloc 来实现。这个函数接受4个参数：
1
2
3
4
5
6
| LPVOID VirtualAlloc(
[in, optional] LPVOID lpAddress,
[in] SIZE_T dwSize,
[in] DWORD flAllocationType,
[in] DWORD flProtect
);
|
根据介绍第一个参数是分配的内存起始地址填写 NULL 参数会让系统自动选择分配的基地址，第二个参数是分配内存区域的大小填写 len+5 后面的5代表跳转指令的长度，第三个参数填写 MEM_COMMIT | MEM_RESERVE 表示直接完成内存的预留和提交可以立即让内存区域可用，第四个参数 PAGE_EXECUTE_READWRITE 让这块地址的拥有执行权限和读写权限。
此函数返回成功能得到新创建的内存区域地址，把这个地址存储在 trampoLine 指针当中：
1
| void * trampoLine = VirtualAlloc(NULL, len + 5, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
|
得到了新内存区域后通过 memcpy 函数把原始指令复制到 trampoLine 区域当中：
1
| memcpy(trampoLine, toHook, len);
|
原始指令后需要跳转到原函数的后面部分去才行，所以这里要先计算跳转回原始函数的地址：
1
| uintptr_t trampoJmpAddy = ((uintptr_t)toHook - (uintptr_t)trampoLine) - 5;
|
将 Jmp 指令的操作码写入内存区域，0xE9 是Jmp指令的操作码。 (uintptr_t)trampoLine + len 计算出原始指令之后的第一个字节处：
1
| *(BYTE*)((uintptr_t)trampoLine + len) = 0xE9;
|
Jmp指令后面紧接着需要跳转的地址，这个地址在上面计算过，直接写入即可：
1
| *(uintptr_t *)((uintptr_t)trampoLine + len + 1) = trampoJmpAddy;
|
现在就可以执行Detour操作来修改目标函数了，这里为了方便可以直接调用在上一期创建的myHook函数：
1
| myHook(toHook, ourFunct, len);
|
根据前面所讲执行完我们的Hook函数之后就可以返回 Trampoline 的地址：
下面是完整的代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| void * TrampolineHook(void * toHook, void * ourFunct, int len)
{
if (len < 5) return NULL;
void * trampoLine = VirtualAlloc(NULL, len + 5, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
memcpy(trampoLine, toHook, len);
uintptr_t trampoJmpAddy = ((uintptr_t)toHook - (uintptr_t)trampoLine) - 5;
*(BYTE*)((uintptr_t)trampoLine + len) = 0xE9;
*(uintptr_t *)((uintptr_t)trampoLine + len + 1) = trampoJmpAddy;
Hook(toHook, ourFunct, len);
return trampoLine;
}
|
2.Trampoline函数的实现
这里我就拿经典的 FPS 游戏 AssaultCube 来举例，这个游戏的渲染是通过 OpenGL 中的 wglSwapBuffers 函数来实现的。通过 IDA 查看 ac_client.exe 中的 Imports 就能搜到此函数的依赖：
1
| 004DA3E0 SDL_GL_SwapBuffers SDL
|
确认了是OpenGL库之后通过 IDA 打开 opengl32.dll 搜索 Exports 窗口中的 wglSwapBuffers 函数：
1
| wglSwapBuffers 6923D080 362
|
双击进入此函数查看函数声明，因为不修改函数内部逻辑所以不用分析函数实现：
1
| int __stdcall wglSwapBuffers(HDC hDC);
|
可以看到 stdcall 调用约定，返回类型为 int ，接受一个HDC类型参数的函数。那么我们通过 typedef 定义一个函数指针类型 wglSwapBuffers ，再声明一个全局函数指针变量用来存储原始函数的地址和 Trampoline 地址：
1
2
| typedef int(__stdcall* p_wglSwapBuffers)(HDC hDC);
p_wglSwapBuffers o_wglSwapBuffers;
|
创建我们的Hook函数用来“替代”原始的 wglSwapBuffers ，每次调用 wglSwapBuffers 时会先调用我们的Hook函数。在 Hook 函数中先执行一段自己想要的代码最后再跳转到 Trampoline 函数：
1
2
3
4
5
| int __stdcall hook_wglSwapBuffers(HDC hDC)
{
return o_wglSwapBuffers(hDC);
}
|
这样以来我们就写完了Hook函数，之后在我们的线程创建处要调用此钩子函数之前先把原始函数 wglSwapBuffers 的地址存放到之前声明的 o_wglSwapBuffers 当中：
1
| o_wglSwapBuffers = (p_wglSwapBuffers)GetProcAddress(GetModuleHandle(L"opengl32.dll"), "wglSwapBuffers");
|
然后就可以正常调用我们的 TrampolineHook 函数了，最重要的一点是要把此函数返回的新内存地址（Trampoline函数地址）赋值给 o_wglSwapBuffers 变量。这样就能实现完整的Hook了，要是这里不改 o_wglSwapBuffers 变量的值，一直保持原始函数地址的话会无限递归导致栈溢出程序崩溃：
1
| o_wglSwapBuffers = (p_wglSwapBuffers)mem::TrampolineHook((void*)o_wglSwapBuffers, (void*)hook_wglSwapBuffers, 5);
|
在游戏中注入线程之后通过 Cheat Engine 查看 wglSwapBuffers 函数：
1
2
3
4
5
6
7
8
| OPENGL32.dll+3D07D - CC - int 3
OPENGL32.dll+3D07E - CC - int 3
OPENGL32.dll+3D07F - CC - int 3
OPENGL32.dll+3D080 - E9 C644BA19 - jmp AssaultCube_TrampolineHook.dll+1154B ;这里被Hook了
OPENGL32.dll+3D085 - 83 E4 F8 - and esp,-08 { 248 }
OPENGL32.dll+3D088 - 83 EC 14 - sub esp,14 { 20 }
OPENGL32.dll+3D08B - 53 - push ebx
|
加个断点一步步执行就能调转到Hook函数：
1
2
3
4
5
6
7
8
9
10
11
| AssaultCube_TrampolineHook.dll+158CC - CC - int 3
AssaultCube_TrampolineHook.dll+158CD - CC - int 3
AssaultCube_TrampolineHook.dll+158CE - CC - int 3
AssaultCube_TrampolineHook.dll+158CF - CC - int 3
AssaultCube_TrampolineHook.dll+158D0 - 55 - push ebp ;Hook函数开始处
AssaultCube_TrampolineHook.dll+158D1 - 8B EC - mov ebp,esp
AssaultCube_TrampolineHook.dll+158D3 - 81 EC 8C010000 - sub esp,0000018C { 396 }
AssaultCube_TrampolineHook.dll+158D9 - 53 - push ebx
AssaultCube_TrampolineHook.dll+158DA - 56 - push esi
AssaultCube_TrampolineHook.dll+158DB - 57 - push edi
|
Visual Studio 的调试器显示了所有变量的地址，Cheat Engine 调转到蹦床函数的地址就能看到新创建的内存空间：
1
2
3
4
5
6
7
| 00FFFFFF - - ??
01000000 - 8B FF - mov edi,edi ;Trampoline 函数开始处执行原始指令
01000002 - 55 - push ebp
01000003 - 8B EC - mov ebp,esp
01000005 - E9 7BD05360 - jmp OPENGL32.dll+3D085 ;跳转回原函数后续
0100000A - 00 00 - add [eax],al
|
对此产生迷惑可以通过 Visual Studio 和 Cheat Engine进行配合调试一步步执行代码进行学习。
3.完整代码
下面是完整带注释的代码可自行实践学习：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
uintptr_t baseAddress = (uintptr_t)GetModuleHandle(L"ac_client.exe");
uintptr_t openglAddress = (uintptr_t)GetModuleHandle(L"opengl32.dll");
typedef int(__stdcall* p_wglSwapBuffers)(HDC hDC);
p_wglSwapBuffers o_wglSwapBuffers;
int __stdcall hook_wglSwapBuffers(HDC hDC)
{
bool bHealth = false, bAmmo = false, bRecoil = false;
uintptr_t playerBase = baseAddress + 0x10f4f4;
uintptr_t healthPtr = mem::findDMMAddy(playerBase, { 0xf8 });
uintptr_t ammoPtr = mem::findDMMAddy(playerBase, { 0x374,0x14,0x0 });
int newValue = 1337;
if (GetAsyncKeyState(VK_NUMPAD1) & 1)
{
bHealth = !bHealth;
}
if (GetAsyncKeyState(VK_NUMPAD2) & 1)
{
bAmmo = !bAmmo;
}
if (GetAsyncKeyState(VK_NUMPAD3) & 1)
{
bRecoil = !bRecoil;
if (bRecoil)
{
mem::nopPatch((BYTE*)(baseAddress + 0x63786), 10);
}
else
{
mem::writePatch((BYTE*)(baseAddress + 0x63786), (BYTE*)("\x50\x8d\x4c\x24\x1c\x51\x8b\xce\xff\xd2"), 10);
}
}
if (playerBase)
{
if (bHealth)
{
mem::writePatch((BYTE*)healthPtr, (BYTE*)&newValue, 4);
}
if (bAmmo)
{
mem::writePatch((BYTE*)ammoPtr, (BYTE*)&newValue, 4);
}
}
return o_wglSwapBuffers(hDC);
}
DWORD WINAPI HackThread(HMODULE hModule)
{
o_wglSwapBuffers = (p_wglSwapBuffers)GetProcAddress(GetModuleHandle(L"opengl32.dll"), "wglSwapBuffers");
o_wglSwapBuffers = (p_wglSwapBuffers)mem::TrampolineHook((void*)o_wglSwapBuffers, (void*)hook_wglSwapBuffers, 5);
return 0;
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
{
HANDLE hThread = nullptr;
hThread = CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)HackThread, hModule, 0, nullptr);
if (hThread)
{
CloseHandle(hThread);
}
}
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
|
每一种Hook技术都有各自的优势和缺点，根据当时的情况来选择适合的技术才是最优解，后续我会继续补充其他的Hook技术。文章当中有需要更改的部分请在评论区指出或者联系我个人邮箱进行反馈，谢谢观看！