前言
fishhook是fackbook开源的一个用来hook c函数的库。在iOS开发中我们一般都是对OC方法进行hook，这是因为OC的动态特性才能实现的，OC的方法调用是在运行时动态查找的。而c函数是静态，为什么同样能够hook呢？接来下就看看这其中用到了什么黑魔法！
一、Mach-O文件
首先，我们将iOS源代码打包后会生成一个.ipa文件，里面包含了一些资源文件以及可执行文件，这个可执行文件就是Mach-O文件。Mach-O文件格式如下(源自官方文档)：
Header: Specifies the target architecture of the file, such as PPC, PPC64, IA-32, or x86-64.
Load commands: Specify the logical structure of the file and the layout of the file in virtual memory.
Raw segment data: Contains raw data for the segments defined in the load commands.
Mach-O文件包含三个部分：
1、Header:头部信息，描述该文件的一些基本信息，例如cpu类型，文件架构类型是arm64还是x86等等。
2、Load commands:主要是描述了文件在内存中的布局，一个segment command对应一个segment data，描述了它在文件中的偏移地址，内存大小等信息。
3、Segment Data:segment的具体数据，__TEXT段表示这部分数据是代码，也即是这部分数据是执行指令的，__DATA段表示存放的是数据,如全局变量、静态变量等数据。
二、准备知识
APP启动的时候是会去链接很多动态库，如UIKit，UIFoundation等。函数的调用是通过跳转指令跳到函数对应的内存地址，而动态库是在程序启动时才去链接的，因此动态库中函数的地址在一开始是不知道的，所以这些函数的地址存放在__DATA,__la_symbol_prt表中，也就是所谓的PIC(位置无关代码)。在函数第一次调用的时候例如NSLog()函数，这个表中的地址不是直接指向NSLog的正确地址，而是指向了dyld_stub_binder函数地址，它的作用就是去计算出NSLog的真正地址，然后将__DATA,__la_symbol_prt中NSLog对应的地址改为它的实际地址，这样第二次调用的时候就是直接调用到NSLog。另外除了__la_symbol_prt表之外，还有与之对应的indirect Symbols、Symbol Table以及String Table。它们之间的关系是，首先通过符号在__la_symbol_prt的index，加上在Load Command中对__la_symbol_prt的描述信息reversed1，找到indirect Symbols中 index+reversed1 位置的数据index2，然后在找到Symbol Table中index2位置的数据拿到偏移地址offset，最后在String Table中找offset处的数据，该数据就是函数名"_NSLog"。下面通过图示演示一下该过程：
以__la_symbol_prt中的第一个函数NSLog举例，index = 0；
Load Commands中找到__la_symbol_prt的描述信息得到reversed1 = 12；
在indirect Symbols找到index+reverse1处的数据，得到index2 = 0x2；
在Symbol Table找到index2处的数据，得到offset = 0x18；
在String Table中首地址是0xC4C8,加上offset得到0xC4C8 + 0x18 = 0xC4E0,也就是箭头所指的位置，结果为_NSLog。
三、fishhook源码分析
先来看下fishhook的用法。
首先构造了一个sturct rebinding结构体的数组rebindArr，调用rebind_symbols函数将数组和数组长度传递进去。
sturct rebinding结构入下：
struct rebinding {
const char *name;//函数名
void *replacement;//hook之后用于替换的函数
void **replaced;//用于保存原来的函数地址，这里传递一个函数指针变量的地址进去
};
rebind_symbols函数
int rebind_symbols(struct rebinding rebindings[], size_t rebindings_nel) {
int retval = prepend_rebindings(&_rebindings_head, rebindings, rebindings_nel);
if (retval < 0) {
return retval;
}
// If this was the first call, register callback for image additions (which is also invoked for
// existing images, otherwise, just run on existing images
if (!_rebindings_head->next) {
_dyld_register_func_for_add_image(_rebind_symbols_for_image);
} else {
uint32_t c = _dyld_image_count();
for (uint32_t i = 0; i < c; i++) {
_rebind_symbols_for_image(_dyld_get_image_header(i), _dyld_get_image_vmaddr_slide(i));
}
}
return retval;
}
首先调用prepend_rebindings函数进行预绑定操作，内部主要是将传递进来的参数rebindings数组生成一个链表节点，然后将这个节点添加到链表的头部，链表结构如下：
struct rebindings_entry {
struct rebinding *rebindings;
size_t rebindings_nel;
struct rebindings_entry *next;
};
prepend_rebindings函数之后，判断这个_rebindings_head链表是否只有一个节点，如果只有一个节点表明是第一次调用fishhook，就去注册dyld加载image的回调函数_rebind_symbols_for_image;否则，遍历所有的image，手动调用_rebind_symbols_for_image函数。
rebind_symbols_for_image函数
static void rebind_symbols_for_image(struct rebindings_entry *rebindings,
const struct mach_header *header,
intptr_t slide) {
Dl_info info;
if (dladdr(header, &info) == 0) {
return;
}
segment_command_t *cur_seg_cmd;//当前的LoadCommand
segment_command_t *linkedit_segment = NULL;//__LINKEDIT段的LoadCommand {LC_SEGMENT_64(__LINKEDIT)}
struct symtab_command* symtab_cmd = NULL;//LC_SYMTAB,可以找到Symbol Table的地址
struct dysymtab_command* dysymtab_cmd = NULL;//LC_DYSYMTAB,可以找到indirect Symbols的地址
uintptr_t cur = (uintptr_t)header + sizeof(mach_header_t);//当前内存地址指向LoadCommand起始地址
//第一次遍历所有的LoadCommand
for (uint i = 0; i < header->ncmds; i++, cur += cur_seg_cmd->cmdsize) {
cur_seg_cmd = (segment_command_t *)cur; //保存当前的LoadCommand
if (cur_seg_cmd->cmd == LC_SEGMENT_ARCH_DEPENDENT) {
if (strcmp(cur_seg_cmd->segname, SEG_LINKEDIT) == 0) {
//判断segment的名称是否为__LINKEDIT
linkedit_segment = cur_seg_cmd;
}
} else if (cur_seg_cmd->cmd == LC_SYMTAB) {
//判断是否是LC_SYMTAB，symtab_cmd->symoff 找到Symbol Table的偏移地址
symtab_cmd = (struct symtab_command*)cur_seg_cmd;
} else if (cur_seg_cmd->cmd == LC_DYSYMTAB) {
//判断是否是LC_DYSYMTAB，dysymtab_cmd->indirectsymoff 找到indirect Symbols的偏移地址
dysymtab_cmd = (struct dysymtab_command*)cur_seg_cmd;
}
}
if (!symtab_cmd || !dysymtab_cmd || !linkedit_segment ||
!dysymtab_cmd->nindirectsyms) {
return;
}
// Find base symbol/string table addresses
//slide是ASLR的随机偏移，linkedit_segment->vmaddr - linkedit_segment->fileoff是mach-o在文件中的基地址，两者相加就是ASLR后的mach-o加载进内存的基地址
uintptr_t linkedit_base = (uintptr_t)slide + linkedit_segment->vmaddr - linkedit_segment->fileoff;
//Symbol Table表的内存地址
nlist_t *symtab = (nlist_t *)(linkedit_base + symtab_cmd->symoff);
//String Table表的内存地址
char *strtab = (char *)(linkedit_base + symtab_cmd->stroff);
// Get indirect symbol table (array of uint32_t indices into symbol table)
//indirect symbols表的内存地址
uint32_t *indirect_symtab = (uint32_t *)(linkedit_base + dysymtab_cmd->indirectsymoff);
cur = (uintptr_t)header + sizeof(mach_header_t);//指针指向LoadCommand起始地址
//第二次遍历所有的LoadCommand
for (uint i = 0; i < header->ncmds; i++, cur += cur_seg_cmd->cmdsize) {
cur_seg_cmd = (segment_command_t *)cur;
if (cur_seg_cmd->cmd == LC_SEGMENT_ARCH_DEPENDENT) {
if (strcmp(cur_seg_cmd->segname, SEG_DATA) != 0 &&
strcmp(cur_seg_cmd->segname, SEG_DATA_CONST) != 0) {
//如果不是__DATA段就跳过
continue;
}
//如果是__DATA段，则遍历该Segment下的Sections
for (uint j = 0; j < cur_seg_cmd->nsects; j++) {
section_t *sect =
(section_t *)(cur + sizeof(segment_command_t)) + j;
if ((sect->flags & SECTION_TYPE) == S_LAZY_SYMBOL_POINTERS) {
//找到__la_symbol_ptr
//重绑定
perform_rebinding_with_section(rebindings, sect, slide, symtab, strtab, indirect_symtab);
}
if ((sect->flags & SECTION_TYPE) == S_NON_LAZY_SYMBOL_POINTERS) {
//找到_nla_symbol_ptr
//重绑定
perform_rebinding_with_section(rebindings, sect, slide, symtab, strtab, indirect_symtab);
}
}
}
}
}
代码中有详细的注释不多做解释了，做一些其他补充。Mach-O加载进内存的地址是经过ASLR(Address Space Layout Randomization),地址空间布局随机化。就是说每次Mach-O的内存地址不是从固定的地址开始，而是每次加上了一个随机数。所以要找到每张表的地址除了从Load Commands中获取offset偏移，还要计算ASLR后的基地址。找到几张符号表的地址之后，调用perform_rebinding_with_section进行重新绑定。
perform_rebinding_with_section函数
static void perform_rebinding_with_section(struct rebindings_entry *rebindings,
section_t *section,
intptr_t slide,
nlist_t *symtab,
char *strtab,
uint32_t *indirect_symtab) {
//indirect Symbols中包含了各个section中符号在Symbol Table的index，这里是直接定位到对应__DATA,__la_symbol_ptr所在的index数组
uint32_t *indirect_symbol_indices = indirect_symtab + section->reserved1;
//__la_symbol_ptr表，符号地址的数组
void **indirect_symbol_bindings = (void **)((uintptr_t)slide + section->addr);
for (uint i = 0; i < section->size / sizeof(void *); i++) {
//找到符号在Symbol Table(数组)中的下标
uint32_t symtab_index = indirect_symbol_indices[i];
if (symtab_index == INDIRECT_SYMBOL_ABS || symtab_index == INDIRECT_SYMBOL_LOCAL ||
symtab_index == (INDIRECT_SYMBOL_LOCAL | INDIRECT_SYMBOL_ABS)) {
continue;
}
//从Symbol Table中找到符号在String Table中的偏移量
uint32_t strtab_offset = symtab[symtab_index].n_un.n_strx;
//String Table的起始地址 + 偏移量，得到符号的名称
char *symbol_name = strtab + strtab_offset;
if (strnlen(symbol_name, 2) < 2) {
continue;
}
struct rebindings_entry *cur = rebindings;
while (cur) {
for (uint j = 0; j < cur->rebindings_nel; j++) {
if (strcmp(&symbol_name[1], cur->rebindings[j].name) == 0) {
//编译的时候会将符号转成带下划线的，比如printf会转成_printf,所以从下划线后面的字符开始比较
if (cur->rebindings[j].replaced != NULL &&
indirect_symbol_bindings[i] != cur->rebindings[j].replacement) {
//保存原来的符号地址
*(cur->rebindings[j].replaced) = indirect_symbol_bindings[i];
}
//替换__DATA,__la_symbol_ptr表中的符号地址
indirect_symbol_bindings[i] = cur->rebindings[j].replacement;
//退出链表的遍历，即针对同一符号多次调用fishhook重绑定，只有会对最后一次调用的生效
goto symbol_loop;
}
}
cur = cur->next;
}
symbol_loop:;
}
}
遍历__la_symbol_ptr表，通过indirect Symbols、Symbol Table和String Table获取符号名称，如果是和我们要重绑定的函数名称一致，则更改__la_symbol_ptr表中的数据为要替换的函数地址。最后放一张官方的图片直观的查看整个过程：
四、是否能hook在项目或者静态库中的定义的C函数
答案是不能！！！因为无论在项目中还是静态库中的函数，在编译的时候它们的地址就已经确定(Mach-O基地址+偏移)，它们不会存在于__la_symbol_ptr表中，自然也就无法更改。