目录

一、关于systcl
二、利用systcl做反调试
（一）、了解原理
（二）、反调试代码
三、反sysctl反调试
四、增强sysctl反调试
五、静态分析绕过反调试
六、小结
Demo

一、关于systcl

通过man sysctl查看该函数的描述

sysctl函数
sysctl函数

根据描述：sysctl可以检索内核状态且运行有权限的进程设置内核状态，同样也可以获取内核、进程的状态。

二、利用systcl做反调试

（一）、了解原理

当一个进程被调试时，该进程中会有对应的标记位来表示自身正在被调试，因此可以通过sysctl函数来获取当前进程的信息，通过这些信息来检查状态，阻止调试。简单说一下原理，在proc.h头文件中定义了一些与进程相关的信息,结构体struct extern_proc中包含一个p_flag表示进程的一些标记

struct extern_proc {
    ···
    struct  vmspace *p_vmspace; /* Address space. */
    struct  sigacts *p_sigacts; /* Signal actions, state (PROC ONLY). */
    int p_flag;         /* P_* flags. */
    char    p_stat;         /* S* process status. */
    pid_t   p_pid;          /* Process identifier. */
    ···
};

接着往下看，会看到一些状态值的宏定义，因为都是数值的定义，我猜测是用于与当前进程标记做某些运算操作得出结果来判断进程状态，看到其中的P_TRACED,根据注释，大概知道是调试、跟踪进程的意思

#define P_TRACED    0x00000800  /* Debugged process being traced */

根据测试，p_flag的值在调试状态与正常运行状态下是不同的，可以通过宏P_TRACED判断，原理如下图:

原理

（二）、反调试代码

//
//  main.m
//  sysctl
//
//  Created by kinken on 2018/12/28.
//  Copyright © 2018 kinkenyuen. All rights reserved.
//

#import <UIKit/UIKit.h>
#import "AppDelegate.h"
#import <sys/sysctl.h>

BOOL isDebuggingWithSysctl(){
    /**
     需要检测进程信息的字段数组
     */
    int name[4];
    name[0] = CTL_KERN;
    name[1] = KERN_PROC;
    name[2] = KERN_PROC_PID;
    name[3] = getpid();

    /**
     查询进程信息结果的结构体
     */
    struct kinfo_proc info;
    size_t info_size = sizeof(info);
    info.kp_proc.p_flag = 0;

    /*查询成功返回0*/
    int error = sysctl(name, sizeof(name) / sizeof(*name), &info, &info_size, NULL, 0);
    if (error == -1) {
        NSLog(@"sysctl process check error ...");
        return NO;
    }
    
    /*根据标记位检测调试状态*/
    return ((info.kp_proc.p_flag & P_TRACED) != 0);
}

/**
 定时器检测是否在调试状态
 */
static dispatch_source_t timer;
void debugCheckTiming() {
    timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_global_queue(0, 0));
    dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 1.0 * NSEC_PER_SEC, 0.0 * NSEC_PER_SEC);
    dispatch_source_set_event_handler(timer, ^{
        if (isDebuggingWithSysctl()) {
            NSLog(@"检测到调试");
            exit(-1);
        }else {
            NSLog(@"正常");
        }
    });
    dispatch_resume(timer);
}

int main(int argc, char * argv[]) {
    debugCheckTiming();
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

说明一下，防护代码仅仅用的是exit函数做了个简单的退出，后续学习更深入的防护。

三、反sysctl反调试

简单来说，hooksysctl函数，修改检测结果来绕过，通常使用动态库注入，由于MonkeyDev自带了反反调试代码，先屏蔽掉，自己练习一遍,代码如下：

@implementation AntiAntiDebug

static int (*orig_sysctl)(int *, u_int, void *, size_t *, void *, size_t);
int my_sysctl(int *name, u_int nameLen ,void *info ,size_t *info_size, void *newp, size_t newLen);

+ (void)load {
    rebind_symbols((struct rebinding[1]){{"sysctl",my_sysctl,(void *)&orig_sysctl}}, 1);
}

int my_sysctl(int *name, u_int nameLen ,void *info ,size_t *info_size, void *newp, size_t newLen) {
    if (nameLen == 4 && name[0] == CTL_KERN && name[1] == KERN_PROC && name[2] == KERN_PROC_PID && info && info_size && ((int)*info_size == sizeof(struct kinfo_proc))) {
        //先调用原始sysctl查询进程信息
        int result = orig_sysctl(name, nameLen, info, info_size, NULL, 0);
        
        //获取进程信息
        struct kinfo_proc *info_ptr = (struct kinfo_proc *)info;
        NSLog(@"检测到调试时p_flag的值:%d",info_ptr->kp_proc.p_flag);
        
        if (info_ptr && (info_ptr->kp_proc.p_flag & P_TRACED) != 0) {
            NSLog(@"检测到反调试，尝试绕过...");
            //两个值按位异或，赋值给p_flag，实质是将p_flag的第12位标记位改为0
            info_ptr->kp_proc.p_flag ^= P_TRACED;
            if ((info_ptr->kp_proc.p_flag & P_TRACED) == 0) {
                NSLog(@"反反调试成功!");
            }
        }
        NSLog(@"去掉检测调试后p_flag的值:%d",info_ptr->kp_proc.p_flag);
        return result;
    }
    return orig_sysctl(name, nameLen, info, info_size, NULL, 0);
}

@end

反反调试结果

四、增强sysctl反调试

思路：先执行防护代码，也就是先于三方注入的动态库加载
操作：反调试防护代码写在自己的库内
原理：自己的动态库先于注入的动态库加载

代码跟上面的一样，只是换了个位置，就不赘述了

动态库防护代码

将上面的*.app复制到MonkeyApp工程，重签名调试，下了一个exit符号断点,运行工程时断住了， 说明防护的代码生效，上一节的绕过反调试代码不起作用，如下:

反反调试失效

五、静态分析绕过反调试

• 尝试下符号断点，查找线索，exit与ptrace可能比较常见,接着查看调用栈
  

  调用栈
  可以看到exit的调用者是AntiDebug里的debugCheckTiming函数，对应上面的防护代码部分。

• 通过image list查看是否有AntiDebug模块加载

  
  查看是否有对应的动态库

• 静态分析该动态库

  
  分析__debugCheckTiming

留意到BL _isDebuggingWithSysctl 的下一条指令TBZ W0,#0,loc_7DCC,该指令的含义为若W0[0] == 0,则跳转到7DCC地址处，可以想到这是一个if-else条件判断，那么我们可以直接修改该指令，让它直接跳转到7DCC处，这样就不会再执行下面的_exit

• 修改汇编指令绕过防护代码
  由于本人对IDA修改指令方面不熟悉，因此使用hopper修改，如下:
  选中需要修改的指令，option + A
  修改指令

修改后的指令直接跳转到0x7DCC处，也就是对应代码的else块

修改后的指令

生成新的可执行文件

image.png

将新的可执行文件（这里是动态库类型）拷贝回Monkey工程下的*.app的Frameworks内的对应动态库内，重新运行工程

成功绕过检测到调试后的防护代码

六、小结

本次学习主要了解防护与破除防护的思路以及通过简单的Demo代码练习加深攻防印象，为日后更深入的分析奠定基础。