• [原创]dpt-shell源码详细解析（v1.11.3）

dpt-shell源码详细解析（v1.11.3）

前言

dpt-shell自22年以来进行了不少的调整，本文试对v1.11.3版的dpt-shell进行源码分析，补充作者在HowItWorks中未撰写出来的部分并作积累。

简而言之，dpt-shell可以分为两个模块，一个是Processeor模块，用于对原app进行指令抽空并构建新app；另一个是shell模块，用于在app运行时回填指令，顺利执行app的代码。以下是对这两个模块的详细分析

Processeor模块分析

入口点在src\main\java\com\luoye\dpt\Dpt.java，解析用户的运行参数后进入apk.protect()进行抽取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
private static void process(Apk apk){
    if(!new File("shell-files").exists()) {
        LogUtils.error("Cannot find shell files!");
        return;
    }
    File apkFile = new File(apk.getFilePath());
 
    if(!apkFile.exists()){
        LogUtils.error("Apk not exists!");
        return;
    }
 
    //apk extract path
    String apkMainProcessPath = apk.getWorkspaceDir().getAbsolutePath();
 
    LogUtils.info("Apk main process path: " + apkMainProcessPath);
 
    ZipUtils.unZip(apk.getFilePath(),apkMainProcessPath);
    String packageName = ManifestUtils.getPackageName(apkMainProcessPath + File.separator + "AndroidManifest.xml");
    apk.setPackageName(packageName);
    // 1. 指令抽空
    apk.extractDexCode(apkMainProcessPath);
    //  2. AMF的处理
    apk.saveApplicationName(apkMainProcessPath);    // 保存原始ApplicationName到assets/app_name
    apk.writeProxyAppName(apkMainProcessPath);  // 写入代理ApplicationName
    if(apk.isAppComponentFactory()){
        apk.saveAppComponentFactory(apkMainProcessPath);    // 保存原始AppComponentFactory到assets/app_acf
        apk.writeProxyComponentFactoryName(apkMainProcessPath); // 写入代理AppComponentFactory
    }
    if(apk.isDebuggable()) {
        LogUtils.info("Make apk debuggable.");
        apk.setDebuggable(apkMainProcessPath, true);
    }
 
    apk.setExtractNativeLibs(apkMainProcessPath);
    apk.addJunkCodeDex(apkMainProcessPath);
    // 3. 压缩源dex到新的路径并删除旧的路径
    apk.compressDexFiles(apkMainProcessPath);   // 源dex压缩存放到assets/i11111i111.zip
    apk.deleteAllDexFiles(apkMainProcessPath);
    // 4. 合并壳dex和原dex
    apk.combineDexZipWithShellDex(apkMainProcessPath);
    // 5. 复制壳的so文件，加密so文件
    apk.copyNativeLibs(apkMainProcessPath); // 复制壳的so文件
    apk.encryptSoFiles(apkMainProcessPath);
 
    // 6. 构建apk
    apk.buildApk(apkFile.getAbsolutePath(),apkMainProcessPath, FileUtils.getExecutablePath());
 
    File apkMainProcessFile = new File(apkMainProcessPath);
    if (apkMainProcessFile.exists()) {
        FileUtils.deleteRecurse(apkMainProcessFile);
    }
    LogUtils.info("All done.");
}
public void protect() {
    process(this);
}

1. 指令抽空

extractDexCode：调用DexUtils.extractAllMethods获取List<Instruction> ret，最后将每个方法的字节码信息写入到assets/OoooooOooo文件

extractAllMethods：解析Dex文件的结构体，获取directMethods，virtualMethods，调用extractMethod来进行patch

extractMethod：一边用byteCode保存原字节码，一边用outRandomAccessFile.writeShort(0)写入nop

下面主要贴一下extractDexCode的源码好了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
private void  extractDexCode(String apkOutDir){
    List<File> dexFiles = getDexFiles(apkOutDir);
    Map<Integer,List<Instruction>> instructionMap = new HashMap<>();
    String appNameNew = "OoooooOooo";
    String dataOutputPath = getOutAssetsDir(apkOutDir).getAbsolutePath() + File.separator + appNameNew;
 
    CountDownLatch countDownLatch = new CountDownLatch(dexFiles.size());
    for(File dexFile : dexFiles) {
        ThreadPool.getInstance().execute(() -> {
            final int dexNo = getDexNumber(dexFile.getName());
            if(dexNo < 0){
                return;
            }
            String extractedDexName = dexFile.getName().endsWith(".dex") ? dexFile.getName().replaceAll("\\.dex$", "_extracted.dat") : "_extracted.dat";
            File extractedDexFile = new File(dexFile.getParent(), extractedDexName);
 
            List<Instruction> ret = DexUtils.extractAllMethods(dexFile, extractedDexFile, getPackageName(), isDumpCode());
            instructionMap.put(dexNo,ret);
 
            File dexFileRightHashes = new File(dexFile.getParent(),FileUtils.getNewFileSuffix(dexFile.getName(),"dat"));
            DexUtils.writeHashes(extractedDexFile,dexFileRightHashes);
            dexFile.delete();
            extractedDexFile.delete();
            dexFileRightHashes.renameTo(dexFile);
            countDownLatch.countDown();
        });
 
    }
 
    ThreadPool.getInstance().shutdown();
 
    try {
        countDownLatch.await();
    }
    catch (Exception ignored){
    }
 
    MultiDexCode multiDexCode = MultiDexCodeUtils.makeMultiDexCode(instructionMap);
 
    MultiDexCodeUtils.writeMultiDexCode(dataOutputPath,multiDexCode);
 
}

2. AMF的处理

主要是保存了一下源ApplicationName和AppComponentFactory，后续壳加载的时候用

此外修改了程序的AMF.xml，替换为代理ApplicationName和代理AppComponentFactory

3. 压缩源dex到新的路径并删除旧的路径

源dex压缩存放到assets/i11111i111.zip

4. 合并壳和原dex

combineDexZipWithShellDex：将壳文件添加到dex，并修复size、sha1、checksum

5. 复制壳so，加密so文件

copyNativeLibs这里就没啥好说的，直接添加（shell-files/libs → assets/vwwwwwvwww）

encryptSoFiles这块对比于初始版本是新添加的功能：

  • assets/vwwwwwvwww文件夹下存放的是壳的so文件，这里遍历so文件，然后对.bitcode节区进行RC4加密
  • key为ncWK&S5wbqU%IX6j，在com\luoye\dpt\Const.java定义

6. 签名构建APK

zipalign，对zip进行对齐

对APK进行签名，assets/dpt.jks

  • signApkDebug

  • signApk，调用command来实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    private static boolean signApk(String apkPath, String keyStorePath, String signedApkPath,
                                   String keyAlias,
                                   String storePassword,
                                   String KeyPassword) {
        ArrayList<String> commandList = new ArrayList<>();
     
        commandList.add("sign");
        commandList.add("--ks");
        commandList.add(keyStorePath);
        commandList.add("--ks-key-alias");
        commandList.add(keyAlias);
        commandList.add("--ks-pass");
        commandList.add("pass:" + storePassword);
        commandList.add("--key-pass");
        commandList.add("pass:" + KeyPassword);
        commandList.add("--out");
        commandList.add(signedApkPath);
        commandList.add("--v1-signing-enabled");
        commandList.add("true");
        commandList.add("--v2-signing-enabled");
        commandList.add("true");
        commandList.add("--v3-signing-enabled");
        commandList.add("true");
        commandList.add(apkPath);
     
        int size = commandList.size();
        String[] commandArray = new String[size];
        commandArray = commandList.toArray(commandArray);
     
        try {
            ApkSignerTool.main(commandArray);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

完成！

Shell模块分析

ProxyApplication-attachBaseContext重写

这里的逻辑也会初始版本发生了一些变化，直接分析当前版本的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Override
protected void attachBaseContext(Context base) {
    super.attachBaseContext(base);  // 先调用父类的attachBaseContext
    Log.d(TAG,"dpt attachBaseContext classloader = " + base.getClassLoader());
    realApplicationName = FileUtils.readAppName(this);
    if(!Global.sIsReplacedClassLoader) {
        ApplicationInfo applicationInfo = base.getApplicationInfo();
        if(applicationInfo == null) {
            throw new NullPointerException("application info is null");
        }
        FileUtils.unzipLibs(applicationInfo.sourceDir,applicationInfo.dataDir);
        JniBridge.loadShellLibs(applicationInfo.dataDir,applicationInfo.sourceDir);
        Log.d(TAG,"ProxyApplication init");
        JniBridge.ia();
        ClassLoader targetClassLoader = base.getClassLoader();
        JniBridge.cbde(targetClassLoader);
        Global.sIsReplacedClassLoader = true;
    }
}

JniBridge.loadShellLibs(applicationInfo.dataDir,applicationInfo.sourceDir)

  • 加载shell的so文件，后面一小节将会分析so的初始化流程
    • System.load(fullLibPath)

JniBridge.ia()：init_app

  • 通过jni调用so文件的ia函数（动调注册init_app），路径在\main\cpp\dpt.cpp
  • load_apk：这里是将apk映射到内存中
    • load_zip_by_mmap，打开zip后通过mmap映射到内存
  • read_zip_file_entry
    • 读取刚刚加载的apk，然后在内存中找到assets/OoooooOooo的地址，保存指针codeItemFilePtr
  • readCodeItem
    • MultiDexCode结构体解析出来获得各个dex的指令字节, 然后添加到dexMap中，dexMap是全局变量
  • extractDexesInNeeded
    • writeDexAchieve：找apk中的classes.dex写入到code_cache/i11111i111.zip
  • unloadapk
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
DPT_ENCRYPT void init_app(JNIEnv *env, jclass __unused) {
    DLOGD("init_app!");
    clock_t start = clock();
 
    void *apk_addr = nullptr;
    size_t apk_size = 0;
    load_apk(env,&apk_addr,&apk_size);
 
    uint64_t entry_size = 0;
    if(codeItemFilePtr == nullptr) {
        read_zip_file_entry(apk_addr,apk_size,CODE_ITEM_NAME_IN_ZIP,&codeItemFilePtr,&entry_size);
    }
    else {
        DLOGD("no need read codeitem from zip");
    }
    readCodeItem((uint8_t *)codeItemFilePtr,entry_size);
 
    pthread_mutex_lock(&g_write_dexes_mutex);
    extractDexesInNeeded(env,apk_addr,apk_size);
    pthread_mutex_unlock(&g_write_dexes_mutex);
 
    unload_apk(apk_addr,apk_size);
    printTime("read apk data took =" , start);
}

JniBridge.cbde：combineDexElements，动态合并新的dex

  • 合并targetClassLoader原来的DexElements和之前释放的code_cache/i11111i111.zip（此时dex还是空的）
  • 合并dexElements目的是把我们新加载的dex放到dexElements数组开头，这样ClassLoader加载类时就会优先从我们的dex中查找。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
DPT_ENCRYPT void combineDexElement(JNIEnv* env, jclass __unused, jobject targetClassLoader, const char* pathChs) {
    jobjectArray extraDexElements = makePathElements(env,pathChs);
 
    dalvik_system_BaseDexClassLoader targetBaseDexClassLoader(env,targetClassLoader);
 
    jobject originDexPathListObj = targetBaseDexClassLoader.getPathList();
 
    dalvik_system_DexPathList targetDexPathList(env,originDexPathListObj);
 
    jobjectArray originDexElements = targetDexPathList.getDexElements();
 
    jsize extraSize = env->GetArrayLength(extraDexElements);
    jsize originSize = env->GetArrayLength(originDexElements);
 
    dalvik_system_DexPathList::Element element(env, nullptr);
    jclass ElementClass = element.getClass();
    jobjectArray  newDexElements = env->NewObjectArray(originSize + extraSize,ElementClass, nullptr);
 
    for(int i = 0;i < originSize;i++) {
        jobject elementObj = env->GetObjectArrayElement(originDexElements, i);
        env->SetObjectArrayElement(newDexElements,i,elementObj);
    }
 
    for(int i = originSize;i < originSize + extraSize;i++) {
        jobject elementObj = env->GetObjectArrayElement(extraDexElements, i - originSize);
        env->SetObjectArrayElement(newDexElements,i,elementObj);
    }
 
    targetDexPathList.setDexElements(newDexElements);
 
    DLOGD("combineDexElement success");
}

ProxyApplication-onCreate重写

先调用父类的onCreate，后面主要看replaceApplication，同样发生在native层

1
2
3
4
5
6
7
8
9
10
private void replaceApplication() {
    if (Global.sNeedCalledApplication && !TextUtils.isEmpty(realApplicationName)) {
        realApplication = (Application) JniBridge.ra(realApplicationName);
        Log.d(TAG, "applicationExchange: " + realApplicationName+"  realApplication="+realApplication.getClass().getName());
 
        JniBridge.craa(getApplicationContext(), realApplicationName);
        JniBridge.craoc(realApplicationName);
        Global.sNeedCalledApplication = false;
    }
}

JniBridge.ra：replaceApplication，主要实例化了一个application，执行replaceApplicationOnLoadedApk和replaceApplicationOnActivityThread来替换这个实例

  • replaceApplicationOnLoadedApk

    • 获取原始程序的Application类并进行替换，替换涉及两处地方：
      • ActivityThread（负责管理应用程序的生命周期和组件加载）中BoundApplication的appBindData（这里还是在为LoadedApk的makeapplication做准备，而不是替换ActivityThread的初始实例）
      • LoadedApk（APK文件在内存中的表示）中的ApplicationInfo
    • 最后调用loadedApk.makeApplication(JNI_FALSE,nullptr) 来初始化真实程序的application
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    DPT_ENCRYPT void replaceApplicationOnLoadedApk(JNIEnv *env, jclass __unused,jobject realApplication) {
        android_app_ActivityThread activityThread(env);
     
        jobject mBoundApplicationObj = activityThread.getBoundApplication();    // 获取 BoundApplication 对象
     
        android_app_ActivityThread::AppBindData appBindData(env,mBoundApplicationObj);
        jobject loadedApkObj = appBindData.getInfo();
     
        android_app_LoadedApk loadedApk(env,loadedApkObj);  // LoadedApk对象是APK文件在内存中的表示
     
        //make it null
        loadedApk.setApplication(nullptr);  // 以便可以替换为新的 Application 对象。
     
        jobject mAllApplicationsObj = activityThread.getAllApplication();
     
        java_util_ArrayList arrayList(env,mAllApplicationsObj);
     
        jobject removed = (jobject)arrayList.remove(0); // 移除原来的 Application 对象。
        if(removed != nullptr){
            DLOGD("replaceApplicationOnLoadedApk proxy application removed");
        }
     
        jobject ApplicationInfoObj = loadedApk.getApplicationInfo();    // 获取 ApplicationInfo 对象。
     
        android_content_pm_ApplicationInfo applicationInfo(env,ApplicationInfoObj);
     
        char applicationName[128] = {0};
        getClassName(env,realApplication,applicationName, ARRAY_LENGTH(applicationName));   // 获取真实 Application 对象的类名
     
        DLOGD("applicationName = %s",applicationName);
        char realApplicationNameChs[128] = {0};
        parseClassName(applicationName,realApplicationNameChs);     // 前面获取了类名了，现在解析类
        jstring realApplicationName = env->NewStringUTF(realApplicationNameChs);
        auto realApplicationNameGlobal = (jstring)env->NewGlobalRef(realApplicationName);
     
        android_content_pm_ApplicationInfo appInfo(env,appBindData.getAppInfo());
     
        //replace class name    替换类名
        applicationInfo.setClassName(realApplicationNameGlobal);
        appInfo.setClassName(realApplicationNameGlobal);
     
        DLOGD("replaceApplicationOnLoadedApk begin makeApplication!");
     
        // call make application
        loadedApk.makeApplication(JNI_FALSE,nullptr);
     
        DLOGD("replaceApplicationOnLoadedApk success!");
    }

  • replaceApplicationOnActivityThread

    • 替换ActivityThread 的初始 Application 实例为 realApplication
    1
    2
    3
    4
    5
    DPT_ENCRYPT void replaceApplicationOnActivityThread(JNIEnv *env,jclass __unused, jobject realApplication){
        android_app_ActivityThread activityThread(env);
        activityThread.setInitialApplication(realApplication);
        DLOGD("replaceApplicationOnActivityThread success");
    }

  • 这里做个区分：

    • 修改 AppBindData 中的 ApplicationInfo 类名，是为了保证 LoadedApk 在将来某一时刻需要重新实例化 Application 时，能够使用新的 Application 类。
    • 调用 setInitialApplication 是为了立即替换 ActivityThread 的 Application 引用，保证当前应用主线程能够立即使用新的 Application 实例。

JniBridge.craa：callRealApplicationAttach

  • 正常走原始程序的Application的attach（反射调用）

JniBridge.craoc：callRealApplicationOnCreate

  • 正常走原始程序的Application的onCreate（反射调用）

so的初始化

壳的so文件在init_array中优先调用

1
2
3
4
5
6
7
8
9
10
11
12
//dpt.h
INIT_ARRAY_SECTION void init_dpt();
 
// dpt.cpp
void init_dpt() {
    decrypt_bitcode();
 
    DLOGI("init_dpt call!");
 
    dpt_hook();
    createAntiRiskProcess();
}

decrypt_bitcode

  • 前面提到现在so文件开启了加密保护，下述JniBridge的一些关键函数都是定义在.bitcode节区的，因此是进行了RC4加密的，而它们在so文件加载的init_array时进行RC4的解密，密钥存到了.data节区中

dpt_hook

  • 函数路径位于src\main\cpp\dpt_hook.cpp

  • hook libc.so的execve

    字符串子串匹配dex2oat，禁用dex2oat

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    DPT_ENCRYPT int fake_execve(const char *pathname, char *const argv[], char *const envp[]) {
        BYTEHOOK_STACK_SCOPE();
        DLOGW("execve hooked: %s", pathname);
        if (strstr(pathname, "dex2oat") != nullptr) {
            DLOGW("execve blocked: %s", pathname);
            errno = EACCES;
            return -1;
        }
        return BYTEHOOK_CALL_PREV(fake_execve, pathname, argv, envp);
    }

  • hook libc.so的mmap

    添加写权限，以便后续修改dex

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    DPT_ENCRYPT void* fake_mmap(void* __addr, size_t __size, int __prot, int __flags, int __fd, off_t __offset){
        BYTEHOOK_STACK_SCOPE();
     
        int prot = __prot;
        int hasRead = (__prot & PROT_READ) == PROT_READ;
        int hasWrite = (__prot & PROT_WRITE) == PROT_WRITE;
     
        char fd_path[256] = {0};
        dpt_readlink(__fd,fd_path, ARRAY_LENGTH(fd_path));
     
        if(strstr(fd_path,"webview.vdex") != nullptr) {
            DLOGW("fake_mmap link path: %s, no need to change prot",fd_path);
            goto tail;
        }
     
        if(hasRead && !hasWrite) {
            prot = prot | PROT_WRITE;
            DLOGD("fake_mmap call fd = %d,size = %zu, prot = %d,flag = %d",__fd,__size, prot,__flags);
        }
     
        if(g_sdkLevel == 30){
            if(strstr(fd_path,"base.vdex") != nullptr){
                DLOGE("fake_mmap want to mmap base.vdex");
                __flags = 0;
            }
        }
        tail:
        void *addr = BYTEHOOK_CALL_PREV(fake_mmap,__addr,  __size, prot,  __flags,  __fd,  __offset);
        return addr;
    }

  • hook DefineClass

    • 这里通过DobbyHook库来对java层的代码进行hook

    • classloader在加载类的时候会调用defineClass，根据sdk版本选择合适的hook函数，如

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      DPT_ENCRYPT void *DefineClassV21(void* thiz,
                           const char* descriptor,
                           void* class_loader,
                           const void* dex_file,
                           const void* dex_class_def) {
       
          if(LIKELY(g_originDefineClassV21 != nullptr)) {
              patchClass(descriptor,dex_file,dex_class_def);
              return g_originDefineClassV21( thiz,descriptor,class_loader, dex_file, dex_class_def);
       
          }
          return nullptr;
      }

    • patchClass**（指令回填的核心函数）**

      • 解析dex，构建结构体，主要是dex::ClassDataMethod directMethods[direct_methods_size]和dex::ClassDataMethod virtualMethods[virtual_methods_size]
      • 然后调用patchMethod来对每个方法进行具体的回填

    • patchMethod

      • 通过传入的参数dexIndex来找到映射到内存空间的dex，然后通过mprotect增加读写权限
      • 获取原始字节码的偏移，然后通过memcpy直接回填
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      DPT_ENCRYPT void patchMethod(uint8_t *begin,__unused const char *location,uint32_t dexSize,int dexIndex,uint32_t methodIdx,uint32_t codeOff){
          if(codeOff == 0){   // 代码偏移为0，不需要patch
              NLOG("[*] patchMethod dex: %d methodIndex: %d no need patch!",dexIndex,methodIdx);
              return;
          }
          auto *dexCodeItem = (dex::CodeItem *) (begin + codeOff);    // 原始的dex codeItem的偏移
       
          uint16_t firstDvmCode = *((uint16_t*)dexCodeItem->insns_);
          if(firstDvmCode != 0x0012 && firstDvmCode != 0x0016 && firstDvmCode != 0x000e){
              NLOG("[*] this method has code no need to patch");
              return;
          }
       
          auto dexIt = dexMap.find(dexIndex);
          if (LIKELY(dexIt != dexMap.end())) {
              auto dexMemIt = dexMemMap.find(dexIndex);
              if(UNLIKELY(dexMemIt == dexMemMap.end())){
                  change_dex_protective(begin,dexSize,dexIndex);
              }
       
              auto codeItemMap = dexIt->second;
              auto codeItemIt = codeItemMap->find(methodIdx);
       
              if (LIKELY(codeItemIt != codeItemMap->end())) {
                  data::CodeItem* codeItem = codeItemIt->second;
                  auto *realCodeItemPtr = (uint8_t *)(dexCodeItem->insns_);
       
                  NLOG("[*] patchMethod codeItem patch, methodIndex = %d,insnsSize = %d >>> %p(0x%x)",
                       codeItem->getMethodIdx(),
                       codeItem->getInsnsSize(),
                       realCodeItemPtr,
                       (unsigned int)(realCodeItemPtr - begin));
       
                  memcpy(realCodeItemPtr,codeItem->getInsns(),codeItem->getInsnsSize());
              }
              else{
                  NLOG("[*] patchMethod cannot find  methodId: %d in codeitem map, dex index: %d(%s)",methodIdx,dexIndex,location);
              }
          }
          else{
              DLOGW("[*] patchMethod cannot find dex: '%s' in dex map",location);
          }
      }

createAntiRiskProcess

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
DPT_ENCRYPT void createAntiRiskProcess() {
    pid_t child = fork();
    if(child < 0) {
        DLOGW("%s fork fail!", __FUNCTION__);
        detectFrida();
    }
    else if(child == 0) {
        DLOGD("%s in child process", __FUNCTION__);
        detectFrida();
        doPtrace();
    }
    else {
        DLOGD("%s in main process, child pid: %d", __FUNCTION__, child);
        protectChildProcess(child);
        detectFrida();
    }
}
  • 这里进行了两种反调试的操作，一个是检测Frida，另一个是常规的PTRACE_TRACEME，无论是子进程还是父进程都会有反调检测

    • detectFrida

      • 创建反调试线程，具体有下面几种检测方法
        • 读取进程的内存映射/proc/%d/maps，直接查frida-agent字符串
        • 读取进程的线程/proc/%d/task，查字符串pool-frida、gmain、gdbus、gum-js-loop，如果线程匹配超过2个就crash
          • pool-frida：管理 Frida 内部的线程池，用于处理多线程任务和通信。
          • gmain：GLib 主循环，处理事件循环和 Frida 的核心事件。
          • gdbus：DBus 线程，处理与系统服务或其他进程的 DBus 消息通信。
          • gum-js-loop：JavaScript 主循环，执行 Frida 注入的 JavaScript 代码和 hook 函数。
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      [[noreturn]] void *detectFridaOnThread(__unused void *args) {
          while (true) {
              int frida_so_count = find_in_maps(1,"frida-agent");
              if(frida_so_count > 0) {
                  DLOGD("detectFridaOnThread found frida so");
                  crash();
              }
              int frida_thread_count = find_in_threads_list(4
                      ,"pool-frida"
                      ,"gmain"
                      ,"gdbus"
                      ,"gum-js-loop");
       
              if(frida_thread_count >= 2) {
                  DLOGD("detectFridaOnThread found frida threads");
                  crash();
              }
              sleep(10);
          }
      }

    • doPtrace

      1
      2
      3
      4
      void doPtrace() {
          __unused int ret = sys_ptrace(PTRACE_TRACEME,0,0,0);
          DLOGD("doPtrace result: %d",ret);
      }

ProxyComponentFactory重写

在系统需要创建组件实例时按需调用，通过代理的方式控制组件的实例化，优先使用目标 AppComponentFactory 创建组件，创建失败再用默认的

其他

hook时机的调整

回看22年的帖子，当时作者使用LoadMethod作为hook和指令回填的目标，现在已经换成DefineClass，原因在HowItWorks.md也有解释

ClassDef这个结构还有一个特点，它是dex文件的结构，也就是说dex文件格式不变，它一般就不会变。还有，DefineClass函数的参数会改变吗？目前来看从Android M到现在没有变过。所以使用它不用太担心随着Android版本的升级而导致字段偏移的变化，也就是兼容性较强。这就是为什么用DefineClass作为Hook点。

dpt之前就是使用的LoadMethod函数作为Hook点，在LoadMethod函数里面做CodeItem填充操作。但是后来发现，LoadMethod函数参数不太固定，随着Android版本的升级可能要不断适配，而且每个函数都要填充，会影响一定的性能。

总结

processor模块

  1. 从原app的各个dex，每个dex的method中抽取字节码存入OoooooOooo文件中，并用nop填充
  2. 修改入口
  3. 合并shell的dex（shell-files/dex/classes.dex）与填充nop后的dex
  4. 复制壳的so文件，并对.bitcode节区进行rc4加密
  5. 最终签名并构建apk

Shell模块

ProxyApplication-attachBaseContext重写

  1. jniBridge.ia初始化一些结构体和变量以便后续用
  2. 加载壳so并初始化
    1. 解密.bitcode节区
    2. 设置hook
      1. 禁用dex2oat
      2. 给dex添加写权限
      3. 调用defineClass时回填指令(关键参数是dex_file和dex_class_def)
    3. 设置反调试
  3. 将现在的apk内的classes.dex缓存到code_cache/i11111i111.zip，然后动态添加到现在的classloader内

ProxyApplication-onCreate重写

  1. 替换当前的application为原始程序的application
  2. 执行原始程序application的初始化流程，如attach、onCreate
  3. 完成原始app的运行

Refs

分享一个自己做的函数抽取壳 - 吾爱破解 - 52pojie.cn

https://github.com/luoyesiqiu/dpt-shell