Java 混淆那些事（三）：了解 ProGuard Keep 规则

最新推荐文章于 2024-07-25 22:51:36 发布
最新推荐文章于 2024-07-25 22:51:36 发布
阅读量761 收藏
点赞数
文章标签： java
原文链接：https://juejin.im/post/5c97485fe51d4552346489ae
版权

本文已授权微信公众号「玉刚说」独家发布。

这篇文章是「Java 混淆那些事」的第三篇，我们来真枪真刀的干一下子，用实际行动验证了解一下 ProGuard 的 Keep 语法，这篇代码偏多，希望大家好好理解。

阅读提示：上半部分纯属个人总结，不明白请看下半部分的例子，读完了根据自己的理解实践一下。

简介 Keep 语法

那么 keep 语法有什么用呢？如果我们对外提供了一套 Library ，如果不指定代码入口点恐怕是所有代码都要被删掉了，所以我们要指定「代码入口点」，并且告诉 ProGuard 那些类名绝对不能变动，那些方法名不能变动等等。

Keep 有以下几种用法
  • -keep [,modifier,…] class_specification 匹配类名以及指定的方法或字段，为代码入口点。可以单独匹配类或者类和类成员。匹配到的类不会被混淆和删除，匹配到的类成员不会被混淆和删除，方法被当作代码入口点。
  • -keepclassmembers [,modifier,…] class_specification 匹配类名以及规则指定的方法或字段，为代码入口点。但是有个前提：就是必须在压缩阶段被保留的类才可以。
  • -keepclasseswithmembers [,modifier,…] class_specification 它和 -keep 的作用基本一致，但是规则必须完全匹配类名以及类成员才能匹配成功，写错类成员名称或写不存在类成员名称都会导致整条规则失效。

其中 modifier 为可选配置，可以指定一个或多个。 class_specification 是类和成员的模板

modifier 共有一下几个可选值，当然匹配范围和限制还是要服从 keep 规则的。
  • includecode 保证所指定的字段名称不被混淆，而类型将被混淆。只能用于字段，否则报错。
  • includedescriptorclasses 指定有返回值的方法或者字段，他们返回值的类型以及字段的类型不会被混淆，相关的类名以及包名也不会被混淆。
  • allowshrinking 缩减 -keep 的匹配范围，如果这个类和方法不是必须的那么有可能会在压缩阶段被删除。
  • allowoptimization -keep 选项中指定的代码入口点可以在优化步骤中被优化改变，但是它们可能会在优化阶段被删除。
  • allowobfuscation -keep 选项中指定的代码入口点可以会被混淆改名，但是它们不会被删除。
还有三种和上面的用法是相对应的用法
  • **-keepnames class_specification ** 就是 -keep,allowshrinking class_specification 的简写
  • **-keepclassmembernames class_specification ** 就是 -keepclassmembers,allowshrinking class_specification 的简写
  • **-keepclasseswithmembernames class_specification ** 就是 -keepclasseswithmembers,allowshrinking class_specification 的简写

实践语法

这部分是实践大家也可以跳过，根据自己的理解亲自动手操作即可，如果我有什么重要的或错误结论欢迎指正。 在 ProGuard GUI 把混淆的配置文件保存，然后使用文件编辑器直接在配置文件下面添加即可。然后在 ProGuard 读取并执行。

/* 
 * 测试代码结构
 * src
 *    -> DownloadClient.java
 *    -> DownloadManager.java
 *    -> http
 *        -> HttpDownload.java
 *        -> HttpRequest.java
*/

// 各个文件的具体代码
// DownloadClient.java
public int status = 0;
public String url;
private HttpDownload httpDownload;

public DownloadClient(String url) {
    this.url = url;
    httpDownload = new HttpDownload();
}

public void start() {
    status = 1;
    httpDownload.start();
}

public void stop() {
    status = 2;
    httpDownload.stop();
}

// DownloadManager.java
HttpRequest httpRequest = new HttpRequest();

public HttpRequest getDownloadUrl() {  
    System.out.println(httpRequest.get());
    return httpRequest;
}
    
// HttpDownload.java
private int i=0;
public void start(){
    System.out.println("开始下载");
    i++;
}

public void stop(){
    System.out.println("停止下载");
    i--;
}
        
// HttpRequest.java
public String get() {
    return "请求成功";
}
    
复制代码
实践 keep 规则

这个例子我们不使用 main 方法，只把这个小例子当做一个 SDK。

-keep 命令
//混淆脚本
-keep class DownloadClient {
    public java.lang.String url;

    public <init>(java.lang.String);
    public void start();
}
复制代码

处理效果

/* 
 * 代码结构
 * a
 *    -> a.java
 * defpackage
 *    -> DownloadClient.java
*/
// 各个文件的具体代码
// a.java
private int a = 0;

public final void a() {
    System.out.println("开始下载");
    this.a++;
}

// DownloadClient.java
private int a = 0;
private a b;
public String url;

public DownloadClient(String str) {
    this.url = str;
    this.b = new a();
}

public void start() {
    this.a = 1;
    this.b.a();
}
复制代码

这个效果很明显：

  1. keep 指定的类和类成员都没有被移除，并且没有被混淆（构造方法和 start() 方法)）。
  2. 指定的字段也没有被混淆。
  3. keep 指定的方法被作为了代码入口点，调用到的相关类和方法也没有被移除，但是被混淆了。

还有几种情况，大家自己试一下。

  1. 如果规则不写任何类成员，就只会留下一个空的类文件
  2. 如果规则写了不存在的类成员，也不会有什么效果。
  3. 可以让字段名不被混淆。但是字段类型被混淆了。
  4. 可以让方法名不被混淆。但是方法返回值类型被混淆了。
-keepclasseswithmembers

这个效果和 keep 完全一样，但是稍微有点不同，大家也可以自己试一试。

  1. 如果不写任何类成员，混淆后就只会留下一个空的类文件，但是 ProGuard 会给出提示将规则改变为 -keep。
  2. 如果写了不存在的类成员，那么当前这条 -keepclasseswithmembers 规则没有任何效果。它就没有 -keep 那么佛系了。
-keepclassmembers
// 混淆脚本
-keep class DownloadClient

-keepclassmembers class DownloadClient {
    private http.HttpDownload httpDownload;

    public <init>(java.lang.String);
    public void start();
}
复制代码

处理效果

/* 
 * 代码结构
 * a
 *    -> a.java
 * defpackage
 *    -> DownloadManager.java
*/
// 各个文件的具体代码
// a.java
null

// DownloadManager.java
a httpRequest = new a();

public a getDownloadUrl() {
    System.out.println("请求成功");
    return this.httpRequest;
}
复制代码

大家看到我这次写了一条 -keep 混淆规则，为什么呢？

因为在压缩阶段能留下来的类上 -keepclassmembers 才能有效果，否则没有效果。所以要先把相关类留下来。

我们总结一下 -keepclassmembers 的效果

  1. 作用的类必须在压缩阶段被保留 -keepclassmembers 才可以生效。
  2. 可以让类的成员不被混淆。但是字段类型被混淆了。
  3. 可以让方法名不被混淆。但是方法返回值类型被混淆了。
  4. -keepclassmembers 同样可以起到指定代码入口点的工作，虽然 a.java 是空的，但这因为是代码优化的作用。

还是几种情况，大家自己试一下。

  1. 如果写的 -keepclassmembers 规则没有写类成员，ProGuard 会给出提示改变为 -keep。
  2. 如果写的某个类成员没有匹配到就不会生效，但是其余规则的匹配到的还是会生效的，并不会像 -keepclasseswithmembers 那么霸道。
实践 modifier 规则
includecode
//混淆脚本
-keep class DownloadClient{
	public <init>(java.lang.String);
    public void start();
}
-keep,includecode class DownloadClient {
    private http.HttpDownload httpDownload;
}
复制代码

混淆效果

/* 
 * 代码结构
 * a
 *    -> a.java
 * defpackage
 *    -> DownloadClient.java
*/
// 各个文件的具体代码
// a.java
private int a = 0;

public final void a() {
    System.out.println("开始下载");
    this.a++;
}

// DownloadClient.java
private int a = 0;
private String b;
private a httpDownload;

public DownloadClient(String str) {
    this.b = str;
    this.httpDownload = new a();
}

public void start() {
    this.a = 1;
    this.httpDownload.a();
}
复制代码

实际效果

  1. -keep 所指定的字段名称不被混淆，但是类型还是被混淆的。

动手试一试

  1. 只能做用于字段，否则报错。
includedescriptorclasses
//混淆脚本
-keep class DownloadClient {
    public <init>(java.lang.String);
    public void start();
}
-keep,includedescriptorclasses class DownloadManager {
    public http.HttpRequest getDownloadUrl();
}
-keep,includedescriptorclasses class DownloadClient {
   private http.HttpDownload httpDownload;
}
复制代码

混淆效果

/* 
 * 代码结构
 * http
 *    -> HttpRequest.java
 *    -> HttpDownload.java
 * defpackage
 *    -> DownloadClient.java
 *    -> DownloadManager.java
*/
// 各个文件的具体代码
// HttpRequest.java
public static String a() {
    return "请求成功";
}

// HttpDownload.java
private int a = 0;

public final void a() {
    System.out.println("开始下载");
    this.a++;
}

// DownloadClient.java
private int a = 0;
private String b;
private HttpDownload httpDownload;

public DownloadClient(String str) {
    this.b = str;
    this.httpDownload = new HttpDownload();
}

public void start() {
    this.a = 1;
    this.httpDownload.a();
}

// DownloadManager.java
private HttpRequest a = new HttpRequest();

public HttpRequest getDownloadUrl() {
    System.out.println(HttpRequest.a());
    return this.a;
}

复制代码

实际效果

  1. keep 所指定的字段名称不被混淆，而且字段类型也没有混淆了。
  2. keep 一个带返回类型的方法，返回值的类型也不会被混淆
allowshrinking
//混淆脚本
-keep class DownloadClient {
    public <init>(java.lang.String);
    public void start();
}
-keep,allowshrinking class DownloadManager {
    public http.HttpRequest getDownloadUrl();
}
复制代码

混淆效果

/* 
 * 代码结构
 * a
 *    -> a.java
 * defpackage
 *    -> DownloadClient.java
*/
// 各个文件的具体代码
// a.java
private int a = 0;

public final void a() {
    System.out.println("开始下载");
    this.a++;
}
// DownloadClient.java
private int a = 0;
private String b;
private a c;

public DownloadClient(String str) {
    this.b = str;
    this.c = new a();
}

public void start() {
    this.a = 1;
    this.c.a();
}
复制代码

实际效果

  1. -keep 指令是保留相关的类，但是 DownloadManager 并没有保留下来，就是因为 allowshrinking 的作用，如果这个类和方法不是必须的那么有可能会在压缩阶段被删除。

动手试一试

  1. 如果其他代码入口点调用了该方法，才会保留，效果跟去掉 allowshrinking modifier 的效果一致。
allowoptimization
//混淆脚本
-keep,allowoptimization class DownloadClient {
    public <init>(java.lang.String);
    public void start();
}
复制代码

混淆效果

/* 
 * 代码结构
 * defpackage
 *    -> DownloadClient.java
*/
// 各个文件的具体代码
// DownloadClient.java
//空的
复制代码

实际效果

  1. 我们虽然指定了代码入口点，但是我们并没有用到，所以全都优化阶段删除了。

动手试一试

  1. 如果我们指定一个其他代码入口点，并且调用了 DownloadClient 的 start() 方法，那么他就会跟没有 allowoptimization modifier 的效果一致了。例如我们的例子，如果被调用就和如下脚本效果一致。
-keep class DownloadClient {
    public <init>(java.lang.String);
    public void start();
}
复制代码
allowobfuscation
//混淆脚本
-keep,allowobfuscation class DownloadClient {
    public <init>(java.lang.String);
    public void start();
}
复制代码

混淆效果

/* 
 * 代码结构
 * a
 *    -> a.java
 * defpackage
 *    -> a.java
*/
// 各个文件的具体代码
// a/a.java
private int a = 0;

public final void a() {
    System.out.println("开始下载");
    this.a++;
}
// defpackage/a.java
private int a = 0;
private String b;
private a.a c;

public a(String str) {
    this.b = str;
    this.c = new a.a();
}

public void a() {
    this.a = 1;
    this.c.a();
}
复制代码

实际效果

  1. 虽然代码入口点的代码保留了，但是名称全部都混淆了。

自己动手

  1. 如果指定没有用到的代码，那么他也会保留并且同样是被混淆的。
简述 class_specification

官方描述的类规范模板，看着 Java 代码很像。

  1. [] 标识可选。
  2. | 表示 ‘或’ 的意思只能取一个。
  3. ...表示可以有多个，简单举个例子 [[!]public|private|protected|static ... ] 可以包含 public static 这两个，从 Java 的角度理解也不难。
  4. {} 大括号是实实在在的大括号。
  5. () 就是实实在在的括号，没有什么其他意思。
  6. ! 表示 ’否‘ ，例如：!class 规则匹配表示不能是这个 class
  7. * 、 、 、 都是通配符，我们下一篇再描述。

再放一张格式化过的比较好理解的图

我对官方的规则进行格式化了一下，这样看是不是就好理解多了，如果不考虑通配符，其实就是跟 Java 正常的写法是一致的。比如我们上面例子中混淆的写法，除了有个 之外，其他都是普通的 Java 语法。

再说几条上面没有体现的规则

  1. 写类名包名必须要写全，比如 String 要写 java.lang.String。
  2. 连接内部类，比如 com.XXX 中有内部类 Builder，这种构建器的写法很常见吧，混淆规则怎么写呢？简单举个例子： ```-keep class com.XXX Builder```,

小结

到此为止 ProGuard 的 Keep 规则我们也简单的聊了一下，希望大家自己多尝试，然后总结一下每条命令的用处，方便日后使用。

weixin_34023982
关注
ProGuard工具包，Java代码混淆
05-13
**ProGuard工具包详解——Java代码混淆** 在Java开发中，为了提高应用程序的安全性和保护知识产权，开发者常常会使用一种称为“代码混淆”的技术。ProGuard是Android和Java平台上的一个强大的开源工具，它能实现...
Proguard的Keep使用方法
wyzzgo的技术博客
01-06 1万+
java代码存在互相引用的关系,构成一个网状关系.(个人理解)引用又分为两种:普通引用和字符串引用(例如反射,native方法等).而java代码的执行入口点必然是采用的字符串引用(例如main等方法),因为外部想要执行此代码必须知道一个明确的入口点名字..Proguard流程
ProGuard 最全混淆规则说明
weixin_43004856的博客
08-31 3818
ProGuard 最全混淆规则说明
混淆（Proguard）用法
bihansheng2010的博客
05-09 1万+
混淆（Proguard）用法
Proguard-Android“混淆”原理规则综述
llululu的博客
08-19 1182
一、概述 Proguard，网上大多数资料都译为混淆，其实是不准确的，根据官方的介绍：ProGuard is an open-sourced Java class file shrinker, optimizer, obfuscator, and preverifier。混淆只占1/4，还包括其他功能，具体如下： shrink（删减）：删减无用代码，包括类、变量、方法和属性 optimize（优化）：优化方法字节码，并移除无用的构造方法 obfuscate（混淆）：混淆现有代码，将有意义的命名替换为
ProGuard详解 - Java代码混淆
热门推荐
weixin_44462773的博客
04-14 3万+
proGuard简介及使用proGuard工具加密混淆java的jar文件的过程示例
ProGuard-java混淆加密
11-27
ProGuard能够对Java类中的代码进行压缩（Shrink）,优化（Optimize）,混淆（Obfuscate）,预检（Preveirfy）。 　1. 压缩（Shrink）:在压缩处理这一步中，用于检测和删除没有使用的类，字段，方法和属性。 　2. 优化...
springboot工程（单个maven工程）利用proguard实现代码混淆 java demo案例
06-05
ProGuard的配置文件通常命名为`proguard.cfg`，在该文件中，我们可以定义混淆规则，比如保留特定包或类不被混淆，以及设置混淆策略等。 1. **ProGuard配置** 在`proguard.cfg`文件中，我们需要指定哪些类和包需要...
AndroidProguardTutorial:设置 proguard 和去混淆堆栈跟踪的教程
07-07
**Android Proguard 教程：设置与去混淆堆栈跟踪** 在Android开发中，Proguard是一个强大的工具，用于优化、压缩、混淆以及移除代码，从而保护应用的安全性，减小APK体积，并提高性能。本教程将详细介绍如何在...
java代码混淆器proGuard
12-12
Java代码混淆器ProGuard是Java开发中用于保护和优化应用程序的重要工具。它的主要功能是对Java字节码进行混淆，使得代码难以被逆向工程解析，从而提高代码的安全性。混淆过程中，函数变量、类和方法名会被重命名为...
ProGuard配置详解
最新发布
彬_小彬的博客
07-25 1250
ProGuard是一个开源的Java class文件缩小器、优化器、混淆器和预验证器。它通过删除未使用的类、字段、方法和属性，优化字节码指令，并重命名类、字段和方法，使反编译后的代码难以理解，从而提高应用的安全性。以下是对ProGuard配置文件的一些详细解释和常见配置项的说明。
[译]区分ProGuard不同的"keep"指令
liken的专栏
11-21 5458
如果搜索Java活Android库的ProGuard规则，你会在StackOverflow上看到一堆回答，告诉你要这样做：-keep class com.foo.library.** { *; }这个建议很糟糕，你永远都不应该这样做。首先，它过于宽泛——包中的双星号表示该顶级包下的每个包里的所有类；而花括号内的星号用于这些类中的每个成员(变量，方法和常量)。也就是说，它使用与库中的所有代码。如果你是
Android混淆规则--proguard-rules.pro
u010194271的博客
07-07 1万+
一、混淆是什么，该怎么做？ 如果我们的app正常发布就必须要经历混淆这一步，混淆可以使我们的app不那么容易被别人用反编译工具破解，就算被破解，想要读懂我们的源码也是非常费劲的，因为混淆过的源码的类和类成员会被随机命名，代码非常的乱和没有规律，除非之前用keep进行了保护。 以我们的常用开发工具andorid studio 为例，Android Studio自身集成Java语言的ProGuard作为压缩，优化,混淆和预校验，并配合Gradle工具进行构建，我们只需要在工程应用目录的build.gradle文
由浅入深 Android 混淆实战
大模型学习路线
08-05 1928
通过本文由浅入深的带大家进行混淆实战，相信 99% 的精准混淆工作已经难不倒你，当然混淆还有更深入和更细节的用法，篇幅关系我们下次再探。如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。...
java class 混淆_Java 混淆那些事（三）：了解 ProGuard Keep 规则
weixin_29091837的博客
03-04 953
本文已授权微信公众号「玉刚说」独家发布。这篇文章是「Java 混淆那些事」的第三篇，我们来真枪真刀的干一下子，用实际行动验证了解一下 ProGuard 的 Keep 语法，这篇代码偏多，希望大家好好理解。阅读提示：上半部分纯属个人总结，不明白请看下半部分的例子，读完了根据自己的理解实践一下。简介 Keep 语法那么 keep 语法有什么用呢？如果我们对外提供了一套 Library ，如果不指定代码...
关于Proguard混淆的一份总结
无名小辈的博客
03-15 2386
ProGuard是最受欢迎的Java字节码优化器。 它使您的Java和Android应用程序缩小了90％，速度提高了20％。ProGuard还通过模糊类，字段和方法的名称来提供对逆向工程的最小保护。本篇将从Android apk混淆和jar混淆两个方面进行展开。 我们通常说的proguard包括四个功能，shrinker（压缩）, optimizer（优化）,obfuscator（混淆）,pr...
android高度混淆,Android代码混淆之混淆规则
weixin_33300389的博客
05-25 622
因为Android是使用Java开发的，所以开发者可以使用ProGuard对代码进行混淆。SDK已经集成了ProGuard工具，开发者可以从SDK目录下的\tools\proguard目录中进行查看。ProGuard是一个免费的Java类文件收缩，优化，混淆和预校验器。它可以检测并删除未使用的类，字段，方法和属性。它可以优化字节码，并删除未使用的指令。它可以将类、字段和方法使用短无意义的名称进行重...
Android混淆需要keep的情况
王温暖的博客
02-19 7390
不需要混淆的场景如下，否则会出现运行错误： 1.如果使用了Gson之类的工具要使JavaBean类即实体类不被混淆。 2.如果使用了自定义控件那么要保证它们不参与混淆。 3.如果使用了枚举要保证枚举不被混淆。 4.对第三方库中的类不进行混淆 5.如果使用了Gson之类的工具要保证实体类不被混淆 6.如果使用了自定义控件那就需要保证它们不参与混淆 7.第三方库中的类不进行混淆 8.代...
proguard keep相关
jzlhll123的专栏
11-17 689
-keep [,modifier,…] class_specification 指定类和类成员(变量和方法) 将被保留，用于往外暴露。举例，为了主入口类， -keep public class com.example.MyMain { public static void main(java.lang.String[]); } 你可以指定main class和他的main函数。另外一个例子，为了处理公开库, 你可以指定所有公开访问的成员。 -keep public class * { .
Spring Boot工程代码混淆实践：Proguard示例教程
资源摘要信息:"springboot工程利用proguard实现代码混淆的java demo案例" Spring Boot作为Java开发者广泛使用的框架，它的简洁性、易用性以及能够快速开发出独立的、生产级别的基于Spring框架的应用程序的特性，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值