安卓逆向 -- 某SDK Frida检测绕过深度分析

0x01 动态定位分析

这里直接选用一款使用该sdk的app作为demo展开分析，直接挂载frida之后会直接死掉，所以先检查一下是在挂载了哪个具体的so文件之后挂掉的，定位到该so文件之后挂掉了。

 复制代码 隐藏代码
functionhookDlopen() {
let linker64_base_addr = Module.getBaseAddress('linker64')
let offset = 0x3ba00// __dl__Z9do_dlopenPKciPK17android_dlextinfoPKv
let android_dlopen_ext = linker64_base_addr.add(offset)
Interceptor.attach(android_dlopen_ext, {
onEnter: function(args){//主要逻辑是hook linker64中的do_dlopen函数，然后在该函数返回的时候检查目标检测库是否加载
this.name = args[0].readCString()
console.log(`dlopen onEnter ${this.name}`)
      }, onLeave: function(retval){
console.log(`dlopen onLeave name: ${this.name}`)
if (this.name != null && this.name.indexOf('目标so文件') >= 0) {
let JNI_OnLoad = Module.getExportByName(this.name, 'JNI_OnLoad')
console.log(`dlopen onLeave JNI_OnLoad: ${JNI_OnLoad}`)
        }//如果加载了目标库的话则获取该库的 JNI_OnLoad 函数地址并打印
      }
    })
  }

结果如下，很明显是没有走到Jni_OnLoad的，根据so文件的加载流程可以初步判断该检测是在so的init_proc中或者init_array段做的。

为了进一步去判断该程序的检测退出的触发，既然挂上Frida后进程就退出，那么我们就来分析是调用哪个系统调用退出的，可以通过strace查看系统调用，但在执行strace时需要在dlopen加载目标so文件之前让线程sleep 10秒，以便留出strace执行时机。使用脚本如下：

 复制代码 隐藏代码
functionhookDlopen() {
// 获取libc中的sleep函数
let sleep = newNativeFunction(Module.getExportByName('libc.so', 'sleep'), 'int', ['int'])
let linker64_base_addr = Module.getBaseAddress('linker64')
let offset = 0x3ba00// __dl__Z9do_dlopenPKciPK17android_dlextinfoPKv
let android_dlopen_ext = linker64_base_addr.add(offset)
Interceptor.attach(android_dlopen_ext, {
onEnter: function(args){
this.name = args[0].readCString()
console.log(`dlopen onEnter ${this.name}`)
if (this.name != null && this.name.indexOf('目标so文件') >= 0) {
sleep(10) // sleep10秒留出strace执行时机
        }
      }, onLeave: function(retval){
console.log(`dlopen onLeave name: ${this.name}`)
      }
    })
  }

setImmediate(hookDlopen)

上述脚本执行之后，找到目标进程的pid之后执行命令strace -e trace=process -i -f -p "目标pid"，挂载系统函数的调用监视使用strace在进入目标检测so之前挂载上之后截取了目标进程的一系列系统调用，主要关注导致进程退出的系统调用，由下图可见是在进程下面的一个线程实现的闪退效果，执行了系统调用exit_group(0 <unfinished ...>。

同时查看了目标进程中的libc的地址也与导致闪退的地址不符，这就说明这个内容是动态加载的，故而会有一个mmap创建内存的操作

动态释放代码一定是要操作内存的，接下来我们用前面相同的逻辑，用strace查看调用了哪些和内存相关的系统调用，strace -e trace=process,memory -i -f -p 目标pid，如下图，mmap一块儿内存之后执行了造成闪退的系统调用（注意：下图是再一次的启动进程打印出来的内容，故而地址与上图可能有点出入）。

于是我们可以hook mmap打印一下调用栈，从而定位到在目标so文件中创建这块内存造成闪退的偏移地址：

 复制代码 隐藏代码
functionhook_mmap() {//打印一下mmap系统调用的调用栈，从而追踪调用源
const mmap = Module.getExportByName("libc.so", "mmap");
console.log("mmap address: " + mmap);
Interceptor.attach(mmap, {
onEnter: function (args) {
let length = args[1].toString(16)
if (parseInt(length, 16) == 28) {
console.log('backtrace:\n' + Thread.backtrace(this.context, Backtracer.ACCURATE)
                                                  .map(DebugSymbol.fromAddress).join('\n') + '\n');
      }
    }
  })
}
functionhookDlopen() {
// 获取libc中的sleep函数
let sleep = newNativeFunction(Module.getExportByName('libc.so', 'sleep'), 'int', ['int'])
let linker64_base_addr = Module.getBaseAddress('linker64')
let offset = 0x3ba00// __dl__Z9do_dlopenPKciPK17android_dlextinfoPKv
let android_dlopen_ext = linker64_base_addr.add(offset)
Interceptor.attach(android_dlopen_ext, {
onEnter: function(args){
this.name = args[0].readCString()
console.log(`dlopen onEnter ${this.name}`)
if (this.name != null && this.name.indexOf('目标so文件') >= 0) {
//sleep(15) // sleep10秒留出strace执行时机
hook_mmap()
        }
      }, onLeave: function(retval){
console.log(`dlopen onLeave name: ${this.name}`)
      }
    })
  }

hookDlopen()

会发现能够打印mmap的地址，但是还没到打印使用该函数的调用栈的时候就挂掉了，此处我理解的是出现这种问题的原因是做hook的时机还是不对，我们的hook还是被检测到了。

因此对于hook的时机问题再探究一下，这里借用一张安卓中so文件的加载图来分析一下何时hook才能实现我们的目的

上图描述的更多的是一个流程，结合如下的安卓源码，我理解的是do_dlopen和call_constructors应该是包含关系，call_constructors于do_dlopen的流程内执行。

 复制代码 隐藏代码
void* do_dlopen(constchar* name, int flags,
const android_dlextinfo* extinfo,
constvoid* caller_addr){
    std::string trace_prefix = std::string("dlopen: ") + (name == nullptr ? "(nullptr)" : name);
ScopedTrace trace(trace_prefix.c_str());
ScopedTrace loading_trace((trace_prefix + " - loading and linking").c_str());
    soinfo* const caller = find_containing_library(caller_addr);
android_namespace_t* ns = get_caller_namespace(caller);

LD_LOG(kLogDlopen,
"dlopen(name=\"%s\", flags=0x%x, extinfo=%s, caller=\"%s\", caller_ns=%s@%p, targetSdkVersion=%i) ...",
        name,
        flags,
android_dlextinfo_to_string(extinfo).c_str(),
        caller == nullptr ? "(null)" : caller->get_realpath(),
        ns == nullptr ? "(null)" : ns->get_name(),
        ns,
get_application_target_sdk_version());

auto purge_guard = android::base::make_scope_guard([&]() { purge_unused_memory(); });

auto failure_guard = android::base::make_scope_guard(
    [&]() { LD_LOG(kLogDlopen, "... dlopen failed: %s", linker_get_error_buffer()); });

if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL|RTLD_NODELETE|RTLD_NOLOAD)) != 0) {
DL_OPEN_ERR("invalid flags to dlopen: %x", flags);
returnnullptr;
    }

if (extinfo != nullptr) {
if ((extinfo->flags & ~(ANDROID_DLEXT_VALID_FLAG_BITS)) != 0) {
DL_OPEN_ERR("invalid extended flags to android_dlopen_ext: 0x%" PRIx64, extinfo->flags);
returnnullptr;
        }

if ((extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) == 0 &&
            (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET) != 0) {
DL_OPEN_ERR("invalid extended flag combination (ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET without "
"ANDROID_DLEXT_USE_LIBRARY_FD): 0x%" PRIx64, extinfo->flags);
returnnullptr;
        }

if ((extinfo->flags & ANDROID_DLEXT_USE_NAMESPACE) != 0) {
if (extinfo->library_namespace == nullptr) {
DL_OPEN_ERR("ANDROID_DLEXT_USE_NAMESPACE is set but extinfo->library_namespace is null");
returnnullptr;
            }
            ns = extinfo->library_namespace;
        }
    }

// Workaround for dlopen(/system/lib/<soname>) when .so is in /apex. http://b/121248172
// The workaround works only when targetSdkVersion < Q.
    std::string name_to_apex;
if (translateSystemPathToApexPath(name, &name_to_apex)) {
constchar* new_name = name_to_apex.c_str();
LD_LOG(kLogDlopen, "dlopen considering translation from %s to APEX path %s",
            name,
            new_name);
// Some APEXs could be optionally disabled. Only translate the path
// when the old file is absent and the new file exists.
// TODO(b/124218500): Re-enable it once app compat issue is resolved
/*
      if (file_exists(name)) {
        LD_LOG(kLogDlopen, "dlopen %s exists, not translating", name);
      } else
      */
if (!file_exists(new_name)) {
LD_LOG(kLogDlopen, "dlopen %s does not exist, not translating",
               new_name);
      } else {
LD_LOG(kLogDlopen, "dlopen translation accepted: using %s", new_name);
        name = new_name;
      }
    }
// End Workaround for dlopen(/system/lib/<soname>) when .so is in /apex.

    std::string translated_name_holder;

assert(!g_is_hwasan || !g_is_asan);
constchar* translated_name = name;
if (g_is_asan && translated_name != nullptr && translated_name[0] == '/') {
char original_path[PATH_MAX];
if (realpath(name, original_path) != nullptr) {
        translated_name_holder = std::string(kAsanLibDirPrefix) + original_path;
if (file_exists(translated_name_holder.c_str())) {
          soinfo* si = nullptr;
if (find_loaded_library_by_realpath(ns, original_path, true, &si)) {
PRINT("linker_asan dlopen NOT translating \"%s\" -> \"%s\": library already loaded", name,
                  translated_name_holder.c_str());
          } else {
PRINT("linker_asan dlopen translating \"%s\" -> \"%s\"", name, translated_name);
            translated_name = translated_name_holder.c_str();
          }
        }
      }
    } elseif (g_is_hwasan && translated_name != nullptr && translated_name[0] == '/') {
char original_path[PATH_MAX];
if (realpath(name, original_path) != nullptr) {
// Keep this the same as CreateHwasanPath in system/linkerconfig/modules/namespace.cc.
std::string path(original_path);
auto slash = path.rfind('/');
if (slash != std::string::npos || slash != path.size() - 1) {
          translated_name_holder = path.substr(0, slash) + "/hwasan" + path.substr(slash);
        }
if (!translated_name_holder.empty() && file_exists(translated_name_holder.c_str())) {
          soinfo* si = nullptr;
if (find_loaded_library_by_realpath(ns, original_path, true, &si)) {
PRINT("linker_hwasan dlopen NOT translating \"%s\" -> \"%s\": library already loaded", name,
                  translated_name_holder.c_str());
          } else {
PRINT("linker_hwasan dlopen translating \"%s\" -> \"%s\"", name, translated_name);
            translated_name = translated_name_holder.c_str();
          }
        }
      }
    }
    ProtectedDataGuard guard;
    soinfo* si = find_library(ns, translated_name, flags, extinfo, caller);
    loading_trace.End();

if (si != nullptr) {
void* handle = si->to_handle();
LD_LOG(kLogDlopen,
"... dlopen calling constructors: realpath=\"%s\", soname=\"%s\", handle=%p",
             si->get_realpath(), si->get_soname(), handle);
      si->call_constructors();//！！！重点看这里！！！
      failure_guard.Disable();
LD_LOG(kLogDlopen,
"... dlopen successful: realpath=\"%s\", soname=\"%s\", handle=%p",
             si->get_realpath(), si->get_soname(), handle);
return handle;
    }

returnnullptr;
}```

跟进到call_constructors函数之后会发现会先调用`.init_xxxx`函数，接着调用`.init_array`中的函数。







7.jpg (198.17 KB, 下载次数: 0)

下载附件



2025-11-2916:45 上传








故而我们的hook应该更精确到call_constructors，所以可以把钩子挂载在call_constructors函数处，来执行我们对目标so文件中mmap系统调用的拦截：

```javascript
function hook_mmap(){//打印一下mmap系统调用的调用栈，从而追踪调用源
const mmap = Module.getExportByName("libc.so", "mmap");
  console.log("mmap address: " + mmap);
  Interceptor.attach(mmap, {
    onEnter: function (args) {
      let length = args[1].toString(16)
if (parseInt(length, 16) == 28) {//过滤到28字节的创建
        console.log('backtrace:\n' + Thread.backtrace(this.context, Backtracer.ACCURATE)
                                                  .map(DebugSymbol.fromAddress).join('\n') + '\n');
      }
    }
  })
}
function hook_linker_call_constructors(){
    let linker64_base_addr = Module.getBaseAddress('linker64')
    let offset = 0x52110//此处偏移的获取使用命令: readelf -sW /apex/com.android.runtime/bin/linker64 | grep call_constructors
    let call_constructors = linker64_base_addr.add(offset)
    let listener = Interceptor.attach(call_constructors,{
        onEnter:function(args){
            console.log('hook_linker_call_constructors onEnter')
            let secmodule = Process.findModuleByName("目标so文件")
if (secmodule != null){
// do something
hook_mmap()
            }
        }
    })
}
hook_linker_call_constructors();

结果如下，成功得到了崩溃前对应的mmap函数的调用栈。

0x02 静态定位分析

那么现在我们能够通过上述最后hook到的mmap调用的偏移定位到目标so中可能存在检测的位置，从而一步步往上交叉引用来进行分析，由调用栈的最顶层0x2358C可以跟到下图这个位置，可以大概看出似乎是在解密一段shellcode然后开辟内存来执行

使用脚本将此执行的shellcode dump下来之后选择arm64架构进行反编译之后发现还是一段跳板，有跳转到指定地址执行的逻辑，看来是为了防止直接调用系统函数被轻易追踪到而设计。
由函数sub_234E0一路交叉引用上去，其上一层有一段检查dex文件完整性的逻辑。

继续由函数sub_11FA4往上回溯，发现于函数sub_19E0C中出现一段无限循环持续检测设备是否处于ADB调试模式的逻辑，当在 sub_19E0C 函数中检测到ADB调试模式时，会调用sub_17C8C和sub_19A58这两个函数进行进一步的环境验证，如若被检测出来了的话直接走我们刚刚交叉引用上来的闪退逻辑。

继续往上回溯，发现下面第二张图中调用了sub_19E0C，但是调用的方法有点奇怪，是作为v24函数的参数进行使用的，同时该段通过动态解密的操作，使用解密后的第一个字符串作为库名，调用dlopen动态加载该库，使用解密后的第二个字符串作为函数名，调用dlsym获取该函数地址，同时最后获取到的函数使用了sub_1B8D4和sub_19E0C作为参数，sub_19E0C是我们回溯上来的引线。

所以这里要搞懂这个函数中做了一件什么事，就得知道它调用dlsym获取了哪个函数的地址，从而进行使用，使用下列frida的脚本进行hook，同样是在call_constructors处做挂载：

 复制代码 隐藏代码
functionhook_do_dlsym() {
// 1. 获取 linker64 基址
const linker = Process.arch === "arm64" ? "linker64" : "linker";
const base = Module.getBaseAddress(linker);
if (!base) {
console.log("[!] Cannot find linker base.");
return;
    }
// 2. do_dlsym 偏移
const offset = 0x3c5b0;//使用命令readelf -sW /apex/com.android.runtime/bin/linker64 | grep do_dlsym
const do_dlsym_addr = base.add(offset);
// 3. Hook 函数
Interceptor.attach(do_dlsym_addr, {
onEnter(args) {
try {
// args[1] 是符号名 char*
let symPtr = args[1];
let symname = symPtr.readCString();

console.log(`[do_dlsym] symbol = ${symname}`);
            } catch (e) {
console.log("[error] readCString failed:", e);
            }
        }
    });
}
functionhookdoDlopen() {
// 获取libc中的sleep函数
let linker64_base_addr = Module.getBaseAddress('linker64')
let offset = 0x3ba00// __dl__Z9do_dlopenPKciPK17android_dlextinfoPKv
let android_dlopen_ext = linker64_base_addr.add(offset)
Interceptor.attach(android_dlopen_ext, {
onEnter: function(args){
this.name = args[0].readCString()
console.log(`dlopen onEnter ${this.name}`)
      }, onLeave: function(retval){
console.log(`dlopen onLeave name: ${this.name}`)
      }
    })
  }
functionhook_linker_call_constructors() {
let linker64_base_addr = Module.getBaseAddress('linker64')
let offset = 0x52110//此处偏移的获取使用命令: readelf -sW /apex/com.android.runtime/bin/linker64 | grep call_constructors
let call_constructors = linker64_base_addr.add(offset)
let listener = Interceptor.attach(call_constructors,{
onEnter:function(args){
let secmodule = Process.findModuleByName("目标so文件")
if (secmodule != null){
// do something
hookdoDlopen()
hook_do_dlsym()
            }
        }
    })
}

hook_linker_call_constructors();

得到结果如下，很明显那么上面那段函数就是去动态获取了libc.so库中的地址，读取了函数pthread_create的地址，然后创建了两个线程，最后都有执行到闪退函数sub_234E0的逻辑

那么这段逻辑就稍微明了了，sub_1B924中动态解密了库名libc.so和函数名pthread_create，开创了两个检测的线程

对此处几个关键函数进行分析之后可知如下图，其中标红的三个函数中都有开创新线程执行持续扫描一些特征的操作

可以知道创建线程之后执行的函数分别是sub_1B8D4、sub_19E0C、sub_1C544，故而可以直接将几个线程执行的函数直接patch掉，实现绕过，但是是有下列脚本之后还是被杀掉了：

 复制代码 隐藏代码
const patchedOffsets = newSet();
functionnopFunctionEntry(module, offset) {
const addr = module.base.add(offset);
if (patchedOffsets.has(offset)) {
console.log("[nopFunctionEntry] already patched 0x" + offset.toString(16));
return;
    }
try {
Memory.patchCode(addr, 4, code => {
const writer = newArm64Writer(code, { pc: addr });
            writer.putRet();
            writer.flush();
        });
        patchedOffsets.add(offset);
console.log("[nopFunctionEntry] patched 0x" + offset.toString(16));
    } catch (e) {
console.log("[nopFunctionEntry] patch failed 0x" + offset.toString(16) + " -> " + e);
    }
}
functionpatch_target_addr() {
constmodule = Process.findModuleByName("目标so文件.so");
if (!module) return;
nopFunctionEntry(module, 0x1B8D4);
nopFunctionEntry(module, 0x19E0C);        //对应的三个线程执行的函数
nopFunctionEntry(module, 0x1C544);
}

functionhook_linker_call_constructors() {
const linker64_base_addr = Module.getBaseAddress('linker64');
if (!linker64_base_addr) {
console.log("linker64 not found");
return;
    }
const offset = 0x52110;
const call_constructors = linker64_base_addr.add(offset);
Interceptor.attach(call_constructors, {
onEnter: function (args) {
const secmodule = Process.findModuleByName("目标so文件.so");
if (secmodule) {
console.log('hook_linker_call_constructors onEnter 目标so文件');
patch_target_addr();
            }
        }
    });
}

hook_linker_call_constructors();

所以还是有点问题，我们继续分析，发现sub_1B8D4和sub_19E0C两个函数最终都会调用sub_234E0这个函数来实现闪退，那么我们直接patch掉这个函数不就等同于对这两个线程函数检测的bypass了嘛。

然后发现在线程函数sub_1C544中对应执行类似的持续扫描闪退的操作的函数应该是sub_26334数。

有此重大发现之后可以将bypass的脚本更新为如下，如此可以最小程度上的对程序进行修改的同时实现bypass：

 复制代码 隐藏代码
const patchedOffsets = newSet();
functionnopFunctionEntry(module, offset) {
const addr = module.base.add(offset);
if (patchedOffsets.has(offset)) {
console.log("[nopFunctionEntry] already patched 0x" + offset.toString(16));
return;
    }
try {
Memory.patchCode(addr, 4, code => {
const writer = newArm64Writer(code, { pc: addr });
            writer.putRet();
            writer.flush();
        });
        patchedOffsets.add(offset);
console.log("[nopFunctionEntry] patched 0x" + offset.toString(16));
    } catch (e) {
console.log("[nopFunctionEntry] patch failed 0x" + offset.toString(16) + " -> " + e);
    }
}

functionpatch_target_addr() {
constmodule = Process.findModuleByName("目标so文件.so");
if (!module) return;
nopFunctionEntry(module, 0x234E0);//直接造成检测闪退的地址
nopFunctionEntry(module, 0x26334);//直接造成检测闪退的地址
}

functionhook_linker_call_constructors() {
const linker64_base_addr = Module.getBaseAddress('linker64');
if (!linker64_base_addr) {
console.log("linker64 not found");
return;
    }
const offset = 0x52110;
const call_constructors = linker64_base_addr.add(offset);
Interceptor.attach(call_constructors, {
onEnter: function (args) {
const secmodule = Process.findModuleByName("目标so文件.so");
if (secmodule) {
console.log('hook_linker_call_constructors onEnter 目标so文件');
patch_target_addr();
            }
        }
    });
}

hook_linker_call_constructors();

可以成功绕过检测：

本文内容来自网络，如有侵权请联系删除