ProGuard代码混淆技术详解

2017-01-12 09:59:53来源:作者:快乐成长人点击

第七城市

https://github.com/wvengen/proguard-maven-plugin

http://wvengen.github.io/proguard-maven-plugin/

https://www.guardsquare.com/en/proguard

https://www.guardsquare.com/en/proguard/manual/usage

ProGuard代码混淆的相关技术知识点。

内容目录 ProGuard简介 ProGuard工作原理 如何编写一个ProGuard文件 其他注意事项 小结 ProGuard简介

因为Java代码是非常容易反编码的,况且Android开发的应用程序是用Java代码写的,为了很好的保护Java源代码,我们需要对编译好后的class文件进行混淆。

ProGuard是一个混淆代码的开源项目,它的主要作用是混淆代码,殊不知ProGuard还包括以下4个功能。

压缩(Shrink):检测并移除代码中无用的类、字段、方法和特性(Attribute)。 优化(Optimize):对字节码进行优化,移除无用的指令。 混淆(Obfuscate):使用a,b,c,d这样简短而无意义的名称,对类、字段和方法进行重命名。 预检(Preveirfy):在Java平台上对处理后的代码进行预检,确保加载的class文件是可执行的。 ProGuard工作原理

ProGuar由shrink、optimize、obfuscate和preveirfy四个步骤组成,每个步骤都是可选的,我们可以通过配置脚本来决定执行其中的哪几个步骤。

混淆就是移除没有用到的代码,然后对代码里面的类、变量、方法重命名为人可读性很差的简短名字。

那么有一个问题,ProGuard怎么知道这个代码没有被用到呢?

这里引入一个Entry Point(入口点)概念,Entry Point是在ProGuard过程中不会被处理的类或方法。在压缩的步骤中,ProGuard会从上述的Entry Point开始递归遍历,搜索哪些类和类的成员在使用,对于没有被使用的类和类的成员,就会在压缩段丢弃,在接下来的优化过程中,那些非Entry Point的类、方法都会被设置为private、static或final,不使用的参数会被移除,此外,有些方法会被标记为内联的,在混淆的步骤中,ProGuard会对非Entry Point的类和方法进行重命名。

那么这个入口点怎么来呢?就是从ProGuard的配置文件来,只要这个配置了,那么就不会被移除。

如何编写一个ProGuard文件

有个三步走的过程:

基本混淆 针对APP的量身定制 针对第三方jar包的解决方案 基本混淆

混淆文件的基本配置信息,任何APP都要使用,可以作为模板使用,具体如下。

1,基本指令

# 代码混淆压缩比,在0和7之间,默认为5,一般不需要改-optimizationpasses 5 # 混淆时不使用大小写混合,混淆后的类名为小写-dontusemixedcaseclassnames # 指定不去忽略非公共的库的类-dontskipnonpubliclibraryclasses # 指定不去忽略非公共的库的类的成员-dontskipnonpubliclibraryclassmembers # 不做预校验,preverify是proguard的4个步骤之一# Android不需要preverify,去掉这一步可加快混淆速度-dontpreverify # 有了verbose这句话,混淆后就会生成映射文件# 包含有类名->混淆后类名的映射关系# 然后使用printmapping指定映射文件的名称-verbose-printmapping proguardMapping.txt # 指定混淆时采用的算法,后面的参数是一个过滤器# 这个过滤器是谷歌推荐的算法,一般不改变-optimizations !code/simplification/arithmetic,!field/*,!class/merging/* # 保护代码中的Annotation不被混淆,这在JSON实体映射时非常重要,比如fastJson-keepattributes *Annotation* # 避免混淆泛型,这在JSON实体映射时非常重要,比如fastJson-keepattributes Signature //抛出异常时保留代码行号,在异常分析中可以方便定位-keepattributes SourceFile,LineNumberTable-dontskipnonpubliclibraryclasses用于告诉ProGuard,不要跳过对非公开类的处理。默认情况下是跳过的,因为程序中不会引用它们,有些情况下人们编写的代码与类库中的类在同一个包下,并且对包中内容加以引用,此时需要加入此条声明。-dontusemixedcaseclassnames,这个是给Microsoft Windows用户的,因为ProGuard假定使用的操作系统是能区分两个只是大小写不同的文件名,但是Microsoft Windows不是这样的操作系统,所以必须为ProGuard指定-dontusemixedcaseclassnames选项

2,需要保留的东西

# 保留所有的本地native方法不被混淆-keepclasseswithmembernames class * { native <methods>;} # 保留了继承自Activity、Application这些类的子类# 因为这些子类,都有可能被外部调用# 比如说,第一行就保证了所有Activity的子类不要被混淆-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.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 # 如果有引用android-support-v4.jar包,可以添加下面这行-keep public class com.xxxx.app.ui.fragment.** {*;} # 保留在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; private void writeObject(java.io.ObjectOutputStream); private void readObject(java.io.ObjectInputStream); java.lang.Object writeReplace(); java.lang.Object readResolve();} # 对于R(资源)下的所有类及其方法,都不能被混淆-keep class **.R$* { *;} # 对于带有回调函数onXXEvent的,不能被混淆-keepclassmembers class * { void *(**On*Event);} 针对APP的量身定制

1,保留实体类和成员被混淆

对于实体,保留它们的set和get方法,对于boolean型get方法,有人喜欢命名isXXX的方式,所以不要遗漏。如下:

# 保留实体类和成员不被混淆-keep public class com.xxxx.entity.** { public void set*(***); public *** get*(); public *** is*();}

一种好的做法是把所有实体都放在一个包下进行管理,这样只写一次混淆就够了,避免以后在别的包中新增的实体而忘记保留,代码在混淆后因为找不到相应的实体类而崩溃。

2,内嵌类

内嵌类经常会被混淆,结果在调用的时候为空就崩溃了,最好的解决方法就是把这个内嵌类拿出来,单独成为一个类。如果一定要内置,那么这个类就必须在混淆的时候保留,比如如下:

# 保留内嵌类不被混淆-keep class com.example.xxx.MainActivity$* { *; }

这个$符号就是用来分割内嵌类与其母体的标志。

3,对WebView的处理

# 对WebView的处理-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, java.lang.String)}

4,对JavaScript的处理

# 保留JS方法不被混淆-keepclassmembers class com.example.xxx.MainActivity$JSInterface1 { <methods>;}

其中JSInterface是MainActivity的子类

5,处理反射

在程序中使用SomeClass.class.method这样的静态方法,在ProGuard中是在压缩过程中被保留的,那么对于Class.forName(“SomeClass”)呢,SomeClass不会被压缩过程中移除,它会检查程序中使用的Class.forName方法,对参数SomeClass法外开恩,不会被移除。但是在混淆过程中,无论是Class.forName(“SomeClass”),还是SomeClass.class,都不能蒙混过关,SomeClass这个类名称会被混淆,因此,我们要在ProGuard.cfg文件中保留这个类名称。

Class.forName("SomeClass") SomeClass.class SomeClass.class.getField("someField") SomeClass.class.getDeclaredField("someField") SomeClass.class.getMethod("someMethod", new Class[] {}) SomeClass.class.getMethod("someMethod", new Class[] { A.class }) SomeClass.class.getMethod("someMethod", new Class[] { A.class, B.class }) SomeClass.class.getDeclaredMethod("someMethod", new Class[] {}) SomeClass.class.getDeclaredMethod("someMethod", new Class[] { A.class }) SomeClass.class.getDeclaredMethod("someMethod", new Class[] { A.class, B.class }) AtomicIntegerFieldUpdater.newUpdater(SomeClass.class, "someField") AtomicLongFieldUpdater.newUpdater(SomeClass.class, "someField") AtomicReferenceFieldUpdater.newUpdater(SomeClass.class, SomeType.class, "someField")

在混淆的时候,要在项目中搜索一下上述方法,将相应的类或者方法的名称进行保留而不被混淆。

6,对于自定义View的解决方案

但凡在Layout目录下的XML布局文件配置的自定义View,都不能进行混淆。为此要遍历Layout下的所有的XML布局文件,找到那些自定义View,然后确认其是否在ProGuard文件中保留。有一种思路是,在我们使用自定义View时,前面都必须加上我们的包名,比如com.a.b.customeview,我们可以遍历所有Layout下的XML布局文件,查找所有匹配com.a.b的标签即可。

针对第三方jar包的解决方案

我们在Android项目中不可避免要使用很多第三方提供的SDK,一般而言,这些SDK是经过ProGuard混淆的,而我们所需要做的就是避免这些SDK的类和方法在我们APP被混淆。

1,针对android-support-v4.jar的解决方案

# 针对android-support-v4.jar的解决方案-libraryjars libs/android-support-v4.jar-dontwarn android.support.v4.**-keep class android.support.v4.** { *; }-keep interface android.support.v4.app.** { *; }-keep public class * extends android.support.v4.**-keep public class * extends android.app.Fragment

2,其他的第三方jar包的解决方案

这个就取决于第三方包的混淆策略了,一般都有在各自的SDK中有关于混淆的说明文字,比如支付宝如下:

# 对alipay的混淆处理-libraryjars libs/alipaysdk.jar-dontwarn com.alipay.android.app.**-keep public class com.alipay.** { *; }

值得注意的是,不是每个第三方SDK都需要-dontwarn指令,这取决于混淆时第三方SDK是否出现警告,需要的时候再加上。

其他注意事项

当然在使用ProGuard过程中,还有一些注意的事项,如下。

1,如何确保混淆不会对项目产生影响

测试工作要基于混淆包进行,才能尽早发现问题 每天开发团队的冒烟测试,也要基于混淆包 发版前,重点的功能和模块要额外的测试,包括推送,分享,打赏

2,打包时忽略警告

当导出包的时候,发现很多could not reference class之类的warning信息,如果确认App在运行中和那些引用没有什么关系,可以添加-dontwarn标签,就不会提示这些警告信息了

3,对于自定义类库的混淆处理

比如我们引用了一个叫做AndroidLib的类库,我们需要对Lib也进行混淆,然后在主项目的混淆文件中保留AndroidLib中的类和类的成员。

4,使用annotation避免混淆

另一种类或者属性被混淆的方式是,使用annotation,比如这样:

@keep@keepPublicGetterSetterspublic class Bean{ public boolean booleanProperty; public int intProperty; public String stringProperty;}

5,在项目中指定混淆文件

到最后,发现没有介绍如何在项目中指定混淆文件。在项目中有一个project.properties文件,在其中写这么一句话,就可以确保每次手动打包生成的apk是混淆过的。

proguard.config=proguard.cfg

其中,proguard.cfg是混淆文件的名称。

小结

总之ProGuard是一个比较枯燥的过程,但Android项目没有了ProGuard就真不行了,这样可以保证我们开发出的APK可以更健壮,毕竟很多核心代码质量也算是一个APK的核心竞争力吧。

1.创建紧凑的代码文档是为了更快的网络传输,快速装载和更小的内存占用.

2.创建的程序和程序库很难使用反向工程.

3.所以它能删除来自源文件中的没有调用的代码

4.充分利用java6的快速加载的优点来提前检测和返回java6中存在的类文件. 参数: -include {filename} 从给定的文件中读取配置参数

-basedirectory {directoryname} 指定基础目录为以后相对的档案名称

-injars {class_path} 指定要处理的应用程序jar,war,ear和目录

-outjars {class_path} 指定处理完后要输出的jar,war,ear和目录的名称

-libraryjars {classpath} 指定要处理的应用程序jar,war,ear和目录所需要的程序库文件

-dontskipnonpubliclibraryclasses 指定不去忽略非公共的库类。

-dontskipnonpubliclibraryclassmembers 指定不去忽略包可见的库类的成员。 保留选项

-keep {Modifier} {class_specification} 保护指定的类文件和类的成员

-keepclassmembers {modifier} {class_specification} 保护指定类的成员,如果此类受到保护他们会保护的更好

-keepclasseswithmembers {class_specification} 保护指定的类和类的成员,但条件是所有指定的类和类成员是要存在。

-keepnames {class_specification} 保护指定的类和类的成员的名称(如果他们不会压缩步骤中删除)

-keepclassmembernames {class_specification} 保护指定的类的成员的名称(如果他们不会压缩步骤中删除)

-keepclasseswithmembernames {class_specification} 保护指定的类和类的成员的名称,如果所有指定的类成员出席(在压缩步骤之后)

-printseeds {filename} 列出类和类的成员-keep选项的清单,标准输出到给定的文件

压缩

-dontshrink 不压缩输入的类文件

-printusage {filename}

-whyareyoukeeping {class_specification}

优化

-dontoptimize 不优化输入的类文件

-assumenosideeffects {class_specification} 优化时假设指定的方法,没有任何副作用

-allowaccessmodification 优化时允许访问并修改有修饰符的类和类的成员

混淆

-dontobfuscate 不混淆输入的类文件

-printmapping {filename}

-applymapping {filename} 重用映射增加混淆

-obfuscationdictionary {filename} 使用给定文件中的关键字作为要混淆方法的名称

-overloadaggressively 混淆时应用侵入式重载

-useuniqueclassmembernames 确定统一的混淆类的成员名称来增加混淆

-flattenpackagehierarchy {package_name} 重新包装所有重命名的包并放在给定的单一包中

-repackageclass {package_name} 重新包装所有重命名的类文件中放在给定的单一包中

-dontusemixedcaseclassnames 混淆时不会产生形形色色的类名

-keepattributes {attribute_name,…} 保护给定的可选属性,例如LineNumberTable, LocalVariableTable, SourceFile, Deprecated, Synthetic, Signature, and InnerClasses.

-renamesourcefileattribute {string} 设置源文件中给定的字符串常量

Ant Example:

<!– This Ant build file illustrates how to process applications,

by including ProGuard-style configuration options.

Usage: ant -f applications2.xml –>

<project name=”Applications” default=”obfuscate” basedir=”../..”>

<target name=”obfuscate”>

<taskdef resource=”proguard/ant/task.properties”

classpath=”lib/proguard.jar” />

<proguard>

<!– Specify the input jars, output jars, and library jars. –>

-injars in.jar

-outjars out.jar

-libraryjars ${java.home}/lib/rt.jar

<!– -libraryjars junit.jar –>

<!– -libraryjars servlet.jar –>

<!– -libraryjars jai_core.jar –>

<!– … –>

<!– Save the obfuscation mapping to a file, and preserve line numbers. –>

-printmapping out.map

-renamesourcefileattribute SourceFile

-keepattributes SourceFile,LineNumberTable

<!– Preserve all annotations. –>

-keepattributes *Annotation*

<!– Preserve all public applications. –>

-keepclasseswithmembers public class * {

public static void main(java.lang.String[]);

}

<!– Preserve all native method names and the names of their classes. –>

-keepclasseswithmembernames class * {

native &lt;methods&gt;;

}

<!– Preserve the methods that are required in all enumeration classes. –>

-keepclassmembers class * extends java.lang.Enum {

public static **[] values();

public static ** valueOf(java.lang.String);

}

<!– Explicitly preserve all serialization members. The Serializable

interface is only a marker interface, so it wouldn’t save them.

You can comment this out if your library doesn’t use serialization.

If your code contains serializable classes that have to be backward

compatible, please refer to the manual. –>

-keepclassmembers class * implements java.io.Serializable {

static final long serialVersionUID;

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();

}

<!– Your application may contain more items that need to be preserved;

typically classes that are dynamically created using Class.forName –>

</proguard>

</target>

</project>

第七城市

最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台