鸿蒙代码配置混淆原理以及混淆命令

想了解更多内容，请访问：

和华为官方合作共建的鸿蒙技术社区

https://harmonyos.

一、前言

Java代码会被编译成字节码，字节码非常容易被反编译，一旦字节码被反编译，源码也就泄露了。为了很好的保护源代码，需要对编译好后的字节码文件进行混淆。代码经过混淆后，包体积会变小，并且源码都被处理过，进一步保障了应用的安全。本文将首先介绍混淆原理以及混淆命令，然后教大家如何在鸿蒙项目里面配置混淆。

二、ProGuard

ProGuard就是用来混淆代码的，主要有以下4个功能。

  • 压缩(Shrink)：检测并移除代码中无用的类、字段、方法和特性。可以使用下面的指令关闭压缩
 
 
 
 
    
  
  
  
  
  1. # 关闭压缩 
    2.   
  
  
  
  2. -dontshrink 
    3.
  •  优化(Optimize)：对字节码进行优化，移除无用的指令。可以使用下面的指令关闭优化
 
 
 
 
    
  
  
  
  
  1. # 关闭优化 
    2.   
  
  
  
  2. -dontoptimize 
    3.   
  
  
  
  3. -optimizationpasses n 表示proguard对代码进行迭代优化的次数 
    4.
  •  混淆(Obfuscate)：使用a，b，c，d这样简短而无意义的名称，对类、字段和方法进行重命名。可以使用下面的指令关闭混淆
 
 
 
 
    
  
  
  
  
  1. # 关闭混淆 
    2.   
  
  
  
  2. -dontobfuscate 
    3.
  •  预检(Preveirfy)：在Java平台上对处理后的代码进行预检，确保加载的字节码文件是可执行的。
  • 总之，Proguard是一个Java类文件压缩器、优化器、混淆器、预校验器。压缩环节会检测以及移除没有用到的类、字段、方法以及属性。优化环节会分析以及优化方法的字节码。混淆环节会用无意义的短变量去重命名类、变量、方法。这些步骤让代码更精简，更高效，也更难被逆向(破解)。
  • 那么有一个问题，ProGuard怎么知道这个代码没有被用到呢?这里引入一个Entry Point(入口点)概念，Entry Point表示在混淆过程中不会被处理的类或方法。在压缩的步骤中，ProGuard会从上述的Entry Point开始递归遍历，搜索哪些类和类的成员在使用，对于没有被使用的类和类的成员，就会在压缩段丢弃，在接下来的优化过程中，那些非Entry Point的类、方法都会被设置为private、static或final，不使用的参数会被移除，此外，有些方法会被标记为内联的，在混淆的步骤中，ProGuard会对非Entry Point的类和方法进行重命名。
  • 一般来说，开启混淆后，代码越乱越无规律越好，但有些代码是不能被混淆的，否则程序运行就会出错，所以就需要我们熟悉混淆指令，当开启混淆的时候，使用混淆指令告诉编译器某些代码不能被混淆。

三、混淆指令

3、1 先看如下如下的命令，一个星号表示只是保持该包下的类名，而子包下的类名还是会被混淆。

 
 
 
 
    
  
  
  
  
  1. -keep class com.poetry.jianjia.bean.* 
    2.

 3、2 两个星号表示把本包和所含子包下的类名都保持。

 
 
 
 
    
  
  
  
  
  1. -keep class com.poetry.jianjia.bean.** 
    2.

 3、3 用以上方法保持类后，虽然类名未混淆，但类里面的方法和变量命名还是会变，如果既想保持类名，又想保持里面的内容不被混淆，就需要加上{*;}

 
 
 
 
    
  
  
  
  
  1. -keep class com.poetry.jianjia.bean.**{*;} 
    2.

 3、4 在此基础上，还可以使用extends、implements等关键字来保护特定类不被混淆，如下例子表示实现Serializable接口的类名不被混淆

 
 
 
 
    
  
  
  
  
  1. -keep class * implements java.io.Serializable 
    2.

 3、5 如果想保留内部类不被混淆则需要用$符号，如下例子MainAbilitySlice内部类InnerClass中的所有public内容不被混淆。

 
 
 
 
    
  
  
  
  
  1. -keepclassmembers class com.poetry.jianjia.slice.MainAbilitySlice$InnerClass{ 
    2.   
  
  
  
  2.    public *; 
    3.   
  
  
  
  3. } 
    4.

 3、6 如果只是希望类里面的特定内容不被混淆，就可以使用

 
 
 
 
    
  
  
  
  
  1. ;     //匹配所有构造方法 
    2.   
  
  
  
  2. ;   //匹配所有变量 
    3.   
  
  
  
  3. ;  //匹配所有方法 
    4.

 3、7 可以在 或 前面加上private 、public、native等来进一步指定不被混淆的内容，如下例子，Banner类中所有的共有方法不被混淆。 

 
 
 
 
    
  
  
  
  
  1. -keep class com.poetry.jianjia.Banner { 
    2.   
  
  
  
  2.     public ; 
    3.   
  
  
  
  3. } 
    4.

 3、8 类中可以有重载方法，如果希望某个重载方法不被混淆，可以加上方法参数，如下例子，带有一个字符串参数的构造方法不被混淆

 
 
 
 
    
  
  
  
  
  1. -keep class com.poetry.jianjia.Banner { 
    2.   
  
  
  
  2.     public (java.lang.String); 
    3.   
  
  
  
  3. } 
    4.

 3、9 有时类名可以被混淆，但是希望该类下的特定方法不被混淆，那就不能用keep了，keep不会混淆类名，而需要用keepclassmembers。如下例子，实现了Serializable接口的类名可以被混淆，但类中的具体变量和方法不被混淆

 
 
 
 
    
  
  
  
  
  1. -keepclassmembers class * implements java.io.Serializable { 
    2.   
  
  
  
  2.     static final long serialVersionUID; 
    3.   
  
  
  
  3.     private static final java.io.ObjectStreamField[] serialPersistentFields; 
    4.   
  
  
  
  4.     private void writeObject(java.io.ObjectOutputStream); 
    5.   
  
  
  
  5.     private void readObject(java.io.ObjectInputStream); 
    6.   
  
  
  
  6.     java.lang.Object writeReplace(); 
    7.   
  
  
  
  7.     java.lang.Object readResolve(); 
    8.   
  
  
  
  8. } 
    9.

 3、10 有些类或者类成员是不能被重命名的，keepclasseswithmembernames会防止类和成员被重命名。如下实例，本地方法不能被重命名。

 
 
 
 
    
  
  
  
  
  1. -keepclasseswithmembernames class * {     
    2.   
  
  
  
  2.     native ; 
    3.   
  
  
  
  3. } 
    4.

 3、11 保持枚举不被混淆

 
 
 
 
    
  
  
  
  
  1. -keepclassmembers enum * { 
    2.   
  
  
  
  2.     public static **[] values(); 
    3.   
  
  
  
  3.     public static ** valueOf(java.lang.String); 
    4.   
  
  
  
  4. } 
    5.

 3、12 反射用到的类不能被混淆。

3、13 配置文件中的类不能被混淆，配置文件中声明的Ability默认不会被混淆，在配置文件中声明的类不需要额外的配置混淆。

3、14 使用gson、fastjson等框架解析服务端数据时，所写的json对象类不能混淆，否则无法将json解析成对应的对象。

3、15 第三方开源库会大量的使用注解、反射、泛型，使用第三方开源库或者引用其他第三方的SDK包时，如果有特别要求，也需要在混淆文件中加入对应的混淆规则。

四、给鸿蒙项目配置混淆

4、1 我们已经熟悉了混淆指令，那如何给鸿蒙项目配置混淆呢?在最新版的编译器里面创建项目，编译器会帮我们创建一个proguard-rules.pro文件，proguard-rules.pro文件是什么呢?鸿蒙使用proguard进行混淆，proguard-rules.pro文件就是用来配置混淆规则的，将不能被混淆的代码配置在proguard-rules.pro文件中。请注意，老版本的编译器不支持混淆，使用老版本的编译器创建项目，编译器不会创建proguard-rules.pro文件。

4、2 编译器除了帮我们创建proguard-rules.pro文件外，还在build.gradle文件中添加了新代码，打开build.gradle文件

编译器在buildTypes闭包里面添加release闭包，release表示正式包。release闭包下面又有一个proguardOpt闭包，proguardOpt就是用来配置混淆的。proguardEnabled表示是否开启混淆，true表示开始混淆，false表示不开启混淆。rulesFiles则表示配置混淆的规则文件。

可以看出，默认情况下，是不开启混淆的，出于保护源码的原因，当我们打正式包的时候，是需要开启混淆的。其实，我们也可以给测试包配置混淆，如下代码。我们手动添加了一个debug闭包，debug表示测试包，不要在测试包里面开启混淆，当你在测试包开启混淆，断点调试的时候将看不到变量的值。

 
 
 
 
    
  
  
  
  
  1. buildTypes { 
    2.   
  
  
  
  2.         // release表示正式包 
    3.   
  
  
  
  3.         release { 
    4.   
  
  
  
  4.             // 配置混淆 
    5.   
  
  
  
  5.             proguardOpt { 
    6.   
  
  
  
  6.                 // 正式包开启混淆 
    7.   
  
  
  
  7.                 proguardEnabled true 
    8.   
  
  
  
  8.                 // 混淆规则配置在proguard-rules.pro文件中 
    9.   
  
  
  
  9.                 rulesFiles 'proguard-rules.pro' 
    10.   
  
  
  
  10.             } 
    11.   
  
  
  
  11.         } 
    12.   
  
  
  
  12.         // debug表示测试包 
    13.   
  
  
  
  13.         debug { 
    14.   
  
  
  
  14.             // 配置混淆 
    15.   
  
  
  
  15.             proguardOpt { 
    16.   
  
  
  
  16.                 // 测试包不开启混淆 
    17.   
  
  
  
  17.                 proguardEnabled false 
    18.   
  
  
  
  18.                 // 混淆规则配置在proguard-rules.pro文件中 
    19.   
  
  
  
  19.                 rulesFiles 'proguard-rules.pro' 
    20.   
  
  
  
  20.             } 
    21.   
  
  
  
  21.         } 
    22.   
  
  
  
  22.     } 
    23.

 4、3 如果使用最新版编译器打开老版本编译器创建的项目，那么项目中不会有proguard-rules.pro文件，同时build.gradle文件中也不会有proguardOpt。这时就需要我们自己手动创建proguard-rules.pro文件，并且在build.gradle文件添加上述代码。

4、4 综上，如何给鸿蒙项目配置混淆?只需两步，第一，将proguardEnabled 设置为true，第二，在proguard-rules.pro文件中使用混淆指令配置混淆规则。

五、给出一个常见的混淆配置

 
 
 
 
    
  
  
  
  
  1. # 代码混淆压缩比，在0~7之间 
    2.   
  
  
  
  2. -optimizationpasses 5 
    3.   
  
  
  
  3. # 混合时不使用大小写混合，混合后的类名为小写 
    4.   
  
  
  
  4. -dontusemixedcaseclassnames 
    5.   
  
  
  
  5. # 指定不去忽略非公共库的类 
    6.   
  
  
  
  6. -dontskipnonpubliclibraryclasses 
    7.   
  
  
  
  7. # 不做预校验，preverify是proguard的四个步骤之一，去掉这一步能够加快混淆速度。 
    8.   
  
  
  
  8. -dontpreverify 
    9.   
  
  
  
  9. -verbose 
    10.   
  
  
  
  10. # 避免混淆泛型 
    11.   
  
  
  
  11. -keepattributes Signature 
    12.   
  
  
  
  12. #google推荐算法 
    13.   
  
  
  
  13. -optimizations !code/simplification/arithmetic,!code/simplification/cast,!field/*,!class/merging/* 
    14.   
  
  
  
  14. # 保留注解、内部类、泛型、匿名类 
    15.   
  
  
  
  15. -keepattributes *Annotation*,InnerClasses,Signature,EnclosingMethod 
    16.   
  
  
  
  16. # 重命名抛出异常时的文件名称 
    17.   
  
  
  
  17. -renamesourcefileattribute SourceFile 
    18.   
  
  
  
  18. # 抛出异常时保留代码行号 
    19.   
  
  
  
  19. -keepattributes SourceFile,LineNumberTable 
    20.   
  
  
  
  20. -dontwarn javax.annotation.** 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22. # 保留本地native方法不被混淆 
    23.   
  
  
  
  23. -keepclasseswithmembernames class * { 
    24.   
  
  
  
  24.     native ; 
    25.   
  
  
  
  25. } 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27. # 保留枚举类不被混淆 
    28.   
  
  
  
  28. -keepclassmembers enum * { 
    29.   
  
  
  
  29.     public static **[] values(); 
    30.   
  
  
  
  30.     public static ** valueOf(java.lang.String); 
    31.   
  
  
  
  31. } 
    32.   
  
  
  
  32.  
    33.   
  
  
  
  33. -keepclassmembers class * implements java.io.Serializable { 
    34.   
  
  
  
  34.    static final long serialVersionUID; 
    35.   
  
  
  
  35.    private static final java.io.ObjectStreamField[]   serialPersistentFields; 
    36.   
  
  
  
  36.    private void writeObject(java.io.ObjectOutputStream); 
    37.   
  
  
  
  37.    private void readObject(java.io.ObjectInputStream); 
    38.   
  
  
  
  38.    java.lang.Object writeReplace(); 
    39.   
  
  
  
  39.    java.lang.Object readResolve(); 
    40.   
  
  
  
  40. } 
    41.   
  
  
  
  41.  
    42.   
  
  
  
  42. # OkHttp3 
    43.   
  
  
  
  43. -dontwarn okhttp3.logging.** 
    44.   
  
  
  
  44. -keep class okhttp3.internal.**{*;} 
    45.   
  
  
  
  45. -dontwarn okio.** 
    46.   
  
  
  
  46.  
    47.   
  
  
  
  47. # gson 
    48.   
  
  
  
  48. -keep class sun.misc.Unsafe { *; } 
    49.   
  
  
  
  49. -keep class com.google.gson.stream.** { *; } 
    50.   
  
  
  
  50. # 在我的示例代码中，com.poetry.jianjia.bean这个包下面的类实现了Serialized接口， 
    51.   
  
  
  
  51. # 实现了Serialized接口的类不能被混淆，请把com.poetry.jianjia.bean这个包名替换成你自己的包名 
    52.   
  
  
  
  52. -keep class com.poetry.jianjia.bean.**{*;} 
    53.

 六、总结

本文主要介绍混淆原理以及混淆命令，并且教大家如何在鸿蒙项目里面配置混淆，大家最好熟悉下混淆指令。在实际开发中，经常性的会遇到这种问题，在测试包里面没有问题，但在正式包里面就出现了问题，这种情况往往是因为在正式包开启了混淆，但没有在proguard-rules.pro文件中配置混淆规则。

想了解更多内容，请访问：

和华为官方合作共建的鸿蒙技术社区

https://harmonyos.

网页题目：鸿蒙代码配置混淆原理以及混淆命令
地址分享：http://www.shufengxianlan.com/qtweb/news19/358569.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站策划知识

同城分类信息

卖链接　　 　华泰海航　　 　自适应网页设计　　 　高端网站设计　　 　添翼二手车鉴定评估　　 　眉山服务器托管　　 　网创优客　　 　温江网站建设　　 　二枢服务器托管　　 　成都网站制作　　 　腾讯云香港虚拟主机　　 　成都企业网站制作　　 　东电技改　　 　四川鸿达　　 　绵阳服务器托管　　 　胜锦安防科技　　 　网站制作　　 　眉山电信机房　　 　重庆手机网站建设　　 　成都网站维护