靠譜的app加固分享（未完成）

先來看看大概流程

加固俯瞰

1、撰寫加密方法，作為工具方法用于后續的加密和解密準備，

2、撰寫代理Application（ProxyApplication），作為加固后的apk的偽入口，（ProxyApplication作為偽入口時，需要將加密apk進行解密并重新加載于classLoader中）

3、對需要加密的apk的AndroidManifest檔案的Application:name 標簽經行更改為ProxyApplication，并用標簽宣告真正的Application入口和版本號，

4、將1、2步的檔案打包成aar包，

5、解壓aar包（于aarTemp檔案夾），并將解壓后的jar檔案，編譯成dex檔案（Entrance.dex）（安卓虛擬機可識別的機器碼檔案），

6、解壓需要加密的apk（于apkTemp檔案夾），遍歷解壓后的檔案夾，取出所有dex檔案，用1步中的加密方法對所有dex檔案進行加密，并替換原本沒加密的dex，
*注：Entrance.dex在aarTemp內，沒被加密

7、將aarTemp中的dex檔案，復制到apkTemp檔案中，并將apkTemp壓縮成apk檔案，

8、對齊 & 簽名（才能正常使用）
附上相關的代碼

public class Main {
    public static void main(String[] args) {
        //第四步：解壓arr(包含加密解密工具和ProxyApplication.java)
        File aarFile = new File("core/build/outputs/aar/core-debug.aar");
        File aarTemp = new File("lib/temp");
        Zip.unZip(aarFile, aarTemp);
        // 生成classes.dex
        File classesJar = new File(aarTemp, "classes.jar");
        File classesDex = new File(aarTemp, "classes.dex");
        Process process = null;
        //dx --dex --output out.dex in.jar
        try {
            process = Runtime.getRuntime().exec("cmd /c  dx --dex --output " + classesDex.getAbsolutePath()
                    + " " + classesJar.getAbsolutePath());
            process.waitFor();
            if (process.exitValue() != 0) {
                System.out.println("dex error");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //第六步：解壓apk
        File apkFile = new File("app/build/outputs/apk/debug/app-debug.apk");
        File apkTemp = new File("lib/Apktemp");
        Zip.unZip(apkFile, apkTemp);
        ArrayList<File> dexFiles = new ArrayList<>();
        for (File file : apkTemp.listFiles()) {
            if (file.getName().endsWith("dex")) {
                dexFiles.add(file);
            }
        }
        //加密apk里面的dex
        AES.init(AES.DEFAULT_PWD);
        for (File dexFile : dexFiles) {
            try {
                byte[] bytes = Utils.getBytes(dexFile);

                byte[] encrypt = AES.encrypt(bytes);
                FileOutputStream fos = new FileOutputStream(new File(apkTemp,
                        "secret-" + dexFile.getName()));
                fos.write(encrypt);
                fos.flush();
                fos.close();
                dexFile.delete();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        classesDex.renameTo(new File("lib/Apktemp", "classes.dex"));
        File unSignedApk = new File("app/build/outputs/apk/debug/app-unsigned.apk");
        //第七步：把apkTemp壓縮成unsightApk
        try {
            Zip.zip(apkTemp, unSignedApk);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //第八步：對齊 簽名
        File alignedApk = new File("app/build/outputs/apk/debug/app-unsigned-aligned.apk");
        try {
            process = Runtime.getRuntime().exec("cmd /c zipalign -v -p 4 " + unSignedApk.getAbsolutePath()
                    + " " + alignedApk.getAbsolutePath());

            process.waitFor();
            if (process.exitValue() != 0) {
                System.out.println("zipalign error");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        File signedApk=new File("app/build/outputs/apk/debug/app-signed-aligned.apk");
        File jks=new File("mykeystore.jks");
        try {
            process=Runtime.getRuntime().exec("cmd /c apksigner sign --ks "+jks.getAbsolutePath()
                    +" --ks-key-alias key0 --ks-pass pass:11111111 --key-pass pass:11111111 --out "
                    +signedApk.getAbsolutePath()+" "+alignedApk.getAbsolutePath());
            process.waitFor();
            if(process.exitValue()!=0){
                System.out.println("sign error");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("over ");
    }
}

這里詳細講講ProxyApplication:
探討1：作為唯一沒加密的dex檔案內的ProxyApplication如何把加密的dex檔案，加載到類加載器（ClassLoader）中？
ProxyApplication三部曲：
1.獲得加密apk，
2.解壓zip并解密dex檔案，
3把新dex檔案索引存在類加載器中，

上述程序中，涉及到把dex檔案加載到類加載器中，下面簡單理解下類加載機制，
前提：android的ClassLoader有兩種型別系統類加載器和自定義加載器，
1）BootClassLoader:
安卓系統啟動時候會使用BCL來預加載常用類，
2）DexClassLoader
加載dex檔案和包含dex檔案的壓縮包
3）PathClassLoader
加載系統類和應用程式的類
4) InMemoryClassLoader：
androidO新增的，用于加載記憶體中的dex
·
·ClassLoader是一個抽象類，定義了classloader的主要功能，BootClassLoader是它的內部類
·SecureClassLoader不是ClassLoader的實作類，拓展了ClassLoader的權限方面的功能
·BaseDexClassLoader繼承ClassLoader，但是是抽象類，PathClassLoader, DexClassLoader, InMemoryClassLoader都繼承它，并各自實作類功能
·雙親委托模式
（講人話：首先判斷該類是否已經加載，如無，不是從自身查找，而是委托到父加載器中找是否有加載目的Class，若無依次向父類遞回，直至最頂層ClassLoader類，如果找到了，就直接回傳Class,若果沒找到就繼續依次向下子加載器findClass…)
優點：
1.避免重復加載
2.保護安全性，
（沙雕A建一個 類名為 android.view.View的自定義類，可能造成系統原本的View不可用，但其實還有一層保護，虛擬機把兩個類名一致的且被同一個類加載器加載的類，虛擬機才會認為他們是同一個類）

來一個demo列印看看應用的類加載器是什么：

這里可以看到PathClassLoader作為加載器，

ClassLoader的加載程序：
ClassLoader.java

  protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
            // First, check if the class has already been loaded
        //找該類是否被加載過了
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                try {
                    //先判斷父類是否存在
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        //如果不存在就在自層找
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    //在委托流程中沒找到該類，就會執行該句
                    c = findClass(name);
                }
            }
            //如果已加載就直接回傳
            return c;
    }

BaseDexClassLoader.java

 @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
        //呼叫pathList的findClass
        Class c = pathList.findClass(name, suppressedExceptions);
        if (c == null) {
            ClassNotFoundException cnfe = new ClassNotFoundException(
                    "Didn't find class \"" + name + "\" on path: " + pathList);
            for (Throwable t : suppressedExceptions) {
                cnfe.addSuppressed(t);
            }
            throw cnfe;
        }
        return c;
    }

先看看pathList是什么物件

 /**
     * Constructs an instance.
     *
     * dexFile must be an in-memory representation of a full dexFile.
     *
     * @param dexFiles the array of in-memory dex files containing classes.
     * @param parent the parent class loader
     *
     * @hide
     */
    public BaseDexClassLoader(ByteBuffer[] dexFiles, ClassLoader parent) {
        // TODO We should support giving this a library search path maybe.
        super(parent);
        //在構造器內初始化 是一個DexPathList物件
        this.pathList = new DexPathList(this, dexFiles);
    }

接下來看看DexPathList物件怎么存放已加載的class

 /**
     * Construct an instance.
     *
     * @param definingContext the context in which any as-yet unresolved
     * classes should be defined
     *
     * @param dexFiles the bytebuffers containing the dex files that we should load classes from.
     */
    public DexPathList(ClassLoader definingContext, ByteBuffer[] dexFiles) {
       ...
        this.definingContext = definingContext;
        // TODO It might be useful to let in-memory dex-paths have native libraries.
        this.nativeLibraryDirectories = Collections.emptyList();
        this.systemNativeLibraryDirectories =
                splitPaths(System.getProperty("java.library.path"), true);
        this.nativeLibraryPathElements = makePathElements(this.systemNativeLibraryDirectories);

        ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();
        //把所有存進來的dex檔案存盤在dexElements物件
        this.dexElements = makeInMemoryDexElements(dexFiles, suppressedExceptions);
        if (suppressedExceptions.size() > 0) {
            this.dexElementsSuppressedExceptions =
                    suppressedExceptions.toArray(new IOException[suppressedExceptions.size()]);
        } else {
            dexElementsSuppressedExceptions = null;
        }
    }

接下來看看dexElements 是何方神圣！？
這是dexElements的物件宣告

  /**
     * List of dex/resource (class path) elements.
     * Should be called pathElements, but the Facebook app uses reflection
     * to modify 'dexElements' (http://b/7726934).
     */
    private Element[] dexElements;

重點來了：

 /**
     * Element of the dex/resource path. Note: should be called DexElement, but apps reflect on
     * this.
     */
    /*package*/ static class Element {
        /**
         * A file denoting a zip file (in case of a resource jar or a dex jar), or a directory
         * (only when dexFile is null).
         */
        private final File path;

        private final DexFile dexFile;

        private ClassPathURLStreamHandler urlHandler;
        private boolean initialized;

        /**
         * Element encapsulates a dex file. This may be a plain dex file (in which case dexZipPath
         * should be null), or a jar (in which case dexZipPath should denote the zip file).
         */
        public Element(DexFile dexFile, File dexZipPath) {
            this.dexFile = dexFile;
            this.path = dexZipPath;
        }

        public Element(DexFile dexFile) {
            this.dexFile = dexFile;
            this.path = null;
        }

        public Element(File path) {
          this.path = path;
          this.dexFile = null;
        }
        ....
     }

從上面代碼可以看到Element存放了dex檔案的實體，和對應路徑，

回來~從BaseDexClassLoader.findClass()->DexPathList.findClass()
就看看DexPathList.findClass()的實作內容

public Class<?> findClass(String name, List<Throwable> suppressed) {
//遍歷dexElements，findClass()
        for (Element element : dexElements) {
        /
            Class<?> clazz = element.findClass(name, definingContext, suppressed);
            if (clazz != null) {
                return clazz;
            }
        }

        if (dexElementsSuppressedExceptions != null) {
            suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
        }
        return null;
    }

看看element.findClass()

 public Class<?> findClass(String name, ClassLoader definingContext,
                List<Throwable> suppressed) {
            return dexFile != null ? dexFile.loadClassBinaryName(name, definingContext, suppressed)
                    : null;
        }

dexFile.loadClassBinaryName(）

  public Class loadClassBinaryName(String name, ClassLoader loader, List<Throwable> suppressed) {
        return defineClass(name, loader, mCookie, this, suppressed);
    }

    private static Class defineClass(String name, ClassLoader loader, Object cookie,
                                     DexFile dexFile, List<Throwable> suppressed) {
        Class result = null;
        try {

            //呼叫native
            result = defineClassNative(name, loader, cookie, dexFile);
        } catch (NoClassDefFoundError e) {
            if (suppressed != null) {
                suppressed.add(e);
            }
        } catch (ClassNotFoundException e) {
            if (suppressed != null) {
                suppressed.add(e);
            }
        }
        return result;
    }

native方法往下就不再分析，從這波代碼分析，找到一個重要轉折點dexElements(Element陣列)，每當找應用程式的類時，都會遍歷這個陣列，找到目的的dex檔案，再得到目的Class，
回到加固
由此，我們把解密的dex檔案通過反射合并到這個dexElements物件(Element陣列)就完事，
如下圖：
上圖對應以下代碼：

public class ProxyApplication extends Application {

    //定義好解密后的檔案的存放路徑
    private String app_name;
    private String app_version;

    /**
     * ActivityThread創建Application之后呼叫的第一個方法
     * 可以在這個方法中進行解密，同時把dex交給android去加載
     */
    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        //獲取用戶填入的metadata
        getMetaData();

        //得到當前加密了的APK檔案
        File apkFile=new File(getApplicationInfo().sourceDir);
        //把apk解壓   app_name+"_"+app_version目錄中的內容需要root權限才能用
        File versionDir = getDir(app_name+"_"+app_version,MODE_PRIVATE);
        File appDir=new File(versionDir,"app");
        File dexDir=new File(appDir,"dexDir");

        Log.e("ProxyApplication", "attachBaseContext:first "+apkFile.getAbsolutePath() );
        Log.e("ProxyApplication", "attachBaseContext:sec "+versionDir.getAbsolutePath() );

        //得到我們需要加載的Dex檔案
        List<File> dexFiles=new ArrayList<>();
        //進行解密（最好做MD5檔案校驗）
        if(!dexDir.exists() || dexDir.list().length==0){
            //把apk解壓到appDir
            Zip.unZip(apkFile,appDir);
            //獲取目錄下所有的檔案
            File[] files=appDir.listFiles();
            for (File file : files) {
                String name=file.getName();
                if(name.endsWith(".dex") && !TextUtils.equals(name,"classes.dex")){
                    try{
                        AES.init(AES.DEFAULT_PWD);
                        //讀取檔案內容
                        byte[] bytes=Utils.getBytes(file);
                        //解密
                        byte[] decrypt=AES.decrypt(bytes);
                        //寫到指定的目錄
                        FileOutputStream fos=new FileOutputStream(file);
                        fos.write(decrypt);
                        fos.flush();
                        fos.close();
                        dexFiles.add(file);

                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }else{
            for (File file : dexDir.listFiles()) {
                dexFiles.add(file);
            }
        }

        try{
            //2.把解密后的檔案加載到系統
            loadDex(dexFiles,versionDir);
        }catch (Exception e){
            e.printStackTrace();
        }


    }

    private void loadDex(List<File> dexFiles, File versionDir) throws Exception{
        //1.獲取pathlist
        Field pathListField = Utils.findField(getClassLoader(), "pathList");
        Object pathList = pathListField.get(getClassLoader());
        //2.獲取陣列dexElements
        Field dexElementsField=Utils.findField(pathList,"dexElements");
        Object[] dexElements=(Object[])dexElementsField.get(pathList);
        //3.反射到初始化dexElements的方法
        Method makeDexElements=Utils.findMethod(pathList,"makePathElements",List.class,File.class,List.class);

        ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();
        Object[] addElements=(Object[])makeDexElements.invoke(pathList,dexFiles,versionDir,suppressedExceptions);

        //合并陣列
        Object[] newElements= (Object[])Array.newInstance(dexElements.getClass().getComponentType(),dexElements.length+addElements.length);
        System.arraycopy(dexElements,0,newElements,0,dexElements.length);
        System.arraycopy(addElements,0,newElements,dexElements.length,addElements.length);

        //替換classloader中的element陣列
        dexElementsField.set(pathList,newElements);
    }

    private void getMetaData() {
        try{
            ApplicationInfo applicationInfo = getPackageManager().getApplicationInfo(
                    getPackageName(), PackageManager.GET_META_DATA);
            Bundle metaData=applicationInfo.metaData;
            if(null!=metaData){
                if(metaData.containsKey("app_name")){
                    app_name=metaData.getString("app_name");
                }
                if(metaData.containsKey("app_version")){
                    app_version=metaData.getString("app_version");
                }
            }

        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

（tinker熱修復共同點：加入新dex去dexElements）
探討2: 初次冷啟動ProxyApplication行程時，已經將ProxyApplication作為入口，后續的冷啟動如何更替為真正的MyApplication作為真正的應用入口？
…