Android逆向-Frida反调试及应对

2023-09-12

字数统计: 2.4k字 | 阅读时长≈ 12分

反调试及应对

Android逆向-Frida反调试及应对

检测`frida-server`文件名

检测有没有叫做frida-server的文件或进程存在。比如：

public boolean checkRunningProcesses() {
  boolean returnValue = false;
  // Get currently running application processes
  List<RunningServiceInfo> list = manager.getRunningServices(300);
  if(list != null){
    String tempName;
    for(int i=0;i<list.size();++i){
      tempName = list.get(i).process;
      if(tempName.contains("frida-server")) {
        returnValue = true;
      }
    }
  }
  return returnValue;
}

绕过：改名字

1	mv frida-server rf-server

检查27042端口

检查Frida默认27042端口，比如：

boolean is_frida_server_listening() {
    struct sockaddr_in sa;
    memset(&sa, 0, sizeof(sa));
    sa.sin_family = AF_INET;
    sa.sin_port = htons(27047);
    inet_aton("127.0.0.1", &(sa.sin_addr));
    int sock = socket(AF_INET , SOCK_STREAM , 0);
    if (connect(sock , (struct sockaddr*)&sa , sizeof sa) != -1) {
      /* Frida server detected. Do something… */
    }
}

绕过：修改端口。

在adb shell里面执行：

1	./rf-server -l 0.0.0.0:11451

然后

1 2	adb forward tcp:11451 tcp:11451 frida -H 127.0.0.1:11451 -f com.baidu.naviauto

即可。

父子进程调试（双进程保护）

Frida反调试 - 简书 (jianshu.com)

这个例子是子进程去Attach父进程。这里的解决方式比较简单：

1	frida -U -f com.shark.tracerpidapp

让Frida去spawn APP父进程，让子进程没法提前Attach。

然后就可以再附上Frida脚本，提前对进程进行patch，从而实现反反调试。

TracerPid反调试

原理

首先ps查看进程号

1	frida-ps -U

然后看status

1 2	adb shell cat /proc/25421/status

比如：

redfin:/ $ cat /proc/25421/status
Name:   .baidu.naviauto
Umask:  0077
State:  S (sleeping)
Tgid:   25421
Ngid:   0
Pid:    25421
PPid:   29984
TracerPid:      0
Uid:    10253   10253   10253   10253
Gid:    10253   10253   10253   10253
FDSize: 512
Groups: 3001 3002 3003 9997 20253 50253
VmPeak:  2345508 kB
VmSize:  1659672 kB
VmLck:         0 kB
VmPin:         0 kB
VmHWM:    513300 kB
VmRSS:    249324 kB
RssAnon:          120584 kB
RssFile:          123048 kB
RssShmem:           5692 kB
VmData:   912304 kB
VmStk:      8192 kB
VmExe:        12 kB
VmLib:    154680 kB
VmPTE:      1552 kB
VmSwap:        0 kB
CoreDumping:    0
Threads:        104
SigQ:   0/28561
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: 0000000080001204
SigIgn: 0000000000000001
SigCgt: 0000006e400084f8
CapInh: 0000000000000000
CapPrm: 0000000000000000
CapEff: 0000000000000000
CapBnd: 0000000000000000
CapAmb: 0000000000000000
NoNewPrivs:     0
Seccomp:        2
Speculation_Store_Bypass:       thread vulnerable
Cpus_allowed:   30
Cpus_allowed_list:      4-5
Mems_allowed:   1
Mems_allowed_list:      0
voluntary_ctxt_switches:        3317
nonvoluntary_ctxt_switches:     413

TracerPid就是调试此进程的pid，在同一时刻只能有一个进程调试本进程

在使用IDA android_server对进程进行调试的时候，这个TracerPid就会变成server的PID。

检测Demo

这是一个检测demo：

#include <jni.h>
#include <string>
#include "antidebug.h"

#define NULL 0
#define CHECK_TIME 10
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "shark chilli", __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, "shark chilli", __VA_ARGS__)

pthread_t id_anti_debug = NULL;

void readStatus() {
    FILE *fd;
    char filename[128];
    char line[128];
    pid_t pid = syscall(__NR_getpid);
    LOGI("PID : %d", pid);
    sprintf(filename, "/proc/%d/status", pid);// 读取proc/pid/status中的TracerPid
    while (1) {
        fd = fopen(filename, "r");
        while (fgets(line, 128, fd)) {
            if (strncmp(line, "TracerPid", 9) == 0) {
                //TracerPid值
                int status = atoi(&line[10]);
                LOGI("########## status = %d, %s", status, line);
                fclose(fd);
                syscall(__NR_close, fd);
                if (status != 0) {
                    LOGI("########## FBI WARNING ##########");
                    LOGI("######### FIND DEBUGGER #########");
                    kill(pid, SIGKILL);
                    return;
                }
                break;
            }
        }
        sleep(CHECK_TIME);
    }
}

void checkAnti() {
    LOGI("Call readStatus...");
    readStatus();
}

void anti_debug() {
    LOGI("Call anti_debug...");
    //创建线程
    if (pthread_create(&id_anti_debug, NULL, (void *(*)(void *)) &checkAnti, NULL) != 0) {
        LOGE("Failed to create a debug checking thread!");
        exit(-1);
    };
    //线程分离 释放资源
    pthread_detach(id_anti_debug);
}

extern "C" JNIEXPORT void JNICALL
Java_com_shark_tracerpidapp_MainActivity_checkTracerPid(
        JNIEnv *env,
        jobject /* this */) {
    anti_debug();
}

Frida fgets反反调试

通过Hook libc.so的fgets函数来检查。

var anti_fgets = function () {
    // dmLogout("anti_fgets");
    var fgetsPtr = Module.findExportByName("libc.so", "fgets");
    var fgets = new NativeFunction(fgetsPtr, 'pointer', ['pointer', 'int', 'pointer']);
    Interceptor.replace(fgetsPtr, new NativeCallback(function (buffer, size, fp) {
        var retval = fgets(buffer, size, fp);
        var bufstr = Memory.readUtf8String(buffer);
        if (bufstr.indexOf("TracerPid:") > -1) {
            Memory.writeUtf8String(buffer, "TracerPid:\t0");
            // dmLogout("tracerpid replaced: " + Memory.readUtf8String(buffer));
        }
        return retval;
    }, 'pointer', ['pointer', 'int', 'pointer']));
};

检测D-Bus

frida-server使用D-Bus协议通信，我们为每个开放的端口发送D-Bus的认证消息，哪个端口回复了哪个就是frida-server。比如：

/*
 * Mini-portscan to detect frida-server on any local port.
 */
for(i = 0 ; i <= 65535 ; i++) {
    sock = socket(AF_INET , SOCK_STREAM , 0);
    sa.sin_port = htons(i);
    if (connect(sock , (struct sockaddr*)&sa , sizeof sa) != -1) {
        __android_log_print(ANDROID_LOG_VERBOSE, APPNAME,  "FRIDA DETECTION [1]: Open Port: %d", i);
        memset(res, 0 , 7);
        // send a D-Bus AUTH message. Expected answer is “REJECT"
        send(sock, "\x00", 1, NULL);
        send(sock, "AUTH\r\n", 6, NULL);
        usleep(100);
        if (ret = recv(sock, res, 6, MSG_DONTWAIT) != -1) {
            if (strcmp(res, "REJECT") == 0) {
               /* Frida server detected. Do something… */
            }
        }
    }
    close(sock);
}

这串代码通过遍历所有端口，向其中开放的端口发送DBus通信来检测是否有Frida存在，而其中最核心的判定点其实是strcmp(res, "REJECT");，因此可以通过**Hook系统库strstr，strcmp**等字符串比对函数来进行绕过。

不过这种字符串比对函数确实没什么设计上的难度，因此如果遇到了自行实现字符串比对的代码的话，那就没戏了。

检测`/proc/pid/maps`映射文件（未解决）

原理

首先手动测试一下，在没有Frida的APP上：

1
2
3

adb shell
su
cat /proc/17637/maps

然后打印：

redfin:/ # cat /proc/17637/maps
08bf0000-08bf2000 r--p 00000000 fd:08 152                                /system/bin/app_process32
08bf2000-08bf3000 r-xp 00001000 fd:08 152                                /system/bin/app_process32
08bf3000-08bf4000 r--p 00001000 fd:08 152                                /system/bin/app_process32
12c00000-32c00000 rw-p 00000000 00:00 0                                  [anon:dalvik-main space (region space)]
6fdce000-6ffb4000 rw-p 00000000 00:00 0                                  [anon:dalvik-/system/framework/boot.art]
6ffb4000-6ffe6000 rw-p 00000000 00:00 0                                  [anon:dalvik-/system/framework/boot-core-libart.art]
6ffe6000-70005000 rw-p 00000000 00:00 0                                  [anon:dalvik-/system/framework/boot-okhttp.art]70005000-7003a000 rw-p 00000000 00:00 0                                  [anon:dalvik-/system/framework/boot-bouncycastle.art]
7003a000-7003b000 rw-p 00000000 00:00 0                                  [anon:dalvik-/system/framework/boot-apache-xml.art]
7003b000-700c9000 r--p 00000000 fd:08 1184                               /system/framework/arm/boot.oat
...

等很多很多的玩意出来，表明了进程中内存的分布。

然后再使用Frida的spawn模式去打开APP：

1	frida -U -f com.baidu.naviauto

然后用同样的方式拿到maps，经过搜索会发现有frida相关的字符串。因此判断代码：

char line[512];
FILE* fp;
fp = fopen("/proc/self/maps", "r");
if (fp) {
    while (fgets(line, 512, fp)) {
        if (strstr(line, "frida")) {
            /* Evil library is loaded. Do something… */
        }
    }
    fclose(fp);
    } else {
       /* Error opening /proc/self/maps. If this happens, something is off. */
    }
}

还有一种改进版本，就是通过进一步进行内存字符串搜索，来检查Frida库特征，比如LIBFRIDA：https://github.com/b-mueller/frida-detection-demo/blob/master/AntiFrida/app/src/main/cpp/native-lib.cpp

static char keyword[] = "LIBFRIDA";
num_found = 0;
int scan_executable_segments(char * map) {
    char buf[512];
    unsigned long start, end;
    sscanf(map, "%lx-%lx %s", &start, &end, buf);
    if (buf[2] == 'x') {
        return (find_mem_string(start, end, (char*)keyword, 8) == 1);
    } else {
        return 0;
    }
}
void scan() {
    if ((fd = my_openat(AT_FDCWD, "/proc/self/maps", O_RDONLY, 0)) >= 0) {
    while ((read_one_line(fd, map, MAX_LINE)) > 0) {
        if (scan_executable_segments(map) == 1) {
            num_found++;
        }
    }
    if (num_found > 1) {
        /* Frida Detected */
    }
}

Android逆向多种特征检测 Frida - 简书 (jianshu.com)

注意 my_openat() 等函数，它们并非平常的 libc 库函数，是自定义实现的，但是功能和 libc 中的一样，设置了系统调用的参数，执行了软中断。因为直接调用公共 API 并不可靠，这样不容易被 hook。完整的实现在 https://github.com/b-mueller/frida-detection-demo/blob/master/AntiFrida/app/src/main/cpp/syscall.S 。下面是 my_openat 的代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "bionic_asm.h"
.text
    .globl my_openat
    .type my_openat,function
my_openat:
    .cfi_startproc
    mov ip, r7
    .cfi_register r7, ip
    ldr r7, =__NR_openat
    swi #0
    mov r7, ip
    .cfi_restore r7
    cmn r0, #(4095 + 1)
    bxls lr
    neg r0, r0
    b __set_errno_internal
    .cfi_endproc
    .size my_openat, .-my_openat;

同时也会有/data/local/tmp的这一串路径名存在。关于这个的解决方法放在另外一个章节。

方案一

直接使用Hluda Frida Server是一种方案。

方案二

检测`/proc/pid/task/tid/stat`或`proc/pid/task/tid/status`（未解决）

方案一

直接使用Hluda Frida Server是一种方案。

`/data/local/tmp`检查

Hook open与read来绕过对maps中/data/local/tmp的检查。

过某交友软件frida反调试_马到成功~的博客-CSDN博客

function main() {
    const openPtr = Module.getExportByName('libc.so', 'open');
    const open = new NativeFunction(openPtr, 'int', ['pointer', 'int']);
    
    var readPtr = Module.findExportByName("libc.so", "read");
    var read = new NativeFunction(readPtr, 'int', ['int', 'pointer', "int"]);
    
    var fakePath = "/data/data/com.xyz.qingtian/maps";
    var file = new File(fakePath, "w");
    
    var buffer = Memory.alloc(512);
    Interceptor.replace(openPtr, new NativeCallback(function (pathnameptr, flag) {
        var pathname = Memory.readUtf8String(pathnameptr);
        var realFd = open(pathnameptr, flag);
        if (pathname.indexOf("maps") >= 0) {	// 是在读maps则搞些操作
            while (parseInt(read(realFd, buffer, 512)) !== 0) {
                var oneLine = Memory.readCString(buffer);
                if (oneLine.indexOf("tmp") === -1) {	// 跳过与tmp文件夹有关的字符串
                    file.write(oneLine);
                }
            }
            var filename = Memory.allocUtf8String(fakePath);
            return open(filename, flag);
        }
        var fd = open(pathnameptr, flag);
        return fd;
    }, 'int', ['pointer', 'int']));
}
setImmediate(main)

其他

Frida-LR寄存器溯源

var anti_antiDebug = function() {
    var funcPtr = null;

    funcPtr = Module.findExportByName("xxxx.so", "p57F7418DCD0C22CD8909F9B22F0991D3");

    console.log("anti_antiDebug " + funcPtr);
    Interceptor.replace(funcPtr, new NativeCallback(function (pathPtr, flags) {
        dmLogout("anti-debug LR: " + this.context.lr);
        return 0;
    }, 'int', ['int', 'int']));
};

检测RPC调用

1
2
3

looperclazz = (*env)->FindClass(env, &xmmword_39010);// android/os/Looper
 myLooper_methodID = (*env)->GetStaticMethodID(env, looperclazz, &qword_39028, &xmmword_39040);// myLooper
 if ( !CallStaticObjectMethodV_(env, (__int64)looperclazz, (__int64)myLooper_methodID) )

在 so 中调用android.os.Looper.myLooper(), 如果是正常的调用, 则通过CallStaticObjectMethodV调用的结果为非 0; 如果是通过 frida 的主动调用, 则返回结果为 0; 因为 frida 的主动调用不在主线程中; 可以作为一个主动调用的检测点。