两种绕过方案

这里有两种方案去绕过这种反调试：

• 静态内存匹配特征patch
• 实现一个简单的inlinehook动态hook绕过

静态内存匹配特征patch

在介绍思路之前，先看下一遍内联汇编去实现反调试的代码

    asm volatile(
                 "mov x0,#31\n"
                 "mov x1,#0\n"
                 "mov x2,#0\n"
                 "mov x3,#0\n"
                 "mov x16,#26\n"
                 "svc #128\n"
                 );

这里可以看出原理就是调用了26号系统调用，那么我们是不是可以去代码段里面去搜索，找到满足该特征的代码位置，然后直接将svc置为 nop不就可以了？下面引出两个问题，如何去遍历代码段以及如何去修改？

获取代码段位置以及大小

void getTextSegmentAddr(struct segmentRange *textSegRange){
    
    int offset = 0;
    struct mach_header_64* header = (struct mach_header_64*)_dyld_get_image_header(0);
    
    if(header->magic != MH_MAGIC_64) {
        return ;
    }
    
    offset = sizeof(struct mach_header_64);
    int ncmds = header->ncmds;
    
    while(ncmds--) {
        /* go through all load command to find __TEXT segment*/
        struct load_command * lcp = (struct load_command *)((uint8_t*)header + offset);
        offset += lcp->cmdsize;
        
        if(lcp->cmd == LC_SEGMENT_64) {
            struct segment_command_64 * curSegment = (struct segment_command_64 *)lcp;
            struct section_64* curSection = (struct section_64*)((uint8_t*)curSegment + sizeof(struct segment_command_64));
            
            // check current section of segment is __TEXT?
            if(!strcmp(curSection->segname, "__TEXT") && !strcmp(curSection->sectname, "__text")){
                uint64_t memAddr = curSection->addr;
                textSegRange->start = memAddr + _dyld_get_image_vmaddr_slide(0);
                textSegRange->end = textSegRange->start + curSection->size;
                break;
            }
            
        }
    }
    return ;
}

代码不复杂，就是动态解析了自身内存里面的macho文件，根据macho文件格式找到代码段LC_SEGMENT_64(_TEXT)然后就能得到__text的开始位置以及大小。

内存搜索匹配ptrace内联汇编代码

void* lookup_ptrace_svc(void* target_addr, uint64_t size){
    uint8_t * p = (uint8_t*)target_addr;
    
    for(int i = 0; i < size ;i++ ){
        /*
         mov       x16, #0x1a -> 0xd2800350
         svc        #0x80 -> 0xd4001001
         */
        if (*((uint32_t*)p) == 0xd2800350 && *((uint32_t*)p+1) == 0xd4001001) {
            return p;
        }
        p++;
    }
    return NULL;
}

传入的就是代码段的地址以及大小，然后遍历整个代码段，找到满足以下ptrace特征汇编代码

 mov       x16, #0x1a -> 0xd2800350
 svc        #0x80 -> 0xd4001001

然后就返回该地址。

patch代码（将svc改为nop）

iOS LLDB中基于内存单指令patch实现反反调试 161这篇文章介绍了如何去patch代码的原理，但当时遇到一个bug：在iOS11/12上面patch会失败，后面我花了一段时间去分析了失败的原因，后来也写了一篇文章去记录了分析的过程，感兴趣的可以访问iOS12内存patch remap bug分析 57

这里我就直接给出patch的代码

uint8_t patch_ins_data[4] = {0x1f, 0x20, 0x03, 0xd5}; // nop
patchCode(ptrace_svc_p+4, patch_ins_data , 4);

完整流程代码如下

- (void)kill_anti_debug{
   
    struct segmentRange textSegRange;
    getTextSegmentAddr(&textSegRange);
    void* ptrace_svc_p = lookup_ptrace_svc((void*)textSegRange.start, textSegRange.end-textSegRange.start);
    if (!ptrace_svc_p) {
        ADDLOG(@"[-] not found ptrace svc");
        return;
    }
    
    ADDXLOG(@"[+] found ptrace svc # address=%p", ptrace_svc_p);
    
    char* ptrace_bytes = hex_dump((void*)ptrace_svc_p, 8);
    
    ADDXLOG(@"[+] read ptrace svc ins address:%p size:0x%x inst_bytes:%s", ptrace_svc_p, 8, ptrace_bytes);
    free(ptrace_bytes);
  
    ADDLOG(@"[*] start to ptach ptrace svc to ret");
    
   
    uint8_t patch_ins_data[4] = {0x1f, 0x20, 0x03, 0xd5};
    
    patchCode(ptrace_svc_p+4, patch_ins_data , 4);
    ADDLOG(@"[*] ptach ptrace svc to nop done, read new value");
    
    ptrace_bytes = hex_dump((void*)ptrace_svc_p, 8);
    ADDXLOG(@"[+] read ptrace svc ins address:%p size:0x%x inst_bytes:%s", ptrace_svc_p, 8, ptrace_bytes);
    free(ptrace_bytes);
    
}

通过比对前后的代码就发现svc出地址的代码已经变成了nop从而绕过了反调试

inlinehook动态hook绕过

这种方式主要针对那些混淆了系统调用号或者其他编译版本，其绕过原理是直接hook svc指令，然后判断是否为26号系统调用（让其他系统调用正常执行），若满足就直接跳过svc指令。

整体流程代码如下

  struct segmentRange textSegRange;
  getTextSegmentAddr(&textSegRange);
  void* svc_p = lookup_svc_ins((void*)textSegRange.start, textSegRange.end-textSegRange.start);
  if (!svc_p) {
      ADDLOG(@"[-] not found svc");
      return;
  }

  ADDXLOG(@"[+] found svc # address=%p", svc_p);

  char* svc_bytes = hex_dump((void*)svc_p, 4);

  ADDXLOG(@"[+] read ptrace svc ins address:%p size:0x%x inst_bytes:%s", svc_p, 4, svc_bytes);
  free(svc_bytes);

  xia0Hook(svc_p);

同样遍历代码段找到所有的svc指令，然后进行hook，下面看hook的具体实现

bool xia0Hook(void* target_addr){
     int len = (int)sysconf(_SC_PAGESIZE);
    
    // 1. get target address page and patch offset
    unsigned long page_start = (unsigned long) (target_addr) & ~PAGE_MASK;
    unsigned long patch_offset = (unsigned long)target_addr - page_start;
    printf("[*] Target address:%p Page start:%p Patch offset:%p", target_addr, (void*)page_start, (void*)patch_offset);
    
    // 2. map new page for patch
    void *new = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
    if (!new ){
        printf("[-] mmap failed!");
        return false;
    }
    
    // 3.copy target 4 ins to new page
    int copy_size = 4*4;
    void* copy_from_addr = target_addr - copy_size;
    memcpy((void *)(new), copy_from_addr, copy_size);
    
    /*
     cmp x16, #0x1a
     b.ne loc_not_ptrace_svc_jmp
     ldr x17, #0x8
     br x17
     orig_svc_next_addr_1
     orig_svc_next_addr_2
     ldr x17, #0x8
     br x17
     orig_svc_addr_1
     orig_svc_addr_2
     */
    uint64_t orig_svc_addr = (uint64_t)target_addr;
    uint64_t orig_svc_next_addr = (uint64_t)(target_addr+1*4);
    uint8_t check_jmp_data[] = {0x1f, 0x6a, 0x00, 0xf1, 0x51, 0x00, 0x00, 0x58, 0x20, 0x02, 0x1f, 0xd6, orig_svc_next_addr&0xff, (orig_svc_next_addr>>8*1)&0xff,  (orig_svc_next_addr>>8*2)&0xff,  (orig_svc_next_addr>>8*3)&0xff,  (orig_svc_next_addr>>8*4)&0xff,  (orig_svc_next_addr>>8*5)&0xff,  (orig_svc_next_addr>>8*6)&0xff,  (orig_svc_next_addr>>8*7)&0xff, 0x51, 0x00, 0x00, 0x58, 0x20, 0x02, 0x1f, 0xd6, orig_svc_addr&0xff, (orig_svc_addr>>8*1)&0xff,  (orig_svc_addr>>8*2)&0xff,  (orig_svc_addr>>8*3)&0xff,  (orig_svc_addr>>8*4)&0xff,  (orig_svc_addr>>8*5)&0xff,  (orig_svc_addr>>8*6)&0xff,  (orig_svc_addr>>8*7)&0xff};
    
    int check_jmp_data_size = 10*4;
    memcpy((void *)(new+4*4), check_jmp_data, check_jmp_data_size);
    
    // 4.patch target address to jmp hook code
    void* patch_addr = copy_from_addr;
    uint64_t new_p = (uint64_t)new;
    
    /*
     ldr x16, #0x8
     br x16
     hook_code_addr_1
     hook_code_addr_2
     */
    uint8_t patch_data[] = {0x50, 0x00, 0x00, 0x58, 0x00, 0x02, 0x1f, 0xd6,new_p&0xff, (new_p>>8*1)&0xff,  (new_p>>8*2)&0xff,  (new_p>>8*3)&0xff,  (new_p>>8*4)&0xff,  (new_p>>8*5)&0xff,  (new_p>>8*6)&0xff,  (new_p>>8*7)&0xff};
    int patch_data_size = 4*4;
    patchCode(patch_addr, patch_data, patch_data_size);
    
    // 5. set new page to r-x
    mprotect(new, len, PROT_READ | PROT_EXEC);
    
    return true;
}

这里代码比较复杂，大致分为以下步骤

• map一页内存new，后面会将hook的代码写到里面
• copy原svc前的四条指令保存到new页（目前没有进行相对寻址修复）
• 将hook判断的代码写到紧接着前面四条指令的后面，汇编代码大致如下
• cmp x16, #0x1a b.ne loc_not_ptrace_svc_jmp ldr x17, #0x8 br x17 orig_svc_next_addr_1 orig_svc_next_addr_2 ldr x17, #0x8 br x17 orig_svc_addr_1 orig_svc_addr_2
• 就是简单的判断了系统调用号是否为26，若满足就跳到svc的下一条指令，若不是则跳回原svc指令以保证其他系统调用正常执行。
• patch目标地址进行hook跳转，由于进行任意地址跳转需要4条指令大小，所以这里覆盖了svc前的四条指令
• ldr x16, #0x8 br x16 hook_code_addr_1 hook_code_addr_2
• 这里就是在执行svc指令前使其跳转到我们的hook代码
• 最后将new这页设置为可读不可写可执行的页属性

总结/Todo

其实对于这种inlinehook去绕过调试，后面发现已经有人已经实现了，因为只要实现了inlinehook，肯定能hook代码绕过。不过我这里主要是想去自己分析以及实现这里面的很多细节。因为hook框架由于要考虑到稳定，兼容等等因素，所以往往代码不是很直接。而这里通过仅仅实现绕过反调试的需求，所以代码都比较通俗易懂，原理来说都是一样的。只有自己去动手写了代码才发现里面的乐趣所在，比如如何去实现系统调用的判断？如何解决寄存器污染?如何去实现代码段patch？当然还有很多汇编级别的坑存在，踩坑解决坑同样有意思，这里就不一一介绍。

后面主要还有两个事需要做：

• 相对寻址指令的修复问题，以及hook代码的稳定兼容扩展问题。
• 抽离相关代码，集成到xia0LLDB 143之中，真正实现调试器中一键绕过反调试。

更新 2019/09/11

xia0LLDB 143中已经集成了两种绕过反调试方案。

• app采取直接或间接调用ptrace函数的反调试方案 # [xia0LLDB#debugme] 单指令patch ptrace函数
• app采取单点或者多点多线程利用内联汇编方式的反调试方案 # [xia0LLDB#debugme] 动态inlinehook app中所有的svc指令，然后判断是否为26号系统调用，然后patch。

https://github.com/4ch12dy/xia0LLDB