游戏逆向中常用的Hook技术

2503_90751789

186人浏览 · 2026-04-16 21:13:03

2503_90751789 · 2026-04-16 21:13:03 发布

一、内联Hook（InlineHook）

（1）inline hook 是什么

当我们想要拦截现有运行中的进程内某个现有的汇编函数体，最常用的办法就是 inline hook。

它可以在权限允许内，通过修改程序运行中的内存代码段汇编，以达到拦截任何函数的目的，包括系统api(只限非内核态的函数体,要hook内核函数需要进内核态)，以及程序内部现有的任何函数体。

比如想拦截系统APICreateFileW的调用，修改原调用参数并继续执行CreateFileW原函数逻辑，获得返回值，或者直接拦截返回NULL失败，或者拦截程序本身代码汇编的函数体，用 inline hook都可以做到。

具体步骤如下：备份原始指令：在目标函数入口处，保存前几个字节（通常是 5 到 12 字节）。写入跳转指令：将目标函数的开头替换为一条跳转指令（通常是 JMP）。执行自己的逻辑：程序运行到目标函数时，会直接跳到你写的“钩子函数”里。跳回原函数：如果你还想让原程序继续运行，就在执行完你的逻辑后，先执行备份的原始指令，再跳回目标函数的后续位置。

（2）示例代码解析

x86示例代码如下，需要注意的是编译器如果发现 OriginalHelloWorldFunction 内容很短，且在同一个文件里，它在编译 main 函数时，将不会去执行 CALL 指令，而是直接把那句 printf 的内容复制到了 main 里面。所以需要在函数定义前加上 __declspec(noinline)，通知编译器不要内联这个函数。

#include <windows.h>

#include <stdio.h>

// --- 被 HOOK 的目标函数 ---

__declspec(noinline) void OriginalHelloWorldFunction() {

printf("[执行] 原始的 Hello World 函数\n");

}

// --- 我们自定义的钩子函数 (Hook 函数) ---

void MyCustomHelloWorldFunction()

{

printf("[拦截] 成功进入了我们的钩子函数！\n");

}

// --- 核心：执行 Inline Hook 的逻辑 ---

void SetupInlineHookJmp32()

{

// 1. 定义跳转机器码结构 (E9 + 4字节偏移量)

// 机器码格式：E9 XX XX XX XX

BYTE JumpInstruction[5] = { 0xE9, 0, 0, 0, 0 };

// 2. 计算跳转偏移量 (公式：目标地址 - 原地址 - 指令长度)

// 注意：跳转是相对于当前指令下一条地址开始计算的

DWORD RelativeOffset = (DWORD)MyCustomHelloWorldFunction - (DWORD)OriginalHelloWorldFunction - 5;

// 将计算好的 4 字节偏移填充到机器码中

*(DWORD*)(JumpInstruction + 1) = RelativeOffset;

// 3. 修改目标内存属性为“可读写执行”，否则修改代码会引发崩溃 (Access Violation)

DWORD OldMemoryProtection;

VirtualProtect(OriginalHelloWorldFunction, 5, PAGE_EXECUTE_READWRITE, &OldMemoryProtection);

// 4. 正式写入机器码 (覆盖原函数开头的 5 个字节)

memcpy(OriginalHelloWorldFunction, JumpInstruction, 5);

// 5. 恢复内存原始保护属性 (养成良好的安全习惯)

VirtualProtect(OriginalHelloWorldFunction, 5, OldMemoryProtection, &OldMemoryProtection);

printf("[系统] Inline Hook 已部署完毕。\n");

}

int main()

{

printf("====== 32位 Inline Hook 测试开始 ======\n\n");

// 第一步：测试 Hook 之前的函数行为

printf("1. 尝试直接调用函数（此时未 Hook）：\n");

// 注意：这里如果先调用，可能会被编译器内联，测试建议直接开始 Hook

OriginalHelloWorldFunction();

// 第二步：部署 Hook

SetupInlineHookJmp32();

// 第三步：再次调用原函数名，观察输出

printf("\n2. 再次尝试调用原函数：\n");

OriginalHelloWorldFunction();

printf("\n====== 测试结束 ======\n");

getchar(); // 暂停程序查看结果

return 0;

}

x64示例代码：

#include <windows.h>

#include <stdio.h>

// 告诉编译器不要内联这些函数

__declspec(noinline) void OriginalHelloWorldFunction()

{

printf("[执行] 原始的 x64 Hello World 函数\n");

}

void MyCustomHelloWorldFunction()

{

printf("[拦截] 成功进入了 x64 钩子函数！\n");

}

void SetupInlineHookX64()

{

// 1. 定义 12 字节的绝对跳转指令

// 48 B8 [8字节地址] FF E0 (jmp rax)

BYTE JumpInstruction[12] = {

0x48, 0xB8, 0, 0, 0, 0, 0, 0, 0, 0, // mov rax, <address>

0xFF, 0xE0 // jmp rax

};

// 2. 将 64 位绝对地址写入机器码

void* TargetAddress = &MyCustomHelloWorldFunction;

memcpy(&JumpInstruction[2], &TargetAddress, 8);

// 3. 修改内存属性（注意：这次需要 12 字节空间）

DWORD OldMemoryProtection;

if (!VirtualProtect((LPVOID)OriginalHelloWorldFunction, 12, PAGE_EXECUTE_READWRITE, &OldMemoryProtection)) {

printf("[错误] 内存权限修改失败！\n");

return;

}

// 4. 写入 Hook

memcpy((LPVOID)OriginalHelloWorldFunction, JumpInstruction, 12);

// 5. 还原属性

VirtualProtect((LPVOID)OriginalHelloWorldFunction, 12, OldMemoryProtection, &OldMemoryProtection);

printf("[系统] x64 绝对跳转 Hook 已部署完毕。\n");

}

int main()

{

printf("====== 64位 Inline Hook 测试开始 ======\n\n");

printf("1. 尝试直接调用函数：\n");

OriginalHelloWorldFunction();

SetupInlineHookX64();

printf("\n2. 再次尝试调用原函数：\n");

OriginalHelloWorldFunction();

printf("\n====== 测试结束 ======\n");

system("pause");

return 0;

}

（3）原理解析

Inline Hook 是通过直接修改目标函数在内存中的机器指令来实现的。

在x86系统中。

常用 JMP（操作码 0xE9）去完成这个跳转操作，而JMP指令有两个特点：1.E9 指令后面需要跟一个 4 字节的偏移地址。2.总计 5 字节。记住这两个之后，就到了跳转地址的计算技术（重点），这是很多初学者容易卡住的地方。JMP 指令里的地址不是目标的绝对内存地址，而是相对偏移量。

计算公式：相对偏移 = 目标函数地址 - 原函数地址 - 跳转指令本身长度(5字节)。之所以这么算，是因为 CPU 执行到 JMP 时，指令寄存器（EIP/RIP）已经指向了 JMP 的下一条指令地址。所以你得把这 5 个字节抠掉，剩下的才是要跨越的距离。

假设：

目标地址 (TargetAddress)：你想跳去的地方（你的钩子函数 MyCustomFunction），地址是 0x00401050。

源地址 (SourceAddress)：你准备动手修改的地方（原函数 OriginalFunction），地址是 0x00401000。

套用公式：我们要计算的是填在 0xE9 后面的那 4 个字节到底是多少。相对偏移 = 0x00401050 - 0x00401000 - 5。先算地址差：0x00401050 - 0x00401000 = 0x50 (十进制的 80)。再减去指令长度：0x50 - 5 = 0x4B (十进制的 75)所以，相对偏移量就是 0x0000004B。

CPU 在执行指令时，EIP（指令指针）永远指向“下一条即将执行的指令”：CPU 读到了 0x00401000 处的 E9。在它还没开始“跳”之前，它的 EIP 已经自动增加，指向了 JMP 指令结束后的那个位置，即 0x00401005。此时 CPU 执行跳转，它会拿 当前的 EIP (0x00401005) + 你的偏移量 (0x4B)。计算结果：0x00401005 + 0x4B = 0x00401050。

如果是“往回跳”怎么办：如果你的目标地址比源地址小（比如从 `0x401050` 跳回 `0x401000`），公式依然成立。相对偏移 = 0x00401000 - 0x00401050 - 5 = -0x50 - 5 = -0x55。在 32 位计算机中，负数用补码表示。`-0x55` 转换成 4 字节十六进制就是 `0xFFFFFFAB`。你写入 `E9 AB FF FF FF`，CPU 同样能带你跳回去。

在x 64 位系统中。

由于内存空间太大，4 字节的偏移量（最大 ±2GB）可能跳不过去。所以常用 12 字节的绝对跳转：

mov rax, 0x1122334455667788  ; 48 B8 ... (把 8 字节绝对地址存入寄存器)
jmp rax                      ; FF E0

也就是把跳转地址存放到寄存器中，然后通过jmp寄存器的方式跳过去。

涉及的关键系统函数是VirtualProtect，代码段在内存里通常是“只读”的（PAGE_EXECUTE_READ）。想要修改人家的机器码，必须先用这个函数把权限改成“可读可写可执行”（PAGE_EXECUTE_READWRITE），改完后再换回去。

在 32 位（或 64 位的 E9 跳转）中，指令里存放的是“距离”。而我们在 64 位中常用的 12 字节 Hook，利用了寄存器作为中转站，直接把目标的绝对地址（Absolute Address）写进了指令里。在这种模式下，你只需要通过 &MyCustomFunction 获取钩子函数的 64 位完整地址，然后用 memcpy 直接把它塞进机器码的第 2 到第 9 个字节位置即可。没有加减法，只有搬运。当然，如果选择5 字节相对跳转，那么必须满足目标函数和原函数的距离必须在 ± 2GB 之内，也就是依旧要用到那个公式。

二、IAT Hook

熟悉PE结构的应该知道.IAT 是导入表。

对于不熟悉PE结构的人：

IAT (Import Address Table)，即导入地址表。

你写了一个程序，调用了 MessageBoxA。但你的程序本身并不知道 MessageBoxA 在内存的哪个角落，因为 user32.dll 每次加载的地址可能都不一样。Windows 的做法：在你的程序（PE文件）里留一张“通讯录”。加载时：当程序启动时，Windows 加载器会找到 MessageBoxA 的真实地址，并把它填进这张表里。运行时：你的程序每次想弹窗，都会去查这张表，然后跳到表里记录的地址。

其IAT表结构如下:

typedef struct _IMAGE_IMPORT_DESCRIPTOR {

union {

DWORD Characteristics;

DWORD OriginalFirstThunk; 指向INT表 4个字节一组.是RVA指向名字跟序号

} DUMMYUNIONNAME;

DWORD TimeDateStamp;

DWORD ForwarderChain;

DWORD Name;

DWORD FirstThunk; 在文件中跟INT表一样.这是IAT

} IMAGE_IMPORT_DESCRIPTOR;

typedef IMAGE_IMPORT_DESCRIPTOR UNALIGNED *PIMAGE_IMPORT_DESCRIPTOR;