精华内容
参与话题
问答
  • Proguard用法

    万次阅读 2018-07-18 16:05:20
    混淆(Proguard)用法 最近项目中遇到一些混淆相关的问题,由于之前对proguard了解不多,所以每次都是面向Stackoverflow的编程。copy别人的答案内心还可以接受,但是copy了之后不懂别人的逻辑是无法忍受的。首先不...

    混淆(Proguard)用法

    最近项目中遇到一些混淆相关的问题,由于之前对proguard了解不多,所以每次都是面向Stackoverflow的编程。copy别人的答案内心还可以接受,但是copy了之后不懂别人的逻辑是无法忍受的。首先不清楚别人的答案是不是一定符合自己的需求;其次,再遇到同类问题还是得抓瞎。于是下决心看了一下proguard的官方文档。很长,但是很详细,在这里整理一下笔记,分享给大家。

    介绍


    我们通常说的proguard包括四个功能,shrinker(压缩), optimizer(优化),obfuscator(混淆),preverifier(预校验)。

    proguard process

    • shrink: 检测并移除没有用到的类,变量,方法和属性;
    • optimize: 优化代码,非入口节点类会加上private/static/final, 没有用到的参数会被删除,一些方法可能会变成内联代码。
    • obfuscate: 使用短又没有语义的名字重命名非入口类的类名,变量名,方法名。入口类的名字保持不变。
    • preverify: 预校验代码是否符合Java1.6或者更高的规范(唯一一个与入口类不相关的步骤)

    如果你的代码中用到了反射,那需要把反射调用的类,变量,方法也设置成入口节点。只需要加上-keep就可以了。(下面会讲)

    除了proguard之外,还有一个DexGuard,是专门用来优化混淆Android应用的。它的功能包括资源混淆,字符串加密,类加密和dex文件分割等。它是在android编译的时候直接产生Dalvik字节码。(这个有兴趣的同学自行了解,这里不详述了)

    用法


    要执行proguard,可以直接执行命令:

    java -jar proguard.jar options ...

    如果有Android SDK的同学可以在{ANDROID_SDK_ROOT}/tools/proguard/lib/目录下找到proguard.jar这个jar包。或者,也可以在{ANDROID_SDK_ROOT}/tools/proguard/bin目录下直接使用脚本执行命令。

    我们也可以把proguard的参数写到一个配置文件中,比如说proguard.cfg。那我们的命令可以这样写:

    java -jar proguard.jar @proguard.cfg

    这个文件也就是我们在Android Studio中经常配置的混淆文件了。我们在编译正式包的时候打包脚本自动帮我们执行了这条命令。通过这个脚本可以避免重复输入参数。

    当然,我们也可以配置文件与命令行参数混用,例如:

    java -jar proguard.jar @proguard.cfg -verbose
    • 配置文件中 # 放在行首,用来做注释;
    • 单词之间多余的空格或分隔符会被忽略;
    • 如果文件名包含空格或者其它特殊符号,应当用单引号或者双引号括起来;
    • 配置参数的顺序与混淆结果是没有关系的

    输入/输出选项


    这部分内容平常比较少用到,如果仅仅是做app开发的话,了解一下这一节即可。

    @_filename_ -include 的简写

    -include filename 需要读取的配置文件

    -basedirectory directory 为所有引用的相对路径指定一个根路径

    -injars classpath 指定输入的包,可以包括 jar, aar, war, ear, zip, apk或者文件目录。这些包或者目录下的class文件将被处理后写入到输出文件中。默认情况下非class文件会被原封不动的复制到输出文件中。

    需要注意的是,默认情况下,一些编译器的临时的文件也会被写入到输出文件中。可以使用过滤选项过滤掉他们。过滤选选项后面有讲到。

    -outjars classpath 指定输出文件,类型包括 jar, aar, war, ear, zip, apk和 目录。

    不要让输出文件覆盖任何一个输入文件!

    -libraryjars classpaath 指定输入文件引用的类库。这些类库不会被写入到输出文件中。每个库至少要有一个类被引用。

    在查找类库的时候,proguard运行时的类库是不算在内的。需要指明的是应用在运行时依赖的类库。

    简单用法:

    
     
    1. -injars classes

    2. -injars in1.jar

    3. -injars in2.jar

    4. -injars in3.jar

    5. -libraryjars <java.home>/lib/rt.jar(java/**,javax/**)

    6. -outjars out.jar

    -skipnonpubliclibraryclasses 指定读取引用库文件的时候跳过非public类。这样做可以提高处理速度并节省内存。一般情况下非public在应用内是引用不到的,跳过它们也没什么关系。但是,在一些java类库中中出现了public类继承非public类的情况,这样就不能用这个选项了。这种情况下,会打印一个警告出来,提示找不到类。

    -dontskipnonpubliclibraryclasses 跟上面的参数相对。版本4.5以上,这个是默认的选项。

    -dontskipnonpubliclibraryclassmembers 指定不忽略库类库中的非public成员(成员变量和方法)。默认情况下,proguard在读取库文件的时候会自动忽略这些类的成员,因为这些非public成员不会被源代码引用到。但有时候他们是可以被引用到的。比如说,源代码中与库文件用同一个包名,那么源代码就可以访问包作用域的变量。在这些情况下,为了引用一致,不被混淆,就需要指定不跳过这些类。

    -keepdirectories directory_filter 指定输出jar包中需要保留的目录名。为了减少输出文件的体积,默认情况下所有的目录都会被删除(个人这里不是很理解,猜测意思是默认所有目录都会被混淆吧)。但是如果你的代码中有需要从目录中寻找文件的逻辑,那你就需要保持目录名一致。这项配置后面不加过滤器的时候,所有目录都会被保留。加了过滤器之后,只有过滤器匹配的目录才会被保留。

    -target version 指定处理的class文件中java的目标版本。版本号是1.0, 1.1, 1.2, 1.3, 1.4, 1.5(或者5), 1.6(或者6), 1.7(或者7),1.8(或者8)之中的一个。默认情况下,class文件的版本号是不会变的。

    -forceprocessing 尽管输出文件已经是最新的,还是强制进行处理一次。

    Keep配置


    -keep [,modifier, ...] class_specification 指定类和类的成员变量是入口节点,保护它们不被移除混淆。例如,对一个可执行jar包来说,需要保护main的入口类;对一个类库来说需要保护它的所有public元素。例子:

    
     
    1. -injars myapplication.jar

    2. -outjars myapplication_out.jar

    3. -libraryjars <java.home>/lib/rt.jar

    4. -printmapping myapplication.map

    5.  
    6. -keep public class mypackage.MyMain {

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

    8. }

    -keepclassmembers [,modifier] class_specification 保护的指定的成员变量不被移除、优化、混淆。例如,保护所有序列化的类的成员变量。
    例子:

    
     
    1. -keepnames class * implements java.io.Serializable

    2. # 这指定了继承Serizalizable的类的如下成员不被移除混淆

    3. -keepclassmembers class * implements java.io.Serializable {

    4. static final long serialVersionUID;

    5. private static final java.io.ObjectStreamField[] serialPersistentFields;

    6. !static !transient <fields>;

    7. !private <fields>;

    8. !private <methods>;

    9. private void writeObject(java.io.ObjectOutputStream);

    10. private void readObject(java.io.ObjectInputStream);

    11. java.lang.Object writeReplace();

    12. java.lang.Object readResolve();

    13. }

    -keepclasseswithmembers [,modifier,...] class_specification 拥有指定成员的类将被保护,根据类成员确定一些将要被保护的类。例如保护所有含有main方法的类。
    例子:

    
     
    1. # 这种情况下含有main方法的类和mainf方法都不会被混淆。

    2. -injars in.jar

    3. -outjars out.jar

    4. -libraryjars <java.home>/lib/rt.jar

    5. -printseeds

    6.  
    7. -keepclasseswithmembers public class * {

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

    9. }

    -keepnames class_specification 是 -keep,allowshrinking class_pecification 的简写。指定一些类名受到保护,前提是他们在shrink这一阶段没有被去掉。也就是说没有被入口节点直接或间接引用的类还是会被删除。仅在obfuscate阶段有效。

    -keepclassmembernames class_specification 是-keepclasseswithmembers,allowshrinking class_specification的简写。与-keepclassmember相似。保护指定的类成员,前提是这些成员在shrink阶段没有被删除。仅在obfuscate阶段有效。

    -keepclasseswithmembernames class_specification 是-keepclasseswithmembers,allowshrinking class_specification的简写。与-keepclasseswithmembers类似。保护指定的类,如果它们没有在shrink阶段被删除。仅在obfuscate阶段有效。

    -printseeds [filename] 指定通过-keep配置匹配的类或者类成员的详细列表。列表可以打印到标准输出流或者文件里面。这个列表可以看到我们想要保护的类或者成员有没有被真正的保护到,尤其是那些使用通配符匹配的类。

    代码压缩配置


    -dontshrink 声明不压缩输入文件。默认情况下,除了-keep相关配置指定的类,所有其它没有被引用到的类都会被删除。每次optimizate操作之后,也会执行一次压缩操作,因为每次optimizate操作可能删除一部分不再需要的类。

    -printusage [filename] 声明 打印出那些被删除的元素。这个列表可能打印到标准输出流或者一个文件中。仅在shrink阶段有效。

    whyareyoukeeping class_specification 声明 打印为什么一个类或类的成员变量被保护。这对检查一个输出文件中的类的结果有帮助。

    代码优化配置


    -dontoptimize 声明不优化输入文件。默认情况下,优化选项是开启的,并且所有的优化都是在字节码层进行的。

    -optimizations optimization_filter 更加细粒度地声明优化开启或者关闭。只在optimize这一阶段有效。这个选项的使用难度较高。

    -optimizationpasses n 指定执行几次优化,默认情况下,只执行一次优化。执行多次优化可以提高优化的效果,但是,如果执行过一次优化之后没有效果,就会停止优化,剩下的设置次数不再执行。这个选项只在optimizate阶段有效

    assumenosideeffects class_specification 指定一些方法被删除也没有影响(尽管这些方法可能有返回值),在optimize阶段,如果确定这些方法的返回值没有使用,那么就会删除这些方法的调用。proguard会自动的分析你的代码,但不会分析处理类库中的代码。例如,可以指定System.currentTimeMillis(),这样在optimize阶段就会删除所有的它的调用。还可以用它来删除打印Log的调用。这条配置选项只在optimizate阶段有用。
    例子:

    
     
    1. # 删除代码中Log相关的代码

    2. -assumenosideeffects class android.util.Log {

    3. public static boolean isLoggable(java.lang.String, int);

    4. public static int v(...);

    5. public static int i(...);

    6. public static int w(...);

    7. public static int d(...);

    8. public static int e(...);

    9. }

    使用这条配置有点危险,如果删除了一些预料之外的代码,很容易就会导致代码崩溃。所以,谨慎使用

    -allowaccessmodification 这项配置是设置是否允许改变作用域的。使用这项配置之后可以提高优化的效果。**但是,如果你的代码是一个库的话,最好不要配置这个选项,因为它可能会导致一些private变量被改成public

    -mergeinterfacesaggressively 指定一些接口可能被合并,即使一些子类没有同时实现两个接口的方法。这种情况在java源码中是不允许存在的,但是在java字节码中是允许存在的。它的作用是通过合并接口减少类的数量,从而达到减少输出文件体积的效果。仅在optimize阶段有效。

    这项配置对于一些虚拟机的65535方法数限制是有一定效果的。

    混淆配置


    -dontobfuscate 声明不混淆。默认情况下,混淆是开启的。除了keep配置中声明的类,其它的类或者类的成员混淆后会改成简短随机的名字。

    -printmapping [filename] 指定输出新旧元素名的对照表的文件。映射表会被输出到标准输出流或者是一个指定的文件。

    这个文件在追踪异常的时候是有用的,在{android_sdk_home}/tools/proguard/lib目录下有一个retrace.jar文件。我们可以把混淆后的Stack Trace用这个工具处理一下,就会转变成容易阅读的类。所以,做app应用的同学每次发版本的时候都要把这个文件留下来,并标记清楚版本。这对线上版本的调试非常重要。

    -applymapping filename 指定重用一个已经写好了的map文件作为新旧元素名的映射。元素名已经存在在mapping文件中的元素,按照映射表重命名;没有存在到mapping文件的元素,重新赋一个新的名字。mapping文件可能引用到输入文件中的类和类库中的类。这里只允许设置一个mapping文件。仅在obfuscate阶段有效。

    -obfuscationdictionary filename 指定一个文本文件用来生成混淆后的名字。默认情况下,混淆后的名字一般为a,b,c这种。通过使用-obfuscationdictionary配置的字典文件,可以使用一些非英文字符做为类名。成员变量名、方法名。字典文件中的空格,标点符号,重复的词,还有以'#'开头的行都会被忽略。需要注意的是添加了字典并不会显著提高混淆的效果,只不过是更不利与人类的阅读。正常的编译器会自动处理他们,并且输出出来的jar包也可以轻易的换个字典再重新混淆一次。最有用的做法一般是选择已经在类文件中存在的字符串做字典,这样可以稍微压缩包的体积。

    查找了字典文件的格式:一行一个单词,空行忽略,重复忽略

    例如:

    
     
    1. # 这里巧妙地使用java中的关键字作字典,混淆之后的代码更加不利于阅读

    2. #

    3. # This obfuscation dictionary contains reserved Java keywords. They can't

    4. # be used in Java source files, but they can be used in compiled class files.

    5. # Note that this hardly improves the obfuscation. Decent decompilers can

    6. # automatically replace reserved keywords, and the effect can fairly simply be

    7. # undone by obfuscating again with simpler names.

    8. # Usage:

    9. # java -jar proguard.jar ..... -obfuscationdictionary keywords.txt

    10. #

    11.  
    12. do

    13. if

    14. for

    15. int

    16. new

    17. try

    18. byte

    19. case

    20. char

    21. else

    22. goto

    23. long

    24. this

    25. void

    26. break

    27. catch

    28. class

    29. const

    30. final

    31. float

    32. short

    33. super

    34. throw

    35. while

    36. double

    37. import

    38. native

    39. public

    40. return

    41. static

    42. switch

    43. throws

    44. boolean

    45. default

    46. extends

    47. finally

    48. package

    49. private

    50. abstract

    51. continue

    52. strictfp

    53. volatile

    54. interface

    55. protected

    56. transient

    57. implements

    58. instanceof

    59. synchronized

    -classobfuscationdictionary filename 指定一个混淆类名的字典,字典的格式与-obfuscationdictionary相同

    -packageobfuscationdictionary filename 指定一个混淆包名的字典,字典格式与-obfuscationdictionary相同

    -overloadaggressively 混淆的时候大量使用重载,多个方法名使用同一个混淆名,但是他们的方法签名不同。这可以使包的体积减小一部分,也可以加大理解的难度。仅在混淆阶段有效。

    注意,这项配置有一定的限制:

    Sun的JDK1.2上会报异常

    Sun JRE 1.4上重载一些方法之后会导致序列化失败

    Sun JRE 1.5上pack200 tool重载一些类之后会报错

    java.lang.reflect.Proxy类不能处理重载的方法

    Google's Dalvik VM can't handle overloaded static fields(这句我不懂,重载静态变量是什么意思?有看懂的同学可以回复一下)

    -useuniqueclassmembernames 指定相同的混淆名对应相同的方法名,不同的混淆名对应不同的方法名。如果不设置这个选项,同一个类中将会有很多方法映射到相同的方法名。这项配置会稍微增加输出文件中的代码,但是它能够保证保存下来的mapping文件能够在随后的增量混淆中继续被遵守,避免重新命名。比如说,两个接口拥有同名方法和相同的签名。如果没有这个配置,在第一次打包混淆之后,他们两个方法可能会被赋予不同的混淆名。如果说下一次添加代码的时候有一个类同时实现了两个接口,那么混淆的时候必然会将两个混淆后的方法名统一起来。这样就必须要改混淆文件其中一处的配置,也就不能保证前后两次混淆的mapping文件一致了。(如果你只想保留一份mapping文件迭代更新的话,这项配置比较有用)

    -dontusemixedcaseclassnames 指定在混淆的时候不使用大小写混用的类名。默认情况下,混淆后的类名可能同时包含大写字母和小写字母。这样生成jar包并没有什么问题。只有在大小写不敏感的系统(例如windows)上解压时,才会涉及到这个问题。因为大小写不区分,可能会导致部分文件在解压的时候相互覆盖。如果有在windows系统上解压输出包的需求的话,可以加上这个配置。

    -keeppackagenames [package_filter] 声明不混淆指定的包名。 配置的过滤器是逗号隔开的一组包名。包名可以包含?,,*通配符,并且可以在前面加!否定符。

    -flatternpackagehierarchy [packagename] 所有重新命名的都重新打包,并把所有的类移动到packagename包下面。如果没有指定packagename或者packagename为"",那么所有的类都会被移动到根目录下

    -repackageclasses [package_name] 所有重新命名过的都重新打包,并把他们移动到指定的packagename目录下。如果没有指定packagename,同样把他们放到根目录下面。这项配置会覆盖-flatternpackagehierarchy的配置。它可以代码体积更小,并且更加难以理解。这个与废弃的配置-defaultpackage作用相同。

    如果需要从目录中读取资源文件,移动包的位置可能会导致异常。如果出现问题,就不要用这个配置了。

    -keepattributes [attribute_filter] 指定受保护的属性,可以有一个或者多个-keepattributes配置项,每个配置项后面跟随的是Java虚拟机和proguard支持的attribute(具体支持的属性先看这里),两个属性之间用逗号分隔。属性名中可以包含*,**,?等通配符。也可以加!做前导符,将某个属性排除在外。当混淆一个类库的时候,至少要保持InnerClassesExceptionsSignature属性。为了跟踪异常信息,需要保留SourceFileLineNumberTable两个属性。如果代码中有用到注解,需要把Annotion的属性保留下来。
    例子:

    
     
    1. -keepattributes SourceFile, LineNumberTable

    2. -keepattributes *Annotation*

    3. -keepattributes EnclosingMethod

    4.  
    5. # 可以直接写在一行

    6. -keepattributes Exceptions, InnerClasses, Signature, Deprecated,

    7. SourceFile, LineNumberTable, *Annotation*, EnclosingMethod

    -keepparameternames 指定被保护的方法的参数类型和参数名不被混淆。这项配置在混淆一些类库的时候特别有用,因为根据IDE提示的参数名和参数类型,开发者可以根据他们的语义获得一些信息,这样的类库更友好。

    -renamesourcefileattribute [string] 指定一个字符串常量设置到源文件的类的属性当中。这样就可以在-keepattributes配置中使用。(这条我理解的也不是很清楚)

    -adaptclassstrings [classfilter] 指定字符串常量如果与类名相同,也需要被混淆。如果没有加classfilter,所有的符合要求的字符串常量都会被混淆;如果带有classfilter,只有在匹配的类中的字符串常量才会受此影响。例如,在你的代码中有大量的类名对应的字符串的hard-code,并且不想保留他们的本名,那就可以利用这项配置完成。这项配置只在混淆阶段有效,但是在压缩/优化阶段,涉及到的类会自动保留下来。

    adaptresourcefilenames [file_filter] 如果资源文件与某类名同,那么混淆后资源文件被命名为与之对应的类的混淆名。不加file_filter的情况下,所有资源文件都受此影响;加了file_filter的情况下,只有匹配到的类受此影响。

    adaptresourcefilecontents [file_filter] 指定资源文件的中的类名随混淆后的名字更新。根据被混淆的名字的前后映射关系,更新文件中对应的包名和类名。同样,如果不配置file_filter,所有的资源文件都会受此影响;配置了filter之后,只有对应的资源文件才受此影响。

    文件的读写都是按照系统默认的字符集。如果有特殊的字符集的需求,可以修改java的执行参数,或者直接修改java虚拟机的配置文件。

    注意,这项配置最好只能影响到字符文件。如果影响到一些二进制文件会产生意外影响。所以,设置filter的时候,要设置的足够 '严格'

    预校验配置


    -dontpreverify 声明不预校验即将执行的类。默认情况下,在类文件的编译版本为java micro 版本或者大于1.6版本时,预校验是开启的。目标文件针对java6的情况下,预校验是可选的;针对java7的情况下,预校验是必须的,除非目标运行平台是Android平台,设置它可以节省一点点时间。

    目标为Java Micro版本的情况下,预校验是必须的。如果你声明了这项配置,你还需要加上下面一条配置。

    -microedition 声明目标平台是java micro版本。预校验会根据这项配置加载合适的StackMap,而不是用标准的StackMap

    普通配置


    -verbose 声明在处理过程中输出更多信息。添加这项配置之后,如果处理过程中出现异常,会输出整个StackTrace而不是一条简单的异常说明。

    -dontnote [class_filter] 声明不输出那些潜在的错误和缺失,比如说错别字或者重要的配置缺失。配置中的class_filter是一串正则表达式,混淆过程中不会输出被匹配到的类相关的内容。

    -dontwarn [class_filter] 声明不输出那些未找到的引用和一些错误,但续混淆。配置中的class_filter是一串正则表达式,被匹配到的类名相关的警告都不会被输出出来。

    慎用!

    -ignorewarnings 输出所有找不到引用和一些其它错误的警告,但是继续执行处理过程。不处理警告有些危险,所以在清楚配置的具体作用的时候再使用。

    -printconfiguration [filename] 输出整个处理过程中的所有配置参数,包括文件中的参数和命令行中的参数。可以不加文件名在标准输出流中输出,也可以指定文件名输出到文件中。它在调试的时候比较有用。

    -dump [filename] 声明输出整个处理之后的jar文件的类结构,可以输出到标准输出流或者一个文件中。

    下面这些说明对应了之前每个参数后面的过滤器

    Class Paths


    它对应上文中的所有class_path,他是用来指定输入输出文件的路径的。它可以有多个路径用分隔符隔开。

    我们也可以使用过滤器来过滤需要输出的文件。过滤器的格式如下:

    classpathentry([[[[[[aarfilter;]apkfilter;]zipfilter;]earfilter;]warfilter;]jarfilter;]filefilter)

    []中包含的内容是可选的意思。这样看有些麻烦,直接上个例子:

    
     
    1. -injars in1.jar

    2. # 输入文件中排除了META-IF/MANIFEST.MF文件

    3. -injars in2.jar(!META-INF/MANIFEST.MF)

    4. -injars in3.jar(!META-INF/MANIFEST.MF)

    5. -outjars out.jar

    
     
    1. # 这个的意思是只引入`java`,`javax`包中的类

    2. -libraryjars rt.jar(java/**.class,javax/**.class)

    File Names


    proguard支持绝对路径和相对路径。相对路径按照下面顺序被解释:

    • 如果设置了base directory,首先按照它来定位;
    • 其次,按照配置文件所在的路径定位;
    • 最后,按照工作路径(working directory,也就是执行这条命令的路径)来解释。(这个不可能没有!)

    名称中可以包含java系统属性,用<>包围。例如:

    -libraryjars <java.home>/lib/rt.jar # 可能代表/usr/local/java/jdk/jre/lib/rt.jar

    如果路径名中带有特殊字符,可以使用单引号或者双引号括起来。

    File Filters


    就像普通的匹配器一样,可以使用通配符来过滤文件名。

    • ? 代表文件名中的一个字符
    • * 代表文件名中的一部分,不包括文件分隔符
    • ** 代表文件名中的一部分,包括文件分隔符
    • ! 放在文件名前面表示将某文件排除在外

    Filters


    匹配的规则与File Filters相似。只是过滤的范围更加广泛。

    Keep配置整理


    -keep-keepnames的关系一开始理解的时候有些混乱。但是它们背后是有一定规则的,下面的表格展示了它们的联系与不同

    <ul><li>class 关键字可以匹配class类或interface类,但是<code>interface</code>关键字只能匹配interface类,<code>enum</code>关键字只能匹配enum类。在<code>interface</code>或<code>enum</code>关键字前加一个<code>!</code>,可以表示非这种类型的类。</li><li>
    <p>classname 必须写全名,比如<code>java.lang.String</code>。内部类用<code>$</code>间隔,例如,<code>java.lang.Thread$State</code>。类名可以用含有下面这些通配符的正则表达式匹配:</p>
    <ul><li>? 匹配类名中的一个字符,不包括文件分隔符。例如,<code>mypackage.Test?</code>可以匹配<code>mypackage.Test1</code>,<code>mypackage.Test2</code>,但不能匹配<code>mypackage.Test12</code>。</li><li>* 匹配类名中的0到多个字符但不包括文件分隔符。例如,<code>mypackage.*Test*</code>可以匹配到<code>mypackage.Test</code>和<code>mypackage.YourTestApplication</code>但是不能匹配<code>mypackage.mysubpackage.MyTest</code>。一种常用的写法<code>mypackage.*</code>就是匹配<code>mypackage</code>下的所有子文件。</li><li>** 可以匹配类名中的所有字符,可能包含多个分隔符。例如,<code>**.Test</code>就是匹配所有目录下的<code>Test</code>类,<code>mypackage.**</code>就是匹配mypackage及其子目录下的所有类。</li></ul></li><li>extend与implements 关键字是用来限制类的范围的。他们目前是等价的,用来匹配某些类的子类。需要注意的是,这个指定的类并不包括在匹配结果中,如果想要该类也被匹配到,就需要额外声明一项配置。</li><li>@ 符号匹配那些注解标志的类或类成员,它的通配符形式与classname的形式一样。</li><li>
    <p>成员变量和成员方法的匹配形式与java非常像,只是方法的参数不带参数名。此外,他们还可以使用通配符:</p>
    <blockquote>
    <p>变量名和方法名可以使用的通配符:</p>
    <ul><li>&lt;init&gt; 匹配一个类的所有构造函数</li><li>&lt;fields&gt; 匹配一个类中的所有成员变量</li><li>&lt;methods&gt; 匹配一个类中的所有方法</li><li>* 匹配类中的所有成员<br>
    列表。</li><li>? 匹配一个字符</li><li>* 匹配0到多个字符<br><strong>注意</strong>上述通配符并不能设置返回类型,并且只有&lt;init&gt;方法带有参数<br>
    修饰符中可以使用以下通配符匹配:</li><li>% 匹配java中的初始类型(int, boolean, long, float,double等)</li><li>? </li><li>* </li><li>** (这三个不解释了,同上)</li><li>*** 匹配所有类型,包括初始类型和非初始类型,数组和非数组。</li><li>... 匹配任意参数列表<br>
    需要注意的是?, *, **不能够匹配初始类型和数组。***可以匹配到数组。例子:
    <pre class="hljs lisp" name="code" οnclick="hljs.copyCode(event)"><code class="lisp hljs vbscript">** <span class="hljs-keyword">get</span>*<span class="hljs-list">()</span></code><div class="hljs-button" data-title="复制"></div></pre>
    上面的例子可以匹配到<code>java.lang.Object getObject()</code>,但是不能匹配<code>float getFloat()</code>或者<code>java.lang.Object[] getObjects()</code>。</li></ul></blockquote>
    </li><li>
    <p>构造函数也可以使用简单类名或全类名来指定。就像java中的构造函数一样有参数列表但是没有返回类型。</p>
    </li><li>
    <p>类或者类成员的修饰符也是匹配类的限制条件。通过修饰符限制,可以缩小匹配的范围。修饰符组合也是可以的,就像java中的<code>public static</code>一样,但是不能冲突, 比如<code>public private</code>。</p>
    </li></ul>
       
         
         
         

    如果不确定自己该用哪个的话,就用-keep吧,它能保证匹配的类在压缩这一阶段不被移除,并且在混淆阶段不会被重新命名。

    • 如果只声明保护一个类,并没有指定受保护的成员。proguard只会保护它的类名和它的无参构造函数。其它成员依旧会被压缩、优化、混淆。
    • 如果声明保护一个方法,proguard会把它当作程序的入口点,方法名不会变,但它里面的代码依旧会被优化、混淆。

    Keep配置的修饰符


    includedescriptorclasses

    它是用来声明描述目标成员的元素也应当被保护。它在保护native方法时特别有效。因为它可以同时保证参数类型,返回类型不被混淆。保证最终的方法签名保持一致。

    例子:

    
     
    1. -keepclasseswithmembernames,includedescriptorclasses class * {

    2. native <methods>;

    3. }

    -keepclasseswithmembernames是保护符合条件的含有native方法的类。附加的includedescriptorclasses是保证参数和返回类型的类同样不被混淆。这样就可以做到这些类的方法签名与调试时完全一致。

    allowshrinking

    修饰-keep, 声明一个元素可以被移除,即使它已经声明了被保护。意味着它有可能在压缩阶段被删除,但是它又是必须的入口,所以它有可能不参与优化和混淆阶段。
    (这里我也看不太懂,压缩阶段不是依赖keep声明的入口节点吗?)

    allowoptimization

    修饰-keep, 声明一个元素可以被优化,即使它已经声明被保护。这意味着该元素参与优化阶段,但是不参与压缩和混淆阶段。特殊用途的时候使用。

    allowobfuscation

    与前几个类似,修饰-keep,只参与混淆阶段,但是不参与压缩和优化阶段。

    类的匹配


    Class Specification是指一个类和类成员的模板。它一般跟在各种-keep配置或者assumenosideeffects配置之后,只有匹配到的类和类成员会受到影响。

    Class Specification的形式与java的类的形式很像,只是而外加了几个通配符。如果想要清晰的看它的形式,最好看例子。但这里还是给出了通用的模型:

    
     
    1. [@annotationtype] [[!]public|final|abstract|@ ...] [!]interface|class|enum classname

    2. [extends|implements [@annotationtype] classname]

    3. [{

    4. [@annotationtype] [[!]public|private|protected|static|volatile|transient ...] <fields> |

    5. (fieldtype fieldname);

    6. [@annotationtype] [[!]public|private|protected|static|synchronized|native|abstract|strictfp ...] <methods> |

    7. <init>(argumenttype,...) |

    8. classname(argumenttype,...) |

    9. (returntype methodname(argumenttype,...));

    10. [@annotationtype] [[!]public|private|protected|static ... ] *;

    11. ...

    12. }]

    • []代表可选可不选;
    • ···代表还有更多选项可以配置;
    • |分隔的部分代表多选一;
    • ()括起来的部分代表是一个整体,不能分割。
    • class 关键字可以匹配class类或interface类,但是interface关键字只能匹配interface类,enum关键字只能匹配enum类。在interfaceenum关键字前加一个!,可以表示非这种类型的类。
    • classname 必须写全名,比如java.lang.String。内部类用$间隔,例如,java.lang.Thread$State。类名可以用含有下面这些通配符的正则表达式匹配:

      • ? 匹配类名中的一个字符,不包括文件分隔符。例如,mypackage.Test?可以匹配mypackage.Test1,mypackage.Test2,但不能匹配mypackage.Test12
      • * 匹配类名中的0到多个字符但不包括文件分隔符。例如,mypackage.*Test*可以匹配到mypackage.Testmypackage.YourTestApplication但是不能匹配mypackage.mysubpackage.MyTest。一种常用的写法mypackage.*就是匹配mypackage下的所有子文件。
      • ** 可以匹配类名中的所有字符,可能包含多个分隔符。例如,**.Test就是匹配所有目录下的Test类,mypackage.**就是匹配mypackage及其子目录下的所有类。
    • extend与implements 关键字是用来限制类的范围的。他们目前是等价的,用来匹配某些类的子类。需要注意的是,这个指定的类并不包括在匹配结果中,如果想要该类也被匹配到,就需要额外声明一项配置。
    • @ 符号匹配那些注解标志的类或类成员,它的通配符形式与classname的形式一样。
    • 成员变量和成员方法的匹配形式与java非常像,只是方法的参数不带参数名。此外,他们还可以使用通配符:

      变量名和方法名可以使用的通配符:

      • <init> 匹配一个类的所有构造函数
      • <fields> 匹配一个类中的所有成员变量
      • <methods> 匹配一个类中的所有方法
      • * 匹配类中的所有成员
        列表。
      • ? 匹配一个字符
      • * 匹配0到多个字符
        注意上述通配符并不能设置返回类型,并且只有<init>方法带有参数
        修饰符中可以使用以下通配符匹配:
      • % 匹配java中的初始类型(int, boolean, long, float,double等)
      • ?
      • *
      • ** (这三个不解释了,同上)
      • *** 匹配所有类型,包括初始类型和非初始类型,数组和非数组。
      • ... 匹配任意参数列表
        需要注意的是?, *, **不能够匹配初始类型和数组。***可以匹配到数组。例子:
        ** get*()
        上面的例子可以匹配到java.lang.Object getObject(),但是不能匹配float getFloat()或者java.lang.Object[] getObjects()
    • 构造函数也可以使用简单类名或全类名来指定。就像java中的构造函数一样有参数列表但是没有返回类型。

    • 类或者类成员的修饰符也是匹配类的限制条件。通过修饰符限制,可以缩小匹配的范围。修饰符组合也是可以的,就像java中的public static一样,但是不能冲突, 比如public private

    混淆相关的点就这些了,下面的例子中是Android应用混淆的默认文件。它放在{android_sdk_home}/tools/proguard/proguard-android.txt文件中,其它的可以参考的例子在{android_sdk_home}/tools/proguard/examples/目录下。

    
     
    1. # This is a configuration file for ProGuard.

    2. # http://proguard.sourceforge.net/index.html#manual/usage.html

    3.  
    4. -dontusemixedcaseclassnames

    5. -dontskipnonpubliclibraryclasses

    6. -verbose

    7.  
    8. # Optimization is turned off by default. Dex does not like code run

    9. # through the ProGuard optimize and preverify steps (and performs some

    10. # of these optimizations on its own).

    11. -dontoptimize

    12. -dontpreverify

    13. # Note that if you want to enable optimization, you cannot just

    14. # include optimization flags in your own project configuration file;

    15. # instead you will need to point to the

    16. # "proguard-android-optimize.txt" file instead of this one from your

    17. # project.properties file.

    18.  
    19. -keepattributes *Annotation*

    20. -keep public class com.google.vending.licensing.ILicensingService

    21. -keep public class com.android.vending.licensing.ILicensingService

    22.  
    23. # For native methods, see http://proguard.sourceforge.net/manual/examples.html#native

    24. -keepclasseswithmembernames class * {

    25. native <methods>;

    26. }

    27.  
    28. # keep setters in Views so that animations can still work.

    29. # see http://proguard.sourceforge.net/manual/examples.html#beans

    30. -keepclassmembers public class * extends android.view.View {

    31. void set*(***);

    32. *** get*();

    33. }

    34.  
    35. # We want to keep methods in Activity that could be used in the XML attribute onClick

    36. -keepclassmembers class * extends android.app.Activity {

    37. public void *(android.view.View);

    38. }

    39.  
    40. # For enumeration classes, see http://proguard.sourceforge.net/manual/examples.html#enumerations

    41. -keepclassmembers enum * {

    42. public static **[] values();

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

    44. }

    45.  
    46. -keepclassmembers class * implements android.os.Parcelable {

    47. public static final android.os.Parcelable$Creator CREATOR;

    48. }

    49.  
    50. -keepclassmembers class **.R$* {

    51. public static <fields>;

    52. }

    53.  
    54. # The support library contains references to newer platform versions.

    55. # Don't warn about those in case this app is linking against an older

    56. # platform version. We know about them, and they are safe.

    57. -dontwarn android.support.**

    展开全文
  • jar包混淆工具ProGuard 5.3

    热门讨论 2016-09-22 16:16:29
    官方网址:http://proguard.sourceforge.net/
  • 1.业务需求 公司有块核心代码不希望...3.下载了proguard6.2.2这个版本,解压缩后执行proguard6.2.2\bin\proguardgui.bat这个文件就可以打开软件,标红框的地方是需要特别设置的,其他地方都可以默认 4.设置Input.

    1.业务需求

    公司有块核心代码不希望给别人抄袭,但系统是用java开发的,无法避免被反编译的情况,于是想到了用代码混淆的方式来解决。

    2.调查

    调查了一下主流的第三方混淆工具,发现只有ProGuard用的最多,而且版本一直在更新维护,功能也比较多,所以打算用这个来混淆。 

    3.下载了proguard6.2.2这个版本,解压缩后执行proguard6.2.2\bin\proguardgui.bat这个文件就可以打开软件,标红框的地方是需要特别设置的,其他地方都可以默认

    4.设置Input/Output,“Add input”就是选择你要混淆的jar文件,“Add output”就是混淆后的文件保存的路径和名字,下面那个“Add”就是把你这个工程所有用到的依赖全部加进来,如何知道你的工程用到哪些依赖?请看下一步

     5.设置maven工程,在pom.xml文件里加上这一段配置,可以把所有用到的依赖导出到指定目录里。Maven install后,会在target\lib目录下导出所有的依赖,把这些jar包加入到第4步的“Add”中,注意java的依赖还是需要你到Java\jdk1.8.0_152\jre\lib目录里Add进来

    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-dependency-plugin</artifactId>
    				<executions>
    					<execution>
    						<id>copy</id>
    						<phase>package</phase>
    						<goals>
    							<goal>copy-dependencies</goal>
    						</goals>
    						<configuration>
    							<outputDirectory>${project.build.directory}/lib</outputDirectory>
    						</configuration>
    					</execution>
    				</executions>
    			</plugin>
    		</plugins>
    	</build>

    6.选择Information设置java的版本

     7.然后一路next,最后按Process进行混淆,看到Processing completed successfully就说明成功了

    展开全文
  • proguard打包问题

    2018-11-08 16:40:44
    前些天更新了AS,打包,报...Caused by: java.io.FileNotFoundException: D:\xxxxx\app\proguard\class_files.txt (系统找不到指定的路径。) at java.io.FileOutputStream.open0(Native Method) at java.io.FileOu...

                    前些天更新了AS,打包,报以下错误:

    
    Caused by: java.io.FileNotFoundException: D:\xxxxx\app\proguard\class_files.txt (系统找不到指定的路径。)
    	at java.io.FileOutputStream.open0(Native Method)
    	at java.io.FileOutputStream.open(FileOutputStream.java:270)
    	at java.io.FileOutputStream.<init>(FileOutputStream.java:213)
    	at proguard.util.PrintWriterUtil.createPrintWriter(PrintWriterUtil.java:86)
    	at proguard.util.PrintWriterUtil.createPrintWriterOut(PrintWriterUtil.java:51)
    	at proguard.util.PrintWriterUtil.createPrintWriterOut(PrintWriterUtil.java:40)
    	at proguard.ProGuard.dump(ProGuard.java:530)
    	at proguard.ProGuard.execute(ProGuard.java:215)
    	at com.android.build.gradle.internal.transforms.BaseProguardAction.runProguard(BaseProguardAction.java:66)
    	at com.android.build.gradle.internal.transforms.ProGuardTransform.doMinification(ProGuardTransform.java:287)
    	at com.android.build.gradle.internal.transforms.ProGuardTransform.access$000(ProGuardTransform.java:68)
    	at com.android.build.gradle.internal.transforms.ProGuardTransform$1.run(ProGuardTransform.java:179)
    	at com.android.builder.tasks.Job.runTask(Job.java:47)
    	at com.android.build.gradle.tasks.SimpleWorkQueue$EmptyThreadContext.runTask(SimpleWorkQueue.java:41)
    	at com.android.builder.tasks.WorkQueue.run(WorkQueue.java:282)
    	... 1 more
    
    

                发现打包需要在项目根目录下自己新建proguard文件夹,不然class_files.txt文件无法新建

    展开全文
  • proguard rule 惨痛教训(记录)

    千次阅读 2018-12-18 10:24:39
    下面是打包配置(app下的build.gradle),关于为什么要proguard应用程序,请看这篇文章为什么每个人都应该将ProGuard用于他们的Android应用程序 android { compileSdkVersion rootProject.ext.android....

    问题

    今天再给项目配置混淆打release包时,遇到了个很尴尬的问题,项目打正式包下奔溃,打测试包正常运行。下面是打包配置(app下的build.gradle),关于为什么要proguard应用程序,请看这篇文章为什么每个人都应该将ProGuard用于他们的Android应用程序

    android {
        compileSdkVersion rootProject.ext.android.compileSdkVersion
        defaultConfig {
            applicationId "com.kanghanbin.wanandroid"
            minSdkVersion rootProject.ext.android.minSdkVersion
            targetSdkVersion rootProject.ext.android.targetSdkVersion
            versionName rootProject.ext.android.versionName
            testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
            ndk {
                // 设置支持的SO库架构
                abiFilters 'armeabi', 'x86', 'armeabi-v7a', 'x86_64', 'arm64-v8a'
            }
        }
        signingConfigs {
            release {
                //RELEASE_KEY_ALIAS等常量放在gradle.properties文件中
                keyAlias RELEASE_KEY_ALIAS
                keyPassword RELEASE_KEY_PASSWORD
                storeFile file(RELEASE_STORE_FILE)
                storePassword RELEASE_STORE_PASSWORD
            }
        }
        buildTypes {
            release {
                minifyEnabled true
                shrinkResources true // 自动清理无用资源
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
                signingConfig signingConfigs.release
            }
            debug {
                signingConfig signingConfigs.release
                minifyEnabled false
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            }
        }
        //只需禁用lint警告。有时应用不会发布到Google Play,因此不需要深层链接等:
        lintOptions {
            disable 'GoogleAppIndexingWarning'
            baseline file("lint-baseline.xml")
            checkReleaseBuilds false
            abortOnError false
        }
    }
    
    

    然后我就将buildType为debug时的minifyEnabled 也改为true,在手机上调试

     debug {
                signingConfig signingConfigs.release
                minifyEnabled true
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            }
    

    不出意外,来了个NPE

    定位错误是在BaseSubscriber的61行代码报错

       if (((ApiException) t).getCode() == Constant.UN_LOGIN
                        || t.getMessage().equals(Constant.UN_LOGIN_MESSAGE)) {
                    mView.startLoginActivity();
                }
                mView.showToast(t.getMessage());
    

    发现就是t.getmessage为空然后我就多加了个判断,BaseSubscriber类的完整代码如下

    public abstract class BaseSubscriber<T> extends ResourceSubscriber<T> {
        private BaseView mView;
        private String mErrorMsg = "";
        private boolean isShowErrorState = true;
    
        public BaseSubscriber(BaseView mView) {
            this.mView = mView;
        }
    
        public BaseSubscriber(BaseView mView, boolean isShowErrorState) {
            this.mView = mView;
            this.isShowErrorState = isShowErrorState;
        }
    
        public BaseSubscriber(BaseView mView, String mErrorMsg) {
            this.mView = mView;
            this.mErrorMsg = mErrorMsg;
        }
    
        public BaseSubscriber(BaseView mView, String mErrorMsg, boolean isShowErrorState) {
            this.mView = mView;
            this.mErrorMsg = mErrorMsg;
            this.isShowErrorState = isShowErrorState;
        }
    
        @Override
        public void onComplete() {
    
        }
    
        @Override
        public void onError(Throwable t) {
            if (mView == null) {
                return;
            }
            if (mErrorMsg != null && !TextUtils.isEmpty(mErrorMsg)) {
                mView.showToast(mErrorMsg);
            } else if (t instanceof ApiException) {
                if (((ApiException) t).getCode() == Constant.UN_LOGIN
                        || t.getMessage() == null
                        || t.getMessage().equals(Constant.UN_LOGIN_MESSAGE)) {
                    mView.startLoginActivity();
                }
    
                mView.showToast(t.getMessage());
    
            } else if (t instanceof HttpException) {
                mView.showToast(MyApplication.getInstance().getString(R.string.data_fail));
            } else {
                mView.showToast(MyApplication.getInstance().getString(R.string.unknow_error));
            }
            if (isShowErrorState) {
                mView.showFailed();
            }
        }
    }
    

    但是我就纳闷为啥会走到onError里,回头一想既然不混淆没问题肯定是混淆规则有问题

    然后我就开始看混淆规则,排查了一遍发现这里用到的retrofit和rxjava2混淆都没问题呢,可是什么导致的一直走onerror。最后发现我只对项目实体类进行了keep

    #-----------处理实体类---------------
    # 在开发的时候我们可以将所有的实体类放在一个包内,这样我们写一次混淆就行了。
    -keep class com.kanghanbin.wanandroid.model.bean.**{ *; }
    

    并没有将自己封装的BaseResponse类进行keep,因为这里的BaseResponse用于http统一响应。BaseResponse完整代码:

    /**
     * 创建时间:2018/10/26
     * 编写人:kanghb
     * 功能描述:封装http响应格式
     */
    public class BaseResponse<T> {
    
        /**
         * data : null
         * errorCode : -1
         * errorMsg : 账号密码不匹配!
         */
    
        private T data;
        private int errorCode;
        private String errorMsg;
    
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
        public int getErrorCode() {
            return errorCode;
        }
    
        public void setErrorCode(int errorCode) {
            this.errorCode = errorCode;
        }
    
        public String getErrorMsg() {
            return errorMsg;
        }
    
        public void setErrorMsg(String errorMsg) {
            this.errorMsg = errorMsg;
        }
    
        @Override
        public String toString() {
            return "BaseResponse{" +
                    "data=" + data +
                    ", errorCode=" + errorCode +
                    ", errorMsg='" + errorMsg + '\'' +
                    '}';
        }
    }
    

    BaseResponse用法举例:

            addSubscribe(apiService.login(username, password)
                    .compose(RxUtil.<BaseResponse<UserBean>>rxFlowableSchedulerHelper())
                    .compose(RxUtil.<UserBean>handleResult())
                    .subscribeWith(new BaseSubscriber<UserBean>(mView) {
                        @Override
                        public void onNext(UserBean userBean) {
                            mView.showToast("登录成功");
                            mView.gotoMain();
                            sharePreferencesHelper.setLoginAccount(username);
                            sharePreferencesHelper.setLoginPassword(password);
                            sharePreferencesHelper.setLoginStatus(true);
                            RxBus.getDefault().post(new EventLogin(true));
                        }
                    }));
    
    

    解决

    在proguard-rules.pro中加入完美结局问题,正式包也可以正常运行了

    
    #-----------处理实体类---------------
    # 在开发的时候我们可以将所有的实体类放在一个包内,这样我们写一次混淆就行了。
    -keep class com.kanghanbin.wanandroid.model.bean.**{ *; }
    -keep class com.kanghanbin.wanandroid.http.BaseResponse{ *; }
    

    科普一下

    多简化序列化和反序列化这些字段的工具都依赖于反射。GSON,Retrofit,Firebase - 它们都检查数据类中的字段名称,并将它们转换为另一种表示形式(例如:),{“name”: “Sue”, “age”: 28}用于传输或存储。当他们将数据读入Java对象时会发生同样的事情 - 他们看到一个键值对“name”:”John”并尝试通过查找String name字段将其应用于Java对象。

    结论:我们不能让ProGuard重命名或删除这些数据类中的任何字段,因为它们必须与序列化格式匹配。可以安全地@Keep在整个类上添加注释或在所有模型上添加通配符规则:

    -keep class com.kanghanbin.wanandroid.model.bean.**{ *; }
    展开全文
  • ProGuard简介

    千次阅读 2018-11-19 16:14:05
    深入学习ProGuard之:ProGuard简介与android的应用 什么是ProGuardProGuard的官网中,关于ProGuard的描述是这样的: ProGuard is a Java class file shrinker, optimizer, obfuscator, and preverifier. ...
  • ProGuard技术详解

    千次阅读 2018-01-17 16:02:08
    ProGuard是一个开源的Java代码混淆器,在Android中一提起ProGuard,我们通常第一想到的是用来混淆代码的,其实它的功能并不仅限于此,有以下四个功能: (1)压缩(Shrink):侦测并移除代码中无用的类、字段、方法和...
  • ProGuard详解

    万次阅读 多人点赞 2016-05-03 23:46:35
     对于ProGuard工具想必我们都不陌生,它能够通过移除无用代码,使用简短无意义的名称来重命名类,字段和方法。从而能够达到压缩、优化和混淆代码的目的。最终我们会获取一个较小的apk文件,并且我们这个通过...
  • 在实际的开发成产品apk的发布过程中,我们经常会使用到代码混淆技术。不过在讲解如何进行代码混淆之前,我先跟大家演示一下反编译的过程,这样才能让大家明白为什么需要进行代码混淆。    一、代码反编译  ...
  • ProGuard 最全混淆规则说明

    万次阅读 2018-08-01 10:19:59
    说明:本文参考(翻译)自Android SDK根目录下的proguard目录下的说明文档,是其中的一篇。,文中除了翻译外加了一些作者的实际验证。文章对Android混淆规则做一个解释说明。作者才疏学浅,如有错误,请谅解!&...
  • ProGuard是一个压缩、优化和混淆Java字节码文件的免费的工具,它可以删除无用的类、字段、方法和属性。可以删除没用的注释,最大限度地优化字节码文件。它还可以使用简短的无意义的名称来重命名已经存在的类、字段、...
  • 转载请标明出处:... 本文出自: 【HansChen的博客】 ProGuard简介和工作流程 PrgGuard环境配置和使用 运行PrgGuard需要以下依赖: 如何运行ProGuard PrgGuard配置文件使用 Entry po...
  • Android gradle proguard 代码混淆详解

    千次阅读 2016-04-28 21:54:07
      简介   Java代码是非常容易反编译的。...ProGuard是一个混淆代码的开源项目。它的主要作用就是混淆,当然它还能对字节码进行缩减体积、优化等,但那些对于我们来说都算是次要的功能。官...
  • ProGuard代码混淆技术详解

    千次阅读 2017-01-19 09:32:29
    讲得比较到位,较实用。 ... 受《APP研发录》启发,里面讲到一名Android程序员,在工作一段时间后,会感觉到迷茫,想进阶的话接下去是看Android系统源码呢,还是每天继续做应用,毕竟每天都是画UI和利用Mobile...
  • Android Studio:ProGuard 混淆配置

    万次阅读 2016-09-22 10:04:46
    Android Studio 创建Module后,会自动生成 proguard-rules.pro 文件,在其中添加需要的规则即可对apk或jar进行混淆
  • Android proguard代码混淆

    千次阅读 2016-11-11 15:52:54
    那么本文我们来学习一下如何防止自己的APK被别人反编译,即代码混淆。 代码混淆并不是让代码无法被反编译,而是将代码中的类、方法、变量等信息进行重命名,将它们改成一些毫无意义的名字,譬如A类的b()方法等。...
  • 今天给大家分享一个只混淆自己的项目代码而不混淆所有第三方jar的方法(没错,是所有的第三方都不进行混淆,无论来什么第三方,都不需要动混淆配置) 一、为app添加混淆 在app的buildTypes里开启对指定包进行混淆...
  • 本来这篇内容是准备分析ant的android多渠道打包过程,但是在测试案例的时候,发现还有一个比较重要的知识点没介绍-ProGuard技术,因此本篇就来介绍一下android的混淆技术之ProGuard。 1.什么是ProGuard技术?  ...
  • Android Proguard混淆打包经验总结

    千次阅读 2016-09-23 14:22:38
    作为一名Android开发,应该了解并尝试给自己的项目进行Proguard混淆打包。项目经过Proguard混淆打包后,会发现apk包体积会变小,也就是混淆可以使得apk瘦身;并且反编译apk的时候会发现, 项目中的源码都被处理过,...
  • Android 项目的代码混淆,Android proguard 使用说明

    万次阅读 多人点赞 2015-08-02 18:43:23
    Android 项目的代码混淆,Android proguard 使用说明
  • JAVA代码proguard混淆

    2019-08-12 11:14:05
    一,通用设置 #输出log -verbose #略过warning,不输出warning(有warning时无法继续) -ignorewarnings #不输出warning,这里可以限定某些类不要warning ...#不混淆 #-dontobfuscate #需要混淆的目录 #-obf...
  • proguard 混淆 demo

    2019-01-11 11:29:41
    混淆了四天,亲测可用,建议先从网上浏览proguard用法,特别是四步骤中混淆那一步,最重要,及验证是否能够省略
  • java代码混淆-ProGuard

    2018-08-16 16:27:48
    仅做记录之用。   java代码可以反编译,因此有时候要保护自己的知识产权还真得费点心思,一般来说有三个思路:  1、将class文件加密,这个是最安全的... 3、代码混淆,提高代码阅读成本;简单易操作,一般采用...
  • Proguard混淆与Maven集成

    千次阅读 2014-09-25 15:03:41
    Proguard混淆与Maven集成 目录 1  prouard与maven集成 2 2  Proguard配置 3 2.1压缩  3 2.2.优化  3 2.3 混淆  3 3.工程搭建  9 3.1.Jar工程混淆  9 3.2.WEB工程混淆  9        ...
  • Android 混淆proguard实践

    千次阅读 2017-12-11 17:49:37
    前言网上关于使用proguard进行混淆的文章很多,但大部分是从讲解proguard知识点这个角度去写的,为什么要混淆,如何去混淆混淆的注意点等重要的问题反而都没有写。 所以想通过这篇文章来记录我学习proguard的过程...
  • ProGuard对java jar包实现混淆加密

    万次阅读 2017-05-31 14:02:11
    随时随地阅读更多技术实战干货,获取项目源码、学习资料,请关注源代码社区公众号(ydmsq666)、博主微信(guyun297890152)、QQ技术交流群(183198395)。 ... Java代码编译后生成的.class 中包含有源代码中的所有信息...
  • Android:混淆文件proguard.cfg详解

    千次阅读 2015-09-19 14:36:42
    下面给出proguard.cfg文件的内容:#指定代码的压缩级别 -optimizationpasses 5 #混淆时不会产生形形色色的类名 是否使用大小写混合 -dontusemixedcaseclassnames #指定不去忽略非公共的类库 是否混淆第三方jar -...
  • 利用Ant与Proguard混淆

    千次阅读 2014-04-04 20:20:21
    当前的web项目有引用到子工程项目,而且多个子工程项目也有引用到其它的工程项目,现要求利用Ant自动将web项目打包成war包,其中引用到的子工程项目...其中混淆代码的工具选择了开源的Proguard(http://proguard.so
  • Android ProGuard 混淆 详解 标签: Android混淆 2015-11-06 20:02 9054人阅读 评论(3) 收藏 举报  分类: Android(40)  版权声明:本文为博主原创文章,未经博主允许不得转载。 ...
  • ProGuard是最受欢迎的Java字节码优化器。 它使您的Java和Android应用程序缩小了90%,速度提高了20%。...我们通常说的proguard包括四个功能,shrinker(压缩), optimizer(优化),obfuscator(混淆),pr...

空空如也

1 2 3 4 5 ... 20
收藏数 334,375
精华内容 133,750
关键字:

proguard