【Android 逆向】函数拦截实例 ( ③ 刷新 CPU 高速缓存 | ④ 处理拦截函数 | ⑤ 返回特定结果 )

#include <time.h>
int clock_gettime(clockid_t clk_id,struct timespec *tp);

/* 清空 CPU 高速缓存 */
#if !defined(__i386__)
  /* 在 arm 架构中必须刷新 CPU 高速缓存 , x86 不需要执行 */
  cacheflush((int)pApi, (int)pApi + size, ICACHE|DCACHE);
#else
  /* x86 下可以执行该系统调用 */
  syscall(0xF002, (int)pApi,(int)pApi + sizeE);

/* 拦截函数 , 拦截 clock_gettime 函数后 , 跳转到此处 */
int dn_clock_gettime(clockid_t id, struct timespec* ts) {
  /*if (ts == NULL) {
  return -1;
  }*/
  /* 如果设备实现了系统调用 , 可以通过该代码调用原有的 clock_gettime 函数 */
  //int ret = syscall(__NR_clock_gettime, id, ts);
  /* 
  此处实际上调用的是原有的 clock_gettime 函数 
  如果设备上没有实现系统调用 , 使用如下方法可以调用原有的 clock_gettime 函数 
  */
  do_clock_gettime(id, ts);
  /* clock_gettime 函数执行完后 , 继续执行一些自己实现的部分 */
  /* 
  上面的代码是 hook 住的真实代码 
  我们可以在真实代码 前面 / 后面 执行一些自定义内容 
  */
  if (id > CLOCK_MONOTONIC)return 0;
  if (clock_base[id] == 0.0) {
  clock_base[id] = ts->tv_sec * 1000000000.0 + ts->tv_nsec;
  clock_new[id] = clock_base[id];
  }
  else {
  //mutex.lock();
  double tick = ts->tv_sec * 1000000000.0 + ts->tv_nsec;
  //printf("tick : %f base: %f delta: %f\n", tick, clock_base[id], tick - clock_base[id]);
  if (tick > clock_base[id]) {
    clock_new[id] += (tick - clock_base[id]) * time_scale;
    ts->tv_sec = (time_t)(clock_new[id] / 1000000000.0);
    ts->tv_nsec = (long)(fmod(clock_new[id], 1000000000.0));
    clock_base[id] = tick;
  }
  //mutex.unlock();
  }
  return 0;
}

/* 这是 hook 标准库中的 clock_gettime 函数的入口方法 , 跳转到自定义的 dn_clock_gettime 方法中 */
hook_func((uint8_t*)clock_gettime, (uint8_t*)dn_clock_gettime, (uint8_t*)do_clock_gettime, 6);

/* hook 函数的完整流程 , 跳转指令 size 是 6 字节*/
/* 这是 hook 标准库中的 clock_gettime 函数的入口方法 , 跳转到自定义的 dn_clock_gettime 方法中 */
/* hook_func((uint8_t*)clock_gettime, (uint8_t*)dn_clock_gettime, (uint8_t*)do_clock_gettime, 6); */
void hook_func(uint8_t* pApi, uint8_t* pUser, uint8_t* pStub, size_t size)
{
  unsigned char code[64] = { 0 };
  /* 插桩前先保存函数的入口 6 字节数据 , 因为之后插桩 , 
  * 会使用跳转代码 0xE9,0,0,0,0 覆盖函数入口内存
  * 该函数最终还是要执行 , 需要拷贝一下 , 供之后实际函数调用使用 
  */
  memcpy(code, pApi, size);
  /* 函数插桩 , pApi 是实际函数 , pUser 是插桩后跳转到的拦截函数 */
  write_code(pApi, pUser);
  /* 
    执行 size + pStub 位置的指令时 , 直接跳转到 size + pApi 位置
    如 : 执行 do_clock_gettime 方法的第 6 字节的指令时 , 跳转到 clock_gettime 函数的第 6 字节指令位置 
    do_clock_gettime 的 0 ~ 6 字节指令是 clock_gettime 实际函数的前 6 字节 , 
    之所以这么定义 , 是因为 clock_gettime 的前 6 个字节被覆盖为 跳转指令了
    调用 do_clock_gettime 方法 , 就相当于调用了
  */
  write_code(size + pStub, size + pApi);
  /* 将复制的 6 字节 代码存放到 pStub 函数中的 0 ~ 6 字节位置 */
  memcpy(pStub, code, size);
  /* 清空 CPU 高速缓存 */
#if !defined(__i386__)
  /* 在 arm 架构中必须刷新 CPU 高速缓存 , x86 不需要执行 */
  cacheflush((int)pApi, (int)pApi + size, ICACHE|DCACHE);
#else
  /* x86 下可以执行该系统调用 */
  syscall(0xF002, (int)pApi,(int)pApi + sizeE);
#endif
}
/*
 * unsigned char* pFunc
 * unsigned char* pStub
 * 上述两个参数分别是两个函数指针
 * 
 * 注意 : 写完之后要刷新 CPU 高速缓存 , 调用 cache_flush 系统调用函数
 */
int write_code(unsigned char* pFunc, unsigned char* pStub) {
  /* 获取 pFunc 函数入口 , 先获取该函数所在内存页地址 */
  void* pBase = (void*)(0xFFFFF000 & (int)pFunc);
  /* 修改整个内存页属性 , 修改为 可读 | 可写 | 可执行 , 
  * 避免因为内存访问权限问题导致操作失败
  * mprotect 函数只能对整个页内存的属性进行修改 
  * 每个 内存页 大小都是 4KB 
  */
  int ret = mprotect(pBase, 0x1000, PROT_WRITE | PROT_READ | PROT_EXEC);
  /* 修改内存页属性失败的情况 */
  if (ret == -1) {
  perror("mprotect:");
  return -1;
  }
#if defined(__i386__) // arm 情况处理
  /* E9 是 JMP 无条件跳转指令 , 后面 4 字节是跳转的地址 */
  unsigned char code[] = { 0xE9,0,0,0,0 };
  /* 计算 pStub 函数跳转地址 , 目标函数 pStub 地址 - 当前函数 pFunc 地址 - 5 
  * 跳转指令 跳转的是 偏移量 , 不是绝对地址值
  */
  *(unsigned*)(code + 1) = pStub - pFunc - 5;
  /* 将跳转代码拷贝到 pFunc 地址处 , 这是 pFunc 函数的入口地址 */
  memcpy(pFunc, code, sizeof(code));
#else // arm 情况处理
  /* B 无条件跳转指令 */
  unsigned char code[] = { 0x04,0xF0,0x1F,0xE5,0x00,0x00,0x00,0x00 };
  /* arm 的跳转是绝对地址跳转 , 传入 pStub 函数指针即可 */
  *(unsigned*)(code + 4) = (unsigned)pStub;
  /* 将机器码复制到函数开始位置 */
  memcpy(pFunc, code, sizeof(code));
#endif
  return 0;
}
/* 拦截函数 , 拦截 clock_gettime 函数后 , 跳转到此处 */
int dn_clock_gettime(clockid_t id, struct timespec* ts) {
  /*if (ts == NULL) {
  return -1;
  }*/
  /* 如果设备实现了系统调用 , 可以通过该代码调用原有的 clock_gettime 函数 */
  //int ret = syscall(__NR_clock_gettime, id, ts);
  /* 
  此处实际上调用的是原有的 clock_gettime 函数 
  如果设备上没有实现系统调用 , 使用如下方法可以调用原有的 clock_gettime 函数 
  */
  do_clock_gettime(id, ts);
  /* clock_gettime 函数执行完后 , 继续执行一些自己实现的部分 */
  /* 
  上面的代码是 hook 住的真实代码 
  我们可以在真实代码 前面 / 后面 执行一些自定义内容 
  */
  if (id > CLOCK_MONOTONIC)return 0;
  if (clock_base[id] == 0.0) {
  clock_base[id] = ts->tv_sec * 1000000000.0 + ts->tv_nsec;
  clock_new[id] = clock_base[id];
  }
  else {
  //mutex.lock();
  double tick = ts->tv_sec * 1000000000.0 + ts->tv_nsec;
  //printf("tick : %f base: %f delta: %f\n", tick, clock_base[id], tick - clock_base[id]);
  if (tick > clock_base[id]) {
    clock_new[id] += (tick - clock_base[id]) * time_scale;
    ts->tv_sec = (time_t)(clock_new[id] / 1000000000.0);
    ts->tv_nsec = (long)(fmod(clock_new[id], 1000000000.0));
    clock_base[id] = tick;
  }
  //mutex.unlock();
  }
  return 0;
}
int do_clock_gettime(clockid_t which_clock, struct timespec* tp)
{//未使用，内核中该函数实际的代码，反汇编libc.so得到
  /*
  这些指令都不重要 
  都会被覆盖调 , 写的这些指令主要是占坑用的 
  实际上调用的是 clock_gettime 函数 
  下面的汇编代码都会被覆盖为 跳转代码 , 跳转到 clock_gettime 函数 , 
  注意 , clock_gettime 函数 的前 6 字节的指令会被拷贝到函数入口 , 
  执行第 6 字节位置时 , 跳转到 clock_gettime 函数 的第 6 字节位置
  */
  //return syscall(__NR_clock_gettime, which_clock, tp);
  __asm__ __volatile__("push %%ebx"::: "ebx");
  __asm__ __volatile__("push %%ecx\n"::: "ecx");
  __asm__ __volatile__("mov 12(%%esp),%%ebx"::: "ebx");
  __asm__ __volatile__("mov 16(%%esp),%%ecx"::: "ecx");
  __asm__ __volatile__("mov $0x109,%%eax"::: "eax");
  __asm__ __volatile__("int $0x80");
  __asm__ __volatile__("pop %%ecx":::"ecx");
  __asm__ __volatile__("pop %%ebx":::"ebx");
  __asm__ __volatile__("retn");
}