java proguard混淆示例和结果

最新推荐文章于 2024-10-04 20:20:08 发布
最新推荐文章于 2024-10-04 20:20:08 发布
阅读量4.3k 收藏 4
点赞数 1
分类专栏： 安卓 java 文章标签： java
本文链接：https://blog.csdn.net/qfanmingyiq/article/details/120827589
版权
本文详细解析了Proguard混淆工具的-keep和-keepclassmembers等关键规则，通过实例展示了如何保护类、成员变量和方法不被混淆和优化，包括公共类、私有方法、类名以及消除警告等不同场景的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

前言

混淆基础知识
混淆基础语法

官方指南


看了很多混淆的文章但是对于混淆的前后结果语法对比很模糊，因此写下这篇文章。

-keep

保持类或者成员不被混淆(obfuscate)或者移除(shrink)

案例1

我们工程下就两个类
在这里插入图片描述

//MySubLib.java
public class MySubLib {
    public void test() {
    }

    public String name = "hehlo";
    public int age =3;
}
//MySubLib2.java
public class MySubLib2 {

    public String hello = "";
    private int age ;

    public String msgPrint() {
        return hello + "----";
    }

    public static void main(String[] args) {

    }
}

执行以下混淆规则

#MySubLib2这个类不会被混淆移除但是其成员会
-keep public class com.example.mymodule.MySubLib2 {
}

结果
在这里插入图片描述
除了MySubLib2其他类都被移除，并且MySubLib2属性都不存在了

案例2

执行以下混淆规则

#MySubLib2这个类不会被混淆移除但是其成员会
-keep public class com.example.mymodule.MySubLib2 {
}

原始类

public class MySubLib2 {

    public String hello = "";
    private String hello2 = "";
    private int age ;

    public String msgPrint() {
        return hello + "----";
    }

    public static void main(String[] args) {

    }
}

结果

public class MySubLib2 {
    public String hello = "";

    public MySubLib2() {
    }
}

案例3

执行以下混淆规则

#MySubLib2这个类不会被混
-keep public class com.example.mymodule.MySubLib2 {
#所有public属性和方法都不混被混淆优化裁剪
 public <fields>;
 public <methods>;
}

原始类

public class MySubLib2 {

    public String hello = "";
    private String hello2 = "";
    private int age;

    public String msgPrint() {
        return hello + "----";
    }

    private String msgPrint2() {
        return hello + "----";
    }

    public static void main(String[] args) {

    }
}

结果


public class MySubLib2 {
    public String hello = "";

    public MySubLib2() {
    }

    public static void main(String[] var0) {
    }

    public String msgPrint() {
        return this.hello + "----";
    }
}

案例4

混淆前
在这里插入图片描述
在这里插入图片描述
执行混淆:

#com.example.mymodule这个包下的类不会被混淆，但是属性会，并且子包也会被混淆裁剪
-keep public class com.example.mymodule.* {

}

结果
在这里插入图片描述
当前语法会导致子包类会被移除

同样环境我们执行一下混淆语法

#com.example.mymodule这个包和子包的类不会被混淆，但是属性方法会被优化移除，
-keep public class com.example.mymodule.** {

}

结果

在这里插入图片描述

同样环境我们执行一下混淆语法

#com.example.mymodule这个包和子包的类不会被混淆，并且属性方法都不会被优化和移除，
-keep public class com.example.mymodule.** {
  *;
}

结果

在这里插入图片描述

案例5



/**
 * 途混淆测试专用
 */
public class MySubLib2 {

    public String hello = "";
    private String hello2 = "";
    private int age;

    public String msgPrint() {
        return hello + "----";
    }

    private String msgPrint2() {
        return hello + "----";
    }

    private String msgPrint2(int i) {
        return hello + "----";
    }

    public static void main(String[] args) {

    }
}

执行混淆:

#MySubLib2类不会被混淆
-keep public class com.example.mymodule.MySubLib2 {
    #所有返回String私有函数 都不会被混淆，不考虑参数
    private java.lang.String *(...);
}

结果:


public class MySubLib2 {
    public MySubLib2() {
    }

    private String msgPrint2() {
        return "" + "----";
    }

    private String msgPrint2(int var1) {
        return "" + "----";
    }
}

同样的环境执行下面的混淆

#MySubLib2类不会被混淆
-keep public class com.example.mymodule.MySubLib2 {
    #所有返回String私有函数并且第一个参数为int不会被混淆
    private java.lang.String *(int);
}

结果:

public class MySubLib2 {
    public MySubLib2() {
    }

    private String msgPrint2(int var1) {
        return "" + "----";
    }
}

案例6

我们对比下这两个规则

#会保护所有public类和内部类。但是默认保护的class不会被保护
-keep public class com.example.myapplication.fmy.**{
    *;
}

;保护所有public类和非bulic类以及内部类
-keep class com.example.myapplication.fmy.**{
    *;
}

我们首先使用public版本
在这里插入图片描述

在这里插入图片描述

//MyDefaultClass .java
package com.example.myapplication.fmy;

class MyDefaultClass {
    String name="MyDefaultClass";
    public   void init() {
        System.out.printf(name);
        MyDefaultClass myDefaultClass = new MyDefaultClass();
        MyPublicClass myPublicClass = new MyPublicClass();
    }
}
//MyPublicClass.java
package com.example.myapplication.fmy;

public class MyPublicClass {
    String name="MyPublicClass";
    public void init(){
        System.out.printf(name);
        MyDefaultClass myDefaultClass = new MyDefaultClass();
        myDefaultClass.init();
    }
}

反编译之后
在这里插入图片描述

我们的MyDefaultClass 被改名为b1.a类了
在这里插入图片描述

-keepclassmembernames

简短名称 -keepclassmembers

当前语法会让其声明的类成员或者方法名不会被混淆(类名依然会被修改)，但是前提是这个属性或者方法在shrink阶段存货下来

环境如下：

//MySubLib.java
public class MySubLib {
    MySubLib2 mySubLib2 = new MySubLib2();

    public void test() {
        //故意引用其内部的一个函数
        System.out.println(mySubLib2.msgPrint2());
    }

    public String name = "hehlo";
    public int age = 3;
}

//MySubLib2.java
public class MySubLib2 {

    public String hello = "xx";
    private String hello2 = "111";
    private int age;

    public String msgPrint() {
        return hello + "----";
    }

    public String msgPrint2() {
        return "zz"+ hello + "----";
    }

    private String msgPrint2(int i) {
        return hello + "----";
    }

    public static void main(String[] args) {

    }
    public void test(java.lang.String d){

    }
}

执行如下混淆:

#利用MySubLib保证MySubLib2不会被shrink阶段移走
#MySubLib内部会引用MySubLib2
-keep public class com.example.mymodule.MySubLib{
  *;
}


-keepclassmembers public class com.example.mymodule.MySubLib2 {
	#这个函数名如果在shrink阶段被保留下来 那么应该保证其函数名不变
    public java.lang.String msgPrint2();
    public java.lang.String msgPrint();
}

结果:
在这里插入图片描述
在这里插入图片描述
你可以看到MySubLib2类名被改为a,但是msgPrint2函数依然没被混淆，另外注意msgPrint函数被移除了。

同样的环境执行如下混淆：

#利用MySubLib保证MySubLib2不会被shrink阶段移走
#MySubLib内部会引用MySubLib2
-keep public class com.example.mymodule.MySubLib{
  *;
}

-keepclassmembers public class com.example.mymodule.MySubLib2 {
	#成员函数运行随意混淆
}

结果：


public class MySubLib {
    public a mySubLib2;
    public String name;
    public int age;

    public MySubLib() {
        MySubLib var10000 = this;
        MySubLib var10001 = this;
        MySubLib var10002 = this;
        super();
        a var1;
        var1 = new a.<init>();
        var10002.mySubLib2 = var1;
        var10001.name = "hehlo";
        var10000.age = 3;
    }

    public void test() {
        PrintStream var10000 = System.out;
        a var1;
        (var1 = this.mySubLib2).getClass();
        var10000.println("zz" + var1.a + "----");
    }
}


//a.java
public class a {
    public String a = "xx";

    public a() {
    }
}

你可以看到函数体都被优化没了，变成了内联

-keepclasseswithmembernames

简短名称 -keepclasseswithmembers

当前语法会让其声明的类成员或者方法名不会被混淆并且类名也不会被混淆，但是前提是这个类和属性或者方法在shrink阶段存活下来

public class MySubLib {
    MySubLib2 mySubLib2 = new MySubLib2();

    public void test() {
        //故意引用其内部的一个函数
        System.out.println(mySubLib2.msgPrint2());
    }

    public String name = "hehlo";
    public int age = 3;
}


public class MySubLib2 {

    public String hello = "xx";
    private String hello2 = "111";
    private int age;

    public String msgPrint() {
        return hello + "----";
    }

    public String msgPrint2() {
        return "zz"+ hello + "----";
    }

    private String msgPrint2(int i) {
        return hello + "----";
    }

    public static void main(String[] args) {

    }
    public void test(java.lang.String d){

    }
}

结果：
在这里插入图片描述

//MySubLib2.java
public class MySubLib2 {
    public String hello = "xx";
    public String hello2 = "111";

    public MySubLib2() {
    }

    public String msgPrint2() {
        return "zz" + this.hello + "----";
    }
}


//MySubLib.java
public class MySubLib {
    public MySubLib2 mySubLib2;
    public String name;
    public int age;

    public MySubLib() {
        MySubLib var10000 = this;
        MySubLib var10001 = this;
        MySubLib var10002 = this;
        super();
        MySubLib2 var1;
        var1 = new MySubLib2.<init>();
        var10002.mySubLib2 = var1;
        var10001.name = "hehlo";
        var10000.age = 3;
    }

    public void test() {
        System.out.println(this.mySubLib2.msgPrint2());
    }
}

你可以看到MySubLib2这个类名和其成员函数都没有被混淆

-assumenosideeffects

高危险操作，慎用.用于移除指定类的函数的调用

原环境

public class MySubLib {
    MySubLib2 mySubLib2 = new MySubLib2();

    @SuppressLint("LogUsage")
    public void test() {
        System.out.printf("----");
        Log.e("hello","hello");
        System.out.printf("++");
    }

    public String name = "hehlo";
    public int age = 3;
}

执行以下混淆


#利用MySubLib不会被shrink阶段移走
-keep public class com.example.mymodule.MySubLib{
  *;
}

# assume no side effects
#删除Log.e等方法的调用
-assumenosideeffects class android.util.Log {
    public static boolean isLoggable(java.lang.String, int);
    public static int v(...);
    public static int i(...);
    public static int w(...);
    public static int d(...);
    public static int e(...);
}

结果


public class MySubLib {
    public a mySubLib2;
    public String name;
    public int age;

    public MySubLib() {
        MySubLib var10000 = this;
        MySubLib var10001 = this;
        MySubLib var10002 = this;
        super();
        a var1;
        var1 = new a.<init>();
        var10002.mySubLib2 = var1;
        var10001.name = "hehlo";
        var10000.age = 3;
    }

    @SuppressLint({"LogUsage"})
    public void test() {
        System.out.printf("----");
        System.out.printf("++");
    }
}

你可以可以清晰的看到test中间的Log.e代码被删除

-dontwarn

用于关闭引用的类未找到的错误.

类型的错误信息如下：

AGPBI: {"kind":"warning","text":"Missing classes detected while running R8. Please add the missing classes or apply additional keep rules that are generated in /Users/fmy/AndroidStudioProjects/ProguardDemo/app/build/outputs/mapping/debug/missing_rules.txt.\n","sources":[{}]}

AGPBI: {"kind":"warning","text":"Missing class org.jsoup.Jsoup (referenced from: void fmy.test.MyProguardTest.test(boolean))","sources":[{}],"tool":"R8"}

上面的大致的意思在你的代码中使用了org.jsoup.Jsoup这个类，但是在类路径却找不到这个类。

我们看看这个到底什么意思呢？

我们首先新建一个maven工件,坐标信息org.example:artifactId:library:3.0-SNAPSHOT。

这个工件里面仅有一个类如下：

//MyProguardTest.java
public class MyProguardTest {
    public static void test(boolean show) {
        if (show) {
            System.out.println("" + Jsoup.class.getSimpleName());
        } else {
            System.out.println("Hello world!");
        }
    }
}

我们不会吧jsoup依赖放入jar所以使用如下声明

dependencies {
    compileOnly group: 'org.jsoup', name: 'jsoup', version: '1.14.3'
}

我们另一个使用工程去引用这个工件：


dependencies {
  // 上面写的组件
  implementation 'org.example:library:3.0-SNAPSHOT'
	//...其他依赖略，但注意我们没有依赖jsoup
}

你在启用混淆编译时便会看到本小结一开始的错误。
解决版本：

  1. 关闭警告信息(及其危险)：在你的混淆文件添加-dontwarn org.jsoup.*

在这里插入图片描述

  1. 给你的依赖添加jsoup工件：
dependencies {
 
  implementation 'org.example:library:3.0-SNAPSHOT'
  implementation group: 'org.jsoup', name: 'jsoup', version: '1.14.3'

}
了解ProGuard 代码混淆
常备不懈
03-19 542
在 Android 开发中，代码混淆（Obfuscation）是一个常见的安全措施，旨在 **让代码难以阅读，以提高破解难度**。
java class 混淆_java混淆了吗
weixin_36268255的博客
02-12 1071
前言最近在项目中碰到个一个场景，我们需要把自己的java项目jar包部署到一个第三方的服务器上，虽然双方互相信任，但是综合考虑，避免别人拿到jar包后可以很快的编译出源码，我们决定给代码加一层混淆，虽然此方法不能从根源上解决问题，但是做了一层混淆，也可以增加阅读源码的难度，总结了一下，写下这篇文章。如何反编译java代码我用的是mac电脑，从官网:http://java-decompiler.gi...
java代码双重混淆
09-04
1，当项目具备商业价值要对外销售的时候，代码混淆是一个必不可少的环节； 2，混淆的目的就是为了不能把class还原成java源码，保护自己的利益； 3，不混淆时，可以被轻而易举的还原，容易泄露商业机密是很不安全的； 4，单次混淆时，仍然有被还原的可能，只是难度偏高； 5，双重混淆之后，安全系数高达99%，不敢说绝对安全，但还原的概率已经非常低了；
EventBus使用、案例、代码混淆报错
李建国的博客
03-08 1411
前言：当我们进行项目开发的时候，往往是需要应用程序的各组件，组件与后台线程间进行通信，比如在子线程中进行请求数据，当数据请求完毕后通过处理程序或者是广播通知UI，而两个片段之家可以通过监听器进行通信等等。当我们的项目越来越复杂，使用意向，处理程序，广播进行模块间通信，模块与后台线程进行通信时，代码量大，而且高度耦合。现在就让我们来学习一下EventBus 3.0吧。 首先使用EventBus之前...
java17使用proguard进行代码混淆的方案
未兆的博客
12-13 3885
proguard进行代码混淆
fastjson混淆规则
pzfpfw_8的博客
02-07 4656
-keepnames class * implements java.io.Serializable -keep public class * implements java.io.Serializable {    public *; } -keepclassmembers class * implements java.io.Serializable {     static fin
springboot工程（单个maven工程）利用proguard实现代码混淆 java demo案例
06-05
ProGuard是一款强大的Java类文件混淆、优化、压缩和预校验工具，它能够帮助我们实现这个目标。 本案例是一个Spring Boot单个Maven工程，通过ProGuard实现代码混淆的实践示例。首先，我们需要了解ProGuard的基本配置...
java混淆框架proguard结合springboot项目混淆打包
feinifi的博客
03-15 3064
java混淆框架proguard对代码进行混淆加密，注意过滤一些类型，不能全部混淆。混淆插件要在spring-boot-maven-plugin之前。
深入浅出Java proguard混淆技术及其使用
在众多Java防编译技术中，proguard混淆器是最常用的工具之一。它通过一系列的代码转换操作，使得代码难以阅读和理解，从而达到保护代码的目的。接下来，我们将详细解析Java防编译技术及proguard混淆器的相关知识点。...
java代码混淆工具proguard及教程讲解
09-05
java代码混淆工具 简单使用docx 字典文件 生成的配置示例
java代码混淆器proGuard
12-12
Java代码混淆器ProGuard是Java开发中用于保护和优化应用程序的重要工具。它的主要功能是对Java字节码进行混淆，使得代码难以被逆向工程解析，从而提高代码的安全性。混淆过程中，函数变量、类和方法名会被重命名为...
很强大的java代码混淆工具 Jocky
09-30
大家熟知的Progaurd只能对class文件进行混淆，也就是必须先把java源码编译为class文件，然后再进行混淆 Jockey跟其他混淆工具不同的是：它是直接对编译过程做文章，也就是在把java文件编译为class文件的过程中对代码进行混淆，混淆后的代码中包含很多JVM 指令，大家知道JVM指令是面向机器的，人类一般很难看懂！。">大家熟知的Progaurd只能对class文件进行混淆，也就是必须先把java源码编译为class文件，然后再进行混淆 Jockey跟其他混淆工具不同的是：它是直接对编译过程做文章，也就是在把java文件编译为class文件的过程中对代码进行混淆，混? [更多]
最新java jar包混淆工具
02-24
java源码加密混淆技术 proguard，可以有效保护java源码
java class 混淆_Java 混淆那些事（三）：了解 ProGuard Keep 规则
weixin_29091837的博客
03-04 1004
本文已授权微信公众号「玉刚说」独家发布。这篇文章是「Java 混淆那些事」的第三篇，我们来真枪真刀的干一下子，用实际行动验证了解一下 ProGuard 的 Keep 语法，这篇代码偏多，希望大家好好理解。阅读提示：上半部分纯属个人总结，不明白请看下半部分的例子，读完了根据自己的理解实践一下。简介 Keep 语法那么 keep 语法有什么用呢？如果我们对外提供了一套 Library ，如果不指定代码...
用混淆器保护你的JAVA(.class)代码(一)
masterjames的专栏
12-01 5788
JAVA代码编译后是.class文件,通过反编工具很容易被别人看到源代码保护JAVA代码的方法很多，下面介绍一种比较方便使用的方法。   obfuscate4e是一款采用混淆器改变CLASS文件内容的方法。下文将介绍具体和eclipse的整合方法1.下载obfuscate4e,加入站点http://obfuscate4e.org/updates/,这个软件是德国人开发的,从他们做汽车的严格程度
JAVA CLASS混淆工具：ProGuard简单试用
柳鲲鹏
08-30 408
下载 没法下载。 proguard.sourceforge.net转到https://www.guardsquare.com/proguard，再转到https://www.guardsquare.com，什么也没找到。
Java代码混淆案例（附反编译工具）
Javaの甘乃迪的博客
03-30 5214
Java代码混淆案例（附反编译工具）
Java后端知识之代码混淆-避免反编译工具获取原码
weixin_43805705的博客
01-05 1970
本文是向大家介绍java后端小知识，它能够实现编译后的class代码加密，能够避免使用反编译工具获取源码。
java混淆的几种方法
最新发布
专注AI大模型,软件混淆,授权
10-04 2742
Java代码混淆是一种通过改变代码结构来增加其可读性和可理解性的复杂度，进而保护源代码的技术。通常，代码混淆用于防止逆向工程和未经授权的代码复制。虽然混淆后的代码可以正常运行，但对开发人员来说阅读和理解变得异常困难。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值