Android中的Apk的加固(加壳)原理解析和实现(转)

一、前言

今天又到周末了,憋了好久又要出博客了,今天来介绍一下Android中的如何对Apk进行加固的原理。现阶段。我们知道Android中的反编译工作越来越让人操作熟练,我们辛苦的开发出一个apk,结果被人反编译了,那心情真心不舒服。虽然我们混淆,做到native层,但是这都是治标不治本。反编译的技术在更新,那么保护Apk的技术就不能停止。现在网上有很多Apk加固的第三方平台,最有名的应当属于:爱加密和梆梆加固了。其实加固有些人认为很高深的技术,其实不然,说的简单点就是对源Apk进行加密,然后在套上一层壳即可,当然这里还有一些细节需要处理,这就是本文需要介绍的内容了。

二、原理解析

下面就来看一下Android中加壳的原理:

我们在加固的过程中需要三个对象:

1、需要加密的Apk(源Apk)

2、壳程序Apk(负责解密Apk工作)

3、加密工具(将源Apk进行加密和壳Dex合并成新的Dex)


主要步骤:

我们拿到需要加密的Apk和自己的壳程序Apk,然后用加密算法对源Apk进行加密在将壳Apk进行合并得到新的Dex文件,最后替换壳程序中的dex文件即可,得到新的Apk,那么这个新的Apk我们也叫作脱壳程序Apk.他已经不是一个完整意义上的Apk程序了,他的主要工作是:负责解密源Apk.然后加载Apk,让其正常运行起来。

在这个过程中我们可能需要了解的一个知识是:如何将源Apk和壳Apk进行合并成新的Dex

这里就需要了解Dex文件的格式了。下面就来简单介绍一下Dex文件的格式

具体Dex文件格式的详细介绍可以查看这个文件:http://download.csdn.net/detail/jiangwei0910410003/9102599

主要来看一下Dex文件的头部信息,其实Dex文件和Class文件的格式分析原理都是一样的,他们都是有固定的格式,我们知道现在反编译的一些工具:

1、jd-gui:可以查看jar中的类,其实他就是解析class文件,只要了解class文件的格式就可以

2、dex2jar:将dex文件转化成jar,原理也是一样的,只要知道Dex文件的格式,能够解析出dex文件中的类信息就可以了

当然我们在分析这个文件的时候,最重要的还是头部信息,应该他是一个文件的开始部分,也是索引部分,内部信息很重要。

我们今天只要关注上面红色标记的三个部分:

1) checksum

文件校验码 ,使用alder32 算法校验文件除去 maigc ,checksum 外余下的所有文件区域 ,用于检查文件错误 。

2) signature

使用 SHA-1 算法 hash 除去 magic ,checksum 和 signature 外余下的所有文件区域 ,用于唯一识别本文件 。

3) file_size

Dex 文件的大小 。

为什么说我们只需要关注这三个字段呢?

因为我们需要将一个文件(加密之后的源Apk)写入到Dex中,那么我们肯定需要修改文件校验码(checksum).因为他是检查文件是否有错误。那么signature也是一样,也是唯一识别文件的算法。还有就是需要修改dex文件的大小。

不过这里还需要一个操作,就是标注一下我们加密的Apk的大小,因为我们在脱壳的时候,需要知道Apk的大小,才能正确的得到Apk。那么这个值放到哪呢?这个值直接放到文件的末尾就可以了。

所以总结一下我们需要做:修改Dex的三个文件头,将源Apk的大小追加到壳dex的末尾就可以了。

我们修改之后得到新的Dex文件样式如下:

那么我们知道原理了,下面就是代码实现了。所以这里有三个工程:

1、源程序项目(需要加密的Apk)

2、脱壳项目(解密源Apk和加载Apk)

3、对源Apk进行加密和脱壳项目的Dex的合并

三、项目案例

下面先来看一下源程序

1、需要加密的源程序Apk项目:ForceApkObj

需要一个Application类,这个到后面说为什么需要:

MyApplication.java

[java] view plaincopy

  1. package com.example.forceapkobj; 
  2. import android.app.Application; 
  3. import android.util.Log; 
  4. public class MyApplication extends Application{ 
  5. @Override
  6. public void onCreate() { 
  7. super.onCreate(); 
  8.         Log.i("demo", "source apk onCreate:"+this); 
  9.     } 

就是打印一下onCreate方法。

MainActivity.java

[java] view plaincopy

  1. package com.example.forceapkobj; 
  2. import android.app.Activity; 
  3. import android.content.Intent; 
  4. import android.os.Bundle; 
  5. import android.util.Log; 
  6. import android.view.View; 
  7. import android.view.View.OnClickListener; 
  8. import android.widget.TextView; 
  9. public class MainActivity extends Activity { 
  10. @Override
  11. protected void onCreate(Bundle savedInstanceState) { 
  12. super.onCreate(savedInstanceState); 
  13.         TextView content = new TextView(this); 
  14.         content.setText("I am Source Apk"); 
  15.         content.setOnClickListener(new OnClickListener(){ 
  16. @Override
  17. public void onClick(View arg0) { 
  18.                 Intent intent = new Intent(MainActivity.this, SubActivity.class); 
  19.                 startActivity(intent); 
  20.             }}); 
  21.         setContentView(content); 
  22.         Log.i("demo", "app:"+getApplicationContext()); 
  23.     } 

也是打印一下内容。

2、加壳程序项目:DexShellTools

加壳程序其实就是一个Java工程,因为我们从上面的分析可以看到,他的工作就是加密源Apk,然后将其写入到脱壳Dex文件中,修改文件头,得到一个新的Dex文件即可。

看一下代码:

[java] view plaincopy

  1. package com.example.reforceapk; 
  2. import java.io.ByteArrayOutputStream; 
  3. import java.io.File; 
  4. import java.io.FileInputStream; 
  5. import java.io.FileOutputStream; 
  6. import java.io.IOException; 
  7. import java.security.MessageDigest; 
  8. import java.security.NoSuchAlgorithmException; 
  9. import java.util.zip.Adler32; 
  10. public class mymain { 
  11. /**
  12.      * @param args
  13.      */
  14. public static void main(String[] args) { 
  15. // TODO Auto-generated method stub
  16. try { 
  17.             File payloadSrcFile = new File("force/ForceApkObj.apk");   //需要加壳的程序
  18.             System.out.println("apk size:"+payloadSrcFile.length()); 
  19.             File unShellDexFile = new File("force/ForceApkObj.dex");    //解客dex
  20. byte[] payloadArray = encrpt(readFileBytes(payloadSrcFile));//以二进制形式读出apk,并进行加密处理//对源Apk进行加密操作
  21. byte[] unShellDexArray = readFileBytes(unShellDexFile);//以二进制形式读出dex
  22. int payloadLen = payloadArray.length; 
  23. int unShellDexLen = unShellDexArray.length; 
  24. int totalLen = payloadLen + unShellDexLen +4;//多出4字节是存放长度的。
  25. byte[] newdex = new byte[totalLen]; // 申请了新的长度
  26. //添加解壳代码
  27.             System.arraycopy(unShellDexArray, 0, newdex, 0, unShellDexLen);//先拷贝dex内容
  28. //添加加密后的解壳数据
  29.             System.arraycopy(payloadArray, 0, newdex, unShellDexLen, payloadLen);//再在dex内容后面拷贝apk的内容
  30. //添加解壳数据长度
  31.             System.arraycopy(intToByte(payloadLen), 0, newdex, totalLen-4, 4);//最后4为长度
  32. //修改DEX file size文件头
  33.             fixFileSizeHeader(newdex); 
  34. //修改DEX SHA1 文件头
  35.             fixSHA1Header(newdex); 
  36. //修改DEX CheckSum文件头
  37.             fixCheckSumHeader(newdex); 
  38.             String str = "force/classes.dex"; 
  39.             File file = new File(str); 
  40. if (!file.exists()) { 
  41.                 file.createNewFile(); 
  42.             } 
  43.             FileOutputStream localFileOutputStream = new FileOutputStream(str); 
  44.             localFileOutputStream.write(newdex); 
  45.             localFileOutputStream.flush(); 
  46.             localFileOutputStream.close(); 
  47.         } catch (Exception e) { 
  48.             e.printStackTrace(); 
  49.         } 
  50.     } 
  51. //直接返回数据,读者可以添加自己加密方法
  52. private static byte[] encrpt(byte[] srcdata){ 
  53. for(int i = 0;i<srcdata.length;i++){ 
  54.             srcdata[i] = (byte)(0xFF ^ srcdata[i]); 
  55.         } 
  56. return srcdata; 
  57.     } 
  58. /**
  59.      * 修改dex头,CheckSum 校验码
  60.      * @param dexBytes
  61.      */
  62. private static void fixCheckSumHeader(byte[] dexBytes) { 
  63.         Adler32 adler = new Adler32(); 
  64.         adler.update(dexBytes, 12, dexBytes.length - 12);//从12到文件末尾计算校验码
  65. long value = adler.getValue(); 
  66. int va = (int) value; 
  67. byte[] newcs = intToByte(va); 
  68. //高位在前,低位在前掉个个
  69. byte[] recs = new byte[4]; 
  70. for (int i = 0; i < 4; i++) { 
  71.             recs[i] = newcs[newcs.length - 1 - i]; 
  72.             System.out.println(Integer.toHexString(newcs[i])); 
  73.         } 
  74.         System.arraycopy(recs, 0, dexBytes, 8, 4);//效验码赋值(8-11)
  75.         System.out.println(Long.toHexString(value)); 
  76.         System.out.println(); 
  77.     } 
  78. /**
  79.      * int 转byte[]
  80.      * @param number
  81.      * @return
  82.      */
  83. public static byte[] intToByte(int number) { 
  84. byte[] b = new byte[4]; 
  85. for (int i = 3; i >= 0; i--) { 
  86.             b[i] = (byte) (number % 256); 
  87.             number >>= 8; 
  88.         } 
  89. return b; 
  90.     } 
  91. /**
  92.      * 修改dex头 sha1值
  93.      * @param dexBytes
  94.      * @throws NoSuchAlgorithmException
  95.      */
  96. private static void fixSHA1Header(byte[] dexBytes) 
  97. throws NoSuchAlgorithmException { 
  98.         MessageDigest md = MessageDigest.getInstance("SHA-1"); 
  99.         md.update(dexBytes, 32, dexBytes.length - 32);//从32为到结束计算sha--1
  100. byte[] newdt = md.digest(); 
  101.         System.arraycopy(newdt, 0, dexBytes, 12, 20);//修改sha-1值(12-31)
  102. //输出sha-1值,可有可无
  103.         String hexstr = ""; 
  104. for (int i = 0; i < newdt.length; i++) { 
  105.             hexstr += Integer.toString((newdt[i] & 0xff) + 0x100, 16) 
  106.                     .substring(1); 
  107.         } 
  108.         System.out.println(hexstr); 
  109.     } 
  110. /**
  111.      * 修改dex头 file_size值
  112.      * @param dexBytes
  113.      */
  114. private static void fixFileSizeHeader(byte[] dexBytes) { 
  115. //新文件长度
  116. byte[] newfs = intToByte(dexBytes.length); 
  117.         System.out.println(Integer.toHexString(dexBytes.length)); 
  118. byte[] refs = new byte[4]; 
  119. //高位在前,低位在前掉个个
  120. for (int i = 0; i < 4; i++) { 
  121.             refs[i] = newfs[newfs.length - 1 - i]; 
  122.             System.out.println(Integer.toHexString(newfs[i])); 
  123.         } 
  124.         System.arraycopy(refs, 0, dexBytes, 32, 4);//修改(32-35)
  125.     } 
  126. /**
  127.      * 以二进制读出文件内容
  128.      * @param file
  129.      * @return
  130.      * @throws IOException
  131.      */
  132. private static byte[] readFileBytes(File file) throws IOException { 
  133. byte[] arrayOfByte = new byte[1024]; 
  134.         ByteArrayOutputStream localByteArrayOutputStream = new ByteArrayOutputStream(); 
  135.         FileInputStream fis = new FileInputStream(file); 
  136. while (true) { 
  137. int i = fis.read(arrayOfByte); 
  138. if (i != -1) { 
  139.                 localByteArrayOutputStream.write(arrayOfByte, 0, i); 
  140.             } else { 
  141. return localByteArrayOutputStream.toByteArray(); 
  142.             } 
  143.         } 
  144.     } 

下面来分析一下:

红色部分其实就是最核心的工作:

1>、加密源程序Apk文件

[java] view plaincopy

  1. byte[] payloadArray = encrpt(readFileBytes(payloadSrcFile));//以二进制形式读出apk,并进行加密处理//对源Apk进行加密操作

加密算法很简单:

[java] view plaincopy

  1. //直接返回数据,读者可以添加自己加密方法
  2. private static byte[] encrpt(byte[] srcdata){ 
  3. for(int i = 0;i<srcdata.length;i++){ 
  4.         srcdata[i] = (byte)(0xFF ^ srcdata[i]); 
  5.     } 
  6. return srcdata; 

对每个字节进行异或一下即可。

(说明:这里是为了简单,所以就用了很简单的加密算法了,其实为了增加破解难度,我们应该使用更高效的加密算法,同事最好将加密操作放到native层去做)

2>、合并文件:将加密之后的Apk和原脱壳Dex进行合并

[java] view plaincopy

  1. int payloadLen = payloadArray.length; 
  2. int unShellDexLen = unShellDexArray.length; 
  3. int totalLen = payloadLen + unShellDexLen +4;//多出4字节是存放长度的。
  4. byte[] newdex = new byte[totalLen]; // 申请了新的长度
  5. //添加解壳代码
  6. System.arraycopy(unShellDexArray, 0, newdex, 0, unShellDexLen);//先拷贝dex内容
  7. //添加加密后的解壳数据
  8. System.arraycopy(payloadArray, 0, newdex, unShellDexLen, payloadLen);//再在dex内容后面拷贝apk的内容

3>、在文件的末尾追加源程序Apk的长度

[java] view plaincopy

  1. //添加解壳数据长度
  2. System.arraycopy(intToByte(payloadLen), 0, newdex, totalLen-4, 4);//最后4为长度

4>、修改新Dex文件的文件头信息:file_size; sha1; check_sum

[java] view plaincopy

  1. //修改DEX file size文件头
  2. fixFileSizeHeader(newdex); 
  3. //修改DEX SHA1 文件头
  4. fixSHA1Header(newdex); 
  5. //修改DEX CheckSum文件头
  6. fixCheckSumHeader(newdex); 

具体修改可以参照之前说的文件头格式,修改指定位置的字节值即可。

这里我们还需要两个输入文件:

1>、源Apk文件:ForceApkObj.apk

2>、脱壳程序的Dex文件:ForceApkObj.dex

那么第一个文件我们都知道,就是上面的源程序编译之后的Apk文件,那么第二个文件我们怎么得到呢?这个就是我们要讲到的第三个项目:脱壳程序项目,他是一个Android项目,我们在编译之后,能够得到他的classes.dex文件,然后修改一下名称就可。

3、脱壳项目:ReforceApk

在讲解这个项目之前,我们先来了解一下这个脱壳项目的工作:

1>、通过反射置换android.app.ActivityThread 中的mClassLoader为加载解密出APK的DexClassLoader,该DexClassLoader一方面加载了源程序、另一方面以原mClassLoader为父节点,这就保证了即加载了源程序又没有放弃原先加载的资源与系统代码。

关于这部分内容,不了解的同学可以看一下ActivityThread.java的源码:

或者直接看一下这篇文章:

http://blog.csdn.net/jiangwei0910410003/article/details/48104455

如何得到系统加载Apk的类加载器,然后我们怎么将加载进来的Apk运行起来等问题都在这篇文章中说到了。

2>、找到源程序的Application,通过反射建立并运行。

这里需要注意的是,我们现在是加载一个完整的Apk,让他运行起来,那么我们知道一个Apk运行的时候都是有一个Application对象的,这个也是一个程序运行之后的全局类。所以我们必须找到解密之后的源Apk的Application类,运行的他的onCreate方法,这样源Apk才开始他的运行生命周期。这里我们如何得到源Apk的Application的类呢?这个我们后面会说道。使用meta标签进行设置。

下面来看一下整体的流程图:

所以我们看到这里还需要一个核心的技术就是动态加载。关于动态加载技术,不了解的同学可以看这篇文章:

http://blog.csdn.net/jiangwei0910410003/article/details/48104581

下面来看一下代码:

[java] view plaincopy

  1. package com.example.reforceapk; 
  2. import java.io.BufferedInputStream; 
  3. import java.io.ByteArrayInputStream; 
  4. import java.io.ByteArrayOutputStream; 
  5. import java.io.DataInputStream; 
  6. import java.io.File; 
  7. import java.io.FileInputStream; 
  8. import java.io.FileOutputStream; 
  9. import java.io.IOException; 
  10. import java.lang.ref.WeakReference; 
  11. import java.lang.reflect.Method; 
  12. import java.util.ArrayList; 
  13. import java.util.HashMap; 
  14. import java.util.Iterator; 
  15. import java.util.zip.ZipEntry; 
  16. import java.util.zip.ZipInputStream; 
  17. import android.app.Application; 
  18. import android.app.Instrumentation; 
  19. import android.content.Context; 
  20. import android.content.pm.ApplicationInfo; 
  21. import android.content.pm.PackageManager; 
  22. import android.content.pm.PackageManager.NameNotFoundException; 
  23. import android.content.res.AssetManager; 
  24. import android.content.res.Resources; 
  25. import android.content.res.Resources.Theme; 
  26. import android.os.Bundle; 
  27. import android.util.ArrayMap; 
  28. import android.util.Log; 
  29. import dalvik.system.DexClassLoader; 
  30. public class ProxyApplication extends Application{ 
  31. private static final String appkey = "APPLICATION_CLASS_NAME"; 
  32. private String apkFileName; 
  33. private String odexPath; 
  34. private String libPath; 
  35. //这是context 赋值
  36. @Override
  37. protected void attachBaseContext(Context base) { 
  38. super.attachBaseContext(base); 
  39. try { 
  40. //创建两个文件夹payload_odex,payload_lib 私有的,可写的文件目录
  41.             File odex = this.getDir("payload_odex", MODE_PRIVATE); 
  42.             File libs = this.getDir("payload_lib", MODE_PRIVATE); 
  43.             odexPath = odex.getAbsolutePath(); 
  44.             libPath = libs.getAbsolutePath(); 
  45.             apkFileName = odex.getAbsolutePath() + "/payload.apk"; 
  46.             File dexFile = new File(apkFileName); 
  47.             Log.i("demo", "apk size:"+dexFile.length()); 
  48. if (!dexFile.exists()) 
  49.             { 
  50.                 dexFile.createNewFile();  //在payload_odex文件夹内,创建payload.apk
  51. // 读取程序classes.dex文件
  52. byte[] dexdata = this.readDexFileFromApk(); 
  53. // 分离出解壳后的apk文件已用于动态加载
  54. this.splitPayLoadFromDex(dexdata); 
  55.             } 
  56. // 配置动态加载环境
  57.             Object currentActivityThread = RefInvoke.invokeStaticMethod( 
  58. "android.app.ActivityThread", "currentActivityThread", 
  59. new Class[] {}, new Object[] {});//获取主线程对象 http://blog.csdn.net/myarrow/article/details/14223493
  60.             String packageName = this.getPackageName();//当前apk的包名
  61. //下面两句不是太理解
  62.             ArrayMap mPackages = (ArrayMap) RefInvoke.getFieldOjbect( 
  63. "android.app.ActivityThread", currentActivityThread, 
  64. "mPackages"); 
  65.             WeakReference wr = (WeakReference) mPackages.get(packageName); 
  66. //创建被加壳apk的DexClassLoader对象  加载apk内的类和本地代码(c/c++代码)
  67.             DexClassLoader dLoader = new DexClassLoader(apkFileName, odexPath, 
  68.                     libPath, (ClassLoader) RefInvoke.getFieldOjbect( 
  69. "android.app.LoadedApk", wr.get(), "mClassLoader")); 
  70. //base.getClassLoader(); 是不是就等同于 (ClassLoader) RefInvoke.getFieldOjbect()? 有空验证下//?
  71. //把当前进程的DexClassLoader 设置成了被加壳apk的DexClassLoader  ----有点c++中进程环境的意思~~
  72.             RefInvoke.setFieldOjbect("android.app.LoadedApk", "mClassLoader", 
  73.                     wr.get(), dLoader); 
  74.             Log.i("demo","classloader:"+dLoader); 
  75. try{ 
  76.                 Object actObj = dLoader.loadClass("com.example.forceapkobj.MainActivity"); 
  77.                 Log.i("demo", "actObj:"+actObj); 
  78.             }catch(Exception e){ 
  79.                 Log.i("demo", "activity:"+Log.getStackTraceString(e)); 
  80.             } 
  81.         } catch (Exception e) { 
  82.             Log.i("demo", "error:"+Log.getStackTraceString(e)); 
  83.             e.printStackTrace(); 
  84.         } 
  85.     } 
  86. @Override
  87. public void onCreate() { 
  88.         { 
  89. //loadResources(apkFileName);
  90.             Log.i("demo", "onCreate"); 
  91. // 如果源应用配置有Appliction对象,则替换为源应用Applicaiton,以便不影响源程序逻辑。
  92.             String appClassName = null; 
  93. try { 
  94.                 ApplicationInfo ai = this.getPackageManager() 
  95.                         .getApplicationInfo(this.getPackageName(), 
  96.                                 PackageManager.GET_META_DATA); 
  97.                 Bundle bundle = ai.metaData; 
  98. if (bundle != null && bundle.containsKey("APPLICATION_CLASS_NAME")) { 
  99.                     appClassName = bundle.getString("APPLICATION_CLASS_NAME");//className 是配置在xml文件中的。
  100.                 } else { 
  101.                     Log.i("demo", "have no application class name"); 
  102. return; 
  103.                 } 
  104.             } catch (NameNotFoundException e) { 
  105.                 Log.i("demo", "error:"+Log.getStackTraceString(e)); 
  106.                 e.printStackTrace(); 
  107.             } 
  108. //有值的话调用该Applicaiton
  109.             Object currentActivityThread = RefInvoke.invokeStaticMethod( 
  110. "android.app.ActivityThread", "currentActivityThread", 
  111. new Class[] {}, new Object[] {}); 
  112.             Object mBoundApplication = RefInvoke.getFieldOjbect( 
  113. "android.app.ActivityThread", currentActivityThread, 
  114. "mBoundApplication"); 
  115.             Object loadedApkInfo = RefInvoke.getFieldOjbect( 
  116. "android.app.ActivityThread$AppBindData", 
  117.                     mBoundApplication, "info"); 
  118. //把当前进程的mApplication 设置成了null
  119.             RefInvoke.setFieldOjbect("android.app.LoadedApk", "mApplication", 
  120.                     loadedApkInfo, null); 
  121.             Object oldApplication = RefInvoke.getFieldOjbect( 
  122. "android.app.ActivityThread", currentActivityThread, 
  123. "mInitialApplication"); 
  124. //http://www.codeceo.com/article/android-context.html
  125.             ArrayList<Application> mAllApplications = (ArrayList<Application>) RefInvoke 
  126.                     .getFieldOjbect("android.app.ActivityThread", 
  127.                             currentActivityThread, "mAllApplications"); 
  128.             mAllApplications.remove(oldApplication);//删除oldApplication
  129.             ApplicationInfo appinfo_In_LoadedApk = (ApplicationInfo) RefInvoke 
  130.                     .getFieldOjbect("android.app.LoadedApk", loadedApkInfo, 
  131. "mApplicationInfo"); 
  132.             ApplicationInfo appinfo_In_AppBindData = (ApplicationInfo) RefInvoke 
  133.                     .getFieldOjbect("android.app.ActivityThread$AppBindData", 
  134.                             mBoundApplication, "appInfo"); 
  135.             appinfo_In_LoadedApk.className = appClassName; 
  136.             appinfo_In_AppBindData.className = appClassName; 
  137.             Application app = (Application) RefInvoke.invokeMethod( 
  138. "android.app.LoadedApk", "makeApplication", loadedApkInfo, 
  139. new Class[] { boolean.class, Instrumentation.class }, 
  140. new Object[] { false, null });//执行 makeApplication(false,null)
  141.             RefInvoke.setFieldOjbect("android.app.ActivityThread", 
  142. "mInitialApplication", currentActivityThread, app); 
  143.             ArrayMap mProviderMap = (ArrayMap) RefInvoke.getFieldOjbect( 
  144. "android.app.ActivityThread", currentActivityThread, 
  145. "mProviderMap"); 
  146.             Iterator it = mProviderMap.values().iterator(); 
  147. while (it.hasNext()) { 
  148.                 Object providerClientRecord = it.next(); 
  149.                 Object localProvider = RefInvoke.getFieldOjbect( 
  150. "android.app.ActivityThread$ProviderClientRecord", 
  151.                         providerClientRecord, "mLocalProvider"); 
  152.                 RefInvoke.setFieldOjbect("android.content.ContentProvider", 
  153. "mContext", localProvider, app); 
  154.             } 
  155.             Log.i("demo", "app:"+app); 
  156.             app.onCreate(); 
  157.         } 
  158.     } 
  159. /**
  160.      * 释放被加壳的apk文件,so文件
  161.      * @param data
  162.      * @throws IOException
  163.      */
  164. private void splitPayLoadFromDex(byte[] apkdata) throws IOException { 
  165. int ablen = apkdata.length; 
  166. //取被加壳apk的长度   这里的长度取值,对应加壳时长度的赋值都可以做些简化
  167. byte[] dexlen = new byte[4]; 
  168.         System.arraycopy(apkdata, ablen - 4, dexlen, 0, 4); 
  169.         ByteArrayInputStream bais = new ByteArrayInputStream(dexlen); 
  170.         DataInputStream in = new DataInputStream(bais); 
  171. int readInt = in.readInt(); 
  172.         System.out.println(Integer.toHexString(readInt)); 
  173. byte[] newdex = new byte[readInt]; 
  174. //把被加壳apk内容拷贝到newdex中
  175.         System.arraycopy(apkdata, ablen - 4 - readInt, newdex, 0, readInt); 
  176. //这里应该加上对于apk的解密操作,若加壳是加密处理的话
  177. //?
  178. //对源程序Apk进行解密
  179.         newdex = decrypt(newdex); 
  180. //写入apk文件  
  181.         File file = new File(apkFileName); 
  182. try { 
  183.             FileOutputStream localFileOutputStream = new FileOutputStream(file); 
  184.             localFileOutputStream.write(newdex); 
  185.             localFileOutputStream.close(); 
  186.         } catch (IOException localIOException) { 
  187. throw new RuntimeException(localIOException); 
  188.         } 
  189. //分析被加壳的apk文件
  190.         ZipInputStream localZipInputStream = new ZipInputStream( 
  191. new BufferedInputStream(new FileInputStream(file))); 
  192. while (true) { 
  193.             ZipEntry localZipEntry = localZipInputStream.getNextEntry();//不了解这个是否也遍历子目录,看样子应该是遍历的
  194. if (localZipEntry == null) { 
  195.                 localZipInputStream.close(); 
  196. break; 
  197.             } 
  198. //取出被加壳apk用到的so文件,放到 libPath中(data/data/包名/payload_lib)
  199.             String name = localZipEntry.getName(); 
  200. if (name.startsWith("lib/") && name.endsWith(".so")) { 
  201.                 File storeFile = new File(libPath + "/"
  202.                         + name.substring(name.lastIndexOf('/'))); 
  203.                 storeFile.createNewFile(); 
  204.                 FileOutputStream fos = new FileOutputStream(storeFile); 
  205. byte[] arrayOfByte = new byte[1024]; 
  206. while (true) { 
  207. int i = localZipInputStream.read(arrayOfByte); 
  208. if (i == -1) 
  209. break; 
  210.                     fos.write(arrayOfByte, 0, i); 
  211.                 } 
  212.                 fos.flush(); 
  213.                 fos.close(); 
  214.             } 
  215.             localZipInputStream.closeEntry(); 
  216.         } 
  217.         localZipInputStream.close(); 
  218.     } 
  219. /**
  220.      * 从apk包里面获取dex文件内容(byte)
  221.      * @return
  222.      * @throws IOException
  223.      */
  224. private byte[] readDexFileFromApk() throws IOException { 
  225.         ByteArrayOutputStream dexByteArrayOutputStream = new ByteArrayOutputStream(); 
  226.         ZipInputStream localZipInputStream = new ZipInputStream( 
  227. new BufferedInputStream(new FileInputStream( 
  228. this.getApplicationInfo().sourceDir))); 
  229. while (true) { 
  230.             ZipEntry localZipEntry = localZipInputStream.getNextEntry(); 
  231. if (localZipEntry == null) { 
  232.                 localZipInputStream.close(); 
  233. break; 
  234.             } 
  235. if (localZipEntry.getName().equals("classes.dex")) { 
  236. byte[] arrayOfByte = new byte[1024]; 
  237. while (true) { 
  238. int i = localZipInputStream.read(arrayOfByte); 
  239. if (i == -1) 
  240. break; 
  241.                     dexByteArrayOutputStream.write(arrayOfByte, 0, i); 
  242.                 } 
  243.             } 
  244.             localZipInputStream.closeEntry(); 
  245.         } 
  246.         localZipInputStream.close(); 
  247. return dexByteArrayOutputStream.toByteArray(); 
  248.     } 
  249. // //直接返回数据,读者可以添加自己解密方法
  250. private byte[] decrypt(byte[] srcdata) { 
  251. for(int i=0;i<srcdata.length;i++){ 
  252.             srcdata[i] = (byte)(0xFF ^ srcdata[i]); 
  253.         } 
  254. return srcdata; 
  255.     } 
  256. //以下是加载资源
  257. protected AssetManager mAssetManager;//资源管理器 
  258. protected Resources mResources;//资源 
  259. protected Theme mTheme;//主题 
  260. protected void loadResources(String dexPath) {   
  261. try {   
  262.             AssetManager assetManager = AssetManager.class.newInstance();   
  263.             Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);   
  264.             addAssetPath.invoke(assetManager, dexPath);   
  265.             mAssetManager = assetManager;   
  266.         } catch (Exception e) {   
  267.             Log.i("inject", "loadResource error:"+Log.getStackTraceString(e)); 
  268.             e.printStackTrace();   
  269.         }   
  270.         Resources superRes = super.getResources();   
  271.         superRes.getDisplayMetrics();   
  272.         superRes.getConfiguration();   
  273.         mResources = new Resources(mAssetManager, superRes.getDisplayMetrics(),superRes.getConfiguration());   
  274.         mTheme = mResources.newTheme();   
  275.         mTheme.setTo(super.getTheme()); 
  276.     }   
  277. @Override
  278. public AssetManager getAssets() {   
  279. return mAssetManager == null ? super.getAssets() : mAssetManager;   
  280.     }   
  281. @Override
  282. public Resources getResources() {   
  283. return mResources == null ? super.getResources() : mResources;   
  284.     }   
  285. @Override
  286. public Theme getTheme() {   
  287. return mTheme == null ? super.getTheme() : mTheme;   
  288.     }  

首先我们来看一下具体步骤的代码实现:

1>、得到脱壳Apk中的dex文件,然后从这个文件中得到源程序Apk.进行解密,然后加载

[java] view plaincopy

  1. //这是context 赋值
  2. @Override
  3. protected void attachBaseContext(Context base) { 
  4. super.attachBaseContext(base); 
  5. try { 
  6. //创建两个文件夹payload_odex,payload_lib 私有的,可写的文件目录
  7.         File odex = this.getDir("payload_odex", MODE_PRIVATE); 
  8.         File libs = this.getDir("payload_lib", MODE_PRIVATE); 
  9.         odexPath = odex.getAbsolutePath(); 
  10.         libPath = libs.getAbsolutePath(); 
  11.         apkFileName = odex.getAbsolutePath() + "/payload.apk"; 
  12.         File dexFile = new File(apkFileName); 
  13.         Log.i("demo", "apk size:"+dexFile.length()); 
  14. if (!dexFile.exists()) 
  15.         { 
  16.             dexFile.createNewFile();  //在payload_odex文件夹内,创建payload.apk
  17. // 读取程序classes.dex文件
  18. byte[] dexdata = this.readDexFileFromApk(); 
  19. // 分离出解壳后的apk文件已用于动态加载
  20. this.splitPayLoadFromDex(dexdata); 
  21.         } 
  22. // 配置动态加载环境
  23.         Object currentActivityThread = RefInvoke.invokeStaticMethod( 
  24. "android.app.ActivityThread", "currentActivityThread", 
  25. new Class[] {}, new Object[] {});//获取主线程对象 http://blog.csdn.net/myarrow/article/details/14223493
  26.         String packageName = this.getPackageName();//当前apk的包名
  27. //下面两句不是太理解
  28.         ArrayMap mPackages = (ArrayMap) RefInvoke.getFieldOjbect( 
  29. "android.app.ActivityThread", currentActivityThread, 
  30. "mPackages"); 
  31.         WeakReference wr = (WeakReference) mPackages.get(packageName); 
  32. //创建被加壳apk的DexClassLoader对象  加载apk内的类和本地代码(c/c++代码)
  33.         DexClassLoader dLoader = new DexClassLoader(apkFileName, odexPath, 
  34.                 libPath, (ClassLoader) RefInvoke.getFieldOjbect( 
  35. "android.app.LoadedApk", wr.get(), "mClassLoader")); 
  36. //base.getClassLoader(); 是不是就等同于 (ClassLoader) RefInvoke.getFieldOjbect()? 有空验证下//?
  37. //把当前进程的DexClassLoader 设置成了被加壳apk的DexClassLoader  ----有点c++中进程环境的意思~~
  38.         RefInvoke.setFieldOjbect("android.app.LoadedApk", "mClassLoader", 
  39.                 wr.get(), dLoader); 
  40.         Log.i("demo","classloader:"+dLoader); 
  41. try{ 
  42.             Object actObj = dLoader.loadClass("com.example.forceapkobj.MainActivity"); 
  43.             Log.i("demo", "actObj:"+actObj); 
  44.         }catch(Exception e){ 
  45.             Log.i("demo", "activity:"+Log.getStackTraceString(e)); 
  46.         } 
  47.     } catch (Exception e) { 
  48.         Log.i("demo", "error:"+Log.getStackTraceString(e)); 
  49.         e.printStackTrace(); 
  50.     } 

这里需要注意的一个问题,就是我们需要找到一个时机,就是在脱壳程序还没有运行起来的时候,来加载源程序的Apk,执行他的onCreate方法,那么这个时机不能太晚,不然的话,就是运行脱壳程序,而不是源程序了。查看源码我们知道。Application中有一个方法:attachBaseContext这个方法,他在Application的onCreate方法执行前就会执行了,那么我们的工作就需要在这里进行

1)、从脱壳程序Apk中找到源程序Apk,并且进行解密操作

[java] view plaincopy

  1. //创建两个文件夹payload_odex,payload_lib 私有的,可写的文件目录
  2. File odex = this.getDir("payload_odex", MODE_PRIVATE); 
  3. File libs = this.getDir("payload_lib", MODE_PRIVATE); 
  4. odexPath = odex.getAbsolutePath(); 
  5. libPath = libs.getAbsolutePath(); 
  6. apkFileName = odex.getAbsolutePath() + "/payload.apk"; 
  7. File dexFile = new File(apkFileName); 
  8. Log.i("demo", "apk size:"+dexFile.length()); 
  9. if (!dexFile.exists()) 
  10.     dexFile.createNewFile();  //在payload_odex文件夹内,创建payload.apk
  11. // 读取程序classes.dex文件
  12. byte[] dexdata = this.readDexFileFromApk(); 
  13. // 分离出解壳后的apk文件已用于动态加载
  14. this.splitPayLoadFromDex(dexdata); 

这个脱壳解密操作一定要和我们之前的加壳以及加密操作对应,不然就会出现Dex加载错误问题

A) 从Apk中获取到Dex文件

[java] view plaincopy

  1. /**
  2. * 从apk包里面获取dex文件内容(byte)
  3. * @return
  4. * @throws IOException
  5. */
  6. private byte[] readDexFileFromApk() throws IOException { 
  7.     ByteArrayOutputStream dexByteArrayOutputStream = new ByteArrayOutputStream(); 
  8.     ZipInputStream localZipInputStream = new ZipInputStream( 
  9. new BufferedInputStream(new FileInputStream( 
  10. this.getApplicationInfo().sourceDir))); 
  11. while (true) { 
  12.         ZipEntry localZipEntry = localZipInputStream.getNextEntry(); 
  13. if (localZipEntry == null) { 
  14.             localZipInputStream.close(); 
  15. break; 
  16.         } 
  17. if (localZipEntry.getName().equals("classes.dex")) { 
  18. byte[] arrayOfByte = new byte[1024]; 
  19. while (true) { 
  20. int i = localZipInputStream.read(arrayOfByte); 
  21. if (i == -1) 
  22. break; 
  23.                 dexByteArrayOutputStream.write(arrayOfByte, 0, i); 
  24.             } 
  25.         } 
  26.         localZipInputStream.closeEntry(); 
  27.     } 
  28.     localZipInputStream.close(); 
  29. return dexByteArrayOutputStream.toByteArray(); 

其实就是解压Apk文件,直接得到dex文件即可

B) 从脱壳Dex中得到源Apk文件

[java] view plaincopy

  1. /**
  2. * 释放被加壳的apk文件,so文件
  3. * @param data
  4. * @throws IOException
  5. */
  6. private void splitPayLoadFromDex(byte[] apkdata) throws IOException { 
  7. int ablen = apkdata.length; 
  8. //取被加壳apk的长度   这里的长度取值,对应加壳时长度的赋值都可以做些简化
  9. byte[] dexlen = new byte[4]; 
  10.     System.arraycopy(apkdata, ablen - 4, dexlen, 0, 4); 
  11.     ByteArrayInputStream bais = new ByteArrayInputStream(dexlen); 
  12.     DataInputStream in = new DataInputStream(bais); 
  13. int readInt = in.readInt(); 
  14.     System.out.println(Integer.toHexString(readInt)); 
  15. byte[] newdex = new byte[readInt]; 
  16. //把被加壳apk内容拷贝到newdex中
  17.     System.arraycopy(apkdata, ablen - 4 - readInt, newdex, 0, readInt); 
  18. //这里应该加上对于apk的解密操作,若加壳是加密处理的话
  19. //?
  20. //对源程序Apk进行解密
  21.     newdex = decrypt(newdex); 
  22. //写入apk文件  
  23.     File file = new File(apkFileName); 
  24. try { 
  25.         FileOutputStream localFileOutputStream = new FileOutputStream(file); 
  26.         localFileOutputStream.write(newdex); 
  27.         localFileOutputStream.close(); 
  28.     } catch (IOException localIOException) { 
  29. throw new RuntimeException(localIOException); 
  30.     } 
  31. //分析被加壳的apk文件
  32.     ZipInputStream localZipInputStream = new ZipInputStream( 
  33. new BufferedInputStream(new FileInputStream(file))); 
  34. while (true) { 
  35.         ZipEntry localZipEntry = localZipInputStream.getNextEntry();//不了解这个是否也遍历子目录,看样子应该是遍历的
  36. if (localZipEntry == null) { 
  37.             localZipInputStream.close(); 
  38. break; 
  39.         } 
  40. //取出被加壳apk用到的so文件,放到 libPath中(data/data/包名/payload_lib)
  41.         String name = localZipEntry.getName(); 
  42. if (name.startsWith("lib/") && name.endsWith(".so")) { 
  43.             File storeFile = new File(libPath + "/"
  44.                     + name.substring(name.lastIndexOf('/'))); 
  45.             storeFile.createNewFile(); 
  46.             FileOutputStream fos = new FileOutputStream(storeFile); 
  47. byte[] arrayOfByte = new byte[1024]; 
  48. while (true) { 
  49. int i = localZipInputStream.read(arrayOfByte); 
  50. if (i == -1) 
  51. break; 
  52.                 fos.write(arrayOfByte, 0, i); 
  53.             } 
  54.             fos.flush(); 
  55.             fos.close(); 
  56.         } 
  57.         localZipInputStream.closeEntry(); 
  58.     } 
  59.     localZipInputStream.close(); 

C) 解密源程序Apk

[java] view plaincopy

  1. ////直接返回数据,读者可以添加自己解密方法
  2. private byte[] decrypt(byte[] srcdata) { 
  3. for(int i=0;i<srcdata.length;i++){ 
  4.         srcdata[i] = (byte)(0xFF ^ srcdata[i]); 
  5.     } 
  6. return srcdata; 

这个解密算法和加密算法是一致的

2>、加载解密之后的源程序Apk

[java] view plaincopy

  1. //配置动态加载环境
  2. Object currentActivityThread = RefInvoke.invokeStaticMethod( 
  3. "android.app.ActivityThread", "currentActivityThread", 
  4. new Class[] {}, new Object[] {});//获取主线程对象 http://blog.csdn.net/myarrow/article/details/14223493
  5. String packageName = this.getPackageName();//当前apk的包名
  6. //下面两句不是太理解
  7. ArrayMap mPackages = (ArrayMap) RefInvoke.getFieldOjbect( 
  8. "android.app.ActivityThread", currentActivityThread, 
  9. "mPackages"); 
  10. WeakReference wr = (WeakReference) mPackages.get(packageName); 
  11. //创建被加壳apk的DexClassLoader对象  加载apk内的类和本地代码(c/c++代码)
  12. DexClassLoader dLoader = new DexClassLoader(apkFileName, odexPath, 
  13.         libPath, (ClassLoader) RefInvoke.getFieldOjbect( 
  14. "android.app.LoadedApk", wr.get(), "mClassLoader")); 
  15. //base.getClassLoader(); 是不是就等同于 (ClassLoader) RefInvoke.getFieldOjbect()? 有空验证下//?
  16. //把当前进程的DexClassLoader 设置成了被加壳apk的DexClassLoader  ----有点c++中进程环境的意思~~
  17. RefInvoke.setFieldOjbect("android.app.LoadedApk", "mClassLoader", 
  18.         wr.get(), dLoader); 
  19. Log.i("demo","classloader:"+dLoader); 
  20. try{ 
  21.     Object actObj = dLoader.loadClass("com.example.forceapkobj.MainActivity"); 
  22.     Log.i("demo", "actObj:"+actObj); 
  23. }catch(Exception e){ 
  24.     Log.i("demo", "activity:"+Log.getStackTraceString(e)); 

2)、找到源程序的Application程序,让其运行

[java] view plaincopy

  1. @Override
  2. public void onCreate() { 
  3.     { 
  4. //loadResources(apkFileName);
  5.         Log.i("demo", "onCreate"); 
  6. // 如果源应用配置有Appliction对象,则替换为源应用Applicaiton,以便不影响源程序逻辑。
  7.         String appClassName = null; 
  8. try { 
  9.             ApplicationInfo ai = this.getPackageManager() 
  10.                     .getApplicationInfo(this.getPackageName(), 
  11.                             PackageManager.GET_META_DATA); 
  12.             Bundle bundle = ai.metaData; 
  13. if (bundle != null && bundle.containsKey("APPLICATION_CLASS_NAME")) { 
  14.                 appClassName = bundle.getString("APPLICATION_CLASS_NAME");//className 是配置在xml文件中的。
  15.             } else { 
  16.                 Log.i("demo", "have no application class name"); 
  17. return; 
  18.             } 
  19.         } catch (NameNotFoundException e) { 
  20.             Log.i("demo", "error:"+Log.getStackTraceString(e)); 
  21.             e.printStackTrace(); 
  22.         } 
  23. //有值的话调用该Applicaiton
  24.         Object currentActivityThread = RefInvoke.invokeStaticMethod( 
  25. "android.app.ActivityThread", "currentActivityThread", 
  26. new Class[] {}, new Object[] {}); 
  27.         Object mBoundApplication = RefInvoke.getFieldOjbect( 
  28. "android.app.ActivityThread", currentActivityThread, 
  29. "mBoundApplication"); 
  30.         Object loadedApkInfo = RefInvoke.getFieldOjbect( 
  31. "android.app.ActivityThread$AppBindData", 
  32.                 mBoundApplication, "info"); 
  33. //把当前进程的mApplication 设置成了null
  34.         RefInvoke.setFieldOjbect("android.app.LoadedApk", "mApplication", 
  35.                 loadedApkInfo, null); 
  36.         Object oldApplication = RefInvoke.getFieldOjbect( 
  37. "android.app.ActivityThread", currentActivityThread, 
  38. "mInitialApplication"); 
  39. //http://www.codeceo.com/article/android-context.html
  40.         ArrayList<Application> mAllApplications = (ArrayList<Application>) RefInvoke 
  41.                 .getFieldOjbect("android.app.ActivityThread", 
  42.                         currentActivityThread, "mAllApplications"); 
  43.         mAllApplications.remove(oldApplication);//删除oldApplication
  44.         ApplicationInfo appinfo_In_LoadedApk = (ApplicationInfo) RefInvoke 
  45.                 .getFieldOjbect("android.app.LoadedApk", loadedApkInfo, 
  46. "mApplicationInfo"); 
  47.         ApplicationInfo appinfo_In_AppBindData = (ApplicationInfo) RefInvoke 
  48.                 .getFieldOjbect("android.app.ActivityThread$AppBindData", 
  49.                         mBoundApplication, "appInfo"); 
  50.         appinfo_In_LoadedApk.className = appClassName; 
  51.         appinfo_In_AppBindData.className = appClassName; 
  52.         Application app = (Application) RefInvoke.invokeMethod( 
  53. "android.app.LoadedApk", "makeApplication", loadedApkInfo, 
  54. new Class[] { boolean.class, Instrumentation.class }, 
  55. new Object[] { false, null });//执行 makeApplication(false,null)
  56.         RefInvoke.setFieldOjbect("android.app.ActivityThread", 
  57. "mInitialApplication", currentActivityThread, app); 
  58.         ArrayMap mProviderMap = (ArrayMap) RefInvoke.getFieldOjbect( 
  59. "android.app.ActivityThread", currentActivityThread, 
  60. "mProviderMap"); 
  61.         Iterator it = mProviderMap.values().iterator(); 
  62. while (it.hasNext()) { 
  63.             Object providerClientRecord = it.next(); 
  64.             Object localProvider = RefInvoke.getFieldOjbect( 
  65. "android.app.ActivityThread$ProviderClientRecord", 
  66.                     providerClientRecord, "mLocalProvider"); 
  67.             RefInvoke.setFieldOjbect("android.content.ContentProvider", 
  68. "mContext", localProvider, app); 
  69.         } 
  70.         Log.i("demo", "app:"+app); 
  71.         app.onCreate(); 
  72.     } 

直接在脱壳的Application中的onCreate方法中进行就可以了。这里我们还可以看到是通过AndroidManifest.xml中的meta标签获取源程序Apk中的Application对象的。

下面来看一下AndoridManifest.xml文件中的内容:

在这里我们定义了源程序Apk的Application类名。

项目下载:http://download.csdn.net/detail/jiangwei0910410003/9102741

四、运行程序

那么到这里我们就介绍完了,这三个项目的内容,下面就来看看如何运行吧:

运行步骤:

第一步:得到源程序Apk文件和脱壳程序的Dex文件

运行源程序和脱壳程序项目,之后得到这两个文件(记得将classes.dex文件改名ForceApkObj.dex),然后使用加壳程序进行加壳: