【逆向分析】落叶思秋（dpt-shell）反脱壳逻辑

岩浆怕

近期，落叶思秋更新了dpt-shell函数抽取壳，导致现在无法正常脱dex
源码github下载
我们来分析一下怎么做到的
Frida 都知道吧？dpt-shell 针对 Frida 设计了专门的检测机制：

1. // 从 dpt_risk.cpp 中提取的关键代码片段
   
2. extern "C" void* detectFridaOnThread(void* arg) {
   
3.     // 无限循环检测，持续监控环境
   
4.     while (1) {
   
5.         // 检测内存中是否存在 frida-agent 字符串
   
6.         if (find_in_maps("frida-agent")) {
   
7.             // 发现 Frida 注入，触发崩溃保护
   
8.             dpt_crash();
   
9.         }
   
10.         
    
11.         // 检测特定的 Frida 线程名
    
12.         if (find_in_threads_list("frida-thread")) {
    
13.             // 发现可疑线程，触发崩溃保护
    
14.             dpt_crash();
    
15.         }
    
16.         
    
17.         // 休眠一段时间后继续检测
    
18.         usleep(100000); // 100ms
    
19.     }
    
20.     return nullptr;
    
21. }

复制代码

这段代码通过两种方式检测 Frida：
扫描进程的内存映射，查找"frida-agent"特征字符串
遍历线程列表，寻找可疑的 Frida 线程名
一旦发现异常，立即调用 dpt_crash() 函数让应用崩溃
反调试
Ptrace 是 Linux 系统上用于进程跟踪和调试的系统调用。dpt-shell 利用了 Ptrace 的特性来防止调试：

1. // doPtrace 函数
   
2. extern "C" void doPtrace() {
   
3.     // 使用 PTRACE_TRACEME 让进程跟踪自身
   
4.     if (ptrace(PTRACE_TRACEME, 0, nullptr, nullptr) == -1) {
   
5.         // 如果 ptrace 失败，说明进程已经被其他调试器附加
   
6.         // 触发崩溃保护
   
7.         dpt_crash();
   
8.     }
   
9.    
   
10.     // 省略
    
11. }

复制代码

这个机制的原理
当一个进程已经被调试器附加时，再次调用 [bPTRACE_TRACEME[/b会失败
DPT 利用这一点来检测是否有调试器正在附加到目标应用
进程保护
通过 fork()创建子进程：

1. // createAntiRiskProcess 函数
   
2. extern "C" void createAntiRiskProcess() {
   
3.     // 创建子进程
   
4.     pid_t pid = fork();
   
5.    
   
6.     if (pid < 0) {
   
7.         // fork 失败，直接退出
   
8.         exit(0);
   
9.     } else if (pid == 0) {
   
10.         // 子进程逻辑
    
11.         // 在子进程中执行 Frida 检测
    
12.         detectFrida();
    
13.         // 使用 ptrace 跟踪父进程
    
14.         doPtrace();
    
15.         
    
16.         // 进入无限循环，持续监控
    
17.         while (1) {
    
18.             sleep(1);
    
19.         }
    
20.     } else {
    
21.         // 父进程逻辑
    
22.         // 父进程也执行 Frida 检测
    
23.         detectFrida();
    
24.         // 保护子进程不被杀死
    
25.         protectChildProcess(pid);
    
26.     }
    
27. }

复制代码

代码完整验证
dpt-shell还实现了代码完整性验证，通过垃圾代码保护机制来防止 DEX 文件被修改：

1. // junkCodeDexProtect 函数
   
2. extern "C" jboolean junkCodeDexProtect(JNIEnv* env, jobject obj, jobject dexFile) {
   
3.     // 获取 DEX 文件相关信息
   
4.     // ...
   
5.    
   
6.     // 验证代码完整性
   
7.     if (!verifyCodeIntegrity(dexFile)) {
   
8.         // 代码被修改，触发崩溃保护
   
9.         dpt_crash();
   
10.         return JNI_FALSE;
    
11.     }
    
12.    
    
13.     return JNI_TRUE;
    
14. }
    

复制代码

junkCodeDexProtect() 函数验证垃圾代码类是否存在
在 patchClass() 函数中实现对垃圾代码类调用模式的检查

1. // DPT_ENCRYPT:
   
2. DPT_ENCRYPT void patchClass(__unused const char* descriptor,  // 类描述符，如"Lcom/example/MyClass;"
   
3.                  const void* dex_file,      // DexFile结构体指针
   
4.                  const void* dex_class_def) // ClassDef结构体指针
   
5. {
   
6. 
   
7.     // 检测：检查是否是恶意调用的垃圾类
   
8.     const char *junkClassName = AY_OBFUSCATE(JUNK_CLASS_FULL_NAME); // AY_OBFUSCATE可能是字符串混淆宏
   
9.     if(descriptor != nullptr && UNLIKELY(dpt_strstr(descriptor, junkClassName) != nullptr)) {
   
10.         size_t descriptorLength = dpt_strlen(descriptor);
    
11.         char ch = descriptor[descriptorLength - 2]; // 获取描述符倒数第二个字符
    
12.         
    
13.         DLOGD("Attempt patch junk class %s ,char is '%c'",descriptor,ch);
    
14.         
    
15.         // 如果字符是数字，说明是恶意调用（正常类名不会以数字结尾）
    
16.         if(isdigit(ch)) {
    
17.             DLOGE("Find illegal call, desc: %s!", descriptor);
    
18.             dpt_crash(); // 触发崩溃，防止分析
    
19.             return;
    
20.         }
    
21.     }
    
22. 
    
23.     // 主要的类修补
    
24.     if(LIKELY(dex_file != nullptr)){
    
25.         std::string location;  // dex文件路径
    
26.         uint8_t *begin = nullptr;  // dex文件内存起始地址
    
27.         uint64_t dexSize = 0;      // dex文件大小
    
28. 
    
29.         // 根据Android SDK版本选择不同的DexFile结构体
    
30.         if(g_sdkLevel >= 35) {
    
31.             // Android 14+ (API 35+)
    
32.             auto* dexFileV35 = (V35::DexFile *)dex_file;
    
33.             location = dexFileV35->location_;
    
34.             begin = (uint8_t *)dexFileV35->begin_;
    
35.             dexSize = dexFileV35->header_->file_size_;
    
36.         }
    
37.         else if(g_sdkLevel >= __ANDROID_API_P__){
    
38.             // Android 9+ (API 28+)
    
39.             auto* dexFileV28 = (V28::DexFile *)dex_file;
    
40.             location = dexFileV28->location_;
    
41.             begin = (uint8_t *)dexFileV28->begin_;
    
42.             dexSize = dexFileV28->size_ == 0 ? dexFileV28->header_->file_size_ : dexFileV28->size_;
    
43.         }
    
44.         else {
    
45.             // Android 5.0-8.1 (API 21-27)
    
46.             auto* dexFileV21 = (V21::DexFile *)dex_file;
    
47.             location = dexFileV21->location_;
    
48.             begin = (uint8_t *)dexFileV21->begin_;
    
49.             dexSize = dexFileV21->size_ == 0 ? dexFileV21->header_->file_size_ : dexFileV21->size_;
    
50.         }
    
51. 
    
52.         // 检查是否是目标dex文件（包含被抽取的函数）
    
53.         if(location.rfind(DEXES_ZIP_NAME) != std::string::npos && dex_class_def){
    
54.             // 从文件路径解析dex索引号
    
55.             int dexIndex = parse_dex_number(&location);
    
56. 
    
57.             auto* class_def = (dex::ClassDef *)dex_class_def;
    
58.             NLOG("class_desc = '%s', class_idx_ = 0x%x, class data off = 0x%x",
    
59.                  descriptor, class_def->class_idx_, class_def->class_data_off_);
    
60. 
    
61.             // 确保类有数据（class_data_off_不为0）
    
62.             if(LIKELY(class_def->class_data_off_ != 0)) {
    
63.                 size_t read = 0;
    
64.                 // 计算类数据在内存中的位置
    
65.                 auto *class_data = (uint8_t *) ((uint8_t *) begin + class_def->class_data_off_);
    
66. 
    
67.                 // 读取类数据头信息（使用ULEB128变长编码）
    
68.                 uint64_t static_fields_size = 0;
    
69.                 read += DexFileUtils::readUleb128(class_data, &static_fields_size);
    
70. 
    
71.                 uint64_t instance_fields_size = 0;
    
72.                 read += DexFileUtils::readUleb128(class_data + read, &instance_fields_size);
    
73. 
    
74.                 uint64_t direct_methods_size = 0;  // 直接方法数
    
75.                 read += DexFileUtils::readUleb128(class_data + read, &direct_methods_size);
    
76. 
    
77.                 uint64_t virtual_methods_size = 0; // 虚方法数
    
78.                 read += DexFileUtils::readUleb128(class_data + read, &virtual_methods_size);
    
79. 
    
80.                 // 跳过字段信息（不需要处理字段）
    
81.                 // staticFields
    
82.                 read += DexFileUtils::getFieldsSize(class_data + read, static_fields_size);
    
83.                 // instanceFields
    
84.                 read += DexFileUtils::getFieldsSize(class_data + read, instance_fields_size);
    
85. 
    
86.                 // 读取直接方法信息
    
87.                 auto *directMethods = new dex::ClassDataMethod[direct_methods_size];
    
88.                 read += DexFileUtils::readMethods(class_data + read, directMethods, direct_methods_size);
    
89. 
    
90.                 // 读取虚方法信息
    
91.                 auto *virtualMethods = new dex::ClassDataMethod[virtual_methods_size];
    
92.                 read += DexFileUtils::readMethods(class_data + read, virtualMethods, virtual_methods_size);
    
93. 
    
94.                 // 修补所有直接方法
    
95.                 for (uint64_t i = 0; i < direct_methods_size; i++) {
    
96.                     auto method = directMethods[i];
    
97.                     patchMethod(begin, location.c_str(), dexSize, dexIndex,
    
98.                                 method.method_idx_delta_, method.code_off_);
    
99.                 }
    
100. 
     
101.                 // 修补所有虚方法
     
102.                 for (uint64_t i = 0; i < virtual_methods_size; i++) {
     
103.                     auto method = virtualMethods[i];
     
104.                     patchMethod(begin, location.c_str(), dexSize, dexIndex,
     
105.                                 method.method_idx_delta_, method.code_off_);
     
106.                 }
     
107. 
     
108.                 // 释放内存
     
109.                 delete[] directMethods;
     
110.                 delete[] virtualMethods;
     
111.             }
     
112.             else {
     
113.                 NLOG("class_def->class_data_off_ is zero"); // 类数据偏移为0（可能是接口或抽象类）
     
114.             }
     
115.         }
     
116.     }
     
117. }
     

复制代码

字符串混淆
字符串混淆，防静态分析：

1. // AY_OBFUSCATE 宏定义，用于混淆关键字符串
   
2. #define AY_OBFUSCATE(str) []() {
   
3.     static const char* s = str;
   
4.     return s;
   
5. }()
   
6. 
   
7. // 示例
   
8. const char* keyword = AY_OBFUSCATE("frida-agent");
   
9. 
   

复制代码

崩溃

实现了一个内联汇编崩溃函数，用于终止程序

1. // dpt_crash 函数在不同架构上的实现
   
2. #ifdef __arm__
   
3. extern "C" void dpt_crash() {
   
4.     // ARM 架构上的实现
   
5.     __asm__ __volatile__("b ."); // 死循环
   
6. }
   
7. #elif defined(__aarch64__)
   
8. extern "C" void dpt_crash() {
   
9.     // ARM64 架构上的实现
   
10.     __asm__ __volatile__("b ."); // 死循环
    
11. }
    
12. #else
    
13. extern "C" void dpt_crash() {
    
14.     // x86 等其他架构
    
15.     *(int*)0 = 0; // 触发段错误
    
16. }
    
17. #endif

复制代码

工作流程
初始化流程：

1. // init_dpt 初始化函数，整个保护系统的入口点
   
2. extern "C" void init_dpt(JNIEnv* env, jclass clazz) {
   
3.     // 解密代码
   
4.     decrypt_section();
   
5.    
   
6.     // 初始化日志
   
7.     init_log();
   
8.    
   
9.     // 安装钩子
   
10.     dpt_hook(env, clazz);
    
11.    
    
12.     // 创建反风险进程
    
13.     createAntiRiskProcess();
    
14.    
    
15.     // ...
    
16. }
    

复制代码

magisk和kernelsu反反脱壳模块开发中.......

若幻

看看

心机

看看

紫浩

看看隐藏

zhao3261

看看隐藏，感谢分享

MW

感谢分享，看看隐藏

一只小蜜蜂

学习一下

困不能寐

感谢分享

夕阳科技

收藏

逗比_滑稽

路过

6a4w

看看

紫檀

看看隐藏

小野猫

看看

一个普通的人

看看隐藏

findkill

谢谢分享！