APatch部署及KPM实现InlineHook及SyscallHook技术

目录

  1. APatch部署获取ROOT
  1. KPM模块实现InlineHook
  1. KPM模块实现SyscallHook
  1. 注意事项
  2. 常见问题解决
  3. 安全注意事项
  4. 参考资源

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

修补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
su

KPM模块编译

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 -f
3. 执行编译
# 使用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/Download

2. 在APatch Manager中加载

  1. 打开APatch Manager
  2. 进入"模块"页面
  3. 点击"从存储加载"
  4. 选择hello.kpm文件
  5. 等待加载完成

3. 验证模块加载

# 查看内核日志
adb shell
su
dmesg | grep -i kp

输出日志信息,查看到模块已加载。

KPM模块实现InlineHook

kpmInlineHook模块解析

一、整体架构

这是一个ARM64平台上的inline hook框架,支持两种钩子模式:

  1. 直接钩子:用自定义函数替换原函数
  2. 钩子链:允许安装多个前置/后置回调函数

二、钩子安装详细流程

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函数,它会:

  1. 遍历所有安装的回调函数
  2. 调用前过滤(before)
  3. 可选执行原函数
  4. 调用后过滤(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. 设为就绪

五、内存布局示例

区域

地址/偏移

指令序列

说明

原函数 (被覆盖)

orig_addr

B.<cond> #8
B #24

被覆盖的原始指令



LDR X17, #8
B #12




targetaddress (8字节)

跳转目标地址



BLR X17 / BR X17
NOP

跳转到 Hook 函数


orig_addr + 16

原函数后续代码

原函数剩余代码





Trampoline (跳板)

tramp_insts

LDR X17, #8

加载 replaceaddr 到 X17



RET X17

跳转到替换函数



replace_addr (8字节)

替换函数地址




实际上 X17 = replaceaddr
trampinsts 就是跳到 replaceaddr 的指令





重定位区域

relo_addr

B.<cond> #8
B #24

复现原函数被覆盖的指令



LDR X17, #8
B #12




targetaddress (8字节)

目标地址



BLR X17 / BR X17
NOP








B.<cond> #8
B #24

继续执行原函数后续



LDR X17, #8
B #12




targetaddress




BLR X17 / BR X17
NOP




...




LDR X17, #8
RET X17

最终返回



back_dst_addr (8字节)

返回目标地址

六、部署调试

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函数查找机制
  1. 动态定位:使用adr指令获取当前PC值
  2. 逆向搜索:向前查找特殊的ARM64_NOP指令
  3. 结构体定位:通过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安装失败

症状:刷入后无法启动或卡在开机画面
解决:

  1. 确保使用正确的原厂boot.img
  2. 检查设备型号和Android版本匹配
  3. 尝试清除缓存: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显示加载失败
解决:

  1. 检查内核版本兼容性
  2. 验证KPM文件完整性
  3. 查看详细错误日志:
adb logcat | grep -i apatch

注意事项

1. 备份要求

  1. 备份原始镜像
fastboot boot boot.img
dd if=/dev/block/bootdevice/by-name/boot of=/sdcard/original_boot.img
  1. 测试环境优先选择测试环境进行调试加载,避免因为模块崩溃造成手机变砖。

2. 恢复方法

# 刷回原始boot镜像
fastboot flash boot boot.img
fastboot reboot
# 清除APatch数据
fastboot erase userdata  

参考资源

官方文档

社区资源

工具下载