Java全系工程源码加密，防止反编译

技术狂潮AI

于 2024-03-14 15:52:16 发布

阅读量1k

点赞数 20

分类专栏： JAVA开发实战文章标签：开发语言源码安全反编译 JAVA源码

本文链接：https://blog.csdn.net/FrenzyTechAI/article/details/136713157

版权

JAVA开发实战专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、前言

在大约2015年左右，由于公司产品序列逐渐增加，涉及到N多项目部署交付，为了有效防止产品被滥用，私自部署，当时技术中心决定开发一套统一的授权认证管理系统，对公司所有产品序列进行 License 控制。

一晃已然快十年了，一直都在平稳运行，从这里发出的授权估计几千个了吧，最近关于授权认证又收到营销提出的新需求，由于我们开发语言以 JAVA 为主，熟悉 JAVA 的同学都清楚 JAVA 源码很容易被反编译，只要找到了认证的入口其实就很好破解。我们暂不探讨原来的授权具体方案。这个经历多次迭代，本身也比较复杂。

现在产品侧提出的需求，希望可以在线上传或者更新所有产品的授权认证文件，不用通过shell登录服务器手动替换，而且希望在上传完授权文件后，系统对文件进行一次解析和验证，对于不合法或者不匹配的文件不予通过，做到提前过滤。

如果直接给下游产品提供授权认证SDK包的话，所有加密的核心代码和逻辑全部会被暴露出来，有没有比较合适的方案可以对源码进行加密呢？这就是今天我们即将介绍的一款小工具 ClassFinal 。

二、ClassFinal 介绍

ClassFinal是一款java class文件安全加密工具，支持直接加密jar包或war包，无需修改任何项目代码，兼容spring-framework；可避免源码泄漏或字节码被反编译。

2.1、项目模块

classfinal-core: ClassFinal的核心模块，几乎所有加密的代码都在这里；
classfinal-fatjar: ClassFinal打包成独立运行的jar包；
classfinal-maven-plugin: ClassFinal加密的maven插件；

2.2、功能特性

无需修改原项目代码，只要把编译好的jar/war包用本工具加密即可。
运行加密项目时，无需修改tomcat，spring等源代码。
支持普通jar包、springboot jar包以及普通java web项目编译的war包。
支持spring framework、swagger等需要在启动过程中扫描注解或生成字节码的框架。
支持maven插件，添加插件后在打包过程中自动加密。
支持加密WEB-INF/lib或BOOT-INF/lib下的依赖jar包。
支持绑定机器，项目加密后只能在特定机器运行。
支持加密springboot的配置文件。

三、普通项目加密

普通的JAVA项目可以直接通过命令行的方式执行加密：

java -jar classfinal-fatjar-1.2.1.jar -file company-license-3.0.0.jar -packages de.schlichtherle,org.apache.mime2.node,xxx.license.core -exclude LicenseTest -pwd '#' -Y

参数说明
-file        加密的jar/war完整路径
-packages    加密的包名(可为空,多个用","分割)
-libjars     jar/war包lib下要加密jar文件名(可为空,多个用","分割)
-cfgfiles    需要加密的配置文件，一般是classes目录下的yml或properties文件(可为空,多个用","分割)
-exclude     排除的类名(可为空,多个用","分割)
-classpath   外部依赖的jar目录，例如/tomcat/lib(可为空,多个用","分割)
-pwd         加密密码，如果是#号，则使用无密码模式加密
-code        机器码，在绑定的机器生成，加密后只可在此机器上运行
-Y           无需确认，不加此参数会提示确认以上信息

结果: 执行命令后生成 company-license-3.0.0-encrypted.jar，这个就是加密后的jar文件；加密后的文件不可直接执行，需要配置VM参数：javaagent。

3.1、启动加密后的jar

加密后的项目需要设置javaagent来启动，项目在启动过程中解密class，完全内存解密，不留下任何解密后的文件。解密功能已经自动加入到 company-license-3.0.0-encrypted.jar中，所以启动时-javaagent与-jar相同，不需要额外的jar包。

启动jar项目执行以下命令：

java -javaagent:company-license-3.0.0-encrypted.jar='-pwd 0000000' -jar company-license-3.0.0-encrypted.jar

//参数说明
// -pwd      加密项目的密码  
// -pwdname  环境变量中密码的名字

或者不加pwd参数直接启动，启动后在控制台里输入密码，推荐使用这种方式：

java -javaagent:company-license-3.0.0-encrypted.jar -jar company-license-3.0.0-encrypted.jar

3.2、在IDEA中启动加密jar

在IDEA中配置javaagent运行参数，可以按以下步骤进行操作：

1、打开项目的"Run/Debug Configurations"窗口。

2、在"Build and run"配置模块，点击"Modify options"选择"Add VM options"，输入'-javaagent:E:\sla_workspace\company-auth-demo\lib\company-auth-3.0.0.jar"

运行程序，开始在内存中揭秘 Class 文件，程序可以正常运行输出结果：

最新的密码读取顺序已经改为：参数获取密码||环境变量获取密码||密码文件获取密码||控制台输入密码||GUI输入密码||退出

3.3、tomcat下运行加密后的war

将加密后的war放在tomcat/webapps下， tomcat/bin/catalina 增加以下配置:

//linux下 catalina.sh
CATALINA_OPTS="$CATALINA_OPTS -javaagent:classfinal-fatjar-1.2.1.jar='-pwd 0000000'";
export CATALINA_OPTS;

//win下catalina.bat
set JAVA_OPTS="-javaagent:classfinal-fatjar.jar='-pwd 000000'"

//参数说明 
// -pwd      加密项目的密码  
// -nopwd    无密码加密时启动加上此参数，跳过输密码过程
// -pwdname  环境变量中密码的名字

本工具使用AES算法加密class文件，密码是保证不被破解的关键，请保存好密码，请勿泄漏。

密码一旦忘记，项目不可启动且无法恢复，请牢记密码。

本工具加密后，原始的class文件并不会完全被加密，只是方法体被清空，保留方法参数、注解等信息，这是为了兼容spring，swagger等扫描注解的框架；方法体被清空后，反编译者只能看到方法名和注解，看不到方法的具体内容；当class被classloader加载时，真正的方法体会被解密注入。

为了保证项目在运行时的安全，启动jvm时请加参数: -XX:+DisableAttachMechanism 。

四、Maven项目加密

Maven项目可以使用classfinal-maven-plugin插件。直接配置一个插件就可以实现源码的安全性保护。并且可以对yml、properties配置文件以及lib目录下的maven依赖进行加密处理。若想指定机器启动，支持绑定机器，项目加密后只能在特定机器运行。

只需要在启动类的pom.xml文件中加如下插件即可，需要注意的是，改插件时要放到spring-boot-maven-plugin插件后面，否则不起作用。

<?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>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.yourcompany</groupId>
    <artifactId>company-auth</artifactId>
    <version>3.0.0</version>
    <packaging>jar</packaging>

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

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                            <overWriteReleases>false</overWriteReleases>
                            <overWriteSnapshots>false</overWriteSnapshots>
                            <overWriteIfNewer>true</overWriteIfNewer>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>CompanyAuthApplication</mainClass>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <!--
                    1. 加密后,方法体被清空,保留方法参数、注解等信息.主要兼容swagger文档注解扫描
                    2. 方法体被清空后,反编译只能看到方法名和注解,看不到方法体的具体内容
                    3. 加密后的项目需要设置javaagent来启动,启动过程中解密class,完全内存解密,不留下任何解密后的文件
                    4. 启动加密后的jar,生成xxx-encrypted.jar,这个就是加密后的jar文件,加密后不可直接执行
                    5. 无密码启动方式,java -javaagent:xxx-encrypted.jar -jar xxx-encrypted.jar
                    6. 有密码启动方式,java -javaagent:xxx-encrypted.jar='-pwd= 密码' -jar xxx-encrypted.jar
                -->
                <groupId>net.roseboy</groupId>
                <artifactId>classfinal-maven-plugin</artifactId>
                <version>1.2.1</version>
                <configuration>
                    <password>#</password><!-- #表示启动时不需要密码,事实上对于代码混淆来说,这个密码没什么用,它只是一个启动密码 -->
                    <excludes>org.spring</excludes>
                    <packages>org.apache.mime2.node,company.license.core</packages><!-- 加密的包名,多个包用逗号分开 -->
                    <!-- <cfgfiles>application.yml,application-dev.yml</cfgfiles>加密的配置文件,多个包用逗号分开 -->
                    <libjars>hutool-all.jar</libjars> <!-- jar包lib下面要加密的jar依赖文件,多个包用逗号分开 -->
                    <code></code> <!-- 指定机器启动,机器码 -->
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>classFinal</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

五、反编译效果

启动包加密之后，方法体被清空,保留方法参数、注解等信息.主要兼容swagger文档注解扫描，反编译只能看到方法名和注解,看不到方法体的具体内容，启动过程中解密class,完全内存解密,不留下任何解密后的文件。

六、绑定机器启动

下载到classfinal-fatjar-1.2.1.jar 依赖，在当前依赖下cmd执行java -jar classfinal-fatjar-1.2.1.jar -C命令，会自动生成一串机器码

将此生成好的机器码，普通项目增加-code参数指定机器码，maven项目放到maven插件中的code里面即可。这样，打包好的项目只能在生成机器码的机器运行，其他机器则启动不了项目。

七、References

[1]. Classfinal Github:

https://github.com/roseboy/classfinal

[2]. Classfinal Gitee：

https://gitee.com/roseboy/classfinal

[3]. Classfinal JAR Download:

https://repo1.maven.org/maven2/net/roseboy/classfinal-fatjar/1.2.1/classfinal-fatjar-1.2.1.jar

技术狂潮AI

关注

20
点赞
踩
22

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java全系工程源码加密，防止反编译

ClassFinal是一款java class文件安全加密工具，支持直接加密jar包或war包，无需修改任何项目代码，兼容spring-framework；可避免源码泄漏或字节码被反编译。
复制链接

扫一扫