Writing

学某通风控参数分析 & Frida 绕过(上)

从 Hook dlopen、clone 绕过 Frida 反调试,到还原登录 data 参数背后的设备信息 JSON、RSA-1024 分段加密与 URL-safe Base64 编码。整理转载自看雪论坛 @A0tem 的逆向分析笔记。

· 更新于 2026/9/27 · 30 分钟阅读 · 3,132 字
目录
  1. 一、过 Frida 检测
  2. 1.1 Hook dlopen:监控 so 加载
  3. 1.2 现象:Frida 进程被杀、界面卡死
  4. 1.3 反制:Hook clone,定位反调试线程
  5. 1.4 疑问:args[3].add(96) 的依据是什么?
  6. 二、Android 线程创建全链路分析
  7. 2.1 Android 的三种线程
  8. 2.2 Java 线程创建流程
  9. 2.3 pthread_create 分析
  10. 2.4 补充:Linux 进程管理
  11. 2.5 实战验证:线程函数存在哪个偏移?
  12. 2.6 从 clone 到 __start_thread
  13. 2.7 最终的绕过脚本
  14. 三、抓包
  15. 四、逆向分析:data 参数的加密逻辑
  16. 4.1 定位 SSO 登录触发点
  17. 4.2 data 参数初探
  18. 4.3 Hook Base64,拿到调用栈
  19. 4.4 分析登录入口:g5 → v0
  20. 4.5 定位关键函数:CxDevice.a
  21. 4.6 深入 so 层:IDA + dump 修复
  22. 4.7 getDeviceInfo 逻辑还原
  23. 4.8 JSON 字段分析
  24. 4.9 加密函数分析
  25. 4.10 小结
  26. 参考资料
  27. 转载声明

本文整理转载自看雪论坛 @A0tem 的原创文章(原文 2025-12-11 发布),原帖链接见文末「转载声明」。

加固检测工具识别出目标 APK 使用梆梆企业版加固

一、过 Frida 检测

1.1 Hook dlopen:监控 so 加载

第一步先 hook dlopen,也就是 android_dlopen_ext。

为什么要 Hook dlopen 呢?因为 App 的 Frida 检测代码一般都在 so 层实现,这些检测代码会在对应的 so 加载时初始化——盯住 dlopen,就能掌握每个 so 的加载时机。

function hook_dlopen() {
  var android_dlopen_ext = Module.findExportByName(null, "android_dlopen_ext");
  console.log("addr_android_dlopen_ext", android_dlopen_ext);
  Interceptor.attach(android_dlopen_ext, {
    onEnter: function (args) {
      var pathptr = args[0];
      if (pathptr != null && pathptr != undefined) {
        var path = ptr(pathptr).readCString();
        console.log("android_dlopen_ext:", path);
      }
    },
    onLeave: function (retval) {
    }
  })
}

function main() {
  hook_dlopen()
}

setImmediate(main)

1.2 现象:Frida 进程被杀、界面卡死

运行后 Frida 进程会被杀死,同时手机也会卡死,而且日志里能看到特征 so 已经加载。这是为什么呢?

Frida spawn 启动 App 后打印 android_dlopen_ext 加载日志,随后进程被终止

App 侧的反调试逻辑大致是这样一个循环:

每隔几毫秒检查一次
    ↓
发现了 Frida 的痕迹
    ↓
执行反制措施:卡死界面 + 杀进程

1.3 反制:Hook clone,定位反调试线程

我们的反制措施是 Hook clone 函数。

clone 是 Linux 创建线程的底层系统调用。Hook 住它,就能拿到每个新线程的详细信息:由谁创建、线程函数在哪、什么时候创建的。这样我们就可以定位到反调试线程,然后分析它、干掉它。

function hook_clone() {
    var clone = Module.findExportByName('libc.so', 'clone');
    Interceptor.attach(clone, {
      onEnter: function (args) {
        console.log("═══ Clone Called ═══");
        console.log("args[0] (wrapper):", args[0]);  // __pthread_start
        console.log("args[1] (stack)  :", args[1]);
        console.log("args[2] (flags)  :", args[2]);
        console.log("args[3] (tls)    :", args[3]);  // 线程局部存储(TLS)
        if (args[3] != 0) {
          try {
            // 读取真正的线程函数
            var real_func = args[3].add(96).readPointer();
            var module = Process.findModuleByAddress(real_func);
            if (module) {
              var offset = real_func.sub(module.base);
              console.log(" 真正的线程函数:");
              console.log("   SO名称:", module.name);
              console.log("   函数地址:", real_func);
              console.log("   偏移:", ptr(offset));
              if (module.name.includes("DexHelper")) {
                console.log(" 检测到目标so!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
              }
            }
          } catch(e) {
            console.log("解析失败:", e);
          }
        }
      }
    });
}

setImmediate(hook_clone);

1.4 疑问:args[3].add(96) 的依据是什么?

为什么要在 var real_func = args[3].add(96).readPointer(); 这里读取?

这就需要了解 pthread_internal_t 结构体,也就是 pthread_t——这是 Android Bionic 库中用来管理线程的内部结构。那么这个结构体是什么时候创建的呢?肯定是线程被创建的时候,也就是 pthread_create 函数。下面就从 Android 的线程创建流程说起。

二、Android 线程创建全链路分析

2.1 Android 的三种线程

安卓平台上总共有三种线程:

  1. Java 线程:ART 虚拟机线程,具有运行 Java 代码的 Runtime
  2. Native 线程(只能执行 C/C++):纯粹的 Linux 线程
  3. Native 线程(还能执行 Java):既能执行 C/C++ 代码,也能通过 JNI 执行 Java 代码

2.2 Java 线程创建流程

整体调用链:Thread.start() → nativeCreate(JNI)→ Thread_nativeCreate → Thread::CreateNativeThread → pthread_create → clone。

(1)Java 层:Thread.start()

// /libcore/libart/src/main/java/java/lang/Thread.java
public synchronized void start() {
    checkNotStarted(); // 保证线程只启动一次
    hasBeenStarted = true;
    // 调用 native 方法创建线程
    nativeCreate(this, stackSize, daemon);
}

nativeCreate 是 JNI 方法,对应 C++ 层的 Thread_nativeCreate。

(2)JNI 方法映射

// /art/runtime/native/java_lang_Thread.cc
// 宏定义
#define NATIVE_METHOD(className, functionName, signature) \
    { #functionName, signature, reinterpret_cast<void*>(className ## _ ## functionName) }

// 方法注册
NATIVE_METHOD(Thread, nativeCreate, "(Ljava/lang/Thread;JZ)V"),

宏展开后,nativeCreate 就映射到了 Thread_nativeCreate 函数。

(3)Thread_nativeCreate

// /art/runtime/native/java_lang_Thread.cc
static void Thread_nativeCreate(JNIEnv* env, jclass, jobject java_thread,
                                jlong stack_size, jboolean daemon) {
    // 创建 Native 线程
    Thread::CreateNativeThread(env, java_thread, stack_size, daemon == JNI_TRUE);
}

(4)Thread::CreateNativeThread

// /art/runtime/thread.cc
void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer,
                                size_t stack_size, bool is_daemon) {
    Thread* self = static_cast<JNIEnvExt*>(env)->self;
    Runtime* runtime = Runtime::Current();
    // 1. 创建 ART 的 Thread 对象
    Thread* child_thread = new Thread(is_daemon);
    // 2. 关联 Java 层的 Thread 对象(jpeer)
    child_thread->tlsPtr_.jpeer = env->NewGlobalRef(java_peer);
    // 3. 修正栈大小
    stack_size = FixStackSize(stack_size);
    // 4. 在 Java Thread 对象中设置 native peer 指针
    env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer,
                      reinterpret_cast<jlong>(child_thread));
    // 5. 创建 JNI 环境
    std::unique_ptr<JNIEnvExt> child_jni_env_ext(
        JNIEnvExt::Create(child_thread, Runtime::Current()->GetJavaVM()));
    // 6. 设置线程属性并创建 pthread
    pthread_t new_pthread;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    child_thread->tlsPtr_.tmp_jni_env = child_jni_env_ext.get();
    // 7. 调用 pthread_create 创建线程
    int pthread_create_result = pthread_create(
        &new_pthread,            // 返回线程句柄
        &attr,
        Thread::CreateCallback,  // 线程入口函数
        child_thread             // 传递给线程的参数
    );
    if (pthread_create_result == 0) {
        child_jni_env_ext.release();
        return;
    }
    // 创建失败的处理...
}

CreateNativeThread 主要做了四件事:

  • 创建 ART 虚拟机的 Thread 对象
  • 关联 Java 和 Native 的 Thread 对象(双向引用)
  • 创建 JNI 环境,使线程能够调用 Java 代码
  • 调用 pthread_create 创建真正的操作系统线程

(5)Thread::CreateCallback

// /art/runtime/thread.cc
void* Thread::CreateCallback(void* arg) {
    Thread* self = reinterpret_cast<Thread*>(arg);
    Runtime* runtime = Runtime::Current();
    // 1. 附加到 ART 虚拟机
    self->Init(runtime->GetThreadList(), runtime->GetJavaVM());
    // 2. 初始化线程相关资源
    self->InitCardTable();
    self->InitTid();
    self->InitAfterFork();
    // 3. 调用 Java 层的 run() 方法
    {
        ScopedObjectAccess soa(self);
        self->NotifyThreadBirth();
        // 获取 Thread.run() 方法
        ArtMethod* run_method =
            WellKnownClasses::java_lang_Thread_run->GetArtMethod();
        // 反射调用 run 方法
        JValue result;
        run_method->Invoke(self,
                          reinterpret_cast<uint32_t*>(&self->tlsPtr_.jpeer),
                          sizeof(void*),
                          &result,
                          "V");
    }
    // 4. 线程执行完毕,清理资源
    self->NotifyThreadDeath();
    return nullptr;
}

线程启动后先初始化 ART 虚拟机环境,然后通过反射调用 Java 层的 run() 方法,执行完毕后进行资源清理。

2.3 pthread_create 分析

pthread_create 在 CreateNativeThread 中被调用:

int pthread_create_result = pthread_create(
        &new_pthread,            // 返回线程句柄
        &attr,
        Thread::CreateCallback,  // 线程入口函数
        child_thread             // 传递给线程的参数
    );

pthread_internal_t 结构体源码截图

pthread_create 会先分配一个 pthread_internal_t 结构体:

// 1. 应用层调用
pthread_t thread;
pthread_create(&thread, NULL, my_function, my_arg);

// 2. pthread_create 内部实现
int pthread_create(pthread_t* thread_out,
                  const pthread_attr_t* attr,
                  void* (*start_routine)(void*),
                  void* arg) {
    // 分配并初始化 pthread_internal_t
    pthread_internal_t* thread =
        reinterpret_cast<pthread_internal_t*>(
            calloc(sizeof(pthread_internal_t), 1));
    // 设置关键字段
    thread->start_routine = start_routine;
    thread->start_routine_arg = arg;
    // 分配线程栈
    thread->stack_base = mmap(...);
    thread->stack_size = stack_size;
    // 调用 clone 系统调用
    int flags = CLONE_VM | CLONE_FS | CLONE_FILES |
                CLONE_SIGHAND | CLONE_THREAD |
                CLONE_SYSVSEM | CLONE_SETTLS |
                CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID;
    // 关键:thread 作为 TLS 参数传递给 clone
    int tid = clone(__pthread_start,           // 包装函数
                   thread->stack_top(),        // 栈顶
                   flags,                      // 克隆标志
                   thread,                     // TLS (args[3])
                   &(thread->tid));            // parent_tidptr
    // 将 pthread_internal_t 加入全局链表
    __pthread_internal_add(thread);
    // 返回线程句柄
    *thread_out = reinterpret_cast<pthread_t>(thread);
    return 0;
}

// 3. __pthread_start 包装函数
static int __pthread_start(void* arg) {
    pthread_internal_t* thread =
        reinterpret_cast<pthread_internal_t*>(arg);
    // 设置线程 ID
    thread->tid = gettid();
    // 调用真正的线程函数
    void* result = thread->start_routine(thread->start_routine_arg);
    // 线程退出
    pthread_exit(result);
    return 0;
}

这个结构体是核心数据结构,包含了线程的所有信息。pthread_create 是 pthread 库中的函数,它通过 syscall 再调用到内核的 clone 来请求创建线程。

2.4 补充:Linux 进程管理

Linux 创建进程采用 fork() + exec() 的方式:

  • fork:采用复制当前进程的方式来创建子进程,此时子进程与父进程的区别仅在于 pid、ppid 以及资源统计量(比如挂起的信号)
  • exec:读取可执行文件并载入地址空间执行,一般称之为 exec 函数族,即一系列 exec 开头的函数,比如 execl、execve 等

fork 过程复制的资源包括代码段、数据段、堆、栈。fork 的调用者所在进程便是父进程,新创建的进程便是子进程;fork 调用结束后从内核返回两次,一次继续执行父进程,一次进入子进程。

Linux 下的三种创建方式:

  • 进程创建:通过 fork() 系统调用创建进程
  • 用户级线程创建:通过 pthread 库中的 pthread_create() 创建线程
  • 内核线程创建:通过 kthread_create()

Linux 线程并非“轻量级进程”——在 Linux 看来,线程是一种进程间共享资源的方式,线程可看做是与其他进程共享资源的进程。

fork、vfork、clone 根据不同参数调用 do_fork:

  • pthread_create:flags 参数为 CLONE_VM、CLONE_FS、CLONE_FILES、CLONE_SIGHAND
  • fork:flags 参数为 SIGCHLD
  • vfork:flags 参数为 CLONE_VFORK、CLONE_VM、SIGCHLD

fork 流程图

进程/线程创建的方法 fork()、pthread_create(),最终在 Linux 都是调用 do_fork 方法。当然还有 vfork 其实也是一样的,通过系统调用到 sys_vfork,然后再调用 do_fork 方法,该方法现在很少使用,所以下图省略该方法。

fork 执行流程图

fork 执行流程:

  1. 用户空间调用 fork() 方法
  2. 经过 syscall 陷入内核空间,内核根据系统调用号找到相应的 sys_fork 系统调用
  3. sys_fork() 会调用 do_fork(),该方法参数中有一个 flags 很重要,代表的是父子进程之间需要共享的资源;对于进程创建 flags=SIGCHLD,即当子进程退出时向父进程发送 SIGCHLD 信号
  4. do_fork() 会进行一些 check 过程,之后便进入核心方法 copy_process

flags 参数

进程与线程最大的区别在于资源是否共享。线程间共享的资源主要包括内存地址空间、文件系统、已打开文件、信号等信息,如下图蓝色部分的 flags 便是线程创建过程所必需的参数。

进程与线程创建所需 flags 参数示意

fork 采用 Copy on Write 机制,父子进程共用同一块内存,只有当父进程或者子进程执行写操作时会拷贝一份新内存。另外,创建进程也是有可能失败的,比如进程个数达到系统上限(32768)或者系统可用内存不足。

Android 源码中线程创建相关代码截图

在安卓源码中对应的内容如上图所示。

2.5 实战验证:线程函数存在哪个偏移?

现在回到最初的问题:pthread_internal_t 结构体中,到底在哪里存储了线程函数?

先从设备上把 libc 拉下来:

adb pull /system/lib64/libc.so ./libc64.so

adb pull 拉取 libc.so 后在 IDA 中打开

在 IDA 中搜索 pthread_create——别忘了,我们关心的正是它的第三个参数(线程入口函数):

int pthread_create_result = pthread_create(
        &new_pthread,            // 返回线程句柄
        &attr,
        Thread::CreateCallback,  // 线程入口函数
        child_thread             // 传递给线程的参数
    );

在 IDA 中搜索 pthread_create

向下追踪,发现第三个参数 a3 的值被赋给了 v54:

反编译代码中第三个参数 a3 被赋值给 v54

所以偏移 0x60(十进制 96)处存放的就是线程函数指针——这正好印证了前面 hook clone 时 args[3].add(96) 的写法:

struct pthread_internal_t {
    void* next;                      // 0x00 - 链表指针
    void* prev;                      // 0x08 - 链表指针
    pid_t tid;                       // 0x10 - 线程 ID
    pid_t cached_pid;                // 0x14 - 缓存的进程 ID
    // ... 省略一些字段 ...
    void* (*start_routine)(void*);   // 0x60 (96) - 线程入口函数(更正!)
    void* start_routine_arg;         // 0x68 (104) - 传递给线程函数的参数
    // ... 其他字段 ...
    pthread_mutex_t startup_mutex;   // 0x88 - 启动互斥锁
    bool startup_flag;               // 0x8C - 启动标志
    void* mmap_base;                 // 0x90 (144) - mmap 分配的基地址
    size_t mmap_size;                // 0x98 (152) - mmap 分配的大小
};  // 总大小:704 字节 (0x2C0)

2.6 从 clone 到 __start_thread

我们再进入 clone 函数:

clone 函数的包装器反编译代码

这个函数只是 clone 系统调用的包装器,真正的 clone 实现在这里:

真正的 clone 实现的反编译代码

如果返回值没问题,就调用 __start_thread:

__start_thread 中初始化 tid 并调用线程函数

在 __start_thread 中,会初始化 tid、调用线程函数,线程函数执行完就退出线程。因此我们通过 hook clone 即可拦截线程!

hook clone 后定位到 libDexHelper.so 中的反调试线程函数并打印偏移

2.7 最终的绕过脚本

思路:轮询等待目标 so 加载,拿到基址后,把分析得到的反调试函数逐个替换/拦截掉:

console.log("启动反调试绕过...");

var anti_debug_offsets = [
    // 文中分析得到的反调试函数偏移
];

function waitForModule() {
    var module = Process.findModuleByName("libDexHelper.so");
    if (module) {
        console.log("找到 libDexHelper.so 基址:", module.base);
        hookAntidebugFunctions(module.base);
    } else {
        console.log("等待 libDexHelper.so 加载...");
        setTimeout(waitForModule, 100);
    }
}

function hookAntidebugFunctions(base) {
    console.log("开始Hook反调试函数");
    var dummy_func = new NativeCallback(function(arg) {
        return 0;
    }, 'int', ['pointer']);

    anti_debug_offsets.forEach(function(offset, index) {
        var func_addr = base.add(offset);
        var hook_num = index + 1;
        console.log("Hook 函数 #" + hook_num + " 偏移:" + ptr(offset) + " 地址:" + func_addr);
        try {
            Interceptor.replace(func_addr, dummy_func);
            console.log("replace 替换成功");
        } catch(e1) {
            console.log("replace 失败,尝试 attach");
            try {
                Interceptor.attach(func_addr, {
                    onEnter: function(args) {
                        console.log("函数 #" + hook_num + " 被调用");
                        for (var i = 0; i < 8; i++) {
                            try {
                                args[i] = ptr(0);
                            } catch(e) {}
                        }
                    },
                    onLeave: function(retval) {
                        retval.replace(0);
                        console.log("返回值已改为0");
                    }
                });
                console.log("attach 拦截成功");
            } catch(e2) {
                console.log("attach 也失败:", e2.message);
            }
        }
    });
    console.log("所有函数Hook完成");
}

setTimeout(waitForModule, 500);

绕过脚本运行输出,四个反调试函数 replace 替换成功

另一个 so 也是相同的思路。

三、抓包

抓到的登录请求如下,data 参数是一大坨密文(第四部分重点分析它):

POST /apis/login/userLogin4Uname.do HTTP/1.1
User-Agent: Dalvik/2.1.0 (Linux; U; Android 10; Pixel 2 XL Build/QQ1A.191205.008) (schild:57e5cafb263d51fa7248f3c0ddcd93df) (device:Pixel 2 XL) Language/zh_CN_#Hans com.chaoxing.mobile/ChaoXingStudy_3_6.6.2_android_phone_10899_284 (@Kalimdor)_c713c8b5b4e24af4840ab6f1e44f6d6f
Accept-Language: zh_CN_#Hans
Content-Type: application/x-www-form-urlencoded
Content-Length: 741
Host: sso.chaoxing.com
Connection: Keep-Alive
Accept-Encoding: gzip
Cookie: fid=2785; _uid=297297071; _d=1760100738594; UID=297297071; vc3=Fk0zNvzdTe7%2BImSyEY%2BrftMrODXhTGfcFw3jxnljlduWgE5r8C0T5l8RYcOtv2RTydE2YMpSk%2FVOcFxUQu7neeNgPtUCQk7kK%2FojgewJg%2FZspamGvH5IwrE1jCexIBk8nVUKzescpiHIeBDqs9HHQQRDpoxE%2FgZmfdwBZ%2Ftvhs8%3Ddce0239082c19383c39d82cbf88df9af; uf=da0883eb5260151ec216b0d5ab4175f9f265e8f2d553141c7a06e39f91d78f9c6ab9b6f1074af198d088e79d3a8ff638a29d455a3bc484c1d807a544f7930b6aed1e6c11a143bb563b0339d97cdac4bab9fe7be6fa3211cd713028f1ec42bf71b1188854805578cc30efcb9395a6b42b9afeb38e675e28e312b47e51bb3d048117261b5a50f9432f0a0c3d0aedbb4bb14df7ff280fcb29d10d8a4c92b12beb4b9d97dfe5b26c691ce0022f71b6d9d4406250480410be0c44e7fafd565af53bf2; cx_p_token=af5660cce0baef49887ca0251893b508; p_auth_token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1aWQiOiIyOTcyOTcwNzEiLCJsb2dpblRpbWUiOjE3NjAxMDA3Mzg1OTYsImV4cCI6MTc2MDcwNTUzOH0.9TZcMPS1EjZdWKlNQ16MKaHN4pbe-drjpQZVSNw1kyM; xxtenc=55bd60e138e7351ede494fa388333930; DSSTASH_LOG=C_38-UN_1605-US_297297071-T_1760100738596

data=dshPLdgyOIBbdl0IOKx8rUlqOvtaCbUwO9yREsDb1HUICzSS%2FCPXlf86RK4hvVtSphjzNXiNUYPndvV9nnEAPdI%2B1nVqNHveTucKYJ34P%2F3fJ%2Fr0L5LMv2pQ2YrAtcexu5PPo2TfcOp%2FLe6msVfifZD9geolVYsfn3Ia%2Fu%2B2F5pF7hfFmbUllumZoYop5mSOHGTkRFX8puf4jUwBFbts1cI1TSYCv8DRuNOggFH3IYePBU5cHY4z%2BlFThw6%2F%2FL9oxs%2Bj0m9ajdK8hw2gJ62QByOJ2jMXyZZwLWm%2BBfaQdSxXRLxTuh3Qd27ZKVggKox4IFSucQoBgGDsttTQX0%2FIRn%2BEHAedMAQ1mCrt76WYz1FfWgBQENzLpp9QtKkotn9QgED4J3oMFJcU%2BdVrUlemkMMIIGV2VkpSbSHg6YBYeINSKS0VJEZXcodHnpiUhljadQJkC5dQnDH8rvrIPEmUD%2F2Nrf8NL61iGwK8mmSSVVDbM0CkAivVRMAlKjOmwyUFKOdF0QxsvYhGVQ0%2BNq%2BcmoSyeEADMIr2%2FQk2MThT1c69I%2FshWy7f05ZhBjBP08gCZDvSciMi2rrl%2FzJt9%2BnyOrqA4QdMXNpnNSly8ejZ4QBzDus8YWHz1%2FZ6DrtuhAMJuwqBIlh%2B23lKJsbmIfMiBFAynf20Is%2FrjhyfWflVFdc%3D

完整登录流程:

1. 发送验证码
   POST /api/sendcaptcha
   ↓
2. 验证码登录
   POST /v11/loginregister  ← 第一个请求
   ↓
3. SSO 登录
   POST /apis/login/userLogin4Uname.do  ← 第二个请求
   ↓
4. 登录成功

四、逆向分析:data 参数的加密逻辑

4.1 定位 SSO 登录触发点

JADX 中定位到 SSO 登录调用点

第一个方法是直接的 SSO 调用:

public final void y5() {
    AccountManager.E().K0("https://sso.chaoxing.com/apis/login/userLogin4Uname.do", 3);
    new Handler().postDelayed(new c(), 150L);
}

第二个方法是 SSO 登录的触发条件(在登录成功的回调里触发):

public void onChanged(@Nullable be.b<ResponseResult> response) {
        if (response.g()) {
            ResponseResult responseResult = response.f4061c;
            if (responseResult != null && responseResult.getResult() == 1) {
                AccountManager.E().K0("https://sso.chaoxing.com/apis/login/userLogin4Uname.do", 3);
                List list = (List) UnitListActivity.this.f54133f.getValue();
                if (list.contains(this.f54144a)) {
                    list.remove(this.f54144a);
                    list.add(0, this.f54144a);
                    UnitListActivity.this.f54134g.notifyDataSetChanged();
                    UnitListActivity.this.f54133f.setValue(list);
                }
                UnitListActivity.this.f54138k = true;
                return;
            }
            return;
        }
        response.d();
    }
}

SSO 登录触发条件相关的代码截图

4.2 data 参数初探

data 参数长度为 512,初步猜测是加密数据(AES)。(注:后面分析会发现其实是 RSA,这里只是当时的初步猜测。)

现在我们还没有定位到关键代码,因为 data 被 Base64 编码了,这时候考虑 hook 一下 Base64。

4.3 Hook Base64,拿到调用栈

[+] Call Details:
    - Flags: 2 (Base64 flags)
    - Thread: main
    - Time: 2025-10-11T12:31:27.655Z
[CALL] com.chaoxing.android.crypto.Ciphertext.getBytes_Base64
[CALL] com.chaoxing.study.account.e.e
[CALL] com.chaoxing.study.account.AccountManager.p0
[CALL] com.chaoxing.study.account.AccountManager.w0
[CALL] com.chaoxing.study.account.AccountManager.v0
[CALL] com.chaoxing.mobile.study.account.LoginByCodeActivity.g5
[CALL] com.chaoxing.mobile.study.account.LoginByCodeActivity.a5
[CALL] com.chaoxing.mobile.study.account.LoginByCodeActivity$j.onClick

调用栈自下而上读:onClick → a5 → g5 → AccountManager.v0 → w0 → p0 → e.e → Ciphertext.getBytes_Base64。

4.4 分析登录入口:g5 → v0

先看 g5:

/* JADX INFO: Access modifiers changed from: private */
public void g5() {
    EditText editText;
    String strTrim = this.f73287c.getText().toString().trim();
    String string = this.f73289e.getText().toString();
    boolean z11 = true;
    if (ge.f.c(strTrim)) {
        com.chaoxing.android.widget.a.j(this, R.string.string_account_enter_phone_number).s();
        editText = this.f73287c;
    } else if (ge.f.c(string)) {
        com.chaoxing.android.widget.a.j(this, R.string.string_account_enter_verification_code).s();
        editText = this.f73289e;
    } else {
        z11 = false;
        editText = null;
    }
    if (z11) {
        if (editText != null) {
            editText.requestFocus();
        }
    } else {
        com.chaoxing.library.helper.a.a(getCurrentFocus());
        if (this.f73295k.e()) {
            AccountManager.E().v0(this, strTrim, this.f73297m, string, this.f73306v);
        } else {
            n5();
        }
    }
}

Hook 一下 AccountManager.E().v0(this, strTrim, this.f73297m, string, this.f73306v);,看看参数都是什么:

============================================================
 参数详情:
    参数1 (this/owner): [object Object]
    参数2 (strTrim/手机号): '1755038xxxx'
    参数3 (f73297m/国家代码): '86'
    参数4 (string/验证码): '296613'
    参数5 (f73306v/回调): [object Object]

继续跟踪代码:

继续跟踪 AccountManager.v0 的实现(一)

继续跟踪 AccountManager.v0 的实现(二)

发现关键代码,hook 一下这个方法并打印调用栈,发现:

  • com.chaoxing.study.account.b(接口)
  • com.chaoxing.study.account.d0(实现类)

Hook 关键方法后打印的调用栈

接口 com.chaoxing.study.account.b 与实现类 d0

实现类 d0 中的加密调用代码

4.5 定位关键函数:CxDevice.a

/**
 * Hook CxDevice.a方法打印返回值
 */
Java.perform(function() {
    try {
        var CxDevice = Java.use("com.chaoxing.securitylib.napi.CxDevice");
        CxDevice.a.overload('android.content.Context', 'java.lang.String').implementation = function(context, str) {
            var result = this.a(context, str);
            console.log("CxDevice.a返回值: " + result);
            return result;
        };
        console.log("[+] Hook设置完成");
    } catch (e) {
        console.log("[-] Hook失败: " + e.message);
    }
});

输出为:

[Pixel 2 XL::com.chaoxing.mobile ]-> [+] Hook设置完成
[+] Hook设置完成
[+] Hook设置完成
CxDevice.a返回值: Tzkdtre+wwVXQLY/YcO+A6r9TLryLQV5ru0KoIlIuec9ehtd6JnTzoyJKAuh998iff8MVj+l+uA1/R6ZkF2hJvwd9KSjvYBqf8SBaE4rMcPtpYnUIcyqUlwzJQVdIX/jGVI+KTyaaJAO5UI8NI7P3Ott0/Kj8xW1UJmTxpzWhcqUwVFHQzZxkYExEd1G/O83whsKk1Kntw8E0MObLdiVy5Dz5KBMhV3E0HWmmLfVeNJKjNnggsQVQ4PMx9VnbPQMYmlYO0ovZ4dgjKTGsZSfbMS+zMoPVgS39kYvdDTItZFq2mbI50XJdYq88qxgj/2ewIYIuQJMT/hB6yU6L712JXKwKmcQsPBXXskVeC64VTwLYXYwW0kbKXHIjIp8txR4ImQWR8V5uJNF4PzwERBi1Q+FHQb50EgXoK1xHhlt/5kjtHfWolJ109kJomUntb6NudHgg83FF4+CFTYnYV/YUw2ZcvmYQyVolE/EHkfLtBsg+3wgrod6WC/RHVZGLSftXOyCqR4ZXOYyE40WB5QjRVAK0tqEPmOV7tjmAdGOWUnm2egthNkJtfVEKbx1zEatlaTAMqNc/6r6O1B4i8m0KFB7MeHtPhCBiZs1AXAO1ysXeHlIqlgTfZJ2ksJ53Mkm8SSNP2ACbMWRaqpTcCcuKdBkhRz3homkprZzmL6RXDI=

到这里,需要去分析 so 层了,使用 IDA。

4.6 深入 so 层:IDA + dump 修复

IDA 中打开目标 so 的函数列表

根据函数的参数调用可以简单分析逻辑,但是因为有混淆不能直接分析:

getDeviceInfo 因混淆导致控制流复杂

我们随便以几个函数为例子,点开第一个函数 sub_4E1C0(v37, &v87); 会发现:

sub_4E1C0 的函数体

跟进:

跟进 sub_4E1C0 后的下一层调用

再跟:

继续跟进后的更深层函数

每个函数都是这样层层跳转。先尝试了一下 inline hook,发现这些函数最终都会指向同一个地方:

inline hook 发现各函数最终都指向同一个函数

也就是这个函数,发现有点复杂。一个思路是 hook 偏移,来打印指定地址的函数调用的 X17 寄存器;不如直接 dump so,在 dump 后使用 sofix 修复即可。

4.7 getDeviceInfo 逻辑还原

__int64 __fastcall Java_com_chaoxing_securitylib_napi_CxDevice_getDeviceInfo(
        JNIEnv *env,
        jclass clazz,
        jobject context,
        jstring str,
        jstring str2,
        jstring str3)
{
  StatusReg = _ReadStatusReg(TPIDR_EL0);
  v103 = *(_QWORD *)(StatusReg + 40);
  v84 = 0;
  v85 = 0;
  v86 = 0;
  v81 = 0;
  v82 = 0;
  v83 = 0;
  v79[0] = 0;
  v79[1] = 0;
  v80 = 0;
  if ( str )
  {
    v12 = (*env)->GetStringUTFChars(env, str, 0);
    v13 = sub_4DFA0();
    sub_4C800(&v84, v12, v13);
    (*env)->ReleaseStringUTFChars(env, str, v12);
  }
  if ( str2 )
  {
    v14 = (*env)->GetStringUTFChars(env, str2, 0);
    v15 = sub_4DFA0();
    sub_4C800(&v81, v14, v15);
    (*env)->ReleaseStringUTFChars(env, str2, v14);
  }
  if ( str3 )
  {
    v16 = (*env)->GetStringUTFChars(env, str3, 0);
    v17 = sub_4DFA0();
    sub_4C800(v79, v16, v17);
    (*env)->ReleaseStringUTFChars(env, str3, v16);
  }
  *(_QWORD *)&v77[7] = 0;
  v76 = 14;
  v78 = 0;
  strcpy(v77, "android");
  sub_4D0B0(v91, env, context);
  sub_4CC20("ro.product.model", v102);
  sub_4CC20("ro.product.brand", v101);
  sub_4CC20("ro.build.version.codename", v100);
  sub_4CC20("ro.build.version.release", v99);
  sub_4CC20("ro.product.locale.language", v98);
  sub_4CC20("ro.product.cpu.abilist", v97);
  sub_4CC20("ro.hardware", v96);
  sub_4CC20("ro.product.board", v95);
  sub_4BDA0(v72, env, context);
  v69 = 0;
  v70 = 0;
  v71 = 0;
  sub_4DDE0(v90, 0);
  sub_4BC40(&v87, &v76);
  v18 = sub_4C940(v90, "platform");
  sub_4E1C0(v18, &v87);
  sub_4CCE0(&v87);
  sub_4BC40(&v87, v91);
  v19 = sub_4C940(v90, "app_name");
  sub_4E1C0(v19, &v87);
  sub_4CCE0(&v87);
  sub_4BC40(&v87, v93);
  v20 = sub_4C940(v90, "app_ver");
  sub_4E1C0(v20, &v87);
  sub_4CCE0(&v87);
  sub_4BC40(&v87, &v69);
  v21 = sub_4C940(v90, "mediaDrmId");
  sub_4E1C0(v21, &v87);
  sub_4CCE0(&v87);
  sub_4D610(&v87, v102);
  v22 = sub_4C940(v90, "cdtype");
  sub_4E1C0(v22, &v87);
  sub_4CCE0(&v87);
  sub_4D610(&v87, v100);
  v23 = sub_4C940(v90, "os_name");
  sub_4E1C0(v23, &v87);
  sub_4CCE0(&v87);
  sub_4D610(&v87, v99);
  v24 = sub_4C940(v90, "os_ver");
  sub_4E1C0(v24, &v87);
  sub_4CCE0(&v87);
  sub_4D610(&v87, v98);
  v25 = sub_4C940(v90, "os_lang");
  sub_4E1C0(v25, &v87);
  sub_4CCE0(&v87);
  sub_4D610(&v87, v97);
  v26 = sub_4C940(v90, "cpu_ar");
  sub_4E1C0(v26, &v87);
  sub_4CCE0(&v87);
  sub_4BC40(&v87, v72);
  v27 = sub_4C940(v90, "resolution");
  sub_4E1C0(v27, &v87);
  sub_4CCE0(&v87);
  sub_4D610(&v87, v101);
  v28 = sub_4C940(v90, "brand");
  sub_4E1C0(v28, &v87);
  sub_4CCE0(&v87);
  sub_4D610(&v87, v96);
  v29 = sub_4C940(v90, "hardware");
  sub_4E1C0(v29, &v87);
  sub_4CCE0(&v87);
  sub_4D610(&v87, v95);
  v30 = sub_4C940(v90, "board");
  sub_4E1C0(v30, &v87);
  sub_4CCE0(&v87);
  sub_4BC40(&v87, v74);
  v31 = sub_4C940(v90, "dpi");
  sub_4E1C0(v31, &v87);
  sub_4CCE0(&v87);
  sub_4BC40(&v87, &v84);
  v32 = sub_4C940(v90, "device_id");
  sub_4E1C0(v32, &v87);
  sub_4CCE0(&v87);
  sub_4BC40(&v87, v79);
  v33 = sub_4C940(v90, "oaid");
  sub_4E1C0(v33, &v87);
  sub_4CCE0(&v87);
  v67[0] = 0;
  v67[1] = 0;
  v68 = 0;
  if ( (v81 & 1) != 0 )
    v34 = v82;
  else
    v34 = (unsigned __int64)(unsigned __int8)v81 >> 1;
  if ( v34 )
  {
    if ( (v81 & 1) != 0 )
      v35 = (char *)v83;
    else
      v35 = (char *)&v81 + 1;
  }
  else
  {
    if ( (v69 & 1) != 0 )
      v34 = v70;
    else
      v34 = (unsigned __int64)(unsigned __int8)v69 >> 1;
    if ( v34 )
    {
      if ( (v69 & 1) != 0 )
        v35 = (char *)v71;
      else
        v35 = (char *)&v69 + 1;
    }
    else
    {
      if ( (v84 & 1) != 0 )
        v35 = (char *)v86;
      else
        v35 = (char *)&v84 + 1;
      if ( (v84 & 1) != 0 )
        v34 = v85;
      else
        v34 = (unsigned __int64)(unsigned __int8)v84 >> 1;
    }
  }
  sub_4C800(v67, v35, v34);
  sub_4BC40(&v87, v67);
  v36 = sub_4C940(v90, "cdid");
  sub_4E1C0(v36, &v87);
  sub_4CCE0(&v87);
  v65 = 0;
  v66 = 0;
  sub_4D1B0(&v65, 0);
  sub_4BE00(&v87, v66 / 1000 + 1000 * v65);
  v37 = sub_4C940(v90, "time_stamp");
  sub_4E1C0(v37, &v87);
  sub_4CCE0(&v87);
  sub_4D850(&v87);
  sub_4C5D0(&v63, &v87, v90);   // 关键加密调用:v87 包含所有设备信息,v90 是加密参数
  v61 = 0u;

因为篇幅问题,部分代码省略。

解密后可以知道,输入都被封装进了 JSON 里面。通过 hook 每次往 JSON 写入字段的函数发现:

4.8 JSON 字段分析

第一次:
返回值JSON字符串: {"app_name":"com.chaoxing.mobile","app_ver":"6.6.2","board":"taimen","brand":"google","cdid":"c713c8b5b4e24af4840ab6f1e44f6d6f","cdtype":"Pixel 2 XL","cpu_ar":"arm64-v8a,armeabi-v7a,armeabi","device_id":"c713c8b5b4e24af4840ab6f1e44f6d6f","dpi":"560","hardware":"taimen","mediaDrmId":"","oaid":"1004","os_lang":"","os_name":"REL","os_ver":"10","platform":"android","resolution":"1440*2712","time_stamp":1760434775772}

第二次:
返回值JSON字符串: {"app_name":"com.chaoxing.mobile","app_ver":"6.6.2","board":"taimen","brand":"google","cdid":"c713c8b5b4e24af4840ab6f1e44f6d6f","cdtype":"Pixel 2 XL","cpu_ar":"arm64-v8a,armeabi-v7a,armeabi","device_id":"c713c8b5b4e24af4840ab6f1e44f6d6f","dpi":"560","hardware":"taimen","mediaDrmId":"","oaid":"1004","os_lang":"","os_name":"REL","os_ver":"10","platform":"android","resolution":"1440*2712","time_stamp":1760434938312}

可以发现 JSON 内容只有一个字段会变,就是时间戳 time_stamp。

4.9 加密函数分析

先分析一下加密函数。

(1)设备信息采集

采集应用版本信息的函数:PackageManager 与 PackageInfo

这个函数会获取 PackageManager、应用包名、PackageInfo,并从 PackageInfo 提取:

  • versionName(版本名称)
  • versionCode(版本号)

获取屏幕分辨率与 DPI 的函数

这个函数会获取屏幕的宽度、高度、DPI,并格式化为“宽度 * 高度”的分辨率字符串以及 DPI 值。

定位 rsa_util 加密函数的调用位置

(2)公钥格式化:format_public_key

rsa_util::format_public_key 的反编译代码

函数内写死了一串公钥:

-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC79d8Ot0hCbxxSISC6x8SCwTBspFSzlLKHJUYqoFNu1TSRaw4hEYkOnvEaL1VyoxV6HXcDrzwYvaFZaZaPQPFnfCHZy5dQwxcmifgSHqS+oKXw40Ys4cVIqnU5d90S7EWSRdBglX489jlqVaNcQSkDx2TYmC+DbAq9FV/BU09ISQIDAQAB
-----END PUBLIC KEY-----

这个函数就是处理前面那串公钥的:

strcpy(v65->__size, "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC79d8Ot0hCbxxSISC6x8SCwTBspFSzlLKHJUYqoFNu1TSRaw4hEYkOnvEaL1VyoxV6HXcDrzwYvaFZaZaPQPFnfCHZy5dQwxcmifgSHqS+oKXw40Ys4cVIqnU5d90S7EWSRdBglX489jlqVaNcQSkDx2TYmC+DbAq9FV/BU09ISQIDAQAB");
rsa_util::format_public_key(v76, &v74);
  1. strcpy 将原始 Base64 公钥数据复制到内存,每 64 个字符插入换行符
  2. rsa_util::format_public_key 将其格式化为完整的 PEM 格式

(3)加密:rsa_util::public_key_encrypt

再分析 rsa_util::public_key_encrypt(v73, v76, &v77);:

rsa_util::public_key_encrypt 的反编译代码

先解析传入的公钥格式,获取密钥的大小——1024 位,即 RSA-1024(对应 128 字节)。对于 1024 位 RSA:max_block_size = 128 - 11 = 117 字节。计算最大加密块大小时的 v17 = v9 - 11,这个减 11 正是 PKCS#1 v1.5(RSA_PKCS1_PADDING = 1)的标志性特征!

完整加密块格式 (128字节,对于1024位RSA):
┌────────┬────────┬────────────────────┬────────┬──────────────┐
│ 0x00   │ 0x02   │   PS (随机非零)     │ 0x00   │   数据       │
│ 1字节  │ 1字节  │   至少8字节         │ 1字节  │ 最多117字节  │
└────────┴────────┴────────────────────┴────────┴──────────────┘
        固定       随机填充              分隔符    实际明文
总计: 1 + 1 + 8 + 1 = 11字节开销

填充方式为 PKCS#1 v1.5。

while 循环逐块加密的逻辑

使用 while 循环来逐块加密,每块最多 117 字节。其中的 syslog 函数根据参数来分析就是调用 SSL 的加密库,点击验证后显示是调用的外部函数,和我们猜测一样。

剩下的就是 Base64 编码了:

Base64 编码使用的自定义码表

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_

注意码表最后是 -_ 而不是 +/,即 URL-safe Base64(RFC 4648 §5)。

4.10 小结

这样就完成了 data 参数的分析:

设备信息 JSON(app_name、brand、cdid、resolution、time_stamp...,两次调用间只有 time_stamp 变化)
    ↓
rsa_util::public_key_encrypt:RSA-1024,PKCS#1 v1.5 填充,117 字节分块加密
    ↓
URL-safe Base64 编码
    ↓
data 参数

复现脚本输出:RSA 分段加密设备信息并发送 SSO 登录请求成功

参考资料

转载声明

本文整理转载自看雪论坛,版权归原作者 看雪 @A0tem 所有,原文于 2025-12-11 发布:

转载说明:本站收录时对原文做了排版整理——代码块还原为可复制的代码、统一标题层级、修正少量笔误;文中图片来自原帖,版权归原作者所有。内容仅用于学习交流,如有侵权请联系删除。

相关文章

某论坛类软件的 Frida 检测绕过

从 RSA 登录加密算法逆向到 libmsaoaidsec.so 检测绕过:_init 状态机里的 10 条检测通道(线程 state、maps、fd、cmdline、linker 完整性等)、_exit(0) + SIGSEGV 双自杀机制,以及「静态补丁重签名不可行、root 替换 .so 保原签名可行」的绕过结论。