前言 最近看到了一个有趣的项目:TrampolineHook (opens new window),一个中心重定向框架,简单来讲可以用于拦截指定函数,在函数被调用时,收到一个回调通知。这个项目没有使用常用的方法交换方案,而是选择汇编实现。非常 amazing 啊,让我对其实现的原理感到好奇。边学习相关知识,边阅读源码,有了初步的理解。 才疏学浅,有误内容还请多多指正。 本文内容相对最新源码有一定的过时,但不妨碍理解核心思路,本文对应的源码可以在 https://github.com/SatanWoo/TrampolineHook/tree/5c161aae9fe2826fd9660029bd5ab5a5eec183e9 (opens new window) 访问。 本文描述版本存在栈污染,详细的描述您可以在作者的博客 TrampolineHook - 解决栈污染问题支持变参 Hook (opens new window) 了解。
# TrampolineHook 使用说明
了解原理前,先了解 TrampolineHook 具体做了啥。
定义一个回调函数:
void myInterceptor() {
printf("调用了 myInterceptor\n");
}
使用 TrampolineHook 替换 -[UIView initWithFrame]
的实现:
THInterceptor *interceptor = [THInterceptor sharedInterceptorWithFunction:(IMP)myInterceptor];
Method m = class_getInstanceMethod([UIView class], @selector(initWithFrame:));
IMP imp = method_getImplementation(m);
THInterceptorResult *interceptorResult = [interceptor interceptFunction:imp];
if (interceptorResult.state == THInterceptStateSuccess) {
method_setImplementation(m, interceptorResult.replacedAddress); // 设置替换的地址
}
UIView *view = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 200, 200)]; // 执行到这一行时,会调用 myInterceptor 方法
此时,每当调用 -[UIView initWithFrame]
,都会回调一次 myInterceptor
。
# 必备知识回顾
先温习一下本文要用到内容,会让理解起来快速很多。
# 用到的 ARM64 汇编指令
# ARM64 伪指令
# .text
.text
用于声明以下是代码段。
# .align
.align
用于将指令对齐到内存地址,对齐位置为参数的 2 的幂次方。
以 .align 10
举例,在没有添加对齐时:
func_1:
ret
func_2:
ret
得到的结果,两个指令构成了连续的地址:
在 func_1
和 func_2
之间加入 .align 10
:
func_1:
ret
.align 10
func_2:
ret
得到如下结果,如果 .align
只是个普通的指令,那 func_2
的 ret
对应地址应当为 0x0000000100008060
,这里却变成了 0x000000010000840
,0x000000010000840
刚好是 2^10 的倍数。
在本文中,会有一个妙用点,我们在 func_1
也加入 .align 10
:
可以看到 0x8800 - 0x8400 = 0x400
,0x400 刚好是 2^10,这说明我只要知道 func_2
的 ret
指令内存地址,就可以得到 func_1
的 ret
指令地址。
# .rept 和 .endr
.rept
和 .endr
是一组循环伪指令。
func_1:
.rept 5
add x0, x0, x1
.endr
ret
上述指令得到内容如下:
生成了 5 个连续的 add
指令。
# 标签
如下代码:
_my_label:
add x0, x0, x1
_my_label
会指向 add x0, x0, x1
的地址,用于辅助标记命令地址。
# .globl
.globl
可以让一个标签对链接器可见,可以供其他链接对象模块使用。
换句话说 .global _my_func
可以在代码中调用到 my_func
。
# ARM64 指令
# nop
什么也不做的指令,愣一下。没什么用途,但可以偏移指令地址。
可以看到 nop 也占了 4 个字节,原本 0000000100013fe
对应的指令应当是 ret。
# sub
减法指令,可以拿来做一些地址偏移计算,用法如下:
sub x1, x1, #0x8 ;相当于 x1 = x1 - 0x8
sub x2, x1, x2 ;相当于 x2 = x1 - x2
# mov
赋值指令,用法如下:
mov x1, x0 ;相当于 x1 = x0
# str 和 stp
两个入栈指令,stp 可以同时操作两个寄存器。
这里涉会及到一些寻址的格式,有 3 种方式:
[x10, #0x10] ;从 x10 + 0x10 的地址取值
[sp, #-16]! ;从 sp - 16 地址取值,取值完后在把 sp 向低地址移 16 字节,即开辟一段新栈空间
[sp], #16 ;从 sp 地址取值,取值完后在把 sp 向高地址偏移 16 字节,即释放一些栈空间
结合上面几种寻址方式,搭配入栈指令,用法如下:
str x8, [sp, #-16]! ;将 x8 存到 sp - 16 的位置,并将 sp -= 16
stp x4, x5, [sp, #-16]! ;将 x4 x5 的值存到 sp - 16 的位置,并将 sp -= 16
# ldr 和 ldp
两个出栈指令,ldp 可以同时操作两个寄存器,用法如下:
ldr x8, [sp], #16 ;将 sp 位置的值取出来,存入 x8 中,并将 sp += 16
ldp x4, x5, [sp], #16 ;将 sp 位置的值取出来,存入 x4 x5 中,并将 sp += 16
# br
跳转指令,直接跳转到指定地址,跳转完不返回。有些类似在一个函数末尾调用了另外的函数。用法如下:
br x10 ;跳转到 x10 中保存的地址
# bl
跳转指令,将 bl 的下一个指令地址保存到 lr 寄存器,然后跳转到指定地址,因为将下一个指令保存到 lr 了,所以跳转完会回来执行下一个指令。用法如下:
mov x0, x1
bl 0x100221232 ;跳转到 0x100221232,执行完毕回来执行下一条指令
sub x0, x0, 0x10
# blr
跳转指令,和 bl 类似,但可以使用动态地址,可以跳转到寄存器的值保存的地址,用法如下:
mov x8, 0x100221232
blr x8
# ret
返回指令,子程序(函数调用)返回指令,返回到寄存器 lr 保存的地址。
# 函数、汇编、寄存器
汇编指令是对寄存器和栈进行各种操作,如何对应到我们日常编写的函数是关键。 寄存器相当于全局变量,在汇编中没有传入参数这样的形式,但我们可以用寄存器进行传递参数。为此,我们进行了一系列约定:
- x0 - x7:用于传递子程序参数和结果,使用时不需要保存,多余参数采用堆栈传递,子程序返回结果写入到 x0
- x8:用于保存子程序返回地址
- x9 - x15:临时寄存器
- x16 - x17:子程序内部调用寄存器
- x18:平台寄存器,它的使用与平台相关
- x19 - x28:临时寄存器
- x29:帧指针寄存器 fp(栈底指针),用于连接栈帧
- x30:链接寄存器 lr,保存了子程序返回的地址
- x31:堆栈指针寄存器 sp
连续调用多个子程序会面临寄存器不够用的问题,大家都要用 lr 作为返回地址,都要用 x0 传递参数。 栈来了!如果后面的操作会对寄存器有修改,先入栈保存起来,等执行完相关操作,在出栈读出来就好了。 比如 lr 是必须入栈的寄存器(当然你脾气硬,不怕其他寄存器被修改,保存到其他寄存器也可以,但一定别这样写,万一啥时候被修改了呢),如果没有保存 lr,调用子程序后,lr 不是当初的 lr 了,会找不到返回的位置。
如下汇编没有保存 lr:
add_func:
add x0, x0, x1
ret
.globl _my_add_func
_my_add_func: ;没有保存 lr,调用后回不去了
bl add_func
ret
调用后:
FOUNDATION_EXTERN int my_add_func(int x, int y);
printf("开始执行 my_add_func\n");
int result = my_add_func(1, 1);
printf("执行 my_add_func 结果: %d\n", result);
得到的输出:
开始执行 my_add_func
为 _my_add_func
增加个 lr 入栈就行了:
_my_add_func:
str lr, [sp, #-16]!
bl add_func
ldr lr, [sp], #16
ret
此时得到的输出为:
开始执行 my_add_func
执行 my_add_func 结果: 2
更复杂的调用场景,需要将更多的寄存器入栈,避免寄存器内容被污染。
有了这些内容,我们可以开始了解 TrampolineHook 的实现原理了。
# 实现原理分析
# 流程设计
根据作者博客内容的描述,TrampolineHook 设计了精心构造的两个连续页,在这两页中保存所有要保存的内容。
为了完成中心重定向,主要思路:
- 取出原方法的 IMP A,保存起来
- 替换原方法 IMP 为一个新地址 B
- 当执行到该方法时,会跳转到新地址 B
- 在 B 中做一些自定义的操作(比如打个日志)
- 获取原先的 A,跳转过去
在 3 - 5 步骤中,注意不能把寄存器、返回地址搞乱了。
替换 IMP 很简单:
Method m = class_getInstanceMethod([UIView class], @selector(initWithFrame:));
IMP imp = method_getImplementation(m);
IMP newImp = ...;
method_setImplementation(m, newImp);
重点在新地址 B 怎么来,后续的跳转如何跳转。这就需要了解精心构造的两个连续页的内容。
# 两页内存
将 TrampolineHook 中汇编代码稍微调整一下,_th_entry
中的内容是执行自定义操作并恢复现场,跳转回原地址,为了理解页结构,先移除 _th_entry
的内容。
.text
.globl _th_dynamic_page
.align 14
interceptor: .quad 0 ;interceptor 是标签,`.quad 0` 分配了 8 字节空间,用于保存自定义跳转函数 IMP
.align 14
_th_dynamic_page: ;th_dynamic_page 是标签,地址在这里第二页起始位置
_th_entry: ;调用 interceptor 和原 IMP 逻辑
...
.rept 2032 ;生成一堆可执行地址
mov x13, lr
bl _th_entry
.endr
我们知道 .align
会将地址对齐,.align 14
中 2^14 为 16KB,在 ARM64 中,这是一页内存的大小。从前面知识我们了解到,两个 .align 14
可以让两部分指令整整齐齐。
以上两个 .align 14
将指令分成两页,第一页只有一个 8 位的 interceptor
在起始地址,第二页起始地址部分为 _th_entry
逻辑,后面通过 .rept 2032
生成了一堆的 mov x13, lr
和 bl _th_entry
指令。
两页内容如图:
上图的可执行地址就是一堆新的 IMP B 的地址。
interceptor 用来保存自定义函数 IMP。
0x10160000
- 0x101604000
中空出来的一大堆地址刚好可以用来保存原 IMP A!!!在 IMP B 上向低地址偏移 0x4000
就是原 IMP 了。
现在我们在汇编中既可以找到原 IMP,又可以找到自定义函数 IMP。保护好寄存器现场,就可以安稳调用两个 IMP 了。
接下来,我们还需要在代码中访问这两页内存。我们需要 vm_remap
完成访问,为了理解两页内存结构,先跳过 vm_remap
部分。
struct
本质上是一段内存,根据字段结构声明顺序构建内存结构。
使用 struct
构建和上面汇编的两页内存一样的结构后,可以准确访问每个地址。
typedef int32_t THDynamicPageEntryGroup[2];
static const int32_t THDynamicPageInstructionCount = 32;
static const int32_t THPageSize = 0x4000;
static const size_t THNumberOfDataPerPage = (0x4000 - THDynamicPageInstructionCount * sizeof(int32_t)) / sizeof(THDynamicPageEntryGroup);
// THNumberOfDataPerPage 为 2032
typedef struct {
union {
struct {
IMP redirectFunction;
int32_t nextAvailableIndex;
};
int32_t placeholder[THDynamicPageInstructionCount]; // 占位
};
THDynamicData dynamicData[THNumberOfDataPerPage]; // IMP 刚好是 8 个字节
} THDataPage;
typedef struct {
int32_t fixedInstructions[THDynamicPageInstructionCount]; // 占位
THDynamicPageEntryGroup jumpInstructions[THNumberOfDataPerPage]; // 可执行地址
} THCodePage;
typedef struct {
THDataPage dataPage;
THCodePage codePage;
} THDynamicPage;
上述的 THDataPage
和 THCodePage
均为 0x4000
大小,对应一页内存大小。
fixedInstructions
和 placeholder
是同大小,用于占位,对应的是 _th_entry
部分指令,这部分地址不能拿来写入 IMP。
下图是 THDynamicPage
和汇编指令地址对应关系:
这里 placeholder
不能太浪费,还用到了 union
关键字,给 redirectFunction
和 nextAvailableIndex
留给空间。
重定向函数指针 redirectFunction
声明在头部,地址对应 0x101600000
,正是 interceptor
。
# 调用 interceptor 和原 IMP 的 _th_entry
_th_entry
主要任务是:
- 偏移地址取出原 IMP
- 保存原 IMP 用的参数寄存器 x0 - x7、浮点寄存器 q0 - q7 、返回地址寄存器 lr
- 调用
interceptor
- 恢复 x0 - x7、q0 - q7、lr
- 转到原 IMP 地址(不返回)
# 取出原 IMP 地址
_th_dynamic_page
中每次循环有两个命令,拿出两个循环:
0x101600080 mov x13, lr ;这是替换的新 IMP 地址,此时 lr 也是返回的地址,需要保存下来
0x101600084 bl _th_entry ;开始调用,此时 lr 为下一个指令 0x101600088
0x101600088 mov x13, lr
0x10160008c bl _th_entry
在 _th_entry
中的 lr
为 0x101600088
,那 0x101600088 - 0x8 = 0x101600080
,也就是新 IMP 地址。再偏移一页内存就得到原 IMP 地址了!
指令如下:
sub x12, lr, #0x8
sub x12, x12, #0x4000
ldr x10, [x12] ;取出 x12 作为地址上保存的 IMP 地址
# 保存恢复现场 & 调用自定义的 interceptor
调用我们加载的函数,会影响寄存器,需要提前入栈保存起来:
stp q0, q1, [sp, #-32]!
stp q2, q3, [sp, #-32]!
stp q4, q5, [sp, #-32]!
stp q6, q7, [sp, #-32]!
stp lr, x10, [sp, #-16]! ;保存 lr 和原 IMP
stp x0, x1, [sp, #-16]!
stp x2, x3, [sp, #-16]!
stp x4, x5, [sp, #-16]!
stp x6, x7, [sp, #-16]!
str x8, [sp, #-16]!
接下来就可以放心调用 interceptor
了,注意 blr
只能传入寄存器,所以要进行一次传值:
ldr x8, interceptor
blr x8
调用完再依次出栈恢复寄存器信息,注意要和入栈顺序一一对应:
ldr x8, [sp], #16
ldp x6, x7, [sp], #16
ldp x4, x5, [sp], #16
ldp x2, x3, [sp], #16
ldp x0, x1, [sp], #16
ldp lr, x10, [sp], #16
ldp q6, q7, [sp], #32
ldp q4, q5, [sp], #32
ldp q2, q3, [sp], #32
ldp q0, q1, [sp], #32
br x10 ;最后跳转到原 IMP 就行啦
# 5 个 nop 做了啥
为啥作者说不要小看这五行汇编,看到这里,我想我们已经清楚了。
用于对齐内存地址,将可执行动态地址和原 IMP 地址对齐。
原本的 _th_entry
有 27 个指令 ,5 个 nop
将 _th_entry
的指令格式变成了 32,用到了 128 个字节。
我们知道 _th_entry
也会在两页内存中占一点空间,占的空间不整齐,后面对齐可执行动态地址和原 IMP 都会遇到阻碍。
同时回顾如下代码:
static const size_t THNumberOfDataPerPage = (0x4000 - THDynamicPageInstructionCount * sizeof(int32_t)) / sizeof(THDynamicPageEntryGroup);
THDynamicPageEntryGroup
是对应两条指令,8 字节大小,一个有 0x4000 字节,增加 5 个 nop
,得到 2032 = (0x4000 - 32 * 4) / 8
。这就对的整整齐齐了。
如果后续迭代调整了 _th_entry
指令个数,也要调整 nop
和 THDynamicPageInstructionCount
。
# vm_remap 技术
iOS 系统存在限制,我们没有权限创建可写可执行内存,但有了 vm_remap
可以将已有地址进行映射拷贝一份可写可执行内存。
这里我们通过 vm_allocate
分配两页内存(0x8000),通过 vm_deallocate
释放第二页内存,最后通过 vm_remap
将 th_dynamic_page
映射到第二页内存。这就构建好了我们需要的两页内存,第一页空的,用于存重定向函数地址和 IMP 地址,第二页映射好了所有的动态可执行地址。
代码如下:
vm_address_t fixedPage = (vm_address_t)&th_dynamic_page; // th_dynamic_page 的地址
vm_address_t newDynamicPage = 0;
kern_return_t kernResult = KERN_SUCCESS;
kernResult = vm_allocate(current_task(), &newDynamicPage, PAGE_SIZE * 2, VM_FLAGS_ANYWHERE); // 申请两页大小的虚拟内存
NSCAssert1(kernResult == KERN_SUCCESS, @"[THDynamicPage]::vm_allocate failed", kernResult);
vm_address_t newCodePageAddress = newDynamicPage + PAGE_SIZE;
kernResult = vm_deallocate(current_task(), newCodePageAddress, PAGE_SIZE); // 释放第二页
NSCAssert1(kernResult == KERN_SUCCESS, @"[THDynamicPage]::vm_deallocate failed", kernResult);
vm_prot_t currentProtection, maxProtection;
kernResult = vm_remap(current_task(), &newCodePageAddress, PAGE_SIZE, 0, 0, current_task(), fixedPage, FALSE, ¤tProtection, &maxProtection, VM_INHERIT_SHARE); // 第二页映射 th_dynamic_page
NSCAssert1(kernResult == KERN_SUCCESS, @"[THDynamicPage]::vm_remap failed", kernResult);
参考文章:
- 基于桥的全量方法 Hook 方案(2) - 全新升级 (opens new window)
- 基于桥的全量方法 Hook 方案(3)- TrampolineHook (opens new window)
- 深入 iOS 系统底层之汇编语言 (opens new window)
- 深入 iOS 系统底层之指令集 (opens new window)
- Hook 原理之 CydiaSubstrate(二):MSHookMessageEx (opens new window)
- Thunk 程序的实现原理以及在 iOS 中的应用 (opens new window)
- 为什么使用汇编可以 Hook objectivec_msgSend(上)- 汇编基础 (opens new window)