Java代码加密与反编译（二） 用加密算法DES修改classLoader实现对 class文件加密

分享一下我老师大神的人工智能教程。零基础！通俗易懂！风趣幽默！还带黄段子！希望你也加入到我们人工智能的队伍中来！https://blog.csdn.net/jiangjunshow

               

二、利用加密算法DES实现java代码加密

        传统的C/C++自动带有保护机制，但java不同，只要使用反编译工具，代码很容易被暴露，这里需要了解的就是Java的ClassLoader对象。

       Java运行时装入字节码的机制隐含地意味着可以对字节码进行修改。JVM每次装入类文件时都需要一个称为ClassLoader的对象，这个对象负责把新的类装入正在运行的JVM。JVM给ClassLoader一个包含了待装入类（比如java.lang.Object）名字的字符串，然后由ClassLoader负责找到类文件，装入原始数据，并把它转换成一个Class对象。可以通过定制ClassLoader，在类文件执行之前修改它。在这里，它的用途是在类文件装入之时进行解密，因此可以看成是一种即时解密器。由于解密后的字节码文件永远不会保存到文件系统，所以窃密者很难得到解密后的代码。

    创建定制ClassLoader对象：只需先获得原始数据，接着就可以进行包含解密在内的任何转换。这里我们可以自己实现loadClass。

制定类装入器：

每一个运行着的JVM已经拥有一个ClassLoader。这个默认的ClassLoader根据CLASSPATH环境变量的值，在本地文件系统中寻找合适的字节码文件。

首先创建一个定制ClassLoader类的实例，然后显式地要求它装入另外一个类。这就强制JVM把该类以及所有它所需要的类关联到定制的ClassLoader。

step1：生成一个安全秘钥。

在加密或解密任何数据之前需要有一个密匙。密匙是随同被加密的应用一起发布的一小段数据。生成过后的秘钥为key.data。

Util.java:

[java]  view plain copy

1. import java.io.*;  
2.   
3. public class Util  
4. {  
5.   // 把文件读入byte数组  
6.   static public byte[] readFile(String filename) throws IOException {  
7.     File file = new File(filename);  
8.     long len = file.length();  
9.     byte data[] = new byte[(int)len];  
10.     FileInputStream fin = new FileInputStream(file);  
11.     int r = fin.read(data);  
12.     if (r != len)  
13.       throw new IOException("Only read "+r+" of "+len+" for "+file);  
14.     fin.close();  
15.     return data;  
16.   }  
17.   
18.   // 把byte数组写出到文件  
19.   static public void writeFile(String filename, byte data[]) throws IOException {  
20.     FileOutputStream fout = new FileOutputStream(filename);  
21.     fout.write(data);  
22.     fout.close();  
23.   }  
24. }  

GenerateKey.java:

[java]  view plain copy

1. import java.security.SecureRandom;  
2. import javax.crypto.KeyGenerator;  
3. import javax.crypto.SecretKey;  
4.   
5. public class GenerateKey  
6. {  
7.   static public void main(String args[]) throws Exception {  
8.     String keyFilename = args[0];  
9.     String algorithm = "DES";  
10.   
11.     // 生成密匙  
12.     SecureRandom sr = new SecureRandom();  
13.     KeyGenerator kg = KeyGenerator.getInstance(algorithm);  
14.     kg.init(sr);  
15.     SecretKey key = kg.generateKey();  
16.   
17.     // 把密匙数据保存到文件  
18.     Util.writeFile(keyFilename, key.getEncoded());  
19.   }  
20. }  

step2：加密待加密的.class文件。

得到密匙之后，接下来就可以用它加密数据。除了解密的ClassLoader之外，一般还要有一个加密待发布应用的独立程序：

EncryptClasses.java:

[java]  view plain copy

1. import java.security.*;  
2. import javax.crypto.*;  
3. import javax.crypto.spec.*;  
4.   
5. public class EncryptClasses  
6. {  
7.   static public void main(String args[]) throws Exception {  
8.     String keyFilename = args[0];  
9.     String algorithm = "DES";  
10.   
11.     // 生成密匙  
12.     SecureRandom sr = new SecureRandom();  
13.     byte rawKey[] = Util.readFile(keyFilename);  
14.     DESKeySpec dks = new DESKeySpec(rawKey);  
15.     SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( algorithm );  
16.     SecretKey key = keyFactory.generateSecret(dks);  
17.   
18.     // 创建用于实际加密操作的Cipher对象  
19.     Cipher ecipher = Cipher.getInstance(algorithm);  
20.     ecipher.init(Cipher.ENCRYPT_MODE, key, sr);  
21.   
22.     // 加密命令行中指定的每一个类  
23.     for (int i=1; i<args.length; ++i) {  
24.       String filename = args[i];  
25.       byte classData[] = Util.readFile(filename);  //读入类文件  
26.       byte encryptedClassData[] = ecipher.doFinal(classData);  //加密  
27.       Util.writeFile(filename, encryptedClassData);  // 保存加密后的内容  
28.       System.out.println("Encrypted "+filename);  
29.     }  
30.   }  
31. }  

step3：加密待加密的.class文件。

编译之后用命令行启动程序，下面是源码：

DecryptStart.java:

[java]  view plain copy

1. import java.io.*;  
2. import java.security.*;  
3. import java.lang.reflect.*;  
4. import javax.crypto.*;  
5. import javax.crypto.spec.*;  
6.   
7. public class DecryptStart extends ClassLoader  
8. {  
9.   // 这些对象在构造函数中设置，以后loadClass()方法将利用它们解密类  
10.   private SecretKey key;  
11.   private Cipher cipher;  
12.   
13.   // 构造函数：设置解密所需要的对象  
14.   public DecryptStart(SecretKey key) throws GeneralSecurityException, IOException {  
15.     this.key = key;  
16.   
17.     String algorithm = "DES";  
18.     SecureRandom sr = new SecureRandom();  
19.     System.err.println("[DecryptStart: creating cipher]");  
20.     cipher = Cipher.getInstance(algorithm);  
21.     cipher.init(Cipher.DECRYPT_MODE, key, sr);  
22.   }  
23.   
24.   // main过程：在这里读入密匙，创建DecryptStart的实例，它就是定制ClassLoader。  
25.   // 设置好ClassLoader以后，用它装入应用实例，  
26.   // 最后，通过Java Reflection API调用应用实例的main方法  
27.   public static void main(String args[]) throws Exception {  
28.     String keyFilename = args[0];  
29.     String appName = args[1];  
30.   
31.     // 传递给应用本身的参数  
32.     String realArgs[] = new String[args.length-2];  
33.     System.arraycopy( args, 2, realArgs, 0, args.length-2 );  
34.   
35.     // 读取密匙  
36.     System.err.println( "[DecryptStart: reading key]" );  
37.     byte rawKey[] = Util.readFile(keyFilename);  
38.     DESKeySpec dks = new DESKeySpec(rawKey);  
39.     SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");