0、背景

众所周知，jar 包反编译还原度较高，存在源代码泄露风险。常见的防护措施包括代码加密和混淆。今天我们重点研究代码加密方法，通常做法是对全部代码加密，程序运行时再加载密钥进行解密。

1、classfinal

classfinal是一个常见的开源加密项目，下载地址：
https://gitee.com/roseboy/classfinal
打包好的jar下载：
http://repo.maven.apache.org/maven2/net/roseboy/classfinal-fatjar/1.2.1/classfinal-fatjar-1.2.1.jar

1.1、加密验证

（1）加密程序
我们可以用一个demo程序来测试加密命令：

 java -jar classfinal-fatjar-1.2.1.jar -file demo-1.0-SNAPSHOT.jar -packages org.example -pwd 123456qq -Y

加密成功，

（2）测试加密后的运行
有以下两种方式：

1、直接指定密码启动（密码会显示在命令历史中，不够安全）：
java -javaagent:demo-1.0-SNAPSHOT-encrypted.jar='-pwd yourpassword' -jar demo-1.0-SNAPSHOT-encrypted.jar


2、推荐方式 - 启动后输入密码（更安全）：
java -javaagent:demo-1.0-SNAPSHOT-encrypted.jar -jar demo-1.0-SNAPSHOT-encrypted.jar

运行正常，

1.2、测试逆向

（1）对比加解密区别
对比发现直接使用反编译工具已经无法看到方法的具体实现

（2）定位到解密方法与密码的hash
net/roseboy/classfinal/JarDecryptor.class

1.3、解密

作者提到，加密保护的关键在于密钥存储。无论是命令行直接输入还是手动输入密钥，最终客户都需要获得密钥。一般项目不太可能每次启动都由代码提供方协助。当前解密操作默认已获取项目密钥。
（1）思路：
我们了解到项目使用AES加密，拿到密钥后，直接用加密jar包的解密方法传入密钥即可完成解密，然后把解密后的内容保存到磁盘即可。
（2）实操
将jar先解压到root文件夹下，然后同目录运行脚本即可

（3）解密对比
对比加密前和解密后的代码，

（4）解密代码

import net.roseboy.classfinal.JarDecryptor;
import java.io.File;
import net.roseboy.classfinal.util.IoUtils;


public class test {
    public static void main(String[] args) {

//        1.将加密jar包解压到当前目录下的ROOT目录下
        String workpath = System.getProperty("user.dir") + "/ROOT/";

//        2.输入密码
        String pass = "123456qq";


        File file = new File(workpath+"META-INF/.classes/");
        File[] array = file.listFiles();
        for(int i=0;i<array.length;i++){
            if(array[i].isFile()){
                JarDecryptor jarde = new JarDecryptor();
                byte[] result = jarde.doDecrypt(workpath,array[i].getName(),pass.toCharArray());

//               判断返回值是否为空
                if (result == null) {
                    System.out.println("解密失败，输出为空: " + array[i].getName());
                    continue;
                }

//                解密写入文件
                String decrypted_path = System.getProperty("user.dir")+"/decodes/";
                File decrypted_dir = new File(decrypted_path);
                if (!decrypted_dir.exists()) {
                    decrypted_dir.mkdirs();
                }

                File outputFile = new File(decrypted_dir, array[i].getName() + ".class");
                IoUtils.writeFile(outputFile, result);

//                输出写入的文件位置
                System.out.println("解密成功，输出文件: " + outputFile.getAbsolutePath());

            }
        }
    }
}

1.4、补充

其实classfinal在加密的时候，是可以选择不指明密码。

加密测试，

这种方式会随机生成一个密码，保存位置见下图，反编译后可以获取。

2、小结

由于启动密码泄露主要由保存方式不当导致，我们可以考虑用Go编写一个专用启动器来管理启动密码，从而提高安全性。不过需要注意，启动器不能直接通过 system 等函数启动项目，否则密码仍可能通过 ps -ef 等命令被获取。实际上，类似的开源项目已有实现，可以进一步参考和研究。

3、xjar

下载地址：
https://github.com/core-lib/xjar

3.1、加密验证

（1）添加依赖

    <!-- 设置 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>

（2）加密
同时生成启动器go的代码

package org.example;

import io.xjar.XCryptos;


public class xjar_en {

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

}

（3）生成启动器与启动项目

# 编译“启动器”
go build xjar.go
 
# 使用启动器启动
.\xjar.exe java -jar .\demo-1.0-SNAPSHOT-encrypted-xjar.jar

3.2、测试逆向

（1）尝试反编译
代码直接无法查看

（2）查看启动器逻辑
项目重点是启动器和密钥。Go 代码中，发现密钥通过 Stdin 传递。
安全检测方面：

通过哈希校验加密 jar 包，防止篡改；
检查命令行参数，若包含 -javaagent: 则直接报错退出，防止通过 Java Agent 注入；

将包含算法、密钥长度、IV 长度和密码的密钥字节流，作为 Java 程序标准输入传递。
xjar.go代码

package main

import (
	"bytes"
	"crypto/md5"
	"crypto/sha1"
	"errors"
	"hash"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
)

var xJar = XJar{
	md5:  []byte{9, 15, 233, 88, 9, 60, 80, 217, 189, 204, 223, 35, 62, 229, 255, 80},
	sha1: []byte{63, 97, 90, 64, 90, 144, 174, 79, 13, 192, 250, 105, 89, 114, 78, 133, 4, 170, 2, 30},
}

var xKey = XKey{
	algorithm: []byte{65, 69, 83, 47, 67, 66, 67, 47, 80, 75, 67, 83, 53, 80, 97, 100, 100, 105, 110, 103},
	keysize:   []byte{49, 50, 56},
	ivsize:    []byte{49, 50, 56},
	password:  []byte{49, 50, 51, 52, 53, 54, 119, 119},
}

func main() {
	// search the jar to start
	jar, err := JAR(os.Args)
	if err != nil {
		panic(err)
	}

	// parse jar name to absolute path
	path, err := filepath.Abs(jar)
	if err != nil {
		panic(err)
	}

	// verify jar with MD5
	MD5, err := MD5(path)
	if err != nil {
		panic(err)
	}
	if bytes.Compare(MD5, xJar.md5) != 0 {
		panic(errors.New("invalid jar with MD5"))
	}

	// verify jar with SHA-1
	SHA1, err := SHA1(path)
	if err != nil {
		panic(err)
	}
	if bytes.Compare(SHA1, xJar.sha1) != 0 {
		panic(errors.New("invalid jar with SHA-1"))
	}

	// check agent forbid
	{
		args := os.Args
		l := len(args)
		for i := 0; i < l; i++ {
			arg := args[i]
			if strings.HasPrefix(arg, "-javaagent:") {
				panic(errors.New("agent forbidden"))
			}
		}
	}

	// start java application
	java := os.Args[1]
	args := os.Args[2:]
	key := bytes.Join([][]byte{
		xKey.algorithm, {13, 10},
		xKey.keysize, {13, 10},
		xKey.ivsize, {13, 10},
		xKey.password, {13, 10},
	}, []byte{})
	cmd := exec.Command(java, args...)
	cmd.Stdin = bytes.NewReader(key)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	err = cmd.Run()
	if err != nil {
		panic(err)
	}
}

// find jar name from args
func JAR(args []string) (string, error) {
	var jar string

	l := len(args)
	for i := 1; i < l-1; i++ {
		arg := args[i]
		if arg == "-jar" {
			jar = args[i+1]
		}
	}

	if jar == "" {
		return "", errors.New("unspecified jar name")
	}

	return jar, nil
}

// calculate file's MD5
func MD5(path string) ([]byte, error) {
	return HASH(path, md5.New())
}

// calculate file's SHA-1
func SHA1(path string) ([]byte, error) {
	return HASH(path, sha1.New())
}

// calculate file's HASH value with specified HASH Algorithm
func HASH(path string, hash hash.Hash) ([]byte, error) {
	file, err := os.Open(path)

	if err != nil {
		return nil, err
	}

	_, _err := io.Copy(hash, file)
	if _err != nil {
		return nil, _err
	}

	sum := hash.Sum(nil)

	return sum, nil
}

type XJar struct {
	md5  []byte
	sha1 []byte
}

type XKey struct {
	algorithm []byte
	keysize   []byte
	ivsize    []byte
	password  []byte
}

3.3、获取密钥

（1）拿到密钥
启动器需要接收参数，可以直接编写一个 Go 程序输出传入的 stdin。

package main
 
import (
    "bufio"
    "fmt"
    "os"
)
 
func main() {
    input := bufio.NewScanner(os.Stdin) //初始化一个扫表对象
    for input.Scan() {                  //扫描输入内容
        line := input.Text() //把输入内容转换为字符串
        fmt.Println(line)    //输出到标准输出
    }
}

拿到密钥

（2）其他拿到密钥思路
其实也可以通过编写一个模拟的 jar 来接收和输出，但需要用 ida 等工具去除哈希校验，操作会稍微复杂一些。
另外，密钥会传入 JVM。我们可以先反编译代码找到加密密钥的位置，再导出 Java 内存获取具体信息。

可以看到很多类都使用到了key。由于 VisualVM 不适合分析只运行几秒的 JAR 包，我们在 demo 代码中增加了一些延时，然后dump内存数据，

根据反编译提示，我们可以在多个位置找到key。

3.4、解密

拿到key之后，解密思路和classfinal一致。

运行代码需要手动导入 commons-compress 的依赖包，

import io.xjar.jar.XJar;

public class de {
    public static void main(String[] args) throws Exception {
        XJar.decrypt("demo-1.0-SNAPSHOT-encrypted-xjar.jar","de_code.zip", "123456ww");
    }
}

查看解密代码，

4、总结

从上述探究可以看出，class final到xjar的方案不断完善，但仍有逆向的风险。开源代码和思路虽带来便利，也可能被攻击者利用，实际环境中建议进行二次开发后再使用。