一、為什麼要加密?
對于傳統的C或C++之類的語言來說，要在Web上保護源代碼是很容易的，隻要不釋出它就可以。遺憾的是，Java程式的源代碼很容易被别人偷看。隻要有一個反編譯器，任何人都可以分析别人的代碼。Java的靈活性使得源代碼很容易被竊取，但與此同時，它也使通過加密保護代碼變得相對容易，我們唯一需要了解的就是Java的ClassLoader對象。當然，在加密過程中，有關Java Cryptography Extension(JCE)的知識也是必不可少的。
有幾種技術可以“模糊”Java類檔案，使得反編譯器處理類檔案的效果大打折扣。然而，修改反編譯器使之能夠處理這些經過模糊處理的類檔案并不是什麼難事，是以不能簡單地依賴模糊技術來保證源代碼的安全。
我們可以用流行的加密工具加密應用，比如PGP(Pretty Good Privacy)或GPG(GNU Privacy Guard)。這時，最終使用者在運作應用之前必須先進行解密。但解密之後，最終使用者就有了一份不加密的類檔案，這和事先不進行加密沒有什麼差别。
Java運作時裝入位元組碼的機制隐含地意味着可以對位元組碼進行修改。JVM每次裝入類檔案時都需要一個稱為ClassLoader的對象，這個對象負責把新的類裝入正在運作的JVM。JVM給ClassLoader一個包含了待裝入類(比如java.lang.Object)名字的字元串，然後由ClassLoader負責找到類檔案，裝入原始資料，并把它轉換成一個Class對象。
我們可以通過定制ClassLoader，在類檔案執行之前修改它。這種技術的應用非常廣泛??在這裡，它的用途是在類檔案裝入之時進行解密，是以可以看成是一種即時解密器。由于解密後的位元組碼檔案永遠不會儲存到檔案系統，是以竊密者很難得到解密後的代碼。
由于把原始位元組碼轉換成Class對象的過程完全由系統負責，是以建立定制ClassLoader對象其實并不困難，隻需先獲得原始資料，接着就可以進行包含解密在内的任何轉換。
Java 2在一定程度上簡化了定制ClassLoader的建構。在Java 2中，loadClass的預設實作仍舊負責處理所有必需的步驟，但為了顧及各種定制的類裝入過程，它還調用一個新的findClass方法。
這為我們編寫定制的ClassLoader提供了一條捷徑，減少了麻煩：隻需覆寫findClass，而不是覆寫loadClass。這種方法避免了重複所有裝入器必需執行的公共步驟，因為這一切由loadClass負責。
不過，本文的定制ClassLoader并不使用這種方法。原因很簡單。如果由預設的ClassLoader先尋找經過加密的類檔案，它可以找到;但由于類檔案已經加密，是以它不會認可這個類檔案，裝入過程将失敗。是以，我們必須自己實作loadClass，稍微增加了一些工作量。
二、定制類裝入器
每一個運作着的JVM已經擁有一個ClassLoader。這個預設的ClassLoader根據CLASSPATH環境變量的值，在本地檔案系統中尋找合适的位元組碼檔案。
應用定制ClassLoader要求對這個過程有較為深入的認識。我們首先必須建立一個定制ClassLoader類的執行個體，然後顯式地要求它裝入另外一個類。這就強制JVM把該類以及所有它所需要的類關聯到定制的ClassLoader。Listing 1顯示了如何用定制ClassLoader裝入類檔案。
【Listing 1：利用定制的ClassLoader裝入類檔案】
// 首先建立一個ClassLoader對象
ClassLoader myClassLoader = new myClassLoader();
// 利用定制ClassLoader對象裝入類檔案
// 并把它轉換成Class對象
Class myClass = myClassLoader.loadClass( "mypackage.MyClass" );
// 最後，建立該類的一個執行個體
Object newInstance = myClass.newInstance();
// 注意，MyClass所需要的所有其他類，都将通過
// 定制的ClassLoader自動裝入
如前所述，定制ClassLoader隻需先擷取類檔案的資料，然後把位元組碼傳遞給運作時系統，由後者完成餘下的任務。
ClassLoader有幾個重要的方法。建立定制的ClassLoader時，我們隻需覆寫其中的一個，即loadClass，提供擷取原始類檔案資料的代碼。這個方法有兩個參數：類的名字，以及一個表示JVM是否要求解析類名字的标記(即是否同時裝入有依賴關系的類)。如果這個标記是true，我們隻需在傳回JVM之前調用resolveClass。
【Listing 2：ClassLoader.loadClass()的一個簡單實作】
public Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
try {
// 我們要建立的Class對象
Class clasz = null;
// 必需的步驟1：如果類已經在系統緩沖之中，
// 我們不必再次裝入它
clasz = findLoadedClass( name );
if (clasz != null)
return clasz;
// 下面是定制部分
byte classData[] = /* 通過某種方法擷取位元組碼資料 */;
if (classData != null) {
// 成功讀取位元組碼資料，現在把它轉換成一個Class對象
clasz = defineClass( name, classData, 0, classData.length );
}
// 必需的步驟2：如果上面沒有成功，
// 我們嘗試用預設的ClassLoader裝入它
if (clasz == null)
clasz = findSystemClass( name );
// 必需的步驟3：如有必要，則裝入相關的類
if (resolve && clasz != null)
resolveClass( clasz );
// 把類傳回給調用者
} catch(IOException ie) {
throw new ClassNotFoundException(ie.toString());
} catch(GeneralSecurityException gse) {
throw new ClassNotFoundException(gse.toString());
}
}
Listing 2顯示了一個簡單的loadClass實作。代碼中的大部分對所有ClassLoader對象來說都一樣，但有一小部分(已認證注釋标記)是特有的。在處理過程中，ClassLoader對象要用到其他幾個輔助方法：
findLoadedClass：用來進行檢查，以便确認被請求的類目前還不存在。loadClass方法應該首先調用它。
defineClass：獲得原始類檔案位元組碼資料之後，調用defineClass把它轉換成一個Class對象。任何loadClass實作都必須調用這個方法。
findSystemClass：提供預設ClassLoader的支援。如果用來尋找類的定制方法不能找到指定的類(或者有意地不用定制方法)，則可以調用該方法嘗試預設的裝入方式。這是很有用的，特别是從普通的JAR檔案裝入标準Java類時。
resolveClass：當JVM想要裝入的不僅包括指定的類，而且還包括該類引用的所有其他類時，它會把loadClass的resolve參數設定成true。這時，我們必須在傳回剛剛裝入的Class對象給調用者之前調用resolveClass。
三、加密、解密
Java加密擴充即Java Cryptography Extension，簡稱JCE。它是Sun的加密服務軟體，包含了加密和密匙生成功能。JCE是JCA(Java Cryptography Architecture)的一種擴充。
JCE沒有規定具體的加密算法，但提供了一個架構，加密算法的具體實作可以作為服務提供者加入。除了JCE架構之外，JCE軟體包還包含了SunJCE服務提供者，其中包括許多有用的加密算法，比如DES(Data Encryption Standard)和Blowfish。
為簡單計，在本文中我們将用DES算法加密和解密位元組碼。下面是用JCE加密和解密資料必須遵循的基本步驟：
步驟1：生成一個安全密匙。在加密或解密任何資料之前需要有一個密匙。密匙是随同被加密的應用一起釋出的一小段資料，Listing 3顯示了如何生成一個密匙。
【Listing 3：生成一個密匙】
// DES算法要求有一個可信任的随機數源
SecureRandom sr = new SecureRandom();
// 為我們選擇的DES算法生成一個KeyGenerator對象
KeyGenerator kg = KeyGenerator.getInstance( "DES" );
kg.init( sr );
// 生成密匙
SecretKey key = kg.generateKey();
// 擷取密匙資料
byte rawKeyData[] = key.getEncoded();
/* 接下來就可以用密匙進行加密或解密，或者把它儲存
為檔案供以後使用 */
doSomething( rawKeyData );
步驟2：加密資料。得到密匙之後，接下來就可以用它加密資料。除了解密的ClassLoader之外，一般還要有一個加密待釋出應用的獨立程式(見Listing 4)。
【Listing 4：用密匙加密原始資料】
// DES算法要求有一個可信任的随機數源
SecureRandom sr = new SecureRandom();
byte rawKeyData[] = /* 用某種方法獲得密匙資料 */;
// 從原始密匙資料建立DESKeySpec對象
DESKeySpec dks = new DESKeySpec( rawKeyData );
// 建立一個密匙工廠，然後用它把DESKeySpec轉換成
// 一個SecretKey對象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( "DES" );
SecretKey key = keyFactory.generateSecret( dks );
// Cipher對象實際完成加密操作
Cipher cipher = Cipher.getInstance( "DES" );
// 用密匙初始化Cipher對象
cipher.init( Cipher.ENCRYPT_MODE, key, sr );
// 現在，擷取資料并加密
byte data[] = /* 用某種方法擷取資料 */
// 正式執行加密操作
byte encryptedData[] = cipher.doFinal( data );
// 進一步處理加密後的資料
doSomething( encryptedData );
步驟3：解密資料。運作經過加密的應用時，ClassLoader分析并解密類檔案。操作步驟如Listing 5所示。
【Listing 5：用密匙解密資料】
byte rawKeyData[] = /* 用某種方法擷取原始密匙資料 */;
// 從原始密匙資料建立一個DESKeySpec對象
// 建立一個密匙工廠，然後用它把DESKeySpec對象轉換成
// Cipher對象實際完成解密操作
cipher.init( Cipher.DECRYPT_MODE, key, sr );
// 現在，擷取資料并解密
byte encryptedData[] = /* 獲得經過加密的資料 */
// 正式執行解密操作
byte decryptedData[] = cipher.doFinal( encryptedData );
// 進一步處了解密後的資料
doSomething( decryptedData );
四、應用執行個體
前面介紹了如何加密和解密資料。要部署一個經過加密的應用，步驟如下：
步驟1：建立應用。我們的例子包含一個App主類，兩個輔助類(分别稱為Foo和Bar)。這個應用沒有什麼實際功用，但隻要我們能夠加密這個應用，加密其他應用也就不在話下。
步驟2：生成一個安全密匙。在指令行，利用GenerateKey工具(參見GenerateKey.java)把密匙寫入一個檔案： % java GenerateKey key.data
步驟3：加密應用。在指令行，利用EncryptClasses工具(參見EncryptClasses.java)加密應用的類： % java EncryptClasses key.data App.class Foo.class Bar.class
該指令把每一個.class檔案替換成它們各自的加密版本。
步驟4：運作經過加密的應用。使用者通過一個DecryptStart程式運作經過加密的應用。DecryptStart程式如Listing 6所示。
【Listing 6：DecryptStart.java，啟動被加密應用的程式】
import java.io.*;
import java.security.*;
import java.lang.reflect.*;
import javax.crypto.*;
import javax.crypto.spec.*;
public class DecryptStart extends ClassLoader {
// 這些對象在構造函數中設定，
// 以後loadClass()方法将利用它們解密類
private SecretKey key;
private Cipher cipher;
// 構造函數：設定解密所需要的對象
public DecryptStart(SecretKey key) throws GeneralSecurityException, IOException {
this.key = key;
String algorithm = "DES";
SecureRandom sr = new SecureRandom();
System.err.println("[DecryptStart: creating cipher]");
cipher = Cipher.getInstance(algorithm);
cipher.init(Cipher.DECRYPT_MODE, key, sr);
// main過程：我們要在這裡讀入密匙，建立DecryptStart的
// 執行個體，它就是我們的定制ClassLoader。
// 設定好ClassLoader以後，我們用它裝入應用執行個體，
// 最後，我們通過Java Reflection API調用應用執行個體的main方法
static public void main(String args[]) throws Exception {
String keyFilename = args[0];
String appName = args[1];
// 這些是傳遞給應用本身的參數
String realArgs[] = new String[args.length - 2];
System.arraycopy(args, 2, realArgs, 0, args.length - 2);
// 讀取密匙
System.err.println("[DecryptStart: reading key]");
byte rawKey[] = Util.readFile(keyFilename);
DESKeySpec dks = new DESKeySpec(rawKey);
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey key = keyFactory.generateSecret(dks);
// 建立解密的ClassLoader
DecryptStart dr = new DecryptStart(key);
// 建立應用主類的一個執行個體
// 通過ClassLoader裝入它
System.err.println("[DecryptStart: loading " + appName + "]");
Class clasz = dr.loadClass(appName);
// 最後，通過Reflection API調用應用執行個體
// 的main()方法
// 擷取一個對main()的引用
String proto[] = new String[1];
Class mainArgs[] = { (new String[1]).getClass() };
Method main = clasz.getMethod("main", mainArgs);
// 建立一個包含main()方法參數的數組
Object argsArray[] = { realArgs };
System.err.println("[DecryptStart: running " + appName + ".main()]");
// 調用main()
main.invoke(null, argsArray);
public Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
try {
// 我們要建立的Class對象
Class clasz = null;
// 必需的步驟1：如果類已經在系統緩沖之中
// 我們不必再次裝入它
clasz = findLoadedClass(name);
if (clasz != null)
return clasz;
// 下面是定制部分
try {
// 讀取經過加密的類檔案
byte classData[] = Util.readFile(name + ".class");
if (classData != null) {
// 解密
byte decryptedClassData[] = cipher.doFinal(classData);
//
再把它轉換成一個類
clasz = defineClass(name, decryptedClassData, 0, decryptedClassData.length);
System.err.println("[DecryptStart: decrypting class " + name + "]");
}
} catch (FileNotFoundException fnfe) {
// 必需的步驟2：如果上面沒有成功
// 我們嘗試用預設的ClassLoader裝入它
if (clasz == null)
clasz = findSystemClass(name);
// 必需的步驟3：如有必要，則裝入相關的類
if (resolve && clasz != null)
resolveClass(clasz);
// 把類傳回給調用者
}
return clasz;
} catch (IOException ie) {
throw new ClassNotFoundException(ie.toString());
} catch (GeneralSecurityException gse) {
throw new ClassNotFoundException(gse.toString());
}
}
對于未經加密的應用，正常執行方式如下： % java App arg0 arg1 arg2
對于經過加密的應用，則相應的運作方式為： % java DecryptStart key.data App arg0 arg1 arg2
DecryptStart有兩個目的。一個DecryptStart的執行個體就是一個實施即時解密操作的定制ClassLoader;同時，DecryptStart還包含一個main過程，它建立解密器執行個體并用它裝入和運作應用。示例應用App的代碼包含在App.java、Foo.java和Bar.java内。Util.java是一個檔案I/O工具，本文示例多處用到了它。完整的代碼請從本文最後下載下傳。
五、注意事項
我們看到，要在不修改源代碼的情況下加密一個Java應用是很容易的。不過，世上沒有完全安全的系統。本文的加密方式提供了一定程度的源代碼保護，但對某些攻擊來說它是脆弱的。
雖然應用本身經過了加密，但啟動程式DecryptStart沒有加密。攻擊者可以反編譯啟動程式并修改它，把解密後的類檔案儲存到磁盤。降低這種風險的辦法之一是對啟動程式進行高品質的模糊處理。或者，啟動程式也可以采用直接編譯成機器語言的代碼，使得啟動程式具有傳統執行檔案格式的安全性。
另外還要記住的是，大多數JVM本身并不安全。狡猾的黑客可能會修改JVM，從ClassLoader之外擷取解密後的代碼并儲存到磁盤，進而繞過本文的加密技術。Java沒有為此提供真正有效的補救措施。
不過應該指出的是，所有這些可能的攻擊都有一個前提，這就是攻擊者可以得到密匙。如果沒有密匙，應用的安全性就完全取決于加密算法的安全性。雖然這種保護代碼的方法稱不上十全十美，但它仍不失為一種保護知識産權和敏感使用者資料的有效方案。
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)