安卓应用加固之各代加壳保护技术详解

#0x00 前言

安卓应用加固技术是伴随安卓应用破解技术一同发展起来的。加固技术分为加壳保护和反反汇编保护技术。市面上成熟的加固厂商一般会使用加壳保护技术配合反反汇编技术对安卓应用进行加固。

安卓反反汇编技术的总结在我以下博客中将进行详细探讨（未写完），链接：

反反汇编：

https://www.cnblogs.com/victor-paladin/p/11406646.html

反动态调试：

https://www.cnblogs.com/victor-paladin/p/11406740.html

安卓应用加壳技术的发展可以划分为以下几代壳技术：

第一代壳——动态加载壳：对用户端的Dex、so、资源进行混淆及加密，在运行时再解密，最后通过自定义ClassLoader动态加载源APK

第二代壳——代码抽取壳：抽取Dex中方法的实现代码加密存储在用户端，APK运行时调用壳的Native方法解密Dex中被加密的方法，执行完后再加密

第三代壳——代码混淆壳：指令变换、花指令混淆、指令膨胀、代码流程混淆等

#0x01 第一代壳

一、Dex、so混淆

1.代码混淆

即将源程序代码中的类名、方法名修改为a、b、c()的形式，让破解这不能通过类名、方法名轻易地寻找/猜测到函数所实现的功能，增加逆向分析的难度

2.编译期混淆

若APK在开发时使用的是LLVM编译套件进行编译，则可以在编译期间对代码进行混淆。分为前端混淆和IR混淆。

前端混淆：指编译器前端在进行原生代码分析时采取的混淆技术

IR混淆：指在编译原生代码时对生成的中间代码IR进行混淆的技术

3.二进制混淆

在生成APK文件后，提取出其中的二进制文件，对二进制文件再进行混淆。典型的技术有Dex二次混淆，即对生成的Dex文件进行反编译后，再进行混淆。使得Dex的执行流程被混淆和字符串被混淆。

 1 //以字符串混淆为例
 2 
 3 //混淆前
 4 void methodA()
 5 {
 6     clz.method1("abc");
 7     clz.method3(clz.method2("def"),"ghi");
 8 }
 9 
10 //使用ProGuard进行代码混淆后的反汇编代码可能如下
11 void methodA()
12 {
13     a.a("abc");
14     a.aaa(a.aa("def"),"ghi");
15 }
16 
17 //使用DexGuard进行代码混淆后的反汇编代码可能如下，b.a()方法
18 void methodA()
19 {
20     a.a(b.a("xxxxxxxxx"));
21     a.aaa(a.aa(b.a("yyyyyyyyy")),b.a("zzzzzzzzz"));
22 }

二、Dex加密

 Dex加密指将APK的DEX文件进行加密，在运行时再解密加载到内存中执行，防止Dex文件被逆向的一种保护技术。

Dex加密APK的执行流程如下图：

加固过程：

1.需要编写三个项目：

（1）源APK（真正的APK程序）

（2）加壳程序（Java项目，用于对源APK进行加密，并将加密后的源APK与脱壳程序的dex进行合并）

（3）脱壳程序（Android项目，用于对加密后的源APK文件进行解密，并将其加载到内存中去）

2.加壳程序将源APK加密成所有操作系统都不能正确读取的APK文件。

3.加壳程序再提取出解密APK的classes.dex文件，将脱壳程序的dex文件与加密后的源apk进行合并，得到新的dex文件

4.在新dex文件的末尾添加一个长度为4位的字段，用于标识加密apk的大小

5.修改新dex文件的头部三个字段：checksum，signature，file_size，以保证新dex文件的正确性

6.生成新的classes.dex文件，打包，生成加固APK

源APK加密原理流程如下图：

 

加壳程序主要逻辑代码分析：

public static void main(String args[])
{
    try
    {
        //---------获取文件-------------------------------------------
        //获取需要加密的源apk程序
        File payloadSrcFile = new File("xxxx/abc.apk");
        System.out.println("SrcAPK size:"+payloadSrcFile.length());
        //获取脱壳(解密)程序的DEX文件,需要提前把脱壳程序的DEX文件解压出来
        File unshellDexFile = new File("yyyy/classes.dex");

        //---------加密源apk文件----------------------------------------
        /*
        以二进制形式读取apk，并加密，存到payloadArray数组中
        readFileBytes是以二进制形式读取文件
        encrpt()是自定义的对二进制流加密的函数
        */
        byte[] payloadArray = encrpt(readFileBytes(payloadSrcFile));
        //以二进制形式读取脱壳dex
        byte[] unshellDexArray = readFileBytes(unshellDexFile);

        //---------合并------------------------------------------------
        //***1.计算出新Dex文件的总长度
        int payloadLen = payloadArray.length();    //加密APK的长度
        int unshellDexLen = unshellDexArray.length();    //脱壳Dex的长度
        int totalLen = payloadLen+unshellDexLen=4    //新的Dex文件长度，最后+4是为了用于存储payloadLen值的
        //***2.定义新dex文件
        //先定义新dex文件的长度
        byte[] newDex = new byte[totalLen];
        //***3.开始合并
        //将脱壳dex文件的内容写入新dex
        System.arraycopy(unshellDexArray,0,newDex,0,unshellDexLen);
        //再将加密后的源APK内容连接在后面
        /*
        arraycopy(arr1,x,arr2,y,m)表示将数组arr1从索引为x开始的元素，复制m个元素到数组arr2中去，从arr2的y索引开始粘贴
        */
        System.arraycopy(payloadArray,0,newDex,unshellDexLen,payloadLen);
        //最后将将加密后的apk长度记录在新dex文件末尾
        /*
        intToByte()将int类型数据转换成Byte
        total是int类型的，newDex是Byte类型
        total是脱壳dex长度+加密apk长度+4，所以，最后是从newDex的第total-4索引开始写入payload的长度
        一个byte是1个字节，即8位;一个int是4个字节，即32位;所以最后的4表示写入intToByte(payloadLen)的4个元素
        */
        System.arraycopy(intToByte(payloadLen),0,newDex,totalLen-4,4);

        //---------修改新dex文件的头部信息----------------------------------
        //修改file_size字段
        fixFileSizeHeader(newDex);
        //修改signature字段
        fixSHA1Header(newDex);
        //修改checksum字段
        fixCheckSumHeader(newDex);

        //---------生成新dex文件------------------------------------------
        //定义要生成文件的路径及名称并创建空文件
        String str = "zzzz/classes.dex";
        File file = new File(str);
        if (!file.exists())
        {
            file.createNewFile();
        }
        //将合并好的数据写入文件
        FileOutputStream localFileOutputStream = new FileOutputStream(str);
        localFileOutputStream.write(newDex);
        localFileOutputStream.flush();
        localFileOutputStream.close();
    }catch (Exception e) {
        e.printStackTrace();
    }
}
    
//加密函数encrpt()的定义
private static byte[] encrpt(byte data[]) 
{
    //加密算法实现，这里就不写了
    return data;
}

脱壳原理流程如下图：

用户执行加固APP，其实进入的是脱壳APK的代码，脱壳APK会先提取并解密出真正的APK，但此时真正的APK并没有被加载到手机的内存中。因此需要在一个恰当的时期，在用户交互界面进入脱壳APK之前将真正的APK解密提取出来并加载到内存中去执行起来。到底在何时进行提取、解密和加载真正APK？如下图分析所示即最佳时机：

 如上图所示，

（1）提取和解密APK的最佳时机则是在脱壳APK的Activity被拉起之前，Activity是通过onCreate()方法拉起来的，因此在onCreate()方法之前，应将源APK提取并解密。

（2）提取并解密出源APK之后，通过改写脱壳APK的onCreate()方法，让其拉起源APK。

脱壳程序主要逻辑代码分析：

//********重写attachBaseContext()函数***********
protected void attachBaseContext(Context base)
{
    super.attachBaseContext(base);
    try
    {
        //---------提取加密apk---------------------------------------------
        //创建两个私有、可写的目录payload_odex和payload_lib
        File odex = this.getDir("payload_odex",MODE_PRIVATE);    //用于存放源APK的dex文件
        File libs = this.getDir("payload_lib",MODE_PRIVATE);    //用于存放源APK的so文件
        odexPath = odex.getAbsolutePath();
        libPath = libs.getAbsolutePath();
        apkFileName = odex.getAbsolutePath()+"/abc.apk";
        File dexFile = new File(apkFileName);
        Log.i("demo","apk size:"+dexFile.length());
        if (!dexFile.exists())
        {
            //在payload_odex文件目录下，创建abc.apk空文件
            dexFile.createNewFile();
            //读取出加壳后的整个dex文件
            //readDexFileFromApk()方法在attachBaseContext()方法外面实现
            byte[] dexdata = this.readDexFileFromApk();
            //脱壳(分离出加密的源apk并进行解密),分离出apk文件以用于动态加载
            //splitPayloadFromDex()方法在attachBaseContext()方法外面实现
            this.splitPayloadFromDex(dexdata);
        }
        
        //---------加载解密之后的源apk程序------------------------------------
        //配置动态加载环境
        //通过反射机制获取当前activity的线程对象
        Object currentActivityThread = RefInvoke.invokeStaticMethod(
            "android.app.ActivityThread",
            "currentActivityThread",
            new Class[] {},
            new Object[] {});

        //获取加壳apk的包名
        String packageName = this.getPackageName();
        //通过反射获取和设置当前APK的各种信息
        ArrayMap mPackages = (ArrayMap) RefInvoke.getFieldObject(
            "android.app.ActivityThread",
            currentActivityThread,
            "mPackages");
        WeakReference wr = (WeakReference) mPackages.get(packageName);

        //自定义一个DexClassLoader对象，用于加载被加载解密后的源apk和源apk内的类和C/C++代码
        DexClassLoader dLoader = new DexClassLoader(
            apkFileName,
            odexPath,
            libPath,
            (ClassLoader) RefInvoke.getFieldObject(
                "android.app.LoadedApk",
                wr.get(),
                "mClassLoader"));
        //把当前进程的DexClassLoader()设置成脱壳apk在上一行自定义的DexClassLoader()
        RefInvoke.setFiedObject(
            "android.app.LoadedApk",
            "mClassLoader",
            wr.get(),
            dLoader);
        
        Log.i("demo","classloader:"+dLoader);

        try
        {
            Object actObj = dLoader.loadClass("com.example.forceapkobj.MainActivity");
            Log.i("demo","actObj:"+actObj);
        }
        catch (Exception e)
        {
            Log.i("demo","activity:"+Log.getStackTraceString(e));
        }
    }catch (Exception e)
    {
        Log.i("demo","error:"+Log.getStackTraceString(e));
        e.printStackTrace();
    }
}


/*
*@name :readDexFileFromApk()
*@function :从脱壳程序中提取脱壳DEX文件内容
*@param     :无
*@throws :IOException
*@return :byte[]
*/
private byte[] readDexFileFromApk() throws IOException
{
    //定义一个Byte类型的数组对象，用于存储dex文件的内容
    ByteArrayOutputStream dexByteArrayOutputStream = new ByteArrayOutputStream();
    //定义一个ZIP对象，用于解压APK
    ZipInputStream localZipInputStream = new ZipInputStream(
        new BufferedInputStream(new FileInputStream(
            this.getApplicationInfo().sourceDir)));

    while (true)
    {    
        ////解压并遍历ZIP文件,以二进制流形式读入数组arrayOfByte[]
        ZipEntry localZipEntry = localZipInputStream.getNextEntry();
        if (localZipEntry == null)
        {
            localZipInputStream.close();
            break;
        }
        //找到脱壳dex文件
        if (localZipEntry.getName().equals("classes.dex"))
        {
            
            byte[] arrayOfByte = new byte[1024];
            while (true)
            {
                int i = localZipInputStream.read(arrayOfByte);
                if (i == -1)
                {
                    break;
                }
                dexByteArrayOutputStream.write(arrayOfByte,0,i);
            }
        }
        localZipInputStream.closeEntry();
    }
    localZipInputStream.close();
    return dexByteArrayOutputStream.toByteArray();
}

/*
*@name :splitPayloadFromDex(byte apkdata[])
*@function :从脱壳dex文件中提取出被加密的apk文件和so文件，并解密
*@param     :apkdata -要解密的DEX文件二进制流
*@throws :IOException
*@return :无
*/
private void splitPayloadFromDex(byte apkdata[]) throws IOException
{
    //---------剥离出加密源APK---------------------------------------------
    //获取整个dex文件的长度
    int ablen = apkdata.length();
    //获取脱壳dex最后4位的数据，即获取源加密APK的长度
    //ablen-4在arraycopy()中即表示从apkdata的第倒数第四位开始
    byte[] dexlen = new byte[4];
    System.arraycopy(apkdata,ablen-4,dexlen,0,4);

    //对获取到的4字节长度值进行转换，将二进制数组类型转换成可以计算的int类型
    ByteArrayInputStream bais = new ByteArrayInputStream(dexlen);
    DataInputStream in = new DataInputStream(bais);
    int readInt = in.readInt();
    System.out.println(Integer.toHexString(readInt));

    //定义一个二进制流数组用来存储即将提取出来的加密apk
    byte[] newdex = new byte[readInt];
    //把加密apk存到newdex中
    /*
    apkdata是整个dex文件的数据内容
    ablen是整个dex文件的长度-4即表示整个dex文件从头到加密apk的末尾的位置
    readInt表示加密apk的长度
    ablen-4再-readInt即表示从整个dex从头到脱壳dex的末尾的位置
    */
    System.arraycopy(apkdata,ablen-4-readInt,newdex,0,readInt);

    //---------解密源APK-------------------------------------------------------
    //decrypt()函数在splitPayloadFromDex()函数外实现
    newdex = decrypt(newdex);

    //---------释放解密后的源APK到磁盘-----------------------------------------
    File file = new File(apkFileName);
    try
    {
        FileOutputStream localFileOutputStream = new FileOutputStream(file);
        localFileOutputStream.write(newdex);
        localFileOutputStream.close();
    }catch (IOException e)
    {
        throw new RuntimeException(localIOException);
    }
    
    //---------分析释放出来的源APK----------------------------------------------
    //定义一个ZIP对象
    ZipInputStream localZipInputStream = new ZipInputStream(
        new BufferedInputStream(new FileOutputStream(file)));
    while (true)
    {
        //解压并遍历ZIP包
        ZipEntry localZipEntry = localZipInputStream.getNextEntry();
        if (localZipInputStream == null)
        {
            localZipInputStream.close();
            break;
        }
        //提取出APK中的so文件，并释放到脱壳程序一开始在磁盘新建的payload_lib目录中去中去
        String name = localZipEntry.getName();
        if (name.startWith("lib/") && name.endwith(".so"))    //确认遍历到的文件是否是so文件
        {
            File storeFile = new File(libPath+"/"+name.substring(name.lastIndexOf('/')));
            storeFile.createNewFile();
            FileOutputStream fos = new FileOutputStream(storeFile);
            byte[] arrayOfByte = new byte[1024];
            while (true)
            {
                int i = localZipInputStream.read(arrayOfByte);
                if (i == -1)
                {
                    break;
                }
                fos.write(arrayOfByte,0,i);
            }
            fos.flush();
            fos.close();
        }
        localZipInputStream.closeEntry();
    }
    localZipInputStream.close();
}

/*
*@name :decrypt(byte srcdata[])
*@function :对被加密的apk文件进行解密
*@param     :srcdata -要解密的apk文件二进制流
*@throws :无byte
*@return :srcdata -byte[]类型
*/
private byte[] decrypt(byte[] srcdata)
{
    //解密算法，根据加密算法编写对应的解密过程
    return srcdata;
}


//**********重写onCreate()方法***********
public void onCreate ()
{
    //未完待续
}

#0x02 第二代壳

 该类型的保护壳依赖的是通过拦截系统的加载类函数，然后对类中的方法指令进行还原的技术。

 待更...

#0x03 第三代壳

 待更.......