fishhook源码学习

fishhook源码学习

IOS小彩虹2021-08-17 2:28:41310A+A-

距离上个文章已经有段时间了,虽然没多少人阅读但是好在自娱自乐,前段时间出去受虐一波,所以又开始发愤图强,开始向以前比较常用的一些厉害的开源库学习学习.闲话不多说,fishhook是facebook出的一款可以修改外链的C方法(非自己所写的方法,一般存在于app启动时使用dyld加载的动态库中)的一个库,整个文件只有200多行代码.

用法

假如你在使用一个三方的framework的时候它里面无时无刻的打印着一些无用的信息而且市面上没有很好的去替代它的产品,这时候就可以把fishhook请出来将对应的打印函数给hook掉,比如

static void (*orig_printf)(char *format, ...);
int main(int argc, const char * argv[]) {
	printf("abcd");
	return 0;
}
static void	 my_printf(const char * s, ...){
//这里可以写你想替换的代码
//比如  orig_printf("dcba");
}
__attribute((constructor)) void injected_function(){
	rebind_symbols((struct rebinding[1]){{"printf", my_printf, (void *)&orig_printf}},1);
}

这样就成功的在main函数调用之前就将printf函数给替换了,可以远离烦人的打印.
int rebind_symbols(struct rebinding rebindings[], size_t rebindings_nel)的第一个参数是个结构体数组

struct rebinding {
  const char *name; 
  void *replacement;
  void **replaced;
};

name是想要hook的的函数名称,replacement是替换后的函数指针,replaced是传入一个指向函数指针的指针(如果将函数成功的替换后,会将原函数的值给放入其中)

当然在很多情况中我们会在逆向中用到fishhook,并且fishhook只能去替换链接外部动态库中的代码,自己写的C函数不能去替换

Mach-O

在去阅读fishhook的时候我个人认为是必须对Mach-O有一些了解。Mach-O是iOS/MacOS下面的可执行文件,在iOS工程下使用command+b编译后会在Products目录下生成一个.app文件,..app中一个同名文件就是我们的Mach-O文件了,它里面包含了我们app的类,方法,以及编译期间就确定常量等内容。

这是Mach-O的大致布局

  • Header:保存了一些Mach-O的基本信息,比如是32位/64位,LoadCommand的个数等
  • LoadCommand: 这一段跟着Header排布,加载Mach-O时会从这里面获取到对应的数据来确定内存分布
  • Data: 这里面保存了具体的数据,里面细分为多个segment,segment在分为多个section,这里面包含了具体的代码与数据等信息
    我们实际用工具去看下Mach-O,新建一个iOS工程,什么代码都不加,直接编译一下,然后使用MachOView查看
    因为本文关注的是fishhook,我们主要关注__Data段中的__la_symbol_ptr这个section(这个section表示的是懒加载的符号表,如果我们自己写的函数会在编译时确定地址写入macho,而系统的例如printf这些编译期间是不确认地址的),然后与之相关的还需要关注Symbol TableDynamic Symbol Table__LINKEDIT

因为MachO里面的东西太多就不过多的去描述,大概有些了解知道它是什么东西就可以阅读fishhook源码,如果想要深入的了解MachO可以看这篇博客

阅读源码

下面就开始进入正题了,开始去阅读fishhook的源码。我们直接从我们的调用函数看int rebind_symbols(struct rebinding rebindings[], size_t rebindings_nel)

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函数,传入了三个参数,第一个参数是指向私有结构体static struct rebindings_entry *_rebindings_head的指针,第二个参数struct rebinding结构体数组,第三个值是结构体数组的长度

static int prepend_rebindings(struct rebindings_entry **rebindings_head,
                              struct rebinding rebindings[],
                              size_t nel) {
  struct rebindings_entry *new_entry = malloc(sizeof(struct rebindings_entry));
  if (!new_entry) {
    return -1;
  }
  new_entry->rebindings = malloc(sizeof(struct rebinding) * nel);
  if (!new_entry->rebindings) {
    free(new_entry);
    return -1;
  }
  memcpy(new_entry->rebindings, rebindings, sizeof(struct rebinding) * nel);
  new_entry->rebindings_nel = nel;
  new_entry->next = *rebindings_head;
  *rebindings_head = new_entry;
  return 0;
}

这里面的代码比较简单

  • 初始化一个struct rebindings_entry结构体
  • 在将结构体中数组初始化
  • 将我们传入的结构体数组的值copy到刚初始化的数组中
  • 在将新初始化的结构体放在这个链表的最前面 在往下走看到以链表的next指针判断该方法是否第一次调用,如果第一次调用则调用_dyld_register_func_for_add_image方法,并传入_rebind_symbols_for_image函数指针

_dyld_register_func_for_add_image 注册自定义的回调函数,同时也会为所有已经加载的动态库或可执行文件执行回调

每个动态库都会回调_rebind_symbols_for_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;
  segment_command_t *linkedit_segment = NULL;
  struct symtab_command* symtab_cmd = NULL;
  struct dysymtab_command* dysymtab_cmd = NULL;

  uintptr_t cur = (uintptr_t)header + sizeof(mach_header_t);
  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_LINKEDIT) == 0) {
        linkedit_segment = cur_seg_cmd;
      }
    } else if (cur_seg_cmd->cmd == LC_SYMTAB) {
      symtab_cmd = (struct symtab_command*)cur_seg_cmd;
    } else if (cur_seg_cmd->cmd == LC_DYSYMTAB) {
      dysymtab_cmd = (struct dysymtab_command*)cur_seg_cmd;
    }
  }
  ...
}

这段代码主要是为了获取对应的Symbol TableDynamic Symbol Table__LINKEDIT段对应的结构体

  • 因为LoadCommand是紧跟着mac_header的 所以uintptr_t cur = (uintptr_t)header + sizeof(mach_header_t);获取到第一个LoadCommand的位置
  • 之后遍历根据cmd的值去取得对应的结构体

在往下看

static void rebind_symbols_for_image(struct rebindings_entry *rebindings,
                                     const struct mach_header *header,
                                     intptr_t slide) {
    ...
  // Find base symbol/string table addresses
  uintptr_t linkedit_base = (uintptr_t)slide + linkedit_segment->vmaddr - linkedit_segment->fileoff;
  nlist_t *symtab = (nlist_t *)(linkedit_base + symtab_cmd->symoff);
  char *strtab = (char *)(linkedit_base + symtab_cmd->stroff);

  // Get indirect symbol table (array of uint32_t indices into symbol table)
  uint32_t *indirect_symtab = (uint32_t *)(linkedit_base + dysymtab_cmd->indirectsymoff);

  cur = (uintptr_t)header + sizeof(mach_header_t);
  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) {
        continue;
      }
      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) {
          perform_rebinding_with_section(rebindings, sect, slide, symtab, strtab, indirect_symtab);
        }
        if ((sect->flags & SECTION_TYPE) == S_NON_LAZY_SYMBOL_POINTERS) {
          perform_rebinding_with_section(rebindings, sect, slide, symtab, strtab, indirect_symtab);
        }
      }
    }
  }
}

首先是可以根据上面代码得到个结论,程序的基地址 = sild + __LINKEDIT->vmaddr - __LINKEDIT->fileoff,这里面的__LINKEDIT->vmaddr__LINKEDIT在内存中的地址,fileoff__LINKEDIT在mach-o文件中的偏移量,那么silde是什么?其实silde就是ASLR,那ASLR又是什么?ASLR:Address space layout randomization,通俗的说就是在app每次启动的时候会随机给一个地址偏移量,然后我们真正的内存地址就是Mach-O中的地址加上这个偏移量。得到程序的基地址后在根据符号表中的偏移值得到符号表中的数据,之后在遍历一遍LoadCommand,寻找__DATA__DATA_CONST的section,并对对__nl_symbol_ptr以及__la_symbol_ptr进行重新绑定。
接下来调用了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) {
  uint32_t *indirect_symbol_indices = indirect_symtab + section->reserved1;
  void **indirect_symbol_bindings = (void **)((uintptr_t)slide + section->addr);
  for (uint i = 0; i < section->size / sizeof(void *); i++) {
    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;
    }
    uint32_t strtab_offset = symtab[symtab_index].n_un.n_strx;
    char *symbol_name = strtab + strtab_offset;
    bool symbol_name_longer_than_1 = symbol_name[0] && symbol_name[1];
    struct rebindings_entry *cur = rebindings;
    while (cur) {
      for (uint j = 0; j < cur->rebindings_nel; j++) {
        if (symbol_name_longer_than_1 &&
            strcmp(&symbol_name[1], cur->rebindings[j].name) == 0) {
          if (cur->rebindings[j].replaced != NULL &&
              indirect_symbol_bindings[i] != cur->rebindings[j].replacement) {
            *(cur->rebindings[j].replaced) = indirect_symbol_bindings[i];
          }
          indirect_symbol_bindings[i] = cur->rebindings[j].replacement;
          goto symbol_loop;
        }
      }
      cur = cur->next;
    }
  symbol_loop:;
  }
}

这段函数看起来稍微有点长,但是逻辑是很好去理解的,首先先根据动态符号表中地址 + 在符号表中的index 获得在该段在动态符号表中的位置(reserved1的值表示偏移量),进行一个for循环在每次循环中获取到对应方法的方法名,然后在遍历私有结构体链表struct rebindings_entry *,把链表中的每个结构体中的数组中的方法名与当前的表中的方法名比较,如果相同就将符号表中的指针信息保存给外面调用时传入的指向函数指针的指针中,在表中的指针替换成我们传入的函数指针,就这样就完成了一次偷天换日的过程。 最后借官方的图

点击这里复制本文地址 以上内容由权冠洲的博客整理呈现,请务必在转载分享时注明本文地址!如对内容有疑问,请联系我们,谢谢!

支持Ctrl+Enter提交

联系我们| 本站介绍| 留言建议 | 交换友链 | 域名展示
本站资源来自互联网收集,仅供用于学习和交流,请遵循相关法律法规,本站一切资源不代表本站立场,如有侵权、后门、不妥请联系本站删除

权冠洲的博客 © All Rights Reserved.  Copyright quanguanzhou.top All Rights Reserved
苏公网安备 32030302000848号   苏ICP备20033101号-1
本网站由 提供CDN/云存储服务

联系我们