11、HOOK原理（上）--- fishHook

作者: Jax_YD | 来源:发表于2021-05-11 17:49 被阅读0次

HOOK

建议大家先对MachO有一定的了解，因为下面的内容会涉及到MachO里面的内容3、iOS强化 --- Mach-O 文件
HOOK，中文译为“挂钩”或“钩子”。在iOS逆向中时指改变程序运行流程的一种技术。通过HOOK可以让别人的程序执行自己所写的代码。在逆向中经常使用这种技术。
下面我们来简单看一下HOOK的工作流程是怎样的。

HOOK示意图

iOS中HOOK的几种方式

1、Method Swizzle
利用OC的Runtime特性，动态改变SEL(方法编号)和IMP(方法实现)的对应关系，达到OC方法调用流程改变的目的。主要用于OC方法。这个我们在10、代码的注入里面有详细讲过。
2、fishHook
它是Facebook提供的一个动态修改链接Mach-O文件的工具。利用Mach-O文件加载原理，通过修改懒加载和非懒加载两个表的指针达到C函数HOOK的目的。
3、Cydia Substrate
Cydia Substrate原名Mobile Substrate，它的主要作用是针对OC方法、C函数以及函数地址进行HOOK。当然它并不是针对iOS而设计的，Android一样可以使用。官网地址

fishHook

这里我们简单的使用一下fishHook。fishHook地址
fishHook只给我们提供了两个函数和一个结构体

FISHHOOK_VISIBILITY
int rebind_symbols(struct rebinding rebindings[], size_t rebindings_nel);
// 参数一 ： 存放rebinding结构体的数组（可以同时交换多个函数）
// 参数二 ： rebinding数组长度

// 跟上面的函数比起来，这个函数可以指定image(镜像文件)
FISHHOOK_VISIBILITY
int rebind_symbols_image(void *header,
                         intptr_t slide,
                         struct rebinding rebindings[],
                         size_t rebindings_nel);

struct rebinding {
  const char *name;//需要HOOK的函数名称，C字符串
  void *replacement;//新函数的地址
  void **replaced;//原始函数地址的指针！
};

下面我们就来使用一下fishHook。

首先将fishHook文件拖进我们的工程，并且在要使用fishHook的类里面，引用fishHook:
引入fishHook
HOOK 系统函数 NSLog
HOOK NSLog
运行结果：
HOOK结果
可以看到，已经HOOK成功了。这里有一点要跟大家讲清楚，就是fishHook在使用的过程中sys_NSLog怎么就跟NSLog联系上了呢？
其实是这个样子的，我们在HOOK过程中：
i：fishHook将NSLog(系统的)的真实地址，赋给了sys_NSLog，注意sys_NSLog只是一个函数指针。
ii：紧接着将NSLog指向我们自定义的my_NSLog。
iii：这样在执行完my_NSLog的代码之后，我们可以利用sys_NSLog回到原本的业务逻辑中，不影响原始业务的执行。

fishHook源码探究
上面我们简单的讲了一下fishHook的运行机制，那么我们接下来就来动态调试一下。
首先我们进入rebind_symbols这个方法去看一下，它里面的实现：

int rebind_symbols(struct rebinding rebindings[], size_t rebindings_nel) {
    //prepend_rebindings的函数会将整个 rebindings 数组添加到 _rebindings_head 这个链表的头部
    //Fishhook采用链表的方式来存储每一次调用rebind_symbols传入的参数，每次调用，就会在链表的头部插入一个节点，链表的头部是：_rebindings_head
    int retval = prepend_rebindings(&_rebindings_head, rebindings, rebindings_nel);
    //根据上面的prepend_rebinding来做判断，如果小于0的话，直接返回一个错误码回去
    if (retval < 0) {
    return retval;
  }
    //根据_rebindings_head->next是否为空判断是不是第一次调用。
  if (!_rebindings_head->next) {
      //第一次调用的话，调用_dyld_register_func_for_add_image注册监听方法.
      //已经被dyld加载的image会立刻进入回调。
      //之后的image会在dyld装载的时候触发回调。
    _dyld_register_func_for_add_image(_rebind_symbols_for_image);
  } else {
      //遍历已经加载的image，进行的hook
    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;
}

根据代码，我们可以看到，首先会有一个retval的判断，那么我们来看看prepend_rebindings这个方法

static int prepend_rebindings(struct rebindings_entry **rebindings_head,
                              struct rebinding rebindings[],
                              size_t nel) {
  struct rebindings_entry *new_entry = (struct rebindings_entry *) malloc(sizeof(struct rebindings_entry));
  if (!new_entry) {
    return -1;
  }
  new_entry->rebindings = (struct rebinding *) 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;
}

可以看到*rebindings_head = new_entry;，也就是我们之前传入的&_rebindings_head。我们再来看一下_rebindings_head是什么：

struct rebindings_entry {
  struct rebinding *rebindings;
  size_t rebindings_nel;
  struct rebindings_entry *next;
};

static struct rebindings_entry *_rebindings_head;

到这里不难看出_rebindings_head其实就是一个链表的表头。
下面我们继续在rebind_symbols方法里面往下走，这里跟大家说一下，我们在动态调试的时候，无论是第一次调用还是第N次调用，都会进入_rebind_symbols_for_image，这里大家只要打断点调试一下就可以看到。那么我们直接去_rebind_symbols_for_image方法。

/*****************************************/
// _rebind_symbols_for_image
/*****************************************/
static void _rebind_symbols_for_image(const struct mach_header *header,
                                      intptr_t slide) {
    rebind_symbols_for_image(_rebindings_head, header, slide);
}
👇
/*****************************************/
// rebind_symbols_for_image
/*****************************************/
//回调的最终就是这个函数！ 三个参数：要交换的数组  、 image的头 、 ASLR的偏移
static void rebind_symbols_for_image(struct rebindings_entry *rebindings,
                                     const struct mach_header *header,
                                     intptr_t slide){}

rebind_symbols_for_image方法中有一个函数，要先跟大家讲清楚，那就是dladdr()。

dladdr() ：用来确认指定的address是否位于构成进程的地址空间中的其中一个加载模块内(可执行库或共享库)。
○：如果某个地址位于在其上面映射加载模块的基址，和为该加载模块映射的最高虚拟地址之间（包括两端），则认为该地址在加载模块的范围内。
○：如果某个加载模块符合这个条件，则会搜索其动态符号表，以查找与指定的adress最接近的符号。最接近的符号是指其值等于，或最为接近但小于指定的adress的符号。
那么dladdr()执行会有什么效果呢？拿下面代码中的来说：
i：如果指定的adress不再其中一个加载模块的范围内，则返回0；且不修改Dl_info结构的内容。否则，返回一个非零值，同时设置Dl_info结构的字段。
ii：如果指定的adress在加载模块的范围内，找不到其值小于或等于adress的符号，则dli_sname、dli_saddr、dli_size字段将设置为0；dli_bind字段设置为STB_LOCAL，dli_type字段设置为STT_NOTYPE。

//回调的最终就是这个函数！ 三个参数：要交换的数组  、 image的头 、 ASLR的偏移
static void rebind_symbols_for_image(struct rebindings_entry *rebindings,
                                     const struct mach_header *header,
                                     intptr_t slide) {
  //这个dladdr函数就是在程序里面找header
  Dl_info info;
  if (dladdr(header, &info) == 0) {
    return;
  }
  //下面就是定义好几个变量，准备从MachO里面去找！
  segment_command_t *cur_seg_cmd;
  segment_command_t *linkedit_segment = NULL;
  struct symtab_command* symtab_cmd = NULL;
  struct dysymtab_command* dysymtab_cmd = NULL;
  //跳过header的大小，找loadCommand
  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;
    }
  }
   //如果刚才获取的，有一项为空就直接返回
  if (!symtab_cmd || !dysymtab_cmd || !linkedit_segment ||
      !dysymtab_cmd->nindirectsyms) {
    return;
  }

  // Find base symbol/string table addresses
  //链接时程序的基址 = __LINKEDIT.VM_Address -__LINKEDIT.File_Offset + silde的改变值
  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) {
        //寻找到data段
      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);
        }
      }
    }
  }
}

最后我们看到，无论是懒加载符号表还是非懒加载符号表，都回去调用perform_rebinding_with_section。那我们就继续跟进perform_rebinding_with_section，这里面就有意思了，有我们想要的HOOK；我们上面提到的函数指针的替换，就在这里面：

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) {
    //nl_symbol_ptr和la_symbol_ptrsection中的reserved1字段指明对应的indirect symbol table起始的index
  uint32_t *indirect_symbol_indices = indirect_symtab + section->reserved1;
    //slide+section->addr 就是符号对应的存放函数实现的数组也就是我相应的__nl_symbol_ptr和__la_symbol_ptr相应的函数指针都在这里面了，所以可以去寻找到函数的地址
  void **indirect_symbol_bindings = (void **)((uintptr_t)slide + section->addr);
    //遍历section里面的每一个符号
  for (uint i = 0; i < section->size / sizeof(void *); i++) {
      //找到符号在Indrect Symbol Table表中的值
      //读取indirect 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;
    }
      //以symtab_index作为下标，访问symbol table
      uint32_t strtab_offset = symtab[symtab_index].n_un.n_strx;
      //获取到symbol_name
      char *symbol_name = strtab + strtab_offset;
      //判断是否函数的名称是否有两个字符，为啥是两个，因为函数前面有个_，所以方法的名称最少要1个
      bool symbol_name_longer_than_1 = symbol_name[0] && symbol_name[1];
      //遍历最初的链表，来进行hook
      struct rebindings_entry *cur = rebindings;
      while (cur) {
          for (uint j = 0; j < cur->rebindings_nel; j++) {
              //这里if的条件就是判断从symbol_name[1]两个函数的名字是否都是一致的，以及判断两个
              if (symbol_name_longer_than_1 &&
                  strcmp(&symbol_name[1], cur->rebindings[j].name) == 0) {
                  //判断replaced的地址不为NULL以及我方法的实现和rebindings[j].replacement的方法不一致
                  if (cur->rebindings[j].replaced != NULL &&
                      indirect_symbol_bindings[i] != cur->rebindings[j].replacement) {
                      //让rebindings[j].replaced保存indirect_symbol_bindings[i]的函数地址
                      *(cur->rebindings[j].replaced) = indirect_symbol_bindings[i];
                  }
                  //将替换后的方法给原先的方法，也就是替换内容为自定义函数地址
                  indirect_symbol_bindings[i] = cur->rebindings[j].replacement;
                  goto symbol_loop;
        }
      }
      cur = cur->next;
    }
  symbol_loop:;
  }
}

最关键的两句代码：

//让rebindings[j].replaced保存indirect_symbol_bindings[i]的函数地址
*(cur->rebindings[j].replaced) = indirect_symbol_bindings[i];

//将替换后的方法给原先的方法，也就是替换内容为自定义函数地址
indirect_symbol_bindings[i] = cur->rebindings[j].replacement;

这就与我们之前分析的fishHook的HOOK过程对应起来了。

总结：

我们利用fishHook对系统方法NSLog进行了HOOK，这是利用了Runtime的特性；这是因为间接符号边在编译的时候，并没有确定函数的真实地址。只有在运行时在确定，所以我们可以HOOK。
如果大家有兴趣，可以自己定义一个C函数，看看能不能HOOK。这里先告诉大家，答案是否定的。虽然NSLog也是一个C函数，但是它是外部符号，我们自己在工程中定义的C函数属于内部符号，在编译链接的时候，会变成地址调用，也就是说会变成类似于这样的：b 0x00000119890。那么我们再利用fishHook就无法HOOK到了。这里大家有兴趣可以试一下（这个之后我们会去探索inlinHook，会去探究静态函数的HOOK）。
在上面的代码注释里面，有提到slide，这就是涉及到PIC计数，也就是ASLR。这个知识点大家要去了解一下，这个以后会经常提到。简单讲，我们的APP包里面的函数地址，或者说我们通过MachOView查看我们的可执行程序时，看到的地址都是虚拟地址，在APP运行在手机上的时候都是会变的。将虚拟地址和ASLR地址结合得到我们要使用的真实地址。

11、HOOK原理（上）--- fishHook

HOOK

iOS中HOOK的几种方式

fishHook

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读