Java代码混淆加密之Xjar

胡八一、

于 2024-08-09 18:03:27 发布

阅读量631

点赞数 7

分类专栏： java 文章标签： java 开发语言 web安全

本文链接：https://blog.csdn.net/qq_44732146/article/details/141062769

版权

java 专栏收录该内容

88 篇文章 5 订阅

订阅专栏

使用背景

代码安全性需求：在交付给客户或第三方时，保护源代码不被泄露或反编译是许多企业的核心需求。尤其是在竞争激烈的市场中，代码泄露可能导致严重的经济损失。
传统工具的局限性：虽然有很多混淆和加密工具，比如 ProGuard，但是它们主要通过混淆代码来增加反编译的难度，并不能完全避免被逆向工程。而且一些工具需要额外的配置，对 Spring 框架的支持不够友好，增加了使用的复杂性。
易用性与跨平台：XJar 强调的是 “加密” 而不是“混淆”，它通过对 JAR 包进行加密，确保即使 JAR 包被破解，里面的代码仍然是不可读的。XJar 保持了 JVM 的跨平台特性，支持 Spring Boot 应用的加密，简化了开发人员的配置工作。
应用场景广泛：XJar 不仅适用于普通的 Java 应用，也适用于 Spring Boot 等框架，开发者可以方便地在其开发流程中集成 XJar 加密，保护应用程序的源代码。

功能特性

无代码侵入, 只需要把编译好的JAR包通过工具加密即可.
完全内存解密, 降低源码以及字节码泄露或反编译的风险.
支持所有JDK内置加解密算法.
可选择需要加解密的字节码或其他资源文件.
支持Maven插件, 加密更加便捷.
动态生成Go启动器, 保护密码不泄露.

开源地址

使用步骤

1.手动加密

添加依赖

<project>
    <!-- 设置 jitpack.io 仓库 -->
    <repositories>
        <repository>
            <id>jitpack.io</id>
            <url>https://jitpack.io</url>
        </repository>
    </repositories>
    <!-- 添加 XJar 依赖 -->
    <dependencies>
        <dependency>
            <groupId>com.github.core-lib</groupId>
            <artifactId>xjar</artifactId>
            <version>4.0.2</version>
            <!-- <scope>test</scope> -->
        </dependency>
    </dependencies>
</project>

注意

必须添加 https://jitpack.io Maven仓库.
如果使用 JUnit 测试类来运行加密可以将 XJar 依赖的 scope 设置为 test.

加密密码

public static void main(String[] args) throws Exception {
        // Spring-Boot Jar包加密
        XCryptos.encryption()
                .from("D:\\IdeaProjects\\mytools\\xjar-demo\\jars\\proguard-demo-0.0.1-SNAPSHOT.jar")//是需要加密的jar包路径（也可以使用绝对路径）
                .use("123456")//是加密的秘钥
                .include("/**/*.class")
                .include("/**/*.yml")
                .include("/**/*.xml")
                .exclude("/static/**/*")
                .exclude("/templates/**/*")
                .exclude("/META-INF/resources/**/*")
                .to("D:\\IdeaProjects\\mytools\\xjar-demo\\jars\\proguard-demo-0.0.1-SNAPSHOT-encry.jar");//加密后的jar包的存放路径
    }

方法名称	参数列表	是否必选	方法说明
from	(String jar)	二选一	指定待加密JAR包路径
from	(File jar)	二选一	指定待加密JAR包文件
use	(String password)	二选一	指定加密密码
use	(String algorithm, int keysize, int ivsize, String password)	二选一	指定加密算法及加密密码
include	(String ant)	可多次调用	指定要加密的资源相对于classpath的ANT路径表达式
include	(Pattern regex)	可多次调用	指定要加密的资源相对于classpath的正则路径表达式
exclude	(String ant)	可多次调用	指定不加密的资源相对于classpath的ANT路径表达式
exclude	(Pattern regex)	可多次调用	指定不加密的资源相对于classpath的正则路径表达式
to	(String xJar)	二选一	指定加密后JAR包输出路径, 并执行加密.
to	(File xJar)	二选一	指定加密后JAR包输出文件, 并执行加密.

指定加密算法的时候密钥长度以及向量长度必须在算法可支持范围内, 具体加密算法的密钥及向量长度请自行百度或谷歌.
include 和 exclude 同时使用时即加密在include的范围内且排除了exclude的资源.

在这里插入图片描述
注意:需要使用agent技术的话,要使用旧的启动脚本(xjar_agentable.go),没有禁用agen

编译脚本

go build xjar.go
go build xjar_agentable.go

在这里插入图片描述
如果报go不是内部或外部命令,请安装一下golang。

windows安装go

'go' 不是内部或外部命令，也不是可运行的程序
或批处理文件。

通过加密成功后XJar会在输出的JAR包同目录下生成一个名为 xjar.go 的的Go启动器源码文件.
将 xjar.go 在不同的平台进行编译即可得到不同平台的启动器可执行文件, 其中Windows下文件名为 xjar.exe 而Linux下为 xjar.
用于编译的机器需要安装 Go 环境, 用于运行的机器则可不必安装 Go 环境, 具体安装教程请自行搜索. windows安装go
由于启动器自带JAR包防篡改校验, 故启动器无法通用, 即便密码相同也不行.

反编译查看加密后的jar包
在这里插入图片描述

原理

对jar的字节码加密 , 启动jar包时调用自定义的类加载器, 重写findClass方法,拿到字节流后,先解密再掉Classloader的defineClass方法,初始化成Class对象

在这里插入图片描述
图片转自 https://blog.csdn.net/qq_35107134/article/details/129407415
如有侵权，请联系删除。

在这里插入图片描述
正常springboot的jar包的Main-Class是Spingboot提供的JarLauncher , 加密后的Springboot的Main-Class指向的是XJar继承JarLaunch的XJarLauncher.

源码结构图

1.加密
在这里插入图片描述

2.解密
在这里插入图片描述
图片转自 https://blog.csdn.net/qq_35107134/article/details/129407415
如有侵权，请联系删除。

启动脚本

/path/to/xjar /path/to/java [OPTIONS] -jar /path/to/encrypted.jar [ARGS]

/path/to/xjar /path/to/javaw [OPTIONS] -jar /path/to/encrypted.jar [ARGS]

nohup /path/to/xjar /path/to/java [OPTIONS] -jar /path/to/encrypted.jar [ARGS]

示例

.\xjar.exe java -jar proguard-demo-0.0.1-SNAPSHOT-encry.jar

说明

在 Java 启动命令前加上编译好的Go启动器可执行文件名(xjar)即可启动运行加密后的JAR包.
若使用 nohup 方式启动则 nohup 要放在Go启动器可执行文件名(xjar)之前.
若Go启动器可执行文件名(xjar)不在当前命令行所在目录则要通过绝对路径或相对路径指定.
仅支持通过 -jar 方式启动, 不支持-cp或-classpath的方式.
-jar 后面必须紧跟着启动的加密jar文件路径
例子: 如果当前命令行就在 xjar 所在目录, java 环境变量也设置好了

 ./xjar java -Xms256m -Xmx1024m -jar /path/to/encrypted.jar

注意事项

不兼容 spring-boot-maven-plugin 的 executable = true 以及 embeddedLaunchScript

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <!-- 需要将executable和embeddedLaunchScript参数删除, 目前还不能支持对该模式Jar的加密！后面可能会支持该方式的打包. 
    <configuration>
        <executable>true</executable>
        <embeddedLaunchScript>...</embeddedLaunchScript>
    </configuration>
    -->
</plugin>

Spring Boot + JPA(Hibernate) 启动报错问题
如果项目中使用了 JPA 且实现为Hibernate时, 由于Hibernate自己解析加密后的Jar文件, 所以无法正常启动, 可以采用以下解决方案:

clone XJar-Agent-Hibernate , 使用 mvn clean package 编译出 xjar-agent-hibernate-${version}.jar 文件
采用 xjar java -javaagent:xjar-agent-hibernate-${version}.jar -jar your-spring-boot-app.jar 命令启动

静态文件浏览器无法加载完成问题
由于静态文件被加密后文件体积变大, Spring Boot 会采用文件的大小作为 Content-Length 头返回给浏览器, 但实际上通过 XJar 加载解密后文件大小恢复了原本的大小, 所以浏览器认为还没接收完导致一直等待服务端. 由此我们需要在加密时忽略静态文件的加密, 实际上静态文件也没加密的必要, 因为即便加密了用户在浏览器查看源代码也是能看到完整的源码.通常情况下静态文件都会放在 static/ 和 META-INF/resources/ 目录下, 我们只需要在加密时通过 exclude 方法排除这些资源即可, 可以参考以下例子：

XCryptos.encryption()
        .from("/path/to/read/plaintext.jar")
        .use("io.xjar")
        .exclude("/static/**/*")
        .exclude("/META-INF/resources/**/*")
        .to("/path/to/save/encrypted.jar");

JDK-9及以上版本由于模块化导致XJar无法使用 jdk.internal.loader 包的问题解决方案
在启动时添加参数 --add-opens java.base/jdk.internal.loader=ALL-UNNAMED

xjar java --add-opens java.base/jdk.internal.loader=ALL-UNNAMED -jar /path/to/encrypted.jar

由于使用了阿里云Maven镜像导致无法从 jitpack.io 下载 XJar 依赖的问题
参考如下设置, 在镜像配置的 mirrorOf 元素中加入 ,!jitpack.io 结尾.

<mirror>
    <id>alimaven</id>
    <mirrorOf>central,!jitpack.io</mirrorOf>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
</mirror>

2.Maven配置自动加密

Maven项目可通过集成 xjar-maven-plugin 以免去每次加密都要执行一次上述的代码, 随着Maven构建自动生成加密后的JAR和Go启动器源码文件.

xjar-maven-plugin 开源地址

<!-- 设置 jitpack.io 插件仓库 -->
    <pluginRepositories>
        <pluginRepository>
            <id>jitpack.io</id>
            <url>https://jitpack.io</url>
        </pluginRepository>
    </pluginRepositories>
    <!-- 添加 XJar Maven 插件 -->
<build>
    <finalName>xjar-demo</finalName>
    <plugins>
        <plugin>
            <groupId>com.github.core-lib</groupId>
            <artifactId>xjar-maven-plugin</artifactId>
            <version>4.0.2</version>
            <executions>
                <execution>
                    <goals>
                        <goal>build</goal>
                    </goals>
                    <phase>package</phase>
                    <configuration>
                     <!-- optional
                            <algorithm/>
                            <keySize/>
                            <ivSize/>
                            <includes>
                                <include/>
                            </includes>
                            <excludes>
                                <exclude/>
                            </excludes>
                            <sourceDir/>
                            <sourceJar/>
                            <targetDir/>
                            <targetJar/>
                            -->
                        <!-- 密码不建议在pom文件里配置 -->
                        <password>io.xjar</password>
                        <includes>
                            <include>/**/*.class</include>
                            <include>/**/*.yml</include>
                            <include>/**/*.xml</include>
                        </includes>
                        <excludes>
                            <exclude>/static/**/*</exclude>
                            <exclude>/templates/**/*</exclude>
                            <exclude>/META-INF/resources/**/*</exclude>
                        </excludes>
                        <targetJar>${parent.artifactId}-encry.jar</targetJar>
 
                    </configuration>
                </execution>
            </executions>
        </plugin>
 
    </plugins>
   
</build>

打包命令

 mvn clean install -Dxjar.password=密码 -Dmaven.test.skip=true

对于Spring Boot 项目或模块, 该插件要后于 spring-boot-maven-plugin 插件执行, 有两种方式：

将插件放置于 spring-boot-maven-plugin 的后面, 因为其插件的默认 phase 也是 package
将插件的 phase 设置为 install（默认值为：package）, 打包命令采用 mvn clean install

也可以通过Maven命令执行

mvn xjar:build -Dxjar.password=io.xjar
mvn xjar:build -Dxjar.password=io.xjar -Dxjar.targetDir=/directory/to/save/target.xjar

但通常情况下是让XJar插件绑定到指定的phase中自动执行, 这样就能在项目构建的时候自动构建出加密的包.

mvn clean package -Dxjar.password=io.xjar
mvn clean install -Dxjar.password=io.xjar -Dxjar.targetDir=/directory/to/save/target.xjar

打包了之后，运行go build xjar.jar名称生成xjar.exe，然后运行xjar.exe java -jar 包名.jar启动项目

建议

强烈建议不要在 pom.xml 的 xjar-maven-plugin 配置中写上密码，这样会导致打包出来的 xjar 包中的 pom.xml 文件保留着密码，极其容易暴露密码！强烈推荐通过 mvn 命令来指定加密密钥！

参数说明

参数名称	命令参数名称	参数说明	参数类型	缺省值	示例值
password	-Dxjar.password	密码字符串	String	必须	任意字符串, io.xjar
algorithm	-Dxjar.algorithm	加密算法名称	String	`AES/CBC/PKCS5Padding`	JDK内置加密算法, 如：`AES/CBC/PKCS5Padding` 和 `DES/CBC/PKCS5Padding`
keySize	-Dxjar.keySize	密钥长度	int	128	根据加密算法而定, 56, 128, 256
ivSize	-Dxjar.ivSize	密钥向量长度	int	128	根据加密算法而定, 128
sourceDir	-Dxjar.sourceDir	源jar所在目录	File	`${project.build.directory}`	文件目录
sourceJar	-Dxjar.sourceJar	源jar名称	String	`${project.build.finalName}.jar`	文件名称
targetDir	-Dxjar.targetDir	目标jar存放目录	File	`${project.build.directory}`	文件目录
targetJar	-Dxjar.targetJar	目标jar名称	String	`${project.build.finalName}.xjar`	文件名称
includes	-Dxjar.includes	需要加密的资源路径表达式	String[]	无	`io/xjar/** , mapper/*Mapper.xml` , 支持Ant表达式
excludes	-Dxjar.excludes	无需加密的资源路径表达式	String[]	无	`static/ , META-INF/resources/` , 支持Ant表达式

指定加密算法的时候密钥长度以及向量长度必须在算法可支持范围内, 具体加密算法的密钥及向量长度请自行百度或谷歌.
当 includes 和 excludes同时使用时，即加密在includes的范围内且排除了excludes的资源.

更多文档：xjar-maven-plugin

胡八一、

关注

7
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Java代码混淆加密之Xjar

代码安全性需求：在交付给客户或第三方时，保护源代码不被泄露或反编译是许多企业的核心需求。尤其是在竞争激烈的市场中，代码泄露可能导致严重的经济损失。传统工具的局限性：虽然有很多混淆和加密工具，比如ProGuard，但是它们主要通过混淆代码来增加反编译的难度，并不能完全避免被逆向工程。而且一些工具需要额外的配置，对Spring框架的支持不够友好，增加了使用的复杂性。XJar强调的是而不是“混淆”，它通过对 JAR 包进行加密，确保即使 JAR 包被破解，里面的代码仍然是不可读的。
复制链接

扫一扫

专栏目录