Java代碼加密與反編譯（二）：用加密算法DES修改classLoader實現對.class文件加密

二、利用加密算法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 print ?

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 print ?

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 print ?

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 print ?

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");  
40.     SecretKey key = keyFactory.generateSecret(dks);  
41.   
42.     // 創建解密的ClassLoader  
43.     DecryptStart dr = new DecryptStart(key);  
44.   
45.     // 創建應用主類的一個實例，通過ClassLoader裝入它  
46.     System.err.println("[DecryptStart: loading "+appName+"]");  
47.     Class clasz = dr.loadClass(appName);  
48.   
49.     // 最后通過Reflection API調用應用實例  
50.     // 的main()方法  
51.   
52.     // 獲取一個對main()的引用  
53.     String proto[] = new String[1];  
54.     Class mainArgs[] = { (new String[1]).getClass() };  
55.     Method main = clasz.getMethod("main", mainArgs);  
56.   
57.     // 創建一個包含main()方法參數的數組  
58.     Object argsArray[] = { realArgs };  
59.     System.err.println("[DecryptStart: running "+appName+".main()]");  
60.   
61.     // 調用main()  
62.     main.invoke(null, argsArray);  
63.   }  
64.   
65.   public Class loadClass(String name, boolean resolve) throws ClassNotFoundException {  
66.     try {  
67.       // 要創建的Class對象  
68.       Class clasz = null;  
69.   
70.       // 必需的步驟1：如果類已經在系統緩沖之中，不必再次裝入它  
71.       clasz = findLoadedClass(name);  
72.   
73.       if (clasz != null)  
74.           return clasz;  
75.   
76.       // 下面是定制部分  
77.       try{  
78.           //讀取經過加密的類文件  
79.           byte classData[] = Util.readFile(name+".class");  
80.           if(classData != null){  
81.             byte decryptedClassData[] = cipher.doFinal(classData);  //解密  
82.               clasz = defineClass( name, decryptedClassData, 0, decryptedClassData.length); // 再把它轉換成一個類  
83.               System.err.println( "[DecryptStart: decrypting class "+name+"]");  
84.          }                  
85.       }catch(FileNotFoundException fnfe){  
86.             
87.       }  
88.   
89.       // 必需的步驟2：如果上面沒有成功  
90.       // 嘗試用默認的ClassLoader裝入它  
91.       if (clasz == null)  
92.           clasz = findSystemClass(name);          
93.   
94.       // 必需的步驟3：如有必要，則裝入相關的類  
95.       if (resolve && clasz != null)  
96.           resolveClass(clasz);          
97.         
98.       return clasz;//把類返回給調用者  
99.         
100.     } catch(IOException ie) {  
101.           throw new ClassNotFoundException(ie.toString());  
102.     } catch(GeneralSecurityException gse) {  
103.           throw new ClassNotFoundException( gse.toString());  
104.     }  
105.   }  
106. }  

step4:運行加密程序。

1.新建java項目，把上面三個.java程序和需要加密的程序.java都放在同一個src目錄下，然后在eclipse里構建項目，把所有的.java文件在bin目錄下生成.class文件。這里我需要加密jar包里有三個程序：SplitAddress.java、IPSeeker.java、IPEntity.java。

 

2.然后在命令行里，cd到bin目錄下啟動程序：

[plain]  view plain copy print ?

1. java com.javacode.GenerateKeykey.data  

這樣就在bin下生成了key.data文件。

 

3.把bin\com\javacode\下的待加密的SplitAddress.class、IPSeeker.class、IPEntity.class拷貝到bin目錄下。然后bin目錄下命令行啟動：

[plain]  view plain copy print ?

1. java com.javacode.EncryptClasseskey.data SplitAddress.class IPSeeker.class IPEntity.class  

該命令把每個.class文件替換成其各自的加密版本。

（注意：加密版本為bin目錄下的.class文件，未加密版本為bin\com\javacode\下的.class文件）

 

4.運行經過加密的應用。

 

對於未經加密的應用（cd到bin\com\javacode\），正常執行方式如下：

[plain]  view plain copy print ?

1. java IPSeeker arg0 arg1 arg2  

對於經過加密的應用（cd到bin\），則相應的運行方式為：

[plain]  view plain copy print ?

1. java DecryptStart key.data IPSeeker arg0 arg1 arg2  

step5:驗證

(1) 未加密的可以直接用反編譯工具jd-gui查看到源碼：

(2) 經過加密的用反編譯工具無法查看：

step6:一些說明

雖然應用本身經過了加密，但啟動程序DecryptStart沒有加密。攻擊者可以反編譯啟動程序並修改它，把解密后的類文件保存到磁盤。解決方法是對啟動程序進行高質量模糊處理。或者可以采用直接編譯成機器語言的代碼，使得啟動程序具有傳統執行文件格式的安全性。

另外大多數JVM本身並不安全，還可以修改JVM，從ClassLoader之外獲取解密后的代碼並保存到磁盤，從而繞過上述加密所做的一切工作。

不過所有這些可能的攻擊都有一個前提，這就是攻擊者可以得到密匙。如果沒有密匙，應用的安全性就完全取決於加密算法的安全性。