1. 首页
  2. Android
  3. Android 代码混淆

Android 代码混淆

2019/03/16 11:56:29 发表 2019/03/18 09:59:06 更新 原创 素颜 699 1 0

我们直接用 Android Studio 来说明如何进行混淆，Android Studio 自身集成 Java 语言的 ProGuard 作为压缩，优化和混淆工具，配合 Gradle 构建工具使用很简单，只需要在工程应用目录的 gradle 文件中设置 minifyEnabled 为 true 即可。然后我们就可以到 proguard-rules.pro 文件中加入我们的混淆规则了。

[TOC]

1、混淆目的

通过代码混淆可以将项目中的类、方法、变量等信息进行重命名，变成一些无意义的简短名字，同时也可以移除未被使用的类、方法、变量等。所以直观的看，通过混淆可以提高程序的安全性，增加逆向工程的难度，同时也有效缩减了apk的体积

2、开启混淆

在基于Android Studio项目的app module的build.gradle中有如下默认代码片段：

  1. buildTypes {
  2.         release {
  3.             // 是否支持zip
  4.             zipAlignEnabled true
  5.             // 注：Android Studio 2.3版本之后默认开启移除无用资源文件
  6.             // 是否进行混淆
  7.             minifyEnabled true
  8.             // 开启资源文件压缩
  9.             shrinkResources true
  10.             // 是否支持调试 测试版开启 正式版关闭
  11.             debuggable false
  12.             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
  13.         }
  14.     }

proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

  • proguard-android.txt代表系统默认的混淆规则配置文件，该文件在Android SDK目录>/tools/proguard下，一般不要更改该配置文件，因为也会作用于其它项目，除非你能确保所做的更改不影响其它项目的混淆。

  • proguard-rules.pro代码表当前project的混淆配置文件，在app module下，可以通过修改该文件来添加适用当前项目的混淆规则。

3、混淆的关键字和通配符

  • Proguard 关键字
关键字 含义
dontwarn dontwarn 是一个和 keep 可以说是形影不离,尤其是处理引入的 library 时.
keep 保留类和类成员，防止被混淆或移除
keepnames 保留类和类成员，防止被混淆，但没有被引用的类成员会被移除
keepclassmembers 只保留类成员，防止被混淆或移除
keepclassmembernames 只保留类成员，防止被混淆，但没有被引用的成员会被移除
keepclasseswithmembers 保留类和类成员，防止被混淆或移除，如果指定的类成员不存在还是会被混淆
keepclasseswithmembernames 保留类和类成员，防止被混淆，如果指定的类成员不存在还是会被混淆，没有被引用的类成员会被移除
  • 通配符
通配符 含义
* 匹配任意长度字符，但不含包名分隔符.。例如一个类的全包名路径是com.mtf.test.Person，使用com.mtf.test.*是可以匹配的，但com.mtf.*就不能匹配
** 匹配任意长度字符，并包含包名分隔符.。例如要匹配com.mtf.test.**包下的所有内容
*** 匹配任意参数类型。例如*** getName(***)可匹配String getName(String)
… 匹配任意长度的任意类型参数。例如void setName(...)可匹配void setName(String firstName, String secondName)
<fileds> 匹配类、接口中所有字段
<methods> 匹配类、接口中所有方法
<init> 匹配类中所有构造函数

4、注意不应该参与混淆的文件或类

  • 使用了自定义控件那么要保证它们不参与混淆
  • 使用了枚举要保证枚举不被混淆
  • 对第三方库中的类不进行混淆
  • 运用了反射的类也不进行混淆
  • 使用了 Gson 之类的工具要使 JavaBean 类即实体类不被混淆
  • 在引用第三方库的时候，一般会标明库的混淆规则的，建议在使用的时候就把混淆规则添加上去，免得到最后才去找
  • 有用到 WebView 的 JS 调用也需要保证写的接口方法不混淆，原因和第一条一样
  • Parcelable 的子类和 Creator 静态成员变量不混淆，否则会产生 Android.os.BadParcelableException 异常
  • 使用的四大组件，自定义的 Application* 实体类
  • JNI 中调用的类
  • Layout 布局使用的 View 构造函数（自定义控件）、android:onClick等。

5、添加混淆配置文件

  1. # -----------------------------基本配置 -----------------------------
  3. # 指定代码的压缩级别 0 - 7(指定代码进行迭代优化的次数，在Android里面默认是5，这条指令也只有在可以优化时起作用。)
  4. -optimizationpasses 5
  5. # 混淆时不会产生形形色色的类名(混淆时不使用大小写混合类名)
  6. -dontusemixedcaseclassnames
  7. # 指定不去忽略非公共的库类(不跳过library中的非public的类)
  8. -dontskipnonpubliclibraryclasses
  9. # 指定不去忽略包可见的库类的成员
  10. -dontskipnonpubliclibraryclassmembers
  11. #不进行优化，建议使用此选项，(不优化输入的类文件)
  12. -dontoptimize
  13. # 不做预校验，可加快混淆速度
  14. # preverify是proguard的4个步骤之一
  15. # Android不需要preverify，去掉这一步可以加快混淆速度
  16. -dontpreverify
  17. # 屏蔽警告
  18. -ignorewarnings
  19. # 指定混淆时采用的算法，后面的参数是一个过滤器
  20. # 这个过滤器是谷歌推荐的算法，一般不做更改
  21. -optimizations !code/simplification/arithmetic,!field/*,!class/merging/* 、
  22. # 保护代码中的Annotation不被混淆
  23. -keepattributes *Annotation*
  24. # 避免混淆泛型, 这在JSON实体映射时非常重要
  25. -keepattributes Signature
  26. # 抛出异常时保留代码行号
  27. -keepattributes SourceFile,LineNumberTable
  28.  #优化时允许访问并修改有修饰符的类和类的成员，这可以提高优化步骤的结果。
  29. # 比如，当内联一个公共的getter方法时，这也可能需要外地公共访问。
  30. # 虽然java二进制规范不需要这个，要不然有的虚拟机处理这些代码会有问题。当有优化和使用-repackageclasses时才适用。
  31. #指示语：不能用这个指令处理库中的代码，因为有的类和类成员没有设计成public ,而在api中可能变成public
  32. -allowaccessmodification
  33. #当有优化和使用-repackageclasses时才适用。
  34. -repackageclasses ''
  35.  # 混淆时记录日志(打印混淆的详细信息)
  36.  # 这句话能够使我们的项目混淆后产生映射文件
  37.  # 包含有类名->混淆后类名的映射关系
  38. -verbose
  39. # 指定映射文件的名称
  40. -printmapping proguardMapping.txt
  1. # -----------------------------Android开发中一些需要保留的公共部分-----------------------------
  3. # 保留我们使用的四大组件，自定义的Application等等这些类不被混淆# 因为这些子类都有可能被外部调用
  4. -keep public class * extends android.app.Activity
  5. -keep public class * extends android.app.Appliction
  6. -keep public class * extends android.app.Service
  7. -keep public class * extends android.content.BroadcastReceiver
  8. -keep public class * extends android.content.ContentProvider
  9. -keep public class * extends android.app.backup.BackupAgentHelper
  10. -keep public class * extends android.preference.Preference
  11. -keep public class * extends android.view.View
  12. -keep public class com.android.vending.licensing.ILicensingService
  14. # 保留support下的所有类及其内部类
  15. -keep class android.support.** {*;}
  16. -dontwarn javax.annotation.**
  17. ## 保留继承的
  18. ## support-v4
  19. #-dontwarn android.support.v4.**
  20. #-keep class android.support.v4.** { *; }
  21. #-keep interface android.support.v4.** { *; }
  22. #-keep public class * extends android.support.v4.**
  23. ## support-v7
  24. #-dontwarn android.support.v7.**                                         #去掉警告
  25. #-keep class android.support.v7.** { *; }                                #过滤android.support.v7
  26. #-keep interface android.support.v7.app.** { *; }
  27. #-keep public class * extends android.support.v7.**
  28. #-keep public class * extends android.support.annotation.**
  30. # 表示不混淆任何包含native方法的类的类名以及native方法名，这个和我们刚才验证的结果是一致
  31. -keepclasseswithmembernames class * {
  32.     native <methods>;
  33. }
  35. # 这个主要是在layout 中写的onclick方法android:onclick="onClick"，不进行混淆
  36. # 表示不混淆Activity中参数是View的方法，因为有这样一种用法，在XML中配置android:onClick=”buttonClick”属性，
  37. # 当用户点击该按钮时就会调用Activity中的buttonClick(View view)方法，如果这个方法被混淆的话就找不到了
  38. -keepclassmembers class * extends android.support.v7.app.AppCompetActivity{
  39.     public void *(android.view.View);
  40. }
  42. # 表示不混淆枚举中的values()和valueOf()方法
  43. -keepclassmembers enum * {
  44.     public static **[] values();
  45.     public static ** valueOf(java.lang.String);
  46. }
  48. # 保持自定义控件类不被混淆
  49. # 表示不混淆任何一个View中的setXxx()和getXxx()方法，
  50. # 因为属性动画需要有相应的setter和getter的方法实现，混淆了就无法工作了。
  51. -keep public class * extends android.view.View{
  52.     *** get*();
  53.     void set*(***);
  54.     public <init>(android.content.Context);
  55.     public <init>(android.content.Context, android.util.AttributeSet);
  56.     public <init>(android.content.Context, android.util.AttributeSet, int);
  57. }
  59. # 保持自定义控件类不被混淆，指定格式的构造方法不去混淆
  60. -keepclasseswithmembers class * {
  61.     public <init>(android.content.Context);
  62.     public <init>(android.content.Context, android.util.AttributeSet);
  63.     public <init>(android.content.Context, android.util.AttributeSet, int);
  64. }
  65. # 保护指定的类和类的成员，但条件是所有指定的类和类成员是要存在
  66. -keepclasseswithmembernames class * {
  67.     public <init>(android.content.Context, android.util.AttributeSet);
  68.     public <init>(android.content.Context, android.util.AttributeSet, int);
  69. }
  71. # 表示不混淆Parcelable实现类中的CREATOR字段，
  72. # 毫无疑问，CREATOR字段是绝对不能改变的，包括大小写都不能变，不然整个Parcelable工作机制都会失败。
  73. -keep class * implements android.os.Parcelable {
  74.   public static final android.os.Parcelable$Creator *;
  75. }
  76. # 这指定了继承Serizalizable的类的如下成员不被移除混淆
  77. -keepclassmembers class * implements java.io.Serializable {
  78.     static final long serialVersionUID;
  79.     private static final java.io.ObjectStreamField[] serialPersistentFields;
  80.     private void writeObject(java.io.ObjectOutputStream);
  81.     private void readObject(java.io.ObjectInputStream);
  82.     java.lang.Object writeReplace();
  83.     java.lang.Object readResolve();
  84. }
  86. # 保留R下面的资源
  87. -keep class **.R$* {
  88.  *;
  89. }
  90. -keep public class **.R$*{
  91.    public static final int *;
  92. }
  93. #不混淆资源类下static的
  94. -keepclassmembers class **.R$* {
  95.     public static <fields>;
  96. }
  98. # 对于带有回调函数的onXXEvent、**On*Listener的，不能被混淆
  99. -keepclassmembers class * {
  100.     void *(**On*Event);
  101.     void *(**On*Listener);
  102. }
  104. # 保留我们自定义控件（继承自View）不被混淆
  105. -keep public class * extends android.view.View{
  106.     *** get*();
  107.     void set*(***);
  108.     public <init>(android.content.Context);
  109.     public <init>(android.content.Context, android.util.AttributeSet);
  110.     public <init>(android.content.Context, android.util.AttributeSet, int);
  111. }
  113. # 保留在Activity中的方法参数是View的方法
  114. # 从而我们在layout里边编写onClick就不会被影响
  115. -keepclassmembers class * extends android.app.Activity {
  116.     public void *(android.view.View);
  117. }
  1. #----------------------------- WebView(项目中没有可以忽略) --------------------------
  3. -keepclassmembers class fqcn.of.javascript.interface.for.Webview {
  4.    public *;
  5. }
  6. -keepclassmembers class * extends android.webkit.WebViewClient {
  7.     public void *(android.webkit.WebView, java.lang.String, android.graphics.Bitmap);
  8.     public boolean *(android.webkit.WebView, java.lang.String);
  9. }
  10. -keepclassmembers class * extends android.webkit.WebViewClient {
  11.     public void *(android.webkit.WebView, jav.lang.String);
  12. }
  13. # 在app中与HTML5的JavaScript的交互进行特殊处理
  14. # 我们需要确保这些js要调用的原生方法不能够被混淆，于是我们需要做如下处理：
  15. -keepclassmembers class com.ljd.example.JSInterface {
  16.     <methods>;
  17. }
  1. # ----------------------------- 其他的 -----------------------------
  3. # 删除代码中Log相关的代码
  4. -assumenosideeffects class android.util.Log {
  5.     public static boolean isLoggable(java.lang.String, int);
  6.     public static int v(...);
  7.     public static int i(...);
  8.     public static int w(...);
  9.     public static int d(...);
  10.     public static int e(...);
  11. }
  13. # 保持测试相关的代码
  14. -dontnote junit.framework.**
  15. -dontnote junit.runner.**
  16. -dontwarn android.test.**
  17. -dontwarn android.support.test.**
  18. -dontwarn org.junit.**
  1. #---------------------------------根据个人项目进行私有配置（以实体类和注解为例）---------------------------------
  2. #--------(实体Model不能混淆，否则找不到对应的属性获取不到值)-----
  3. -dontwarn com.mtf.test.model.**
  4. #对含有反射类的处理
  5. -keep class com.mtf.test.model.** { *; }
  7. #---------自定义的注解--------
  8. -keep class com.mtf.test.permission.** {*;}
  9. # 不混淆使用了注解的类及类成员
  10. -keep @com.mtf.test.permission class * {*;}
  11. # 如果类中有使用了注解的方法，则不混淆类和类成员
  12. -keepclasseswithmembers class * {    @com.mtf.test.permission <methods>;}
  13. # 如果类中有使用了注解的字段，则不混淆类和类成员
  14. -keepclasseswithmembers class * {    @com.mtf.test.permission <fields>;}
  15. # 如果类中有使用了注解的构造函数，则不混淆类和类成员
  16. -keepclasseswithmembers class * {    @com.mtf.test.permission <init>(...);}
  1. #-------------------最后不要忘记添加项目中第三方引用的混淆规则---------------
  2. #----------以友盟为例---------
  3. -dontwarn com.umeng.**
  4. -dontwarn com.tencent.weibo.sdk.**
  6. -keep public interface com.tencent.**
  7. -keep public interface com.umeng.socialize.**
  8. -keep public interface com.umeng.socialize.sensor.**
  9. -keep public interface com.umeng.scrshot.**
  11. -keep public class com.umeng.socialize.* {*;}
  13. -keep class com.umeng.scrshot.**
  14. -keep public class com.tencent.** {*;}
  15. -keep class com.umeng.socialize.sensor.**
  16. -keep class com.umeng.socialize.handler.**
  17. -keep class com.umeng.socialize.handler.*
  18. -keep class com.tencent.mm.sdk.modelmsg.WXMediaMessage {*;}
  19. -keep class com.tencent.mm.sdk.modelmsg.** implements com.tencent.mm.sdk.modelmsg.WXMediaMessage$IMediaObject {*;}
  21. -keep class im.yixin.sdk.api.YXMessage {*;}
  22. -keep class im.yixin.sdk.api.** implements im.yixin.sdk.api.YXMessage$YXMessageData{*;}
  24. -keep class com.tencent.** {*;}
  25. -dontwarn com.tencent.**
  26. -keep public class com.umeng.soexample.R$*{
  27. public static final int *;
  28. }
  29. -keep class com.tencent.open.TDialog$*
  30. -keep class com.tencent.open.TDialog$* {*;}
  31. -keep class com.tencent.open.PKDialog
  32. -keep class com.tencent.open.PKDialog {*;}
  33. -keep class com.tencent.open.PKDialog$*
  34. -keep class com.tencent.open.PKDialog$* {*;}
  36. -keep class com.sina.** {*;}
  37. -dontwarn com.sina.**
  38. -keep class com.alipay.share.sdk.** {*;}

6、查看混淆结果

混淆后打包，会在appmodule/build/outputs/mapping/release目录下生成如下文件

混淆

  • dump.txt：描述apk文件中所有类的内部结构
  • mapping.txt：混淆前后的类、类成员、方法的对照关系（重要，追溯Crash堆栈信息要用到）
  • resources.txt：资源文件的压缩信息
  • seeds.txt：未被混淆的类和成员
  • usage.txt：被移除的代码

注意混淆后的apk包，需要系统的测试，防止混淆导致的潜在bug。

（完）