android反调试技术

检测调试相关文件android_server等#

int SearchFile(std::string file_path)
{
    int ret = 0;
    // fork进程检测
    std::string command = "cat ";
    command.append(file_path.c_str());
    FILE *fd1 = popen(command.c_str(), "r");
    if(NULL != fd1){
        char m_buffer[10] = {0};
        if(fgets(m_buffer, sizeof(m_buffer), fd1)){
            return -1;
        }
        pclose(fd1);
    }

    // 直接打开
    int fd2 = open(file_path.c_str(), O_RDONLY);
    if(fd2 != -1){
        close(fd2);
        return -1;
    }

    //fd反查
    DIR *dir = opendir("/proc/self/fd/");
    if (dir != NULL) {
        struct dirent *entry = NULL;
        while ((entry = readdir(dir)) != NULL) {
            char buf[0x1000] = {0};
            char filePath[0x1000] = {0};
            snprintf(filePath, sizeof(filePath), "/proc/self/fd/%s", entry->d_name);
            readlinkat(AT_FDCWD, filePath, buf, 0x1000);
            if (NULL != strstr(buf, file_path.c_str())) {
                ret = -1;
                break;
            }
        }
        closedir(dir);
    }
    return ret;
}

这种检测方法很好绕过，直接修改文件名称即可。

检测特定的字段#

调试状态下/proc/pid/stat 和/proc/pid/task/pid/stat的第三个字段会变成t

调试状态下/proc/pid/wchan 和/proc/pid/task/pid/wchan的值会变成ptrace_stop

/proc/pid/status文件的TracerPid的值为调试器进程的pid

检测android_server等调试器进程默认端口号#

android_server进程默认监听的是23946端口，gdbserver默认监听的是27042端口
通过/proc/net/tcp文件获取正在被监听的端口

int SearchPort()
{
    int ret = 0;
    char m_buffer[0x1000] = {0};
    FILE *fd = fopen("/proc/net/tcp","r");
    if(NULL == fd){
        return -1;
    }
    while(fgets(m_buffer, sizeof(m_buffer), fd)){
        if( strstr(m_buffer, "5D8A") ||
            strstr(m_buffer, "69A2")){
            printf("check debug!\n");
            ret = -1;
            break;
        }
    }
    fclose(fd);
    return ret;
}

android 10之后/proc/net文件系统的访问权限实施了限制，可以直接建立socket连接来确认是否存在端口占用。

inotify监控文件#

通过linux提供的inotify来监控文件/proc/pid/mem和/proc/pid/pagemap是否被读写，防止一些dump操作。

检测指令间运行时间差#

程序正常执行两天指令执行的时间差是很短的，如果被调试的话时间差会大大增加。

扫描内存断点#

内存断点是通过修改程序指令实现的，通过遍历内存中的各个段并判断是否为bkpt指令可以发现是否存在内存断点。

bool check_break_point (uint32_t module_base)
{
    Elf32_Ehdr *elf_header;
    uint32_t program_offset, program_header;
    if (module_base == 0) {
        return false;
    }
    elf_header = (Elf32_Ehdr *) module_base;
    program_header = module_base + elf_header->e_phoff;
    for (int i = 0; i < elf_header->e_phnum; i++) {
        Elf32_Phdr *ph_t;
        ph_t = (Elf32_Phdr*)(program_header + i * sizeof(Elf32_Phdr));
        if ( !(ph_t->p_flags & 1) ) continue;
        program_offset = module_base + ph_t->p_vaddr;
        program_offset += sizeof(Elf32_Ehdr) + sizeof(Elf32_Phdr) * elf_header->e_phnum;
        char *p = (char*)program_offset;
        for (int j = 0; j < ph_t->p_memsz; j++) {
            if(*p == 0x01 && *(p+1) == 0xde) {
                //thumb16
                return true;
            } else if (*p == 0xf0 && *(p+1) == 0xf7 && *(p+2) == 0x00 && *(p+3) == 0xa0) {
                //thumb32
                return true;
            } else if (*p == 0x01 && *(p+1) == 0x00 && *(p+2) == 0x9f && *(p+3) == 0xef) {
                //arm断点
                return true;
            }
            p++;
        }
    }
    return false;
}

主动抛出SIGTRAP异常反调试#

程序主动抛出SIGTRAP异常信号，操作系统在得到SIGTRAP信号后会检查是否存在调试器，如果存在调试器会将信号先传递给调试器。这样程序中的异常处理程序就得不到执行，调试器就会陷入死循环。

//利用ida先截获信号的特性进行反调试
//异常处理函数
void my_signal(int sig)
{
    printf("not find debugger!\n");
}
int SetSignal()
{
    //设置异常对应的异常处理函数
    sighandler_t ret = signal(SIGTRAP, my_signal);
    if(SIG_ERR == ret){
        return -1;
    }
    //主动抛出异常
    raise(SIGTRAP);
    return 0;
}

bkpt指令反调试#

在程序中malloc申请内存硬编码存放bkpt指令，然后设置异常处理函数来恢复程序执行。如果程序被调试的话操作系统会先将异常信号传递给调试器，异常处理函数就得不到执行，程序无法恢复执行陷入死循环。

//利用bkpt指令反调试
uint32_t pBkpt;
//SIGTRAP信号处理函数
void my_sigtrap(int sig)
{
    //将bkpt指令覆盖填充为arm模式的mov pc,r1指令，执行此指令后返回
    *((uint32_t*)pBkpt) = 0xE1A0F001;
}
int SetBkpt()
{
    pBkpt = (uint32_t)malloc(0x10);
    if(NULL == pBkpt){
        return -1;
    }
    if(mprotect((void*)((uint32_t)pBkpt / PAGE_SIZE * PAGE_SIZE), PAGE_SIZE,PROT_READ|PROT_WRITE|PROT_EXEC)){
        return -1;
    }

    *((uint32_t*)pBkpt) = 0xE1200070;    //填充arm模式的bkpt指令
    signal(SIGTRAP, my_sigtrap);         //设置SIGTRAP异常处理函数

     __asm__ volatile(
            "mov r0, %[pBkpt]\n\t"
            "mov r1,pc\n\t"             //保存返回地址
            "BX r0\n\t"                 //执行bkpt指令
            :                           //在内联汇编代码中修改的变量列表
            :[pBkpt]    "r"(pBkpt)      //在内联汇编代码中使用的变量列表
            : "cc", "r0","r1","pc"      //在内联汇编中使用的寄存器列表
            );
    return 0;
}

rtld_db_dlactivity#

linker的rtld_db_dlactivity函数在非调试模式下为空函数，如果程序被调试则会被修改为对应的断点指令，可以对此函数进行检测。

ptrace反调试#

因为一个程序只能被一个调试进程调试，所以有其他进程ptrace的话就会失败。可以创建一个守护进程，并通过ptarce轮询附加主进程，如果失败则证明主进程被调试。

int ret = ptrace(PTRACE_ATTACH, pid, NULL, NULL);
if(ret){
    return -1;
}
return 0;

双进程反调试#

• 可以通过主进程fork子进程，然后子进程ptarce调试父进程并监控父进程所有的线程（ptrace 附加的单位是线程），同时父进程通过进程间通讯（信号量等）检测子进程是否存活，这样其他进程就无法ptrace调试主进程。
  针对上述方法可以ptrace注入子进程并在子进程中调用ptrace PTRACE_DETACH 父进程解除保护，这样就可以正常调试父进程了。针对这种方法可以对双进程保护逻辑进行优化，子进程 ptrace父进程的所有线程，但是需要保留一个守护线程。此守护线程ptrace 附加子进程，这样子进程与父进程都无法被ptrace。https://blog.csdn.net/u011247544/article/details/78248427 ，https://xz.aliyun.com/t/9815。

反ida静态分析#

• 因为ida使用的递归下降的反汇编引擎，而这种引擎有个最大的缺点就是无法识别间接跳转指令。在函数中穿插间接跳转指令可以反ida F5分析

int OrderObscure()
{
    __asm__ volatile( \
    "mov r0,pc \n\t" \
    "adds r0,0xc \n\t" \
    "push {r0} \n\t" \
    "pop {r0} \n\t" \
    "bx r0 \n\t"
    :::"r0" \
    );
    
    printf("is ok");
    return 0;
}

上面的代码在函数中使用的间接跳转指令bx r0，ida查看此汇编代码bx r0后的指令是没有识别的。

IDA F5也是无法正确分析的

但是还是ida还是可以正确查看整个函数对应的反汇编代码的

因为ida无法同时解析arm与thumb指令，所以进一步的在代码中硬编码穿插thumb指令可以使ida连汇编代码也无法解析。

//1. 利用代码中穿插BX R0间接跳转指令
//2. 利用代码中混合使用thumb和arm指令
int OrderObscure()
{
    __asm__ volatile( \
    "mov r0,pc \n\t" \
    "adds r0,0xd \n\t" \
    "push {r0} \n\t" \
    "pop {r0} \n\t" \
    "bx r0 \n\t"


    //thhub指令
    ".byte 0x00 \n\t" \
    ".byte 0xBF \n\t" \
    \
    ".byte 0x78 \n\t" \
    ".byte 0x46 \n\t" \
    \
    ".byte 0x02 \n\t" \
    ".byte 0x30 \n\t" \
    \
    ".byte 0x00 \n\t" \
    ".byte 0x47 \n\t" \
    :::"r0" \
    );
    //nop
    //mov r0,pc
    //adds r0,2
    //bx r0

    printf("is ok");
    return 0;
}

ida查看对应的反汇编代码，发现无法正确解析thumb指令集的汇编代码以及后续的代码。