安卓内核Hook技术实现分析与应用

本文是基于知名Root框架APatch作者bmax121开源的KernelHook项目源码做的深度技术分析。本文从接口到实现，逐层拆解ARM64内核函数Hook的工程细节。

本文项目开源地址为：https://github.com/bmax121/KernelHook

本文作者：非虫（fei_cong@hotmail.com）

1 引言

在安卓安全研究、性能分析和内核功能扩展等场景中，内核函数 Hook 是一项基础技术。它的核心目标是在不修改内核源码、不重新编译内核的前提下，拦截并改变目标内核函数的行为。

传统方案各有局限：

KernelHook采用Inline Hook方案——直接修改目标函数入口处的机器码，将控制流导向自定义逻辑。相比上述方案，它不依赖内核编译选项，不受GKI 模块限制，支持安卓9到安卓16全版本。能Hook任意导出或未导出的内核函数，且性能接近原生调用。

本文以KernelHook项目的源码为基础，从接口设计、指令重定位、中转桩、内存管理、安全机制适配等维度，完整剖析其技术实现。

2 接口与示例

KernelHook 对外暴露一组 C 接口，覆盖四大类操作：符号查找、函数替换、回调链注册、函数指针 Hook。所有接口声明在 include/hook.h 和 include/ksyms.h。

2.1 初始化

Freestanding模式（Mode A）下，模块加载后需依次完成符号系统、内存池、页表遍历器和代码写入器的初始化：

#include<hook.h>
#include<ksyms.h>
#include<kmod_compat.h>

staticint __init my_module_init(void)
{
// kallsyms_lookup_name_addr 由 kmod_loader 在加载时注入
int err = kmod_compat_init(kallsyms_lookup_name_addr);
if (err) return err;

    err = kmod_hook_mem_init();   // ROX/RW 内存池
if (err) return err;

    kh_pgtable_init();            // 页表遍历器（读取 TCR_EL1 检测页大小）
    kh_write_insts_init();        // 解析 set_memory_rw/ro/x

return0;
}

Kbuild 模式（Mode C）使用内核构建系统，直接调用内核头文件中的函数，初始化链更短。

2.2 符号查找

ksyms_lookup 和 ksyms_lookup_cache 是运行时符号查找的核心接口：

#include<ksyms.h>

// 按名称查找内核符号地址
unsignedlong addr = ksyms_lookup("do_sys_openat2");

// 带缓存版本：首次查找后缓存结果，后续直接命中
unsignedlong addr2 = ksyms_lookup_cache("vfs_read");

ksyms_lookup_cache 在全局缓存表中维护 (name, addr) 映射。对于反复查找同一符号的场景（如模块初始化期间多次引用），可显著减少开销。

2.3 函数替换

最直接的 Hook 方式：用自定义函数完全取代目标函数。

#include<hook.h>

staticunsignedlong orig_func;

// 替换函数，签名必须与目标函数一致
staticintmy_openat2(int dfd, constchar *filename,
struct open_how *how, size_t usize)
{
// 自定义前置逻辑 ...
int ret = ((typeof(&my_openat2))orig_func)(dfd, filename, how, usize);
// 自定义后置逻辑 ...
return ret;
}

staticint __init example_init(void)
{
unsignedlong target = ksyms_lookup("do_sys_openat2");
int err = hook((void *)target, (void *)my_openat2, (void **)&orig_func);
return err;
}

staticvoid __exit example_exit(void)
{
unsignedlong target = ksyms_lookup("do_sys_openat2");
    unhook((void *)target);
}

hook() 在目标函数入口写入跳板指令，跳转到 my_openat2。orig_func 指向一段经过重定位的代码——它执行被跳板覆盖的原始指令后，跳回原函数继续运行。

2.4 回调链

相比直接替换，回调链（Hook Wrap）更灵活——多个模块可以在同一函数上注册 before/after 回调，彼此互不干扰：

#include<hook.h>

// before 回调：在目标函数执行前调用
// hook_fargs4_t 表示目标函数有 4 个参数
staticvoidbefore_openat2(hook_fargs4_t *fargs, void *udata)
{
int dfd = (int)fargs->arg0;
constchar *filename = (constchar *)fargs->arg1;
    logki("openat2: dfd=%d, file=%s", dfd, filename);

// 修改参数
// fargs->arg1 = (uint64_t)new_filename;

// 跳过原始函数并直接返回
// fargs->skip_origin = true;
// fargs->ret = -EPERM;
}

// after 回调：在目标函数执行后调用
staticvoidafter_openat2(hook_fargs4_t *fargs, void *udata)
{
long ret = fargs->ret;
    logki("openat2 returned: %ld", ret);

// 修改返回值
// fargs->ret = -EACCES;
}

staticint __init example_init(void)
{
unsignedlong target = ksyms_lookup("do_sys_openat2");
// hook_wrap4: 4 参数的便捷宏，优先级默认为 0
int err = hook_wrap4(target, before_openat2, after_openat2, NULL);
return err;
}

staticvoid __exit example_exit(void)
{
unsignedlong target = ksyms_lookup("do_sys_openat2");
    hook_unwrap(target, (void *)before_openat2, (void *)after_openat2);
}

hook_wrapN 是 hook_wrap 的便捷宏，N 表示目标函数的参数个数（0 到 12），默认优先级为 0。完整形式为：

inthook_wrap(void *func, int argno, void *before, void *after,
void *udata, int priority);

其中 before 和 after 均可为 NULL——只传 before 可以做纯拦截，只传 after 可以做纯审计。

多回调与优先级

同一目标函数上可注册最多 8 个回调。每个回调携带一个priority值，决定执行顺序：

• before 回调
  ：按 priority 降序执行——值越大越先执行
• after 回调
  ：按 priority 升序执行——值越小越先执行

这形成了洋葱式的包裹结构：

before(100) -> before(50) -> before(0)
  -> 原始函数 ->
after(0) -> after(50) -> after(100)

多回调注册示例：

unsignedlong target = ksyms_lookup("do_sys_openat2");

// 高 priority 值的 before 回调先执行
hook_wrap(target, 4, (void *)audit_callback,  NULL, NULL, 100);
hook_wrap(target, 4, (void *)filter_callback, NULL, NULL, 50);
hook_wrap(target, 4, (void *)log_callback,    NULL, NULL, 0);

// before 执行顺序：audit(100) -> filter(50) -> log(0) -> 原始函数
// after 执行顺序：log(0) -> filter(50) -> audit(100)

回调间数据传递

before/after 回调对可通过 hook_local_t 共享数据：

staticvoidbefore_func(hook_fargs4_t *fargs, void *udata)
{
hook_local_t *local = &fargs->chain.local;
    local->data0 = ktime_get_ns();  // 记录进入时间戳
}

staticvoidafter_func(hook_fargs4_t *fargs, void *udata)
{
hook_local_t *local = &fargs->chain.local;
uint64_t elapsed = ktime_get_ns() - local->data0;
    logki("function took %llu ns", elapsed);
}

hook_local_t 提供 4 个 uint64_t 字段（data0 ~ data3），在同一次调用的 before 和 after 之间共享。不同回调槽位的local相互独立。

如需在回调中手动调用原始函数（较少见），可通过以下接口获取函数指针：

void *orig = wrap_get_origin_func(fargs);    // inline hook 场景
void *orig = fp_get_origin_func(fargs);      // 函数指针 hook 场景

2.5 函数指针 Hook

函数指针 Hook 用于拦截通过函数指针表（如 struct file_operations）间接调用的函数。与 Inline Hook 不同，它不修改目标函数的代码，而是替换指针本身的值。

直接替换：

#include<hook.h>

staticunsignedlong orig_read;

staticssize_tmy_read(struct file *filp, char __user *buf,
size_t count, loff_t *pos)
{
    logki("read intercepted: count=%zu", count);
return ((typeof(&my_read))orig_read)(filp, buf, count, pos);
}

staticint __init example_init(void)
{
// fp_addr 指向某个 file_operations 结构体的 read 字段
void **fp_addr = get_target_fops_read_ptr();
int err = fp_hook(fp_addr, (void *)my_read, (void **)&orig_read);
return err;
}

staticvoid __exit example_exit(void)
{
void **fp_addr = get_target_fops_read_ptr();
    fp_unhook(fp_addr, (void *)orig_read);
}

回调链与Inline Hook 类似，但最多支持16个回调：

fp_hook_wrap4(fp_addr, before_read, after_read, NULL);
// ...
fp_hook_unwrap(fp_addr, (void *)before_read, (void *)after_read);

2.6 接口一览

3 Inline Hook 原理

Inline Hook 的核心思路：覆盖目标函数入口处的若干条指令，替换为跳板指令（trampoline），将控制流引向自定义代码。被覆盖的原始指令经过重定位后保存在另一块内存中，执行完毕后跳回原函数继续运行。

3.1 跳板结构

ARM64 上，KernelHook 使用 4 条指令（16 字节）构造跳板：