Android漏洞之战——整体加壳原理和脱壳技巧详解

1

加载BootLoader --> 初始化内核 --> 启动init进程 --> init进程fork出Zygote进程 --> Zygote进程fork出SystemServer进程

1

2

3

4

· 系统启动时安装，没有安装界面

· 第三方应用安装，有安装界面，也是我们最熟悉的方式

· ADB命令安装，没有安装界面

· 通过各类应用市场安装，没有安装界面

1

2

3

4

5

6

public static final IPackageManager main(Context context, Installer installer,

    boolean factoryTest, boolean onlyCore) {

        PackageManagerService m = new PackageManagerService(context, installer, factoryTest, onlyCore);

        ServiceManager.addService("package", m);

    return m;

}

1

2

3

4

5

6

7

8

(1)点击桌面APP图标时，Launcher的startActivity()方法，通过Binder通信，调用system_server进程中AMS服务的startActivity方法，发起启动请求

(2)system_server进程接收到请求后，向Zygote进程发送创建进程的请求

(3)Zygote进程fork出App进程，并执行ActivityThread的main方法，创建ActivityThread线程，初始化MainLooper，主线程Handler，同时初始化ApplicationThread用于和AMS通信交互

(4)App进程，通过Binder向sytem_server进程发起attachApplication请求，这里实际上就是APP进程通过Binder调用sytem_server进程中AMS的attachApplication方法,AMS的attachApplication方法的作用是将ApplicationThread对象与AMS绑定

(5)system_server进程在收到attachApplication的请求，进行一些准备工作后，再通过binder IPC向App进程发送handleBindApplication请求（初始化Application并调用onCreate方法）和scheduleLaunchActivity请求（创建启动Activity）

(6)App进程的binder线程（ApplicationThread）在收到请求后，通过handler向主线程发送BIND_APPLICATION和LAUNCH_ACTIVITY消息，这里注意的是AMS和主线程并不直接通信，而是AMS和主线程的内部类ApplicationThread通过Binder通信，ApplicationThread再和主线程通过Handler消息交互。

(7)主线程在收到Message后，创建Application并调用onCreate方法，再通过反射机制创建目标Activity，并回调Activity.onCreate()等方法

(8)到此，App便正式启动，开始进入Activity生命周期，执行完onCreate/onStart/onResume方法，UI渲染后显示APP主界面

1

2

3

4

5

6

7

8

9

10

public void handleMessage(Message msg) {

****

    case BIND_APPLICATION:

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");

        AppBindData data = (AppBindData)msg.obj;

        handleBindApplication(data);

        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

        break;

****

}

1

2

（1）完成了Application的实例化

（2）并调用Application.attach()函数

1

2

3

4

从上可知, App的运行流程是

    初始化————>Application的构造函数————>Application.attachBaseContext()————>Application.onCreate()函数

最后才会进入MainActivity中的attachBaseContext函数、onCreate函数

所以加壳厂商要在程序正式执行前，也就是上面的流程中进行动态加载和类加载器的修正，这样才能对加密的dex进行释放，而一般的1厂商往往选择在Application中的attachBaseContext或onCreate函数进行

1

2

3

4

5

6

（1）BootClassLoader加载系统核心库

（2）PathClassLoader加载APP自身dex

（3）进入APP自身组件，解析AndroidManifest.xml，然后查找Application代理

（4）调用声明Application的attachBaseContext()对源程序进行动态加载或解密

（5）调用声明Application的onCreate()对源程序进行动态加载或解密

（6）进入MainActivity中的attachBaseContext()，然后进入onCreate()函数，执行源程序代码

1

2

3

4

5

6

7

8

Android中的ClassLoader类型分为系统ClassLoader和自定义ClassLoader。其中系统ClassLoader包括3种是BootClassLoader、DexClassLoader、PathClassLoader

(1)BootClassLoader:Android平台上所有Android系统启动时会使用BootClassLoader来预加载常用的类

(2)BaseDexClassLoader:实际应用层类文件的加载，而真正的加载委托给pathList来完成

(3)DexClassLoader:可以加载dex文件以及包含dex的压缩文件(apk,dex,jar,zip),可以安装一个未安装的apk文件，一般为自定义类加载器

(4)PathClassLoader:可以加载系统类和应用程序的类，通常用来加载已安装的apk的dex文件

补充：

Android 提供的原生加载器叫做基础类加载器，包括：BootClassLoader，PathClassLoader，DexClassLoader，InMemoryDexClassLoader（Android 8.0 引入），DelegateLastClassLoader（Android 8.1 引入）

1

DexClassLoader加载的类是没有组件生命周期的，即DexClassLoader即使通过对APK的动态加载完成了对组件类的加载，当系统启动该组件时，依然会出现加载类失败的异常

1

2

（1）替换系统组件类加载器为我们的DexClassLoader，同时设置DexClassLoader的parent为系统组件加载器

（2）打破原有的双亲委派关系，在系统组件类加载器PathClassLoader和BootClassLoader的中间插入我们自己的DexClassLoader

1

2

3

4

5

6

总结：

    （1）获取ActivityThread实例

    （2）通过反射获取类加载器

    （3）获取LoadedApk

    （4）获取mClassLoader系统类加载器

    （5）替换自定义类加载器为系统类加载器

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

public static void replaceClassLoader(Context context,ClassLoader dexClassLoader){

       ClassLoader pathClassLoader = MainActivity.class.getClassLoader();

       try {

           //1.获取ActivityThread实例

           Class ActivityThread = pathClassLoader.loadClass("android.app.ActivityThread");

           Method currentActivityThread = ActivityThread.getDeclaredMethod("currentActivityThread");

           Object activityThreadObj = currentActivityThread.invoke(null);

           //2.通过反射获得类加载器

           //final ArrayMap<String, WeakReference<LoadedApk>> mPackages = new ArrayMap<>();

           Field mPackagesField = ActivityThread.getDeclaredField("mPackages");

           mPackagesField.setAccessible(true);

           //3.拿到LoadedApk

           ArrayMap mPackagesObj = (ArrayMap) mPackagesField.get(activityThreadObj);

           String packagename = context.getPackageName();

           WeakReference wr = (WeakReference) mPackagesObj.get(packagename);

           Object LoadApkObj = wr.get();

           //4.拿到mclassLoader

           Class LoadedApkClass = pathClassLoader.loadClass("android.app.LoadedApk");

           Field mClassLoaderField = LoadedApkClass.getDeclaredField("mClassLoader");

           mClassLoaderField.setAccessible(true);

           Object mClassLoader =mClassLoaderField.get(LoadApkObj);

           Log.e("mClassLoader",mClassLoader.toString());

           //5.将系统组件ClassLoader给替换

           mClassLoaderField.set(LoadApkObj,dexClassLoader);

       }

       catch (ClassNotFoundException e) {

           e.printStackTrace();

       } catch (NoSuchMethodException e) {

           e.printStackTrace();

       } catch (IllegalAccessException e) {

           e.printStackTrace();

       } catch (InvocationTargetException e) {

           e.printStackTrace();

       } catch (NoSuchFieldException e) {

           e.printStackTrace();

       }

   }

1

2

3

总结：

    （1）将DexClassloader父节点设置为BootClassLoader

    （2）将PathClassLoader父节点设置为DexClassloader

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

public static void replaceClassLoader(Context context, ClassLoader dexClassLoader){

        //将pathClassLoader父节点设置为DexClassLoader

        ClassLoader pathClassLoaderobj = context.getClassLoader();

        Class<ClassLoader> ClassLoaderClass = ClassLoader.class;

        try {

            Field parent = ClassLoaderClass.getDeclaredField("parent");

            parent.setAccessible(true);

            parent.set(pathClassLoaderobj,dexClassLoader);

        } catch (NoSuchFieldException e) {

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        }

    }

1

2

源程序

加壳程序

1

2

3

DexPathList:该类主要用来查找Dex、SO库的路径，并这些路径整体呈一个数组

Element:根据多路径的分隔符“;”将dexPath转换成File列表，记录所有的dexFile

DexFile:用来描述Dex文件，Dex的加载以及Class的查找都是由该类调用它的native方法完成的

1

2

3

4

5

6

7

8

/libcore/dalvik/src/main/java/dalvik/system/DexPathList.java

public DexPathList(ClassLoader definingContext, String dexPath,

            String librarySearchPath, File optimizedDirectory) {

**********************     

   this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,

                                         suppressedExceptions, definingContext);   

********************** 

            }

1

2

3

4

5

6

private static Element[] makeDexElements(List<File> files, File optimizedDirectory,

          List<IOException> suppressedExceptions, ClassLoader loader) {

**********************           

       DexFile dex = loadDexFile(file, optimizedDirectory, loader, elements);   

**********************        

          }

1

2

3

4

5

6

7

8

9

10

private static DexFile loadDexFile(File file, File optimizedDirectory, ClassLoader loader,

                                       Element[] elements)

            throws IOException {

        if (optimizedDirectory == null) {

            return new DexFile(file, loader, elements);

        } else {

           String optimizedPath = optimizedPathFor(file, optimizedDirectory);

            return DexFile.loadDex(file.getPath(), optimizedPath, 0, loader, elements);

        }

    }

1

2

3

4

static DexFile loadDex(String sourcePathName, String outputPathName,

      int flags, ClassLoader loader, DexPathList.Element[] elements) throws IOException {

      return new DexFile(sourcePathName, outputPathName, flags, loader, elements);

  }

1

2

3

4

5

6

7

/libcore/dalvik/src/main/java/dalvik/system/DexFile.java

DexFile(String fileName, ClassLoader loader, DexPathList.Element[] elements) throws IOException {

        mCookie = openDexFile(fileName, null, 0, loader, elements);

        mInternalCookie = mCookie;

        mFileName = fileName;

        //System.out.println("DEX FILE cookie is " + mCookie + " fileName=" + fileName);

    }

1

2

3

4

5

6

7

8

9

10

11

private static Object openDexFile(String sourceName, String outputName, int flags,

        ClassLoader loader, DexPathList.Element[] elements) throws IOException {

       // Use absolute paths to enable the use of relative paths when testing on host.

        return openDexFileNative(new File(sourceName).getAbsolutePath(),

                                 (outputName == null)

                                    ? null

                                   : new File(outputName).getAbsolutePath(),

                                      flags,

                                   loader,

                                   elements);

    }

1

2

3

4

OpenDexFilesFromOat()

MakeUpToDate()

GenerateOatFileNoChecks()

Dex2Oat()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

/art/runtime/dex_file.cc

std::unique_ptr<const DexFile> DexFile::OpenFile(int fd,

                                                const std::string& location,

                                                bool verify,

                                                bool verify_checksum,

                                                std::string* error_msg) {

 **************************************

 std::unique_ptr<DexFile> dex_file = OpenCommon(map->Begin(),

                                                map->Size(),

                                                location,

                                                dex_header->checksum_,

                                                kNoOatDexFile,

                                                verify,

                                                verify_checksum,

                                                error_msg);  

  **************************************

                                                }

1

2

3

4

5

6

7

8

9

10

11

/art/runtime/exec_utils.cc

bool Exec(std::vector<std::string>& arg_vector, std::string* error_msg) {

  int status = ExecAndReturnCode(arg_vector, error_msg);

  if (status != 0) {

    const std::string command_line(android::base::Join(arg_vector, ' '));

    *error_msg = StringPrintf("Failed execv(%s) because non-0 exit status",

                              command_line.c_str());

    return false;

  }

  return true;

}

1

2

3

4

5

6

7

/art/dex2oat/dex2oat.cc

 int main(int argc, char** argv) {

  int result = static_cast<int>(art::Dex2oat(argc, argv));

  if (!art::kIsDebugBuild && (RUNNING_ON_MEMORY_TOOL == 0)) {

    _exit(result);

  }

  return result;

1

2

3

4

5

6

7

8

9

10

11

12

/art/dex2oat/dex2oat.cc

static dex2oat::ReturnCode Dex2oat(int argc, char** argv) {

   **************************************

   dex2oat::ReturnCode setup_code = dex2oat->Setup();

    dex2oat::ReturnCode result;

  if (dex2oat->IsImage()) {

    result = CompileImage(*dex2oat);

  } else {

    result = CompileApp(*dex2oat);

 }

   **************************************

}

1

2

3

4

5

6

7

8

9

1.隐式加载:

    (1)创建类的实例,也就是new一个对象

    (2)访问某个类或接口的静态变量,或者对该静态变量赋值

    (3)调用类的静态方法

    (4)反射Class.forName("android.app.ActivityThread")

    (5)初始化一个类的子类(会首先初始化子类的父类)

2.显示加载：

    (1)使用LoadClass()加载

    (2)使用forName()加载

1

2

3

Class.forName 和 ClassLoader.loadClass加载有何不同：

（1）ClassLoader.loadClass也能加载一个类,但是不会触发类的初始化(也就是说不会对类的静态变量,静态代码块进行初始化操作)

（2）Class.forName这种方式,不但会加载一个类,还会触发类的初始化阶段,也能够为这个类的静态变量,静态代码块进行初始化操作

1

ConvertJavaArrayToDexFiles对cookie进行了处理

1

2

3

4

5

6

7

8

9

10

11

art/runtime/class_linker.cc

mirror::Class* ClassLinker::DefineClass(Thread* self,

                                      const char* descriptor,

                                        size_t hash,

                                       Handle<mirror::ClassLoader> class_loader,

                                        const DexFile& dex_file,

                                        const DexFile::ClassDef& dex_class_def) {

***************

LoadClass(self, *new_dex_file, *new_class_def, klass);

***************

}

1

2

3

4

5

6

7

8

9

10

11

art/runtime/class_linker.cc

void ClassLinker::LoadClass(Thread* self,

3120                            const DexFile& dex_file,

3121                            const DexFile::ClassDef& dex_class_def,

3122                            Handle<mirror::Class> klass) {

3123  const uint8_t* class_data = dex_file.GetClassData(dex_class_def);

3124  if (class_data == nullptr) {

3125    return;  // no fields or methods - for example a marker interface

3126  }

3127  LoadClassMembers(self, dex_file, class_data, klass);

3128}

1

2

3

4

5

6

7

8

9

10

art/runtime/class_linker.cc

void ClassLinker::LoadClassMembers(Thread* self,

                                   const DexFile& dex_file,

                                   const uint8_t* class_data,

                                   Handle<mirror::Class> klass) {

***************

      LoadMethod(dex_file, it, klass, method);

      LinkCode(this, method, oat_class_ptr, class_def_method_index);

***************

}

1

2

3

4

5

6

art/runtime/class_linker.cc

void ClassLinker::LoadMethod(const DexFile& dex_file,

                           const ClassDataItemIterator& it,

                            Handle<mirror::Class> klass,

                             ArtMethod* dst) {

}

1

2

3

如果壳没有禁用dex2oat，那类中的初始化函数运行在解释器模式下

如果壳禁用dex2oat，dex文件中的所有函数都运行在解释器模式下

则类的初始化函数运行在解释器模式下

1

2

3

4

5

6

7

8

9

10

11

12

13

art/runtime/interpreter/interpreter.cc

static inline JValue Execute(

    Thread* self,

    const DexFile::CodeItem* code_item,

    ShadowFrame& shadow_frame,

    JValue result_register,

    bool stay_in_interpreter = false) REQUIRES_SHARED(Locks::mutator_lock_){

***************

      ArtMethod *method = shadow_frame.GetMethod();

***************

    }

1

2

getDexFile()

getMethod()

1

这里之所以获取begin加上一个指针，是因为我们前面讲了dexfile含有一个虚函数地址，所以加上一个指针偏移

1

2

3

4

5

6

7

8

9

10

11

12

13

14

//add

char dexfilepath[100]=0;

memset(dexfilepath,0,100);

sprintf(dexfilepath,"%d_%zu_LoadMethod.dex",getpid(),dex_file.Size());

int dexfd = open(dexfilepathm,O_CREAT|O_RDWR,666);

if(dexfd>0){

    int result = write(dexfd,dex_file.Begin(),dex_file.Size());

    if(result>0){

        close(dexfd);

        LOG(WARNING)<<"LoadMethod"<<dexfilepath;

    }

}

//add

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

核心思路：反射 + mCookie

步骤：

1、找到加固apk的任一class，一般选择主Application或Activity

2、通过该类找到对应的Classloader

3、通过该Classloader找到BaseDexClassLoader

4、通过BaseDexClassLoader找到其字段DexPathList

5、通过DexPathList找到其变量Element数组dexElements

6、迭代该数组，该数组内部包含DexFile结构

7、通过DexFile获取其变量mCookie和mFileName

至此我们已经获取了mCookie

对该mCookie的解释:

#1、4.4以下好像，mCookie对应的是一个int值，该值是指向native层内存中的dexfile的指针

#2、5.0是一个long值，该值指向native层std::vector<const DexFile*>* 指针，注意这里有多个dex，你需要找到你要的

#3、8.0，该值也是一个long型的值，指向底层vector，但是vector下标0是oat文件，从1开始是dex文件

// 至于你手机是那个版本，如果没有落入我上面描述的，你需要自己看看代码

8、根据mCookie对应的值做转换，最终你能找到dexfile内存指针

9、把该指针转换为dexfile结构，通过findClassDef来匹配你所寻找的dex是你要的dex

10、dump写文件

1

2

3

4

5

6

7

8

9

10

11

static main(void){   

    auto fp, begin, end, dexbyte;     

    fp = fopen("d:\\dump.dex", "wb+");     

    begin =  0x76FCD93020;   

    end = begin + 0x7EEC5600;

    for ( dexbyte = begin; dexbyte<end;dexbyte++)

    {

    fputc(Byte(dexbyte), fp);       

    }  

}

1

2

3

4

1.使用frida枚举所有Classloader

2.确定正确的ClassLoader并获取目标类的Class对象

3.通过Class对象获取得到dex对象

4.通过dex对象获取内存字节流并保存

1

2

3

4

https://bbs.pediy.com/thread-252630.htm#msg_header_h2_4

https://bbs.pediy.com/thread-254555.htm#msg_header_h2_4

https://www.anquanke.com/post/id/221905?display=mobile

https://www.qj301.com/news/317.html文章来源地址https://www.toymoban.com/news/detail-654668.html