Android 中的反编译、混淆和加固

很久没写博文了，晚上做噩梦醒来了，顺手写一下吧

反编译

准备工具

• apktool：
  获取 APK 的资源文件，能够提取 APP 的图片文件和布局文件
  下载地址：apktool
• dex2jar：
  将 classes.dex转化成jar文件
  下载地址：dex2jar
• jd-gui：
  查看APK中classes.dex转化成出的jar文件
  下载地址：jd-gui

下载后的 apktool 是一个 jar 文件，你需要在这个 jar 文件的同一目录（最好是英文目录）下创建一个 apktool.bat 文件：

@echo off
if "%PATH_BASE%" == "" set PATH_BASE=%PATH%
set PATH=%CD%;%PATH_BASE%;
chcp 65001 2>nul >nul
java -jar -Duser.language=en -Dfile.encoding=UTF8 "%~dp0\apktool_2.4.0.jar" %*
@pause

其中 apktool_2.4.0.jar 修改为你下载的 jar 文件
这时候你通过 CMD 进入到该目录下，执行 apktool 命令，会看到如下内容：

证明 Apktool 可以使用了

开始反编译

使用ApkTool反编译APK得到xml文件、AndroidManifest.xml和图片

进入到存放 apltool 的目录，执行如下命令：

apktool d -f 你要反编译的apK -o 反编译之后存放的文件路径

你会看到如下界面：

这个时候你的文件夹中就会看到这个 APP 相关的资源文件
包含了：

• Manifest 清单文件
• 各种 layout 布局
• 各种 drawable、color、mipmap 资源等等

使用 dex2jar 将 dex 反编译成 jar

• 解压之前下载的 dex2jar
• 解压 APK 文件，你会看到 classes.dex 文件
• 将 classes.dex 放到 dex2jar 目录
• MCD 运行 d2j-dex2jar.bat classes.dex

之后你就会看到 classes-dex2jar.jar

使用 jd-gui 阅读 jar 文件内容

这个就不用说了吧

拿到源码之后自然可以为所欲为了，这么看起来，Android 反编译是不是很简单？那我们的 APP 岂不是完全暴露在别人的目光之下？我们的数据如何得到保障呢？

这里就需要用到混淆加密了：

混淆

混淆又叫 花指令，简单来说，混淆就是将我们 APP 当中的一些关键字、类名等修改为无意义的字符串，加大别人阅读代码的难度，从而达到安全的目的。

开启混淆

AndroidStudio 为我们集成了 ProGuard 作为压缩、优化和混淆工具，ProGurad 是一款开源的混淆工具[这里是它的官网]，在它的官网中这么形容它：

ProGuard also provides minimal protection against reverse engineering by obfuscating the names of classes, fields and methods.

ProGuard 通过模糊类，字段和方法的名称来提供对逆向工程的最小保护。

我们使用它也十分简单，只需要在 Module 下 build.gradle 中配置即可：

android{
  buildTypes{
    release { 
       minifyEnabled false  //是否进行混淆，默认为 false
       // 混淆文件的位置，其中'proguard-android.txt'为sdk默认的混淆配置，
       //'proguard-rules.pro' 是该模块下的混淆配置
       proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'  
    } 
  }
}

然后我们修改 proguard-rules.pro 自定义我们的混淆规则即可

混淆规则

之前说了，混淆实际上是将类、关键字和方法进行模糊处理，我们制定规则，是要标出那些不需要混淆，那么编译时，ProGurad 会将我们没有标识的内容全部混淆。

• 为什么不全部混淆呢？
  • 我们暴露给外部 C/C++ 访问的接口需要通过方法名去访问
  • 混淆 R 文件会导致引用错误。

我们要尽最大限度的将代码混淆，因为混淆程度越大，代码阅读越难，但为了保证正常运行，又有一些不能混淆，那么哪些内容不能混淆呢？

• 自定义控件不参与混淆
• 枚举
• 对第三方库中的类
• 运用了反射的类
• 使用了 Gson 之类的工具要使 JavaBean 类即实体类不被混淆
• 在引用第三方库的时候
• 有用到 WebView 的 JS 调用接口方法
• Parcelable 的子类和 Creator 静态成员变量不混淆
• 使用的四大组件，自定义的Application* 实体类
• JNI中调用的类
• Layout 布局使用的 View 构造函数（自定义控件）、android:onClick等。

ProGuard常用操作

• Shrinking：压缩，默认开启，用以减小应用体积，移除未被使用的类和成员，并且会在优化动作执行之后再次执行（因为优化后可能会再次暴露一些未被使用的类和成员）。

-dontshrink #关闭压缩

• Optimization：优化，默认开启，在字节码级别执行优化，让应用运行的更快。

  -dontoptimize  #关闭优化
  -optimizationpasses n  #表示proguard对代码进行迭代优化的次数，Android一般为5

• Obfuscation：混淆，默认开启，增大反编译难度，类和类成员会被随机命名，除非用keep保护。

 -dontobfuscate  #关闭混淆

• keep：跳过，一颗星表示只是保持该包下的类名，而子包下的类名还是会被混淆；

  -keep class com.lixyz.test.*

• keep：跳过，两颗星表示把本包和所含子包下的类名都保持；

  -keep class com.lixyz.test.**

（上面两种方式保持类后，会发现类名虽然未混淆，但里面的具体方法和变量命名还是变了）

• keep：跳过，既可以保持该包下的类名，又可以保持类里面的内容不被混淆;

   -keep class com.lixyz.test.*{*;}

• keep：跳过，既可以保持该包及子包下的类名，又可以保持类里面的内容不被混淆;

   -keep class com.lixyz.test.**{*;}

• keep：跳过，保持某个类名不被混淆（但是内部内容会被混淆）

   -keep class com.lixyz.BaseDaoImpl

• keep：跳过，保持某个类的 类名及内部的所有内容不会混淆

  -keep class com.lixyz.BaseDaoImpl{*;}

• keep：跳过，保持类中特定内容，而不是所有的内容可以使用如下：

  -keep class com.lixyz.gradlestudy.MyProguardBean{
      <init>; #匹配所有构造器
      <fields>;#匹配所有域
      <methods>;#匹配所有方法
  }

上面就保持住了MyProguardBean这个类中的所有的构造方法、变量、和方法

• 可以在或前面加上private 、public、native等来进一步指定不被混淆的内容

  -keep class com.lixyz.BaseDaoImpl{
      public <methods>;#保持该类下所有的共有方法不被混淆
      public *;#保持该类下所有的共有内容不被混淆
      private <methods>;#保持该类下所有的私有方法不被混淆
      private *;#保持该类下所有的私有内容不被混淆
      public <init>(java.lang.String);#保持该类的String类型的构造方法
  }

• 在方法后加入参数，限制特定的方法(经测试：仅限于构造方法可以混淆)

  -keep class com.lixyz.gradlestudy.MyProguardBean{
      public <init>(String);
  }

• 要保留一个类中的内部类不被混淆需要用 $ 符号

  #保持ProguardTest中的MyClass不被混淆
  -keep class com.lixyz.ProguardTest$MyClass{*;}

• 使用Java的基本规则来保护特定类不被混淆，比如用extends，implement等这些Java规则，如下：保持Android底层组件和类不要混淆

  -keep public class * extends android.app.Activity
  -keep public class * extends android.app.Application
  -keep public class * extends android.app.Service
  -keep public class * extends android.content.BroadcastReceiver
  -keep public class * extends android.content.ContentProvider
  -keep public class * extends android.view.View

• 如果不需要保持类名，只需要保持该类下的特定方法保持不被混淆，需要使用keepclassmembers，而不是keep，因为keep方法会保持类名。

  #保持ProguardTest类下test(String)方法不被混淆
  -keepclassmembernames class com.lixyz.ProguardTest{
      public void test(java.lang.String);
  }

• 如果拥有某成员，保留类和类成员

  -keepclasseswithmembernames class com.lixyz.ProguardTest

一个模板，转自：简书 > 一s独秀 > Android混淆

#
#-------------------------------------------基本不用动区域----------------------------------------------
#
#
# -----------------------------基本 -----------------------------
#

# 指定代码的压缩级别 0 - 7(指定代码进行迭代优化的次数，在Android里面默认是5，这条指令也只有在可以优化时起作用。)
-optimizationpasses 5
# 混淆时不会产生形形色色的类名(混淆时不使用大小写混合类名)
-dontusemixedcaseclassnames
# 指定不去忽略非公共的库类(不跳过library中的非public的类)
-dontskipnonpubliclibraryclasses
# 指定不去忽略包可见的库类的成员
-dontskipnonpubliclibraryclassmembers
#不进行优化，建议使用此选项，
-dontoptimize
 # 不进行预校验,Android不需要,可加快混淆速度。
-dontpreverify
# 屏蔽警告
-ignorewarnings
# 指定混淆是采用的算法，后面的参数是一个过滤器
# 这个过滤器是谷歌推荐的算法，一般不做更改
-optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
# 保护代码中的Annotation不被混淆
-keepattributes *Annotation*
# 避免混淆泛型, 这在JSON实体映射时非常重要
-keepattributes Signature
# 抛出异常时保留代码行号
-keepattributes SourceFile,LineNumberTable
 #优化时允许访问并修改有修饰符的类和类的成员，这可以提高优化步骤的结果。
# 比如，当内联一个公共的getter方法时，这也可能需要外地公共访问。
# 虽然java二进制规范不需要这个，要不然有的虚拟机处理这些代码会有问题。当有优化和使用-repackageclasses时才适用。
#指示语：不能用这个指令处理库中的代码，因为有的类和类成员没有设计成public ,而在api中可能变成public
-allowaccessmodification
#当有优化和使用-repackageclasses时才适用。
-repackageclasses ''
 # 混淆时记录日志(打印混淆的详细信息)
 # 这句话能够使我们的项目混淆后产生映射文件
 # 包含有类名->混淆后类名的映射关系
-verbose

#
# ----------------------------- 默认保留 -----------------------------
#
#----------------------------------------------------
# 保持哪些类不被混淆
#继承activity,application,service,broadcastReceiver,contentprovider....不进行混淆
-keep public class * extends android.app.Activity
-keep public class * extends android.app.Application
-keep public class * extends android.support.multidex.MultiDexApplication
-keep public class * extends android.app.Service
-keep public class * extends android.content.BroadcastReceiver
-keep public class * extends android.content.ContentProvider
-keep public class * extends android.app.backup.BackupAgentHelper
-keep public class * extends android.preference.Preference
-keep public class * extends android.view.View
-keep class android.support.** {*;}## 保留support下的所有类及其内部类

-keep public class com.google.vending.licensing.ILicensingService
-keep public class com.android.vending.licensing.ILicensingService
#表示不混淆上面声明的类，最后这两个类我们基本也用不上，是接入Google原生的一些服务时使用的。
#----------------------------------------------------

# 保留继承的
-keep public class * extends android.support.v4.**
-keep public class * extends android.support.v7.**
-keep public class * extends android.support.annotation.**


#表示不混淆任何包含native方法的类的类名以及native方法名，这个和我们刚才验证的结果是一致
-keepclasseswithmembernames class * {
    native <methods>;
}


#这个主要是在layout 中写的onclick方法android:onclick="onClick"，不进行混淆
#表示不混淆Activity中参数是View的方法，因为有这样一种用法，在XML中配置android:onClick=”buttonClick”属性，
#当用户点击该按钮时就会调用Activity中的buttonClick(View view)方法，如果这个方法被混淆的话就找不到了
-keepclassmembers class * extends android.app.Activity{
    public void *(android.view.View);
}

#表示不混淆枚举中的values()和valueOf()方法，枚举我用的非常少，这个就不评论了
-keepclassmembers enum * {
    public static **[] values();
    public static ** valueOf(java.lang.String);
}

#表示不混淆任何一个View中的setXxx()和getXxx()方法，
#因为属性动画需要有相应的setter和getter的方法实现，混淆了就无法工作了。
-keep public class * extends android.view.View{
    *** get*();
    void set*(***);
    public <init>(android.content.Context);
    public <init>(android.content.Context, android.util.AttributeSet);
    public <init>(android.content.Context, android.util.AttributeSet, int);
}
-keepclasseswithmembers class * {
    public <init>(android.content.Context, android.util.AttributeSet);
    public <init>(android.content.Context, android.util.AttributeSet, int);
}

#表示不混淆Parcelable实现类中的CREATOR字段，
#毫无疑问，CREATOR字段是绝对不能改变的，包括大小写都不能变，不然整个Parcelable工作机制都会失败。
-keep class * implements android.os.Parcelable {
  public static final android.os.Parcelable$Creator *;
}
# 这指定了继承Serizalizable的类的如下成员不被移除混淆
-keepclassmembers class * implements java.io.Serializable {
    static final long serialVersionUID;
    private static final java.io.ObjectStreamField[] serialPersistentFields;
    private void writeObject(java.io.ObjectOutputStream);
    private void readObject(java.io.ObjectInputStream);
    java.lang.Object writeReplace();
    java.lang.Object readResolve();
}
# 保留R下面的资源
#-keep class **.R$* {
# *;
#}
#不混淆资源类下static的
-keepclassmembers class **.R$* {
    public static <fields>;
}

# 对于带有回调函数的onXXEvent、**On*Listener的，不能被混淆
-keepclassmembers class * {
    void *(**On*Event);
    void *(**On*Listener);
}

# 保留我们自定义控件（继承自View）不被混淆
-keep public class * extends android.view.View{
    *** get*();
    void set*(***);
    public <init>(android.content.Context);
    public <init>(android.content.Context, android.util.AttributeSet);
    public <init>(android.content.Context, android.util.AttributeSet, int);
}

#
#----------------------------- WebView(项目中没有可以忽略) -----------------------------
#
#webView需要进行特殊处理
-keepclassmembers class fqcn.of.javascript.interface.for.Webview {
   public *;
}
-keepclassmembers class * extends android.webkit.WebViewClient {
    public void *(android.webkit.WebView, java.lang.String, android.graphics.Bitmap);
    public boolean *(android.webkit.WebView, java.lang.String);
}
-keepclassmembers class * extends android.webkit.WebViewClient {
    public void *(android.webkit.WebView, jav.lang.String);
}
#在app中与HTML5的JavaScript的交互进行特殊处理
#我们需要确保这些js要调用的原生方法不能够被混淆，于是我们需要做如下处理：
-keepclassmembers class com.ljd.example.JSInterface {
    <methods>;
}

#
#---------------------------------实体类---------------------------------
#--------(实体Model不能混淆，否则找不到对应的属性获取不到值)-----
#
-dontwarn com.suchengkeji.android.confusiondemo.md.**
#对含有反射类的处理
-keep class com.suchengkeji.android.confusiondemo.md.** { *; }
#
# ----------------------------- 其他的 -----------------------------
#
# 删除代码中Log相关的代码
-assumenosideeffects class android.util.Log {
    public static boolean isLoggable(java.lang.String, int);
    public static int v(...);
    public static int i(...);
    public static int w(...);
    public static int d(...);
    public static int e(...);
}

# 保持测试相关的代码
-dontnote junit.framework.**
-dontnote junit.runner.**
-dontwarn android.test.**
-dontwarn android.support.test.**
-dontwarn org.junit.**


#
# ----------------------------- 第三方 -----------------------------
#
-dontwarn com.orhanobut.logger.**
-keep class com.orhanobut.logger.**{*;}
-keep interface com.orhanobut.logger.**{*;}

-dontwarn com.google.gson.**
-keep class com.google.gson.**{*;}
-keep interface com.google.gson.**{*;}
#        。。。。。。

加固

之前说的混淆可以增加反编译代码的阅读难度，从而达到安全的目的，但反编译技术日新月异，APK 的保护措施也不能停止，现在网上有很多给 APK 加固的技术，本质上是给 APK 穿一件衣服加一层壳。

比较推荐腾讯的 乐固，官方地址，相当于在混淆的基础上又多了一层保护。

操作傻瓜式的，就不赘述了，看官网吧。

想要了解原理的，可以戳这个链接：Android中的Apk的加固(加壳)原理解析和实现（转）