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

2、利用加密算法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:

import java.io.*;

public class Util
{
  // 把文件讀入byte數組
  static public byte[] readFile(String filename) throws IOException {
    File file = new File(filename);
    long len = file.length();
    byte data[] = new byte[(int)len];
    FileInputStream fin = new FileInputStream(file);
    int r = fin.read(data);
    if (r != len)
      throw new IOException("Only read "+r+" of "+len+" for "+file);
    fin.close();
    return data;
  }

  // 把byte數組寫出到文件
  static public void writeFile(String filename, byte data[]) throws IOException {
    FileOutputStream fout = new FileOutputStream(filename);
    fout.write(data);
    fout.close();
  }
}

GenerateKey.java:

import java.security.SecureRandom;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

public class GenerateKey
{
  static public void main(String args[]) throws Exception {
    String keyFilename = args[0];
    String algorithm = "DES";

    // 生成密匙
    SecureRandom sr = new SecureRandom();
    KeyGenerator kg = KeyGenerator.getInstance(algorithm);
    kg.init(sr);
    SecretKey key = kg.generateKey();

    // 把密匙數據保存到文件
    Util.writeFile(keyFilename, key.getEncoded());
  }
}

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

獲得密匙以後，接下來就能夠用它加密數據。除了解密的ClassLoader以外，通常還要有一個加密待發布應用的獨立程序：

EncryptClasses.java:

import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;

public class EncryptClasses
{
  static public void main(String args[]) throws Exception {
    String keyFilename = args[0];
    String algorithm = "DES";

    // 生成密匙
    SecureRandom sr = new SecureRandom();
    byte rawKey[] = Util.readFile(keyFilename);
    DESKeySpec dks = new DESKeySpec(rawKey);
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( algorithm );
    SecretKey key = keyFactory.generateSecret(dks);

    // 建立用於實際加密操做的Cipher對象
    Cipher ecipher = Cipher.getInstance(algorithm);
    ecipher.init(Cipher.ENCRYPT_MODE, key, sr);

    // 加密命令行中指定的每個類
    for (int i=1; i<args.length; ++i) {
      String filename = args[i];
      byte classData[] = Util.readFile(filename);  //讀入類文件
      byte encryptedClassData[] = ecipher.doFinal(classData);  //加密
      Util.writeFile(filename, encryptedClassData);  // 保存加密後的內容
      System.out.println("Encrypted "+filename);
    }
  }
}

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

編譯以後用命令行啓動程序，下面是源碼：

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方法
  public static 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());
    }
  }
}

step4:運行加密程序。

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

 

2.而後在命令行裏，cd到bin目錄下啓動程序：

java com.javacode.GenerateKeykey.data

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

 

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

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

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

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

 

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

 

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

java IPSeeker arg0 arg1 arg2

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

java DecryptStart key.data IPSeeker arg0 arg1 arg2

step5:驗證

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

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

step6:一些說明

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

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

不過全部這些可能的攻擊都有一個前提，這就是攻擊者能夠獲得密匙。若是沒有密匙，應用的安全性就徹底取決於加密算法的安全性。