美文网首页
Android代码混淆

Android代码混淆

作者: 涛涛123759 | 来源:发表于2020-08-05 16:09 被阅读0次

    一、配置( 项目的app/build.gradle)

        buildTypes {
        release {
            /*打开混淆*/
            minifyEnabled true
            /*打开资源压缩*/
            shrinkResources true
            zipAlignEnabled true // Zipalign优化 
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

    二、混淆为什么要保留类名或方法名？

    • 1、让C/C++程序可以通过jni使用对应的java方法
    • 2、四大组件由于在AndroidManifest.xml里面注册了，所以需要保留。
    • 3、R文件混淆会导致引用错误。
    • 4、第三方架包有的已经经过混淆了，再次混淆会导致找不到类名或者方法名

    三、什么时候不被混淆？

    一般以下情况都会不混淆：

    • 1、使用了自定义控件那么要保证它们不参与混淆
    • 2、使用了枚举要保证枚举不被混淆
    • 3、对第三方库中的类不进行混淆
    • 4、运用了反射的类也不进行混淆
    • 5、使用了 Gson 之类的工具要使 JavaBean 类即实体类不被混淆
    • 6、静态成员、JNI中调用的类
    • 7、有用到 WebView 的 JS 调用也需要保证写的接口方法不混淆，原因和第一条一样
    • 8、Serializable,Parcelable的子类和 Creator 静态成员变量不混淆，否则会产生 Android.os.BadParcelableException 异常
    • 9、四大组件 ，自定义的Application

    四、混淆语法

    • 2.1 基本规则
      两个常用的混淆命令，注意一颗星表示只是保持该包下的类名，而子包下的类名还是会被混淆；而两颗星表示把本包和所包含的子包下的类名都保留。
    -keep class cn.hadcn.test.**
-keep class cn.hadcn.test.*

    如果既想保持类名，又想保持里面的内容不被混淆，就执行以下方法

     -keep class com.example.bean.** { *; }

    在此基础上，我们也可以使用Java的基本规则来保护特定类不被混淆，比如我们可以用extend，implement等这些Java规则。如下例子就避免所有继承Activity的类被混淆

    保留我们使用的四大组件，自定义的Application等等这些类不被混淆
    因为这些子类都有可能被外部调用

    -keep public class * extends android.app.Activity
-keep public class * extends android.app.Appliction
-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 public class com.android.vending.licensing.ILicensingService
    • 2.2、基本混淆模板
      对于一些基本指令的添加
    #############################################
#
# 对于一些基本指令的添加
#
#############################################
# 代码混淆压缩比，在0~7之间，默认为5，一般不做修改
-optimizationpasses 5
# 混合时不使用大小写混合，混合后的类名为小写
-dontusemixedcaseclassnames
# 指定不去忽略非公共库的类
-dontskipnonpubliclibraryclasses
# 这句话能够使我们的项目混淆后产生映射文件# 包含有类名->混淆后类名的映射关系
-verbose
# 指定不去忽略非公共库的类成员
-dontskipnonpubliclibraryclassmembers
# 不做预校验，preverify是proguard的四个步骤之一，Android不需要preverify，去掉这一步能够加快混淆速度。
-dontpreverify
# 保留Annotation不混淆
-keepattributes *Annotation*,InnerClasses
# 避免混淆泛型
-keepattributes Signature
#将文件来源重命名为“SourceFile”字符串
-renamesourcefileattribute SourceFile
# 抛出异常时保留代码行号
-keepattributes SourceFile,LineNumberTable
# 避免混淆Annotation、内部类、泛型、匿名类
-keepattributes *Annotation*,InnerClasses,Signature,EnclosingMethod
# 指定混淆是采用的算法，后面的参数是一个过滤器# 这个过滤器是谷歌推荐的算法，一般不做更改
-optimizations !code/simplification/cast,!field/*,!class/merging/*
#把混淆类中的方法名也混淆了
-useuniqueclassmembernames
#优化时允许访问并修改有修饰符的类和类的成员
-allowaccessmodification

    Android开发中一些需要保留的公共部分

    #############################################
#
# Android开发中一些需要保留的公共部分
#
#############################################
# 保留我们使用的四大组件，自定义的Application等等这些类不被混淆# 因为这些子类都有可能被外部调用
-keep public class * extends android.app.Activity
-keep public class * extends android.app.Appliction
-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 public class com.android.vending.licensing.ILicensingService

# 保留support下的所有类及其内部类
-keep class android.support.** {*;}
# 保留继承的
-keep public class * extends android.support.v4.**
-keep public class * extends android.support.v7.**
-keep public class * extends android.support.annotation.**
# 保留R下面的资源
-keep class **.R$* {*;}
# 保留本地native方法不被混淆
-keepclasseswithmembernames class * {
    native <methods>;
}
# 保留在Activity中的方法参数是view的方法，
# 这样以来我们在layout中写的onClick就不会被影响
-keepclassmembers class * extends android.app.Activity{
    public void *(android.view.View);
}
# 保留枚举类不被混淆
-keepclassmembers enum * {
    public static **[] values();
    public static ** valueOf(java.lang.String);
}
# 保留我们自定义控件（继承自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);
}
# 保留Parcelable序列化类不被混淆
-keep class * implements android.os.Parcelable {
    public static final android.os.Parcelable$Creator *;
}
# 保留Serializable序列化的类不被混淆
-keepclassmembers class * implements java.io.Serializable {
    static final long serialVersionUID;
    private static final java.io.ObjectStreamField[] serialPersistentFields;
    !static !transient <fields>;
    !private <fields>;
    !private <methods>;
    private void writeObject(java.io.ObjectOutputStream);
    private void readObject(java.io.ObjectInputStream);
    java.lang.Object writeReplace();
    java.lang.Object readResolve();
}
# 对于带有回调函数的onXXEvent、**On*Listener的，不能被混淆
-keepclassmembers class * {
    void *(**On*Event);
    void *(**On*Listener);
}
# 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);
}

# assume no side effects:删除android.util.Log输出的日志
-assumenosideeffects class android.util.Log {
    public static *** v(...);
    public static *** d(...);
    public static *** i(...);
    public static *** w(...);
    public static *** e(...);
}

#保留Keep注解的类名和方法
-keep,allowobfuscation @interface android.support.annotation.Keep
-keep @android.support.annotation.Keep class *
-keepclassmembers class * {
    @android.support.annotation.Keep *;
}

#fastjson混淆
-keepattributes Signature
-dontwarn com.alibaba.fastjson.**
-keep class com.alibaba.**{*;}
-keep class com.alibaba.fastjson.**{*; }
-keep public class com.ninstarscf.ld.model.entity.**{*;}

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

# webview
-keep class android.webkit.JavascriptInterface {*;}
#自定义webview接口实现类
-keep public class com.gjmetal.app.ui.ball.**{*;}

# 微信支付
-dontwarn com.tencent.mm.**
-dontwarn com.tencent.wxop.stat.**
-keep class com.tencent.mm.** {*;}
-keep class com.tencent.wxop.stat.**{*;}

# 支付宝钱包
-dontwarn com.alipay.**
-dontwarn HttpUtils.HttpFetcher
-dontwarn com.ta.utdid2.**
-dontwarn com.ut.device.**
-keep class com.alipay.android.app.IAlixPay{*;}
-keep class com.alipay.android.app.IAlixPay$Stub{*;}
-keep class com.alipay.android.app.IRemoteServiceCallback{*;}
-keep class com.alipay.android.app.IRemoteServiceCallback$Stub{*;}
-keep class com.alipay.sdk.app.PayTask{ public *;}
-keep class com.alipay.sdk.app.AuthTask{ public *;}
-keep class com.alipay.mobilesecuritysdk.*
-keep class com.ut.*

    五、其他混淆

    然后需要在项目生成的混淆脚本中添加过滤混淆的条件

    # Glide
-dontwarn com.bumptech.glide.**
-keep class com.bumptech.glide.**{*;}
-keep public class * implements com.bumptech.glide.module.GlideModule
-keep public class * extends com.bumptech.glide.AppGlideModule
-keep public enum com.bumptech.glide.load.resource.bitmap.ImageHeaderParser$** {
  **[] $VALUES;
  public *;
}

# Gson
-keep class sun.misc.Unsafe { *; }
-keep class com.google.gson.stream.** { *; }
# OkHttp3
-keep class okhttp3.** { *; }
-keep interface okhttp3.** { *; }
-dontwarn okhttp3.**
# Okio
-dontwarn com.squareup.**
-dontwarn okio.**
-keep public class org.codehaus.* { *; }
-keep public class java.nio.* { *; }
# Retrofit
-dontwarn retrofit2.**
-keep class retrofit2.** { *; }
-keepattributes Signature
-keepattributes Exceptions
# RxJava RxAndroid
-dontwarn sun.misc.**
-keepclassmembers class rx.internal.util.unsafe.*ArrayQueue*Field* {
   long producerIndex;
   long consumerIndex;
}
-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueProducerNodeRef {
   rx.internal.util.atomic.LinkedQueueNode producerNode;
}
-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueConsumerNodeRef {
   rx.internal.util.atomic.LinkedQueueNode consumerNode;
}
#数据模型(实体类)
-keep class com.seekfangle.pad.bean.* {*;}
#第三方架包
-keep class  cn.com.** { *;}
-keep class  android_serialport_api.** { *;}

#butterknife
-dontwarn butterknife.internal.**
-keep class **$$ViewInjector { *; }
-keepnames class * { @butterknife.InjectView *;}

#EventBus3.0
-keepattributes *Annotation*
-keepclassmembers class ** {
    @org.greenrobot.eventbus.Subscribe <methods>;
}
-keep enum org.greenrobot.eventbus.ThreadMode { *; }

#友盟
-keep class com.umeng.** {*;}
-keepclassmembers class * {
   public <init> (org.json.JSONObject);
}
-keepclassmembers enum * {
    public static **[] values();
    public static ** valueOf(java.lang.String);
}
-keep public class com.gjmetal.app.R$*{
public static final int *;
}

#个推
-dontwarn com.igexin.**
-keep class com.igexin.** { *; }
-keep class org.json.** { *; }
-keep class android.support.v4.app.NotificationCompat { *; }
-keep class android.support.v4.app.NotificationCompat$Builder { *; }

#routes
-keep public class com.alibaba.android.arouter.routes.**{*;}
-keep class * implements com.alibaba.android.arouter.facade.template.ISyringe{*;}


#ShareSdk
-keep class cn.sharesdk.**{*;}
-keep class com.sina.**{*;}
-keep class **.R$* {*;}
-keep class **.R{*;}
-keep class com.mob.**{*;}
-keep class m.framework.**{*;}
-dontwarn cn.sharesdk.**
-dontwarn com.sina.**
-dontwarn com.mob.**
-dontwarn **.R$*

#Picasso
-keep class com.parse.*{ *; }
-dontwarn com.parse.**
-dontwarn com.squareup.picasso.**
-keepclasseswithmembernames class * {
    native <methods>;
}

#GreenDao
-keepclassmembers class * extends org.greenrobot.greendao.AbstractDao {
public static java.lang.String TABLENAME;
}
-keep class **$Properties

# If you do not use SQLCipher:
-dontwarn org.greenrobot.greendao.database.**
# If you do not use Rx:
-dontwarn rx.**

#百度定位混淆配置
-keep class vi.com.gdi.** { *; }
-keep public class com.baidu.** {*;}
-keep public class com.mobclick.** {*;}
-dontwarn com.baidu.mapapi.utils.*
-dontwarn com.baidu.platform.comapi.b.*
-dontwarn com.baidu.platform.comapi.map.*
#百度地图混淆配置
-keep class com.baidu.** {*;}
-keep class vi.com.** {*;}
-dontwarn com.baidu.**
-keep class mapsdkvi.com.** {*;}

#QQ分享
-dontwarn com.tencent.**
-keep class com.tencent.** {*; }

#微信分享
-keep class com.tencent.mm.opensdk.** {*;}
-keep class com.tencent.wxop.** {*;}
-keep class com.tencent.mm.sdk.** { *;}

    六、检查混淆结果

    混淆过的包必须进行检查，避免因混淆引入的bug。
    一方面，需要从代码层面检查。使用上文的配置进行混淆打包后在<module-name>/build/outputs/mapping/release/目录下会输出以下文件：
    dump.txt
    描述APK文件中所有类的内部结构
    mapping.txt
    提供混淆前后类、方法、类成员等的对照表
    seeds.txt
    列出没有被混淆的类和成员
    usage.txt
    列出被移除的代码
    我们可以根据 seeds.txt 文件检查未被混淆的类和成员中是否已包含所有期望保留的，再根据 usage.txt文件查看是否有被误移除的代码。
    另一方面，需要从测试方面检查。将混淆过的包进行全方面测试，检查是否有 bug 产生。

    七、解出混淆栈

    混淆后的类、方法名等等难以阅读，这固然会增加逆向工程的难度，但对追踪线上 crash 也造成了阻碍。我们拿到 crash 的堆栈信息后会发现很难定位，这时需要将混淆反解。
    在 <sdk-root>/tools/proguard/路径下有附带的的反解工具（Window 系统为proguardgui.bat，Mac 或 Linux 系统为proguardgui.sh）。
    这里以 Window 平台为例。双击运行 proguardgui.bat 后，可以看到左侧的一行菜单。点击 ReTrace，选择该混淆包对应的 mapping 文件（混淆后在 <module-name>/build/outputs/mapping/release/路径下会生成 mapping.txt 文件，它的作用是提供混淆前后类、方法、类成员等的对照表），再将 crash 的 stack trace 黏贴进输入框中，点击右下角的 ReTrace ，混淆后的堆栈信息就显示出来了。
    以上使用 GUI 程序进行操作，另一种方式是利用该路径下的 retrace 工具通过命令行进行反解，命令是
    retrace.bat|retrace.sh [-verbose] mapping.txt [<stacktrace_file>]
    例如：

    retrace.bat -verbose mapping.txt obfuscated_trace.txt
    注意事项：
    所有在 AndroidManifest.xml涉及到的类已经自动被保持，因此不用特意去添加这块混淆规则。（很多老的混淆文件里会加，现在已经没必要）
    proguard-android.txt已经存在一些默认混淆规则，没必要在proguard-rules.pro 重复添加

    八、自定义混淆规则

    在上文“混淆配置”中有这样一行代码

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

    这行代码定义了混淆规则由两部分构成：位于 SDK 的tools/proguard/ 文件夹中的 proguard-android.txt的内容以及默认放置于模块根目录的proguard-rules.pro 的内容。前者是 SDK 提供的默认混淆文件，后者是开发者自定义混淆规则的地方。

    九、常见的混淆指令

    • 1、 optimizationpasses代码混淆压缩比，在0~7之间，默认为5，一般不做修改
    • 2、 dontoptimize 不进行优化
    • 3、 dontusemixedcaseclassnames 混合时不使用大小写混合，混合后的类名为小写
    • 4、 dontskipnonpubliclibraryclasses 指定不去忽略非公共库的类
    • 5、 dontpreverify 不做预校验
    • 6、 dontwarn 不提示警告，和keep可以说是形影不离,尤其是处理引入的library时.
    • 7、 verbose 混淆时是否记录日志
    • 8、 optimizations 指定混淆是采用的算法，后面的参数是一个过滤器
    • 9、 keep 保留类和类中的成员，防止被混淆或移除
    • 10、keepnames 保留类和类中的成员，防止被混淆，成员没有被引用会被移除
    • 11、 keepclassmembers 只保留类中的成员，防止被混淆或移除
    • 12、keepclassmembernames 只保留类中的成员，防止被混淆，成员没有引用会被移除
    • 13、 keepclasseswithmembers 保留类和类中的成员，防止被混淆或移除，保留指明的成员
    • 14、 keepclasseswithmembernames 保留类和类中的成员，防止被混淆，保留指明的成员，成员没有引用会被移除
      更多详细的请到官网

    十、规则

      [保持命令] [类] {
    [成员] 
}

    “类”代表类相关的限定条件，它将最终定位到某些符合该限定条件的类。它的内容可以使用：

    • 具体的类
    • 访问修饰符public、protected、private
    • 通配符*，匹配任意长度字符，但不含包名分隔符(.)
    • 通配符**，匹配任意长度字符，并且包含包名分隔符(.)
    • extends，即可以指定类的基类
      *implement，匹配实现了某接口的类
    • $，内部类

    “成员”代表类成员相关的限定条件，它将最终定位到某些符合该限定条件的类成员。它的内容可以使用：

    • <init>匹配所有构造器
    • <fields> 匹配类中的所有字段
    • <methods> 匹配所有方法
    • 通配符*，匹配任意长度字符，但不含包名分隔符(.)
    • 通配符**，匹配任意长度字符，并且包含包名分隔符(.)
    • 通配符***，匹配任意参数类型
      *…，匹配任意长度的任意类型参数。比如void test(…)就能匹配任意void test(String a)或者是 void test(int a, String b)这些方法。
    • 访问修饰符public、protected、private

    举个例子，假如需要将com.biaobiao.test包下所有继承Activity的public类及其构造函数都保持住，可以这样写：

     -keep public class com.biaobiao.test.** extends Android.app.Activity {
    <init>
}

    十一、常用自定义混淆规则

    1、不混淆某个类

    -keep public class com.biaobiao.example.Test { *; }

    2、不混淆某个包所有的类

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

    3、不混淆某个类的子类

    -keep public class * extends com.biaobiao.example.Test { *; }

    4、不混淆某个接口的实现

    -keep class * implements com.biaobiao.example.TestInterface { *; }

    5、不混淆某个类的构造方法

    -keepclassmembers class com.biaobiao.example.Test { 
    public <init>(); 
}
//保持指定类的所有字段
-keep class com.xy.myapp.MyClass { public <fields>; }

    6、不混淆某个类的特定的方法

    -keepclassmembers class com.biaobiao.example.Test { 
    public void test(java.lang.String); 
}
//保持指定类的所有方法
-keep class com.xy.myapp.MyClass { public <methods>; }
//保持用指定参数作为形参的方法
-keep class com.xy.myapp.MyClass { public <methods>(java.lang.String); }

    7、不混淆某个类的内部类

    //所有内部类
-keep class com.biaobiao.example.Test$* { *; }
//内部类 Builder
-keep class com.biaobiao.example.Test$Builder { *; }
//保持MyClass内部类JavaScriptInterface中的所有public内容。
-keepclassmembers class com.xy.myapp.MyClass$JavaScriptInterface { 
    #保持该类下所有的共有内容不被混淆
    public *;
    #保持该类下所有的私有方法不被混淆
    private * ;
 }

    8、混淆引入的 library

    //使指定的类不输出警告信息
-dontwarn purang.purang_shop.**
-keep class purang.purang_shop.**{*;}

    十二、组件模块定义混淆规则

    子模块混淆文件的指定是通过consumerProguardFiles这个属性来指定的，并不是proguardFiles属性，而且我们无需配置其他的选项，只需要配置consumerProguardFiles属性就可以。该属性表示在打包的时候会自动寻找该module下我们指定的混淆文件对代码进行混淆。可以把一些公共的混淆定义在子模块中。

       release {
            consumerProguardFiles   'proguard-rules.pro'
        }

    consumerProguardFiles作用:

    • proguard.txt会被打包进aar中
    • 此配置只对aar进行混淆。
    • 此配置只对库文件有效，对应用程序无效。

    当app模块将全部代码汇总混淆时，Library 模块会被打包为release aar，然后被引用汇总，通过proguard-rule.pro规则各自混淆，保证只混淆一次。

    组件化工程中具体混淆用法：
    我们可以将固定的第三方混淆放到base模块的proguard-rule.pro文件中，每个模块独有的第三方引用库混淆放到各自的proguard-rule.pro文件中，在app模块的proguard-rule.pro文件中放入Android基础属性的混淆声明，如四大组件和全局的混淆等配置。这样可以最大限度的完成混淆解耦操作。

    十三、自定义要保持的资源

    资源压缩包含了“合并资源”和“移除资源”两个流程。“合并资源”流程中，名称相同的资源被视为重复资源会被合并。需要注意的是，这一流程不受shrinkResources属性控制，也无法被禁止， gradle 必然会做这项工作。
    当我们开启了资源压缩之后，系统会默认替我们移除所有未使用的资源，假如我们需要保留某些特定的资源，可以在我们项目中创建一个被 <resources> 标记的 XML 文件（如 res/raw/keep.xml），并在tools:keep属性中指定每个要保留的资源，在tools:discard属性中指定每个要舍弃的资源。这两个属性都接受逗号分隔的资源名称列表。同样，我们可以使用字符 * 作为通配符。

    <?xml version="1.0" encoding="utf-8"?><resources xmlns:tools="http://schemas.android.com/tools"
    tools:keep="@layout/activity_video*,@layout/dialog_update_v2"
    tools:discard="@layout/unused_layout,@drawable/unused_selector" />

    十四、移除替代资源

    一些替代资源，例如多语言支持的 strings.xml，多分辨率支持的 layout.xml 等，在我们不需要使用又不想删除掉时，可以使用资源压缩将它们移除。我们使用 resConfig 属性来指定需要支持的属性，例如

      android {
      defaultConfig {
          ...
          resConfigs "en", "fr"
      }
  }

    相关文章

      网友评论

          本文标题：Android代码混淆

          本文链接：https://www.haomeiwen.com/subject/refsrktx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|Android代码混淆|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！