fishhook源码解析

前言

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格式官方图片

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 SymbolsSymbol 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;

__la_symbol_prt

Load Commands中找到__la_symbol_prt的描述信息得到reversed1 = 12;

Load Commands

indirect Symbols找到index+reverse1处的数据,得到index2 = 0x2;

indirect Symbols

Symbol Table找到index2处的数据,得到offset = 0x18;

Symbol Table

String Table中首地址是0xC4C8,加上offset得到0xC4C8 + 0x18 = 0xC4E0,也就是箭头所指的位置,结果为_NSLog。

String Table

三、fishhook源码分析

先来看下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 SymbolsSymbol TableString Table获取符号名称,如果是和我们要重绑定的函数名称一致,则更改__la_symbol_ptr表中的数据为要替换的函数地址。最后放一张官方的图片直观的查看整个过程:

fishhook官方图片

四、是否能hook在项目或者静态库中的定义的C函数

答案是不能!!!因为无论在项目中还是静态库中的函数,在编译的时候它们的地址就已经确定(Mach-O基地址+偏移),它们不会存在于__la_symbol_ptr表中,自然也就无法更改。

推荐阅读更多精彩内容