ClassFinal-maven-plugin实现jar包加密

ClassFinal-maven-plugin 是一个用于对 Java 项目进行代码混淆和保护的 Maven 插件。虽然它主要的功能是代码混淆，但你也可以通过一些自定义配置和额外的工具来实现对 JAR 包的加密。不过，需要注意的是，直接对 JAR 包进行加密并不常见，因为 Java 的类加载机制需要能够读取和解析类文件。

通常，保护 JAR 包内容的方法包括：

1. 代码混淆：通过混淆类名、方法名、变量名等，使反编译后的代码难以理解。
2. 签名和校验：对 JAR 包进行签名，并在运行时进行校验，确保 JAR 包未被篡改。
3. 自定义类加载器：通过自定义类加载器在加载类文件时进行解密。

下面是一个使用 ClassFinal-maven-plugin 进行代码混淆的示例配置，以及如何通过自定义类加载器实现 JAR 包内容加密的简要思路。

使用 ClassFinal-maven-plugin 进行代码混淆

首先，在你的 pom.xml 文件中添加 ClassFinal-maven-plugin 插件配置：

<build>  
    <plugins>  
        <plugin>  
            <groupId>net.roseboy</groupId>  
            <artifactId>classfinal-maven-plugin</artifactId>  
            <version>1.2.10</version> <!-- 请使用最新版本 -->  
            <executions>  
                <execution>  
                    <goals>  
                        <goal>classFinal</goal>  
                    </goals>  
                </execution>  
            </executions>  
            <configuration>  
                <!-- 配置参数，例如混淆级别等 -->  
                <password>your-password</password> <!-- 可选，用于加密混淆后的类文件 -->  
                <packages>  
                    <package>com.yourcompany.yourproject</package>  
                </packages>  
            </configuration>  
        </plugin>  
    </plugins>  
</build>

自定义类加载器实现 JAR 包内容加密

虽然 ClassFinal-maven-plugin 本身不提供直接的 JAR 包加密功能，但你可以通过以下步骤实现：

1. 加密 JAR 包内容：在构建 JAR 包之前，使用自定义脚本或工具对类文件进行加密。
2. 自定义类加载器：编写一个自定义类加载器，在加载类文件时先解密，然后再进行类定义。

加密 JAR 包内容

你可以使用任何对称或非对称加密算法对 JAR 包中的类文件进行加密。例如，使用 AES 对称加密算法：

import javax.crypto.Cipher;  
import javax.crypto.KeyGenerator;  
import javax.crypto.SecretKey;  
import javax.crypto.spec.SecretKeySpec;  
import java.io.*;  
import java.nio.file.*;  
import java.util.Base64;  
  
public class JarEncryptor {  
    private static final String ALGORITHM = "AES";  
  
    public static void encryptFile(File inputFile, File outputFile, SecretKey secretKey) throws Exception {  
        Cipher cipher = Cipher.getInstance(ALGORITHM);  
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);  
  
        try (FileInputStream fis = new FileInputStream(inputFile);  
             FileOutputStream fos = new FileOutputStream(outputFile);  
             CipherOutputStream cos = new CipherOutputStream(fos, cipher)) {  
  
            byte[] buffer = new byte[1024];  
            int bytesRead;  
            while ((bytesRead = fis.read(buffer)) != -1) {  
                cos.write(buffer, 0, bytesRead);  
            }  
        }  
    }  
  
    public static SecretKey generateKey() throws Exception {  
        KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);  
        keyGen.init(128); // 可以使用 192 或 256 位密钥，但需要相应的 Java 加密扩展 (JCE) 无限制权限策略文件  
        return keyGen.generateKey();  
    }  
  
    public static void main(String[] args) throws Exception {  
        // 生成密钥并保存到文件（实际应用中应安全存储密钥）  
        SecretKey secretKey = generateKey();  
        String keyStr = Base64.getEncoder().encodeToString(secretKey.getEncoded());  
        Files.write(Paths.get("secret.key"), keyStr.getBytes());  
  
        // 加密 JAR 包中的类文件（这里假设 JAR 包已解压）  
        File dir = new File("path/to/your/jar/contents");  
        for (File file : dir.listFiles((d, name) -> name.endsWith(".class"))) {  
            encryptFile(file, new File(dir, file.getName() + ".enc"), secretKey);  
        }  
  
        // 重新打包 JAR（这里需要额外的脚本或工具）  
    }  
}

自定义类加载器

编写一个自定义类加载器，在加载类文件时先解密：

import java.io.*;  
import java.nio.file.*;  
import javax.crypto.Cipher;  
import javax.crypto.spec.SecretKeySpec;  
  
public class EncryptedClassLoader extends ClassLoader {  
    private static final String ALGORITHM = "AES";  
    private final SecretKey secretKey;  
  
    public EncryptedClassLoader(SecretKey secretKey) {  
        this.secretKey = secretKey;  
    }  
  
    @Override  
    protected Class<?> findClass(String name) throws ClassNotFoundException {  
        try {  
            String fileName = name.replace('.', '/') + ".class.enc";  
            Path path = Paths.get("path/to/your/encrypted/jar/contents", fileName);  
  
            byte[] encryptedClassBytes = Files.readAllBytes(path);  
            byte[] decryptedClassBytes = decrypt(encryptedClassBytes);  
  
            return defineClass(name, decryptedClassBytes, 0, decryptedClassBytes.length);  
        } catch (IOException e) {  
            throw new ClassNotFoundException("Cannot find or decrypt class " + name, e);  
        }  
    }  
  
    private byte[] decrypt(byte[] encryptedBytes) throws Exception {  
        Cipher cipher = Cipher.getInstance(ALGORITHM);  
        cipher.init(Cipher.DECRYPT_MODE, secretKey);  
        return cipher.doFinal(encryptedBytes);  
    }  
  
    public static void main(String[] args) throws Exception {  
        // 从文件读取密钥  
        String keyStr = new String(Files.readAllBytes(Paths.get("secret.key")));  
        byte[] keyBytes = Base64.getDecoder().decode(keyStr);  
        SecretKey secretKey = new SecretKeySpec(keyBytes, 0, keyBytes.length, ALGORITHM);  
  
        // 使用自定义类加载器加载类  
        EncryptedClassLoader classLoader = new EncryptedClassLoader(secretKey);  
        Class<?> clazz = classLoader.loadClass("com.yourcompany.yourproject.YourClass");  
        // ... 使用加载的类  
    }  
}

注意事项

1. 密钥管理：确保密钥的安全存储和管理，不要硬编码在代码中。
2. 性能影响：加密和解密操作会对性能产生影响，特别是在类加载时。
3. 兼容性：确保加密和解密算法在目标平台上可用，并且与 Java 的类加载机制兼容。

通过上述方法，你可以在一定程度上保护 JAR 包的内容，但请注意，完全防止反编译和逆向工程是非常困难的。还可以参考网上教程：我不允许还有人不知道，SpringBoot的jar包如何防止他人反编译！_哔哩哔哩_bilibili