安卓應用加固之各代加殼保護技術詳解

#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 第三代殼

 待更.......