java字节码混淆-- proguard.version  6.2

最新推荐文章于 2025-06-04 11:45:00 发布
最新推荐文章于 2025-06-04 11:45:00 发布
阅读量615 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ywtech/article/details/113735379
该Maven配置文件展示了如何使用ProGuard Maven插件进行代码混淆和优化。配置中指定了ProGuard版本为6.2.0，目标JDK版本为1.8，并定义了混淆规则，包括保留特定类、方法、注解和参数名称，同时启用了适应类字符串选项以处理反射。此外，还设置了不压缩和不优化代码的选项，以及忽略警告。

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

 

 

 

 

 

proguard.version   6.2


<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>net.zjhz</groupId>
        <artifactId>zjclass</artifactId>
        <version>1.2.2</version>
    </parent>

    <artifactId>zjclass-core</artifactId>
    <packaging>jar</packaging>
    <name>zjclass-core</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <proguard.version>6.2.0</proguard.version>
        <proguard.maven.plugin.version>2.2.0</proguard.maven.plugin.version>

    </properties>

    <dependencies>
        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.25.0-GA</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>

            <!--代码混淆-->
            <plugin>
                <groupId>com.github.wvengen</groupId>
                <artifactId>proguard-maven-plugin</artifactId>
                <version>${proguard.maven.plugin.version}</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>proguard</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <proguardVersion>${proguard.version}</proguardVersion>
                    <injar>${project.build.finalName}.jar</injar>
                    <outjar>${project.build.finalName}.jar</outjar>
                    <obfuscate>true</obfuscate>
                    <options>
                        <option>-dontshrink</option>
                        <option>-dontoptimize</option>
                        <!-- This option will replace all strings in reflections method invocations with new class names.
                             For example, invokes Class.forName('className')-->
                        <option>-adaptclassstrings</option>
                        <!-- This option will save all original annotations and etc. Otherwise all we be removed from files.-->
                        <option>-keepattributes
                            Exceptions,
                            InnerClasses,
                            Signature,
                            Deprecated,
                            SourceFile,
                            LineNumberTable,
                            *Annotation*,
                            EnclosingMethod
                        </option>
                        <!-- This option will save all original names in interfaces (without obfuscate).-->
                        <option>-keepnames interface **</option>
                        <!-- This option will save all original methods parameters in files defined in -keep sections,
                             otherwise all parameter names will be obfuscate.-->
                        <option>-keepparameternames</option>
                        <!-- This option will save all original class files (without obfuscate) but obfuscate all
                             in domain and service packages.-->
              <!--          <option>-keep
                            class net.zjhz.zjclass.Main {
                            public static void main(java.lang.String[]);
                            }
                        </option>-->


                        <option>-keepclassmembers class * {
                            public static   *;
                            @org.springframework.beans.factory.annotation.Value *;
                            }
                        </option>
                        <option>-keep
                            class net.zjhz.zjclass.CoreAgent {
                            public static void premain();
                            }
                        </option>
                        <option>-keep
                            class net.zjhz.zjclass.Const
                        </option>

                        <option>-keep
                            class net.zjhz.zjclass.util.CmdLineOption{
                            public static void pringInfo();
                            }
                        </option>

                        <option>-keep
                            class net.zjhz.zjclass.Main
                        </option>
                        <option>-keep
                            class net.zjhz.zjclass.util.Log
                        </option>
                        <option>-keep
                            class net.zjhz.zjclass.util.IoUtils
                        </option>

                        <option>-keep
                            class net.zjhz.zjclass.util.JarUtils
                        </option>

                        <option>-keep
                            class net.zjhz.zjclass.util.StrUtils
                        </option>
                        <option>-keep
                            class net.zjhz.zjclass.util.Log
                        </option>
                        <option>-keep
                            class net.zjhz.zjclass.JarEncryptor
                        </option>
                        <!-- This option ignore warnings such as duplicate class definitions and classes in incorrectly
                            named files-->
                        <option>-ignorewarnings</option>
                        <!-- This option will save all original class files (without obfuscate) in service package-->
                        <!--<option>-keep class com.slm.proguard.example.spring.boot.service { *; }</option>-->
                        <!-- This option will save all original interfaces files (without obfuscate) in all packages.-->
                        <option>-keep interface * extends * { *; }</option>
                        <!-- This option will save all original defined annotations in all class in all packages.-->
                        <option>-keepclassmembers class * {
                            @org.springframework.beans.factory.annotation.Autowired *;
                            @org.springframework.beans.factory.annotation.Value *;
                            }
                        </option>
                    </options>
                    <injarNotExistsSkip>true</injarNotExistsSkip>
                    <libs>
                        <!--Put here your libraries if required-->
                        <!--<lib>${java.home}/lib/rt.jar</lib>-->
                    </libs>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>net.sf.proguard</groupId>
                        <artifactId>proguard-base</artifactId>
                        <version>${proguard.version}</version>
                    </dependency>
                </dependencies>
            </plugin>

        </plugins>
    </build>


    <distributionManagement>
        <repository>
            <id>nexus-releases</id>
            <name>Nexus Releases Repository</name>
            <url>http://192.168.0.114:8081/nexus/content/repositories/releases/</url>
        </repository>
        <snapshotRepository>
            <id>cn.ucmed-Snapshots</id>
            <name>UCMED Snapshots Repository</name>
            <url>http://192.168.0.114:8081/nexus/content/repositories/snapshots/</url>
        </snapshotRepository>
    </distributionManagement>
</project>


 

移动开发：利用 Gradle 进行代码混淆配置
移动开发前沿的博客
06-11 1155
在移动开发中，代码混淆是一项重要的安全和优化技术。其主要目的是保护应用的源代码不被轻易反编译和分析，防止代码逻辑和商业机密泄露。同时，代码混淆还能减少应用的安装包大小，提高应用的性能。本文的范围主要聚焦于如何利用 Gradle 这一强大的构建自动化工具，在 Android 移动开发中进行代码混淆配置，涵盖了从基本概念到实际项目应用的各个方面。
浅谈build.gradle.kts编译脚本
跟着哆啦学Android
05-26 1164
我这里只是简单讲解了一些主要的配置代码，你在实际的项目开发中可能还需要自行研究Gradle Kotlin DSL的更多源码以满足不同的编译需要。当你迈出了将build.gradle转化为build.gradle.kts这关键的一步，你离熟练掌握Gradle构建脚本就很近了。当然你也要常常关注Gradle的最新变化，最后附上Gradle的官方文档地址，https://docs.gradle.org/current/userguide/userguide.html ，祝你好运。
java字节码混淆开源工具-ProGuard
RodJohnsonDoctor的专栏
05-14 2675
定义编辑 ProGuard是一个压缩、优化和混淆Java字节码文件的免费的工具，它可以删除无用的类、字段、方法和属性。可以删除没用的注释，最大限度地优化字节码文件。它还可以使用简短的无意义的名称来重命名已经存在的类、字段、方法和属性。 2压缩编辑 JAVA源代码（.java文件）通常被编译为字节码（.class文件）。而完整的程序或程序库通常被压缩和发布成Java文档（.jar文件）。字
Maven环境下Java/Android代码混淆指南
weixin_36019375的博客
06-04 428
代码混淆是一种代码保护手段，它通过一系列的转换将应用中的代码名称、结构和逻辑转换成难以理解的形式，以防止或增加应用程序被逆向工程分析的难度。混淆的主要目的是为了防止竞争对手或恶意攻击者轻易理解代码逻辑，从而保护知识产权和提高代码的安全性。混淆并不是万能的，它并不能完全阻止有经验的攻击者对应用进行逆向工程，但它可以在一定程度上提高逆向工程的难度，进而减缓对应用的分析过程。此外，合理的代码混淆还可以在不损害应用功能的前提下，帮助减少应用的大小，因为它可以移除未使用到的代码和简化类、方法的名称。
ProGuard Version5.2（1）Main
JianYiLead
08-05 1038
最近需要自己写代码混淆，在网上找了挺久，没找到完整详尽的教程，所以自己看看，并加以记录 ProGuard（混淆器）官网：http://proguard.sourceforge.net/ 今天先记录下Main中的内容 ProGuard是一个免费的Java类文件收缩器，优化器，混淆器，和预校验器。它检测并删除未使用的类、字段、方法和属性。它优化字节码和删除未使用的指令。它将剩余类字段和方法，使用
java字节码反编译,反编译混淆的Java字节码
weixin_39777488的博客
02-16 144
I work on a platform which runs Java apps. Those apps are often obfuscated, most of them using ProGuard, which makes debugging issues with our platform very difficult.Currently I'm using JD (http://ja...
ProGuard Version5.2（4.2）Manual-->Limitations
JianYiLead
08-20 710
当使用ProGuard时，你应该知道一些技术性的问题，所有这些都是很容易避免或解决的：         最好的结果是，为了获得一些有用的东西,混淆器的优化算法假设处理的代码不会故意抛出NullPointerExceptions或ArrayIndexOutOfBoundsExceptions，甚至OutOfMemoryErrors或StackOverflowErrors。例如，如果调用不会有任何影
Java字节码操作最佳实践：代码生成与性能优化的10大秘籍
![Java字节码操作最佳实践：代码生成与性能优化的10大秘籍]...Java字节码是Java平台的一种中间表示形式，它在Java源代码被编译成机器码
【ADT-24.0.2环境搭建秘诀】：打造兼容性极佳的Java环境
本文旨在全面介绍Java与ADT-24.0.2环境的安装、配置和高级管理技巧，同时探讨了兼容性问题的排查与解决方法，并提出了在跨平台开发中处理复杂兼容性挑战的实战案例。文章从环境概述出发，详细讲解了Java开发工具包...
深入理解Android DEX文件格式：揭秘字节码至优化全流程（必读）
[深入理解Android DEX文件格式：揭秘字节码至优化全流程（必读）](https://clipground.com/images/png-file-header-structure-7.png) # 摘要 本论文全面分析了DEX文件格式及其编译过程，探讨了DEX编译为.class文件...
proguard-proguard6.2.2.zip
08-16
1.支持ant 使用proguard标签 2.支持windows环境混淆代码 3.支持Java8+ 新版本6x系列不再提供编译好的jar包 需要自己手动编译，7系列使用的gradle编译管理 国内不太好用，6x系列基本满足Java8+ 的代码混淆，具体可以参考docs文档
proguard6.2.2.rar
06-24
资源是proguard6.2.2版本，里面附上了中文的使用教程，一看就懂，非常简单，不懂的可以私信问我。
ProGuard-version 5.2.1
08-17
ProGuard最新版本 5.2.1
proguard 6.2.2魔改版
11-03
proguard 6.2.2的魔改版本用于混淆app、jar、class等，将所有a,b,c等等的字符改成不可见字符，从而提高安全性。里面包括源码和编译好的jar包。编译源码使用core/build.sh，编译好的jar包在lib目录下。android app使用时可以将lib目录复制至工程目录中。在工程目录中的build.gradle中使用自定义proguard，如:classpath ':lib:' //自定义proguard工具路径。
ProGuard Version5.2（4.1）Manual-->Introduction
JianYiLead
08-10 592
ProGuard是一个Java类文件收缩器，优化器，混淆器和预校验器。收缩步骤检测并删除未使用的类、字段、方法和属性。优化步骤分析和优化方法的字节码。混淆步骤用短的无意义的名称重命名剩余的类、属性和方法。以上的步骤使得代码库更小，效率更高，更难反向工程。最后的预校验步骤添加预校验信息到类中，这是Java Micro Edition，Java 6和更高版本的要求。 这些步骤中的每一个都是可选的。例
ProGuard Version5.2（3）FAQ
JianYiLead
08-07 705
3.1What is shrinking?（什么是收缩？） Java源代码（.Java文件）通常被编译成字节码（.class文件）。字节码比Java源代码更紧凑，但它仍可能包含大量的无用代码，特别是如果它包括程序库。Shrinking程序如ProGuard可以分析字节码和删除未使用的类、属性和方法。该程序仍然在功能上等效，包括在异常堆栈跟踪的信息。 3.2What is obfuscation
ProGuard Version5.2（4.2）Manual-->Usage
JianYiLead
08-11 932
为了运行ProGuard，输入： java -jar proguard.jar options ... 你可以在ProGuard分布的lib目录下找到ProGuard jar。或者，使用bin目录下包含一些短的Linux和Windows包含命令的脚本。通常，你可以把大多数的选项放在配置文件（例如，myconfig.pro）中，然后调用： java -jar proguard.jar
[proguard] Warning: there were 38 classes in incorrectly named files. [proguard] You should make sure all file names correspond to their class names. [proguard] The directory hierarchies must correspond to the package hierarchies. [proguard] (https://www.guardsquare.com/proguard/manual/troubleshooting#unexpectedclass) [proguard] If you don't mind the mentioned classes not being written out, [proguard] you could try your luck using the '-ignorewarnings' option. [proguard] Unexpected error [proguard] java.io.IOException: Please correct the above warnings first. [proguard] at proguard.InputReader.execute(InputReader.java:196) ~[proguard-base-7.2.2.jar:7.2.2] [proguard] at proguard.pass.PassRunner.run(PassRunner.java:24) ~[proguard-base-7.2.2.jar:7.2.2] [proguard] at proguard.ProGuard.readInput(ProGuard.java:309) ~[proguard-base-7.2.2.jar:7.2.2] [proguard] at proguard.ProGuard.execute(ProGuard.java:111) ~[proguard-base-7.2.2.jar:7.2.2] [proguard] at proguard.ProGuard.main(ProGuard.java:623) [proguard-base-7.2.2.jar:7.2.2]
最新发布
07-22
<think>我们正在处理ProGuard混淆过程中出现的警告："Warning: there were classes in incorrectly named files." 这个警告表明存在类文件命名不规范的问题，即类文件所在的目录结构（包层次）与类中声明的包名不匹配。这可能导致ProGuard处理时出现问题，甚至引发构建失败（IOException）。下面将逐步解释问题原因并提供解决方案。 ### 问题原因 在Java中，类文件的存放路径必须与包名完全匹配。例如，包名为`com.example`的类必须位于`com/example/`目录下。如果类文件的实际存放路径与类中声明的包名不一致，ProGuard就会发出此警告。若不解决，可能导致后续步骤（如生成JAR包）失败。 ### 解决步骤 1. **定位问题类**： - 查看ProGuard的完整输出日志，找到具体哪些类文件存在路径与包名不匹配的问题。日志中会列出这些类的名称和实际路径。 - 示例日志片段： ``` Warning: there were 2 classes in incorrectly named files. Class 'com.example.MyClass' is in unnamed module of loader 'app' Class 'com.example.AnotherClass' is in unnamed module of loader 'app' ``` 2. **检查目录结构**： - 根据日志中列出的类名，在项目源文件目录（如`src/main/java`）中检查这些类的实际存放路径。 - 例如，类`com.example.MyClass`应位于`src/main/java/com/example/MyClass.java`。如果路径为`src/main/java/example/MyClass.java`（缺少`com`目录），则不符合规范。 3. **修正目录结构**： - 调整目录结构，使其与包名完全一致。将类文件移动到正确的目录下。 - 如果使用IDE（如IntelliJ IDEA或Eclipse），可以右键点击类名，选择"Refactor" → "Move"来安全移动文件。 4. **清理并重新构建**： - 修正后，清理项目（如使用Maven：`mvn clean`或Gradle：`./gradlew clean`）。 - 重新构建项目，确保ProGuard警告消失。 ### 预防措施 - **构建前检查**：在构建脚本中添加预检查任务，自动扫描包名与路径不匹配的类。例如，使用Maven插件`maven-enforcer-plugin`配置规则[^1]。 - **IDE设置**：确保IDE的编译输出路径设置正确，避免手动移动文件导致路径错误。 ### 示例：构建脚本检查（Maven） 在`pom.xml`中添加以下插件，可在构建时自动检查包路径： ```xml <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-enforcer-plugin</artifactId> <version>3.0.0</version> <executions> <execution> <id>enforce-package-convention</id> <goals><goal>enforce</goal></goals> <configuration> <rules> <requireFilesMatch> <files>${project.build.sourceDirectory}/**/*.java</files> <pattern>.*/${package.path.replace('.','/')}/.*</pattern> </requireFilesMatch> </rules> </configuration> </execution> </executions> </plugin> ``` ### 总结 通过修正类文件的存放路径，使其与包名完全匹配，即可消除ProGuard的"incorrectly named files"警告。同时，通过自动化检查预防问题重现，可提升构建稳定性[^2][^3]。 §§相关问题§§ 1. ProGuard混淆时如何处理第三方库的类路径问题？ 2. 如何配置ProGuard规则以避免混淆特定类或方法？ 3. ProGuard混淆后出现运行时错误（如ClassNotFoundException）如何排查？</think>### ProGuard 类文件命名警告解决方案 当 ProGuard 报告 `Warning: there were classes in incorrectly named files` 时，表明存在类文件存储路径与类声明包名不匹配的问题。这种文件路径与包名不一致会导致构建失败（IOException）。以下是系统化的解决方案： #### 问题原因分析 1. **类文件位置错误**：Java 要求类文件必须存储在与其包名匹配的目录结构中。例如： - 包声明：`package com.example;` - 正确路径：`com/example/MyClass.class` - 错误路径：`example/MyClass.class`（缺少 `com` 目录） 2. **构建流程问题**：编译过程中类文件被错误地放置在非标准目录[^3] #### 解决步骤 1. **定位问题类**： ```log # 查看完整构建日志，找出具体类名 Warning: com.example.MyClass: can't find superclass or interface... ``` 2. **检查目录结构**： - 验证类文件实际存储路径是否匹配包声明 - 示例检查： ```bash # 在构建输出目录执行 find . -name "MyClass.class" | grep "com/example" ``` 3. **修正文件位置**： - 方案1：手动移动文件到正确路径 ```bash mv build/incorrect/path/MyClass.class build/com/example/ ``` - 方案2：修复构建脚本中的输出目录配置 ```gradle // Gradle 示例 android { sourceSets.main.java.srcDirs = ['src/main/java'] } ``` 4. **清理重建**： ```bash ./gradlew clean && ./gradlew build ``` #### 高级场景处理 当问题涉及第三方库时： 1. 添加 `-dontwarn` 规则（临时方案）： ``` -dontwarn com.example.mismatchedpackage.** ``` 2. 重打包依赖库（推荐）： ```bash # 解压jar→修正路径→重新打包 jar xf library.jar mv com/wrongpath com/rightpath jar cf fixed-library.jar com/rightpath ``` #### 预防措施 1. 在构建脚本中添加路径验证： ```gradle task validatePackagePaths { doLast { fileTree("build/classes").visit { f -> if (f.file.directory) return def path = f.relativePath.toString().replace('.class','') if (!path.contains(f.file.text.match(/package (\S+);/)[1].replace('.','/'))) { throw new GradleException("路径不匹配: ${f.file}") } } } } ``` 2. 持续集成检查：在 CI 流程中添加包路径验证脚本 > **关键提示**：此错误常发生在多模块项目中，当子模块的构建输出路径配置不一致时。检查所有模块的 `build.gradle` 配置是否统一[^1][^4]。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值