APatch部署及KPM实现InlineHook及SyscallHook技术
安卓设备APatch部署及利用KPM模块实现InlineHook及SyscallHook技术
APatch部署及KPM实现InlineHook及SyscallHook技术
目录
APatch部署获取ROOT
准备工作
必需工具
- APatch Manager
- 原厂boot.img (从官方固件包提取)
- ADB工具 (Android Debug Bridge)
- Fastboot工具
- 交叉编译工具链 (用于编译KPM模块)
环境要求
- Android设备已解锁Bootloader
- 电脑已安装ADB和Fastboot驱动
- 设备支持内核模块加载
驱动安装
- 准备ADB工具,打开android studio
打开SDK Manager,下载USB Driver; - 打开设备管理器:
找到便携设备或者其他设备,找到对应安卓设备,选择更新驱动程序; - 更新完毕后,进入手机fastboot,输入测试命令:
fastboot devices驱动正常安装并能够使用。
卸载Magisk
步骤1:卸载Magisk应用
在Magisk Manager中选择"卸载" → "完全卸载"
步骤2:验证卸载成功
# 连接设备
adb shell
# 尝试获取root权限
su
# 结果:su命令未找到或权限被拒绝
# su: inaccessible or not found确认卸载成功的标志:
- su命令不存在或无权限
- Magisk Manager无法启动
- 已安装的root应用无法工作
APatch安装部署
通过APatch Manager安装
安装APatch Manager
- 下载最新版APatch Manager APK
github链接:Releases · bmax121/APatch - 在设备上安装并打开应用
修补Boot镜像
APatch Manager → 修补内核 → 选择原厂boot.img
显示img已修补,将修补后的img文件导出到本地目录。
刷入修补后的镜像
# 重启到fastboot模式
adb reboot bootloader
# 刷入修补后的boot镜像
fastboot flash boot apatched_patched.img
# 重启设备
fastboot reboot验证APatch安装
- APatch Manager显示版本信息
验证Apatch正常工作。 - Root权限验证
adb shell
suKPM模块编译
Linux环境编译
1. 安装交叉编译工具链
# Ubuntu/Debian
sudo apt update
sudo apt install gcc-aarch64-linux-gnu
# 下载 ARM GNU bare-metal 工具链
cd /tmp
wget https://developer.arm.com/-/media/Files/downloads/gnu/11.2-2022.02/binrel/gcc-arm-11.2-2022.02-x86_64-aarch64-none-elf.tar.xz
# 解压到 /opt
sudo tar -xf gcc-arm-11.2-2022.02-x86_64-aarch64-none-elf.tar.xz -C /opt/arm-tools/2. 设置编译环境
# 下载KernelPatch源码
git clone https://github.com/bmax121/KernelPatch
cd KernelPatch/kpms/demo-hello
# 设置环境变量
export PATH=/opt/arm-tools/gcc-arm-11.2-2022.02-x86_64-aarch64-none-elf/bin:$PATH
export TARGET_COMPILE=aarch64-none-elf-3. 编译KPM模块
# 执行编译
make
# 编译输出
# aarch64-linux-gnu-gcc -I../../kernel/. -I../../kernel/include ...
# aarch64-linux-gnu-gcc -r -o hello.kpm hello.o输出文件:hello.kpm
Windows环境编译
1. 安装工具链
- 下载ARM GNU Toolchain
- 添加工具链到系统PATH
2. 配置Makefile
使用Makefile:
TARGET_COMPILE=F:\Program Files\Arm\GNUToolchain\bin\aarch64-none-elf-
ifndef TARGET_COMPILE
$(error TARGET_COMPILE not set)
endif
ifndef KP_DIR
KP_DIR = ../..
endif
CC = $(TARGET_COMPILE)gcc
LD = $(TARGET_COMPILE)ld
INCLUDE_DIRS := . include patch/include linux/include linux/arch/arm64/include linux/tools/arch/arm64/include
INCLUDE_FLAGS := $(foreach dir,$(INCLUDE_DIRS),-I$(KP_DIR)/kernel/$(dir))
objs := hello.o
all: hello.kpm
hello.kpm: ${objs}
${CC} -r -o $@ $^
%.o: %.c
${CC} $(CFLAGS) $(INCLUDE_FLAGS) -Thello.lds -c -O2 -o $@ $<
.PHONY: clean
clean:
rm -rf *.kpm
find . -name "*.o" | xargs rm -f3. 执行编译
# 使用GNU环境
make示例KPM模块代码
hello.c:
static long hello_init(const char *args, const char *event, void *__user reserved)
{
pr_info("kpm hello init, event: %s, args: %s\n", event, args);
pr_info("kernelpatch version: %x\n", kpver);
return 0;
}
static long hello_control0(const char *args, char *__user out_msg, int outlen)
{
pr_info("kpm hello control0, args: %s\n", args);
char echo[64] = "echo: ";
strncat(echo, args, 48);
compat_copy_to_user(out_msg, echo, sizeof(echo));
return 0;
}
static long hello_control1(void *a1, void *a2, void *a3)
{
pr_info("kpm hello control1, a1: %llx, a2: %llx, a3: %llx\n", a1, a2, a3);
return 0;
}
static long hello_exit(void *__user reserved)
{
pr_info("kpm hello exit\n");
return 0;
}
KPM_INIT(hello_init);
KPM_CTL0(hello_control0);
KPM_CTL1(hello_control1);
KPM_EXIT(hello_exit);执行结果:
KPM模块加载
1. 推送KPM模块到设备
adb push hello.kpm /storage/emulated/0/Download2. 在APatch Manager中加载
- 打开APatch Manager
- 进入"模块"页面
- 点击"从存储加载"
- 选择
hello.kpm文件 - 等待加载完成
3. 验证模块加载
# 查看内核日志
adb shell
su
dmesg | grep -i kp输出日志信息,查看到模块已加载。
KPM模块实现InlineHook
kpmInlineHook模块解析
一、整体架构
这是一个ARM64平台上的inline hook框架,支持两种钩子模式:
- 直接钩子:用自定义函数替换原函数
- 钩子链:允许安装多个前置/后置回调函数
二、钩子安装详细流程
2.1 调用流程(hook_wrap2)
// 用户调用
hook_err_t err = hook_wrap2((void *)add, before_add, after_add, 0);
// 实际流程:
hook_wrap() -> hook_prepare() -> hook_install()2.2 hook_prepare() 核心步骤
步骤1:地址验证和初始化
// 检查所有相关地址的有效性
if (is_bad_address((void *)hook->func_addr)) return -HOOK_BAD_ADDRESS;
// ... 其他地址检查
// 备份原始指令(TRAMPOLINE_NUM=12条指令,48字节)
for (int i = 0; i < TRAMPOLINE_NUM; i++) {
hook->origin_insts[i] = *((uint32_t *)hook->origin_addr + i);
}步骤2:生成跳转代码(trampoline)
// 生成从原函数跳转到替换函数的代码
hook->tramp_insts_len = branch_from_to(hook->tramp_insts, hook->origin_addr, hook->replace_addr);步骤3:指令重定位
这是最关键的部分,因为ARM64指令有PC相对寻址,移动指令后需要修复地址。
重定位算法:
for (int i = 0; i < hook->tramp_insts_len; i++) {
uint64_t inst_addr = hook->origin_addr + i * 4;
uint32_t inst = hook->origin_insts[i];
hook_err_t relo_res = relocate_inst(hook, inst_addr, inst);
}示例:重定位B指令
原指令:B <offset> (相对跳转)
重定位后:
B.COND #8 ; 条件跳转时才有
B #24 ; 跳到加载地址部分
LDR X17, #8 ; 加载目标地址到X17
B #12 ; 跳过地址数据
.word addr_low ; 目标地址低32位
.word addr_high ; 目标地址高32位
BLR X17 ; 调用(BL)或BR X17(B)
NOP步骤4:生成返回跳转
// 从重定位代码跳回原函数继续执行
uint64_t back_src_addr = hook->relo_addr + hook->relo_insts_len * 4;
uint64_t back_dst_addr = hook->origin_addr + hook->tramp_insts_len * 4;
hook->relo_insts_len += branch_from_to(buf, back_src_addr, back_dst_addr);2.3 hook_install() 安装钩子
内存保护处理:
// 1. 获取页表项,修改权限
uint64_t *entry = pgtable_entry_kernel(va);
uint64_t ori_prot = *entry;
*entry = (ori_prot | PTE_DBM) & ~PTE_RDONLY; // 去除只读,设置脏位
// 2. 刷新TLB
flush_tlb_kernel_page(va);
// 3. 写入跳转指令
for (int32_t i = 0; i < hook->tramp_insts_len; i++) {
*((uint32_t *)hook->origin_addr + i) = hook->tramp_insts[i];
}
// 4. 刷新指令缓存(重要!)
flush_icache_all();
// 5. 恢复原始内存保护
*entry = ori_prot;
flush_tlb_kernel_page(va);三、链式钩子特殊处理
3.1 transit 函数机制
对于链式钩子,替换地址指向一个transit函数,它会:
- 遍历所有安装的回调函数
- 调用前过滤(before)
- 可选执行原函数
- 调用后过滤(after)
transit函数定位技巧:
// 使用ADRP获取当前PC,然后向前查找NOP标记
asm volatile("adr %0, ." : "=r"(this_va));
uint32_t *vptr = (uint32_t *)this_va;
while (*--vptr != ARM64_NOP) {
// 查找NOP,找到hook_chain_t结构起始
};
hook_chain_t *hook_chain = local_container_of((uint64_t)vptr, hook_chain_t, transit);四、关键技术解析
4.1 PC相对地址处理
ARM64大量使用PC相对寻址,重定位时必须正确处理:
static int is_in_tramp(hook_t *hook, uint64_t addr)
{
uint64_t tramp_start = hook->origin_addr; // trampoline 起始地址(原函数首地址)
uint64_t tramp_end = tramp_start + hook->tramp_insts_num * 4; // 结束地址(ARM64 指令定长 4 字节)
if (addr >= tramp_start && addr < tramp_end) {
return 1;
}
return 0;
}
static uint64_t relo_in_tramp(hook_t *hook, uint64_t addr)
{
uint64_t tramp_start = hook->origin_addr;
uint64_t tramp_end = tramp_start + hook->tramp_insts_num * 4;
/* 快速路径:地址不在 trampoline 内,无需转换 */
if (!(addr >= tramp_start && addr < tramp_end)) return addr;
/* 计算该地址在 trampoline 中的指令序号 */
uint32_t addr_inst_index = (addr - tramp_start) / 4;
/* 从重定位区域起始地址开始,逐条累加每条指令的实际长度 */
uint64_t fix_addr = hook->relo_addr;
for (int i = 0; i < addr_inst_index; i++) {
inst_type_t inst = hook->origin_insts[i]; // 取出第 i 条原始指令
/* 在指令类型表中匹配,决定该指令在重定位副本中的长度倍数 */
for (int j = 0; j < sizeof(relo_len) / sizeof(relo_len[0]); j++) {
if ((inst & masks[j]) == types[j]) { // 匹配指令类型
fix_addr += relo_len[j] * 4; // 按类型对应长度累加
break;
}
}
}
return fix_addr;
}4.2 指令编码解码
使用位操作宏处理ARM64指令编码:
#define bits32(n, high, low) ((uint32_t)((n) << (31u - (high))) >> (31u - (high) + (low)))
#define bit(n, st) (((n) >> (st)) & 1)
#define sign64_extend(n, len) (((uint64_t)((n) << (63u - (len - 1))) >> 63u) ? ((n) | (0xFFFFFFFFFFFFFFFF << (len))) : n)
//提取B指令的26位立即数
uint64_t imm26 = bits32(inst, 25, 0);
uint64_t imm64 = sign64_extend(imm26 << 2u, 28u); // 左移2位,符号扩展到64位4.3 并发安全
钩子链使用状态机保证线程安全:
// 添加回调时的状态变化
chain->states[i] = CHAIN_ITEM_STATE_BUSY; // 1. 设为忙碌
dsb(ish); // 2. 内存屏障
chain->udata[i] = udata; // 3. 设置数据
chain->befores[i] = before;
chain->afters[i] = after;
dsb(ish); // 4. 再次内存屏障
chain->states[i] = CHAIN_ITEM_STATE_READY; // 5. 设为就绪五、内存布局示例
区域 | 地址/偏移 | 指令序列 | 说明 |
原函数 (被覆盖) |
|
| 被覆盖的原始指令 |
| |||
| 跳转目标地址 | ||
| 跳转到 Hook 函数 | ||
| 原函数后续代码 | 原函数剩余代码 | |
Trampoline (跳板) |
|
| 加载 replaceaddr 到 X17 |
| 跳转到替换函数 | ||
| 替换函数地址 | ||
实际上 X17 = replaceaddr | |||
重定位区域 |
|
| 复现原函数被覆盖的指令 |
| |||
| 目标地址 | ||
| |||
| 继续执行原函数后续 | ||
| |||
| |||
| |||
... | |||
| 最终返回 | ||
| 返回目标地址 |
六、部署调试
1、执行make命令生成目标kpm文件
2、安卓设备进行模块加载
3、查看linux日志:
dmesg | grep "inline"
dmesg | grep -i kp可以查看到inline hook模块已经正常加载,并进行了对add函数的inlinehook挂钩操作。
KPM模块实现SyscallHook
syscall Hook模块解析
一、整体架构分析
1.1 KPM模块结构
kpm-syscall-hook-demo
├── 模块接口部分
│ ├── KPM_* 宏定义 - 模块元信息
│ ├── syscall_hook_demo_init - 模块初始化
│ ├── syscall_hook_control0 - 控制接口
│ └── syscall_hook_demo_exit - 模块卸载
├── Hook回调函数
│ ├── before_openat_0 - 第一个钩子前处理
│ ├── before_openat_1 - 第二个钩子前处理
│ └── after_openat_1 - 第二个钩子后处理
└── Hook底层实现
├── fp_hook_wrap - 函数指针钩子包装器
├── transit函数 - 跳板/中转函数
└── fp_hook/unhook - 实际hook/unhook操作二、关键代码详细解析
2.1 Hook初始化流程(syscall_hook_demo_init)
关键代码
static long syscall_hook_demo_init(const char *args, const char *event, void *__user reserved)
{
//参数解析
margs = args;
pr_info("kpm-syscall-hook-demo init ..., args: %s\n", margs);
//获取内核符号地址(用于获取进程信息)
__task_pid_nr_ns = (typeof(__task_pid_nr_ns))kallsyms_lookup_name("__task_pid_nr_ns");
pr_info("kernel function __task_pid_nr_ns addr: %llx\n", __task_pid_nr_ns);
//根据参数选择hook类型
if (!strcmp("function_pointer_hook", margs)) {
pr_info("function pointer hook ...");
hook_type = FUNCTION_POINTER_CHAIN;
//安装第一个hook(只有before回调)
err = fp_hook_syscalln(__NR_openat, 4, before_openat_0, 0, 0);
if (err) goto out;
//安装第二个hook(有before和after回调)
err = fp_hook_syscalln(__NR_openat, 4, before_openat_1, after_openat_1, &open_counts);
} else if (!strcmp("inline_hook", margs)) {
//inline hook方式
pr_info("inline hook ...");
hook_type = INLINE_CHAIN;
err = inline_hook_syscalln(__NR_openat, 4, before_openat_0, 0, 0);
}
}2.2 Hook安装核心流程(fp_hook_wrap)
hook_err_t fp_hook_wrap(uintptr_t fp_addr, int32_t argno, void *before, void *after, void *udata)
{
//地址有效性检查
if (is_bad_address((void *)fp_addr)) return -HOOK_BAD_ADDRESS;
//获取或创建hook链
fp_hook_chain_t *chain = hook_get_mem_from_origin(fp_addr);
if (!chain) {
//首次hook:分配内存并初始化
chain = (fp_hook_chain_t *)hook_mem_zalloc(fp_addr, FUNCTION_POINTER_CHAIN);
if (!chain) return -HOOK_NO_MEM;
chain->hook.fp_addr = fp_addr;
chain->hook.replace_addr = (uint64_t)chain->transit;
//准备跳板代码(根据参数数量选择不同的transit函数)
err = hook_chain_prepare(chain->transit, argno);
if (err) return err;
flush_icache_all(); // 刷新指令缓存
//执行实际hook:替换函数指针
fp_hook(chain->hook.fp_addr, (void *)chain->hook.replace_addr, (void **)&chain->hook.origin_fp);
}
//向hook链中添加新的hook项
for (int i = 0; i < FP_HOOK_CHAIN_NUM; i++) {
if (chain->states[i] == CHAIN_ITEM_STATE_EMPTY) {
chain->states[i] = CHAIN_ITEM_STATE_BUSY;
dsb(ish); // 数据同步屏障
// 设置hook回调函数和用户数据
chain->udata[i] = udata;
chain->befores[i] = before;
chain->afters[i] = after;
if (i + 1 > chain->chain_items_max) {
chain->chain_items_max = i + 1;
}
dsb(ish);
chain->states[i] = CHAIN_ITEM_STATE_READY;
logkv("Wrap func pointer add: %llx, %llx, %llx successed\n",
chain->hook.fp_addr, before, after);
return HOOK_NO_ERR;
}
}
//Hook链已满
return -HOOK_CHAIN_FULL;
}2.3 Transit函数机制(以_fp_transit4为例)
uint64_t __attribute__((section(".fp.transit4.text"))) __attribute__((__noinline__))
_fp_transit4(uint64_t arg0, uint64_t arg1, uint64_t arg2, uint64_t arg3)
{
//获取当前指令地址
uint64_t this_va;
asm volatile("adr %0, ." : "=r"(this_va));
//向前查找NOP指令,定位hook链结构
uint32_t *vptr = (uint32_t *)this_va;
while (*--vptr != ARM64_NOP) {
// 循环查找,直到找到标记NOP
};
//通过container_of获取hook链结构体
fp_hook_chain_t *hook_chain = local_container_of((uint64_t)vptr, fp_hook_chain_t, transit);
//准备参数结构
hook_fargs4_t fargs;
fargs.skip_origin = 0; // 默认不跳过原函数
fargs.arg0 = arg0;
fargs.arg1 = arg1;
fargs.arg2 = arg2;
fargs.arg3 = arg3;
fargs.chain = hook_chain;
//执行所有before回调(正向遍历)
for (int32_t i = 0; i < hook_chain->chain_items_max; i++) {
if (hook_chain->states[i] != CHAIN_ITEM_STATE_READY) continue;
hook_chain4_callback func = hook_chain->befores[i];
if (func) func(&fargs, hook_chain->udata[i]);
}
//执行原函数(如果未跳过)
if (!fargs.skip_origin) {
transit4_func_t origin_func = (transit4_func_t)hook_chain->hook.origin_fp;
fargs.ret = origin_func(fargs.arg0, fargs.arg1, fargs.arg2, fargs.arg3);
}
//执行所有after回调(反向遍历)
for (int32_t i = hook_chain->chain_items_max - 1; i >= 0; i--) {
if (hook_chain->states[i] != CHAIN_ITEM_STATE_READY) continue;
hook_chain4_callback func = hook_chain->afters[i];
if (func) func(&fargs, hook_chain->udata[i]);
}
//返回结果
return fargs.ret;
}2.4 实际的Hook/Unhook操作
void fp_hook(uintptr_t fp_addr, void *replace, void **backup)
{
//修改页表权限(使目标地址可写)
uint64_t *entry = pgtable_entry_kernel(fp_addr);
uint64_t ori_prot = *entry;
*entry = (ori_prot | PTE_DBM) & ~PTE_RDONLY;
flush_tlb_kernel_page(fp_addr); // 刷新TLB
//备份原函数指针并替换
*(uintptr_t *)backup = *(uintptr_t *)fp_addr;
*(uintptr_t *)fp_addr = (uintptr_t)replace;
//内存屏障和恢复页表权限
dsb(ish); // 数据同步屏障
*entry = ori_prot;
flush_tlb_kernel_page(fp_addr);
}三、关键技术详解
3.1 多Hook链管理机制
// Hook链数据结构
typedef struct {
hook_common_t hook; // 基础hook信息
uint8_t states[FP_HOOK_CHAIN_NUM]; // 每个hook项的状态
void *udata[FP_HOOK_CHAIN_NUM]; // 用户数据数组
void *befores[FP_HOOK_CHAIN_NUM]; // before前过滤数组
void *afters[FP_HOOK_CHAIN_NUM]; // after后过滤数组
int32_t chain_items_max; // 当前最大hook项数
uint32_t transit[TRANSIT_INST_NUM]; // 跳板代码区
} fp_hook_chain_t;状态机:
CHAIN_ITEM_STATE_EMPTY:空槽位CHAIN_ITEM_STATE_BUSY:正在修改(原子操作保护)CHAIN_ITEM_STATE_READY:就绪可执行
3.2 Transit函数查找机制
- 动态定位:使用
adr指令获取当前PC值 - 逆向搜索:向前查找特殊的
ARM64_NOP指令 - 结构体定位:通过
container_of宏计算结构体起始地址
3.3 参数传递机制
根据系统调用参数数量,选择不同的transit函数:
- 0参数:
_fp_transit0 - 1-4参数:
_fp_transit4 - 5-8参数:
_fp_transit8 - 9+参数:
_fp_transit12
3.4 执行流程
用户态调用openat()
↓
进入内核系统调用
↓
查sys_call_table[__NR_openat]
↓
跳转到hook后的地址(transit函数)
↓
执行所有before回调钱过滤
↓
执行原系统调用
↓
执行所有after回调后过滤
↓
返回用户态四、部署调试
4.1 执行make命令生成目标kpm文件
4.2 安卓设备进行模块加载
4.3 查看日志信息
dmesg | grep "syscall"
dmesg | grep "function pointer hook"可以看到syscallhook挂钩成功,模块运行正常。
常见问题解决
问题1:APatch安装失败
症状:刷入后无法启动或卡在开机画面
解决:
- 确保使用正确的原厂boot.img
- 检查设备型号和Android版本匹配
- 尝试清除缓存:
fastboot erase cache
问题2:KPM编译错误
症状:linux编译时和安卓架构不匹配
解决:
# 下载 ARM GNU bare-metal 工具链
cd /tmp
wget https://developer.arm.com/-/media/Files/downloads/gnu/11.2-2022.02/binrel/gcc-arm-11.2-2022.02-x86_64-aarch64-none-elf.tar.xz
# 解压到 /opt
sudo tar -xf gcc-arm-11.2-2022.02-x86_64-aarch64-none-elf.tar.xz -C /opt/arm-tools/
# 确保内核头文件路径正确
export PATH=/opt/arm-tools/gcc-arm-11.2-2022.02-x86_64-aarch64-none-elf/bin:$PATH
export TARGET_COMPILE=aarch64-none-elf-问题3:模块加载失败
症状:APatch Manager显示加载失败
解决:
- 检查内核版本兼容性
- 验证KPM文件完整性
- 查看详细错误日志:
adb logcat | grep -i apatch注意事项
1. 备份要求
- 备份原始镜像
fastboot boot boot.img
dd if=/dev/block/bootdevice/by-name/boot of=/sdcard/original_boot.img- 测试环境优先选择测试环境进行调试加载,避免因为模块崩溃造成手机变砖。
2. 恢复方法
# 刷回原始boot镜像
fastboot flash boot boot.img
fastboot reboot
# 清除APatch数据
fastboot erase userdata 参考资源
官方文档
社区资源
工具下载
- APatch Manager: https://github.com/bmax121/APatch/releases
- 交叉编译工具链: https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads
- KernelPatch源码: GitHub - https://github.com/bmax121/kernelpatch
详解APatch ROOT部署流程及KPM模块开发,涵盖ARM64平台InlineHook指令重定位与SyscallHook函数指针劫持关键技术。
由 AI 根据全文自动生成,仅供参考,以原文为准

nice 好文