package com.tmri.sourcesafe;
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="key.data";
      byte rawKey[] = Util.readFile( keyFilename );
      DESKeySpec dks = new DESKeySpec( rawKey );
      SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( "DES" );
      SecretKey key = keyFactory.generateSecret( dks );
      DecryptStart test=new DecryptStart(key);
      String _args[]={"key.data","Foo","Bar","App"};
      test.test(_args);
  }

  public void test(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()
);
    }
  }
}