加密與解密
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：用密匙解密數據】 

    // 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.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() 
); 
    } 
  } 
}