JAVA加密解密---自定义类加载器应用

JAVA安全

    JAVA是解释执行的语言，对于不同的操作平台都有相应的JVM对字节码文件进行解释执行。而这个字节码文件，也就是我们平时所看到的每一个.class文件。

    这是我们大家都知道的常识，也就是由.java文件，经过编译器编译，变成JVM所能解释的.class文件。

    而这个过程，在现在公开的网络技术中，利用一个反编译器，任何人都可以很容易的获取它的源文件。这对于很多人来说是不希望看到的。

    对于加密解密技术，我懂的不多，有些可以利用某种技术“模糊”JAVA类文件。这样能够使反编译的难度增加。但估计反编译器的技术水平也在不断提升，导致这种方法层层受阻。另外还有很多其他的技术也可以实现对JAVA文件的加密解密。我现在所想要研究的，就是其中的一种。

    JAVA的灵活性使反编译变得容易，同时，也让我们的加密解密的方法变得灵活。

利用自定义的CLASSLOADER

参照：http://www.blogjava.net/realsmy/archive/2007/04/18/111582.html

JAVA中的每一个类都是通过类加载器加载到内存中的。对于类加载器的工作流程如下表示：
1.searchfile() 
找到我所要加载的类文件。（抛除JAR包的概念，现在只是要加载一个.class文件）
2.loadDataClass()
读取这个类文件的字节码。
3.difineClass()
加载类文件。（加载的过程其实很复杂，我们现在先不研究它。）

    从这个过程中我们能很清楚的发现，自定义的类加载能够很轻松的控制每个类文件的加载过程。这样在第二步（loadDataClass）和第三步（difineClass）之间，我们将会有自己的空间灵活的控制这个过程。

我们加密解密的技术就应用到这里。

加密解密

    JAVA加密解密的技术有很多。JAVA自己提供了良好的类库对各种算法进行支持。对于采用哪种算法，网络上说法不一，自己去GOOGLE一下吧。

下面用DES对称加密算法（设定一个密钥，然后对所有的数据进行加密）来简单举个例子。

首先，生成一个密钥KEY。
我把它保存到key.txt中。这个文件就象是一把钥匙。谁拥有它，谁就能解开我们的类文件。代码参考如下：

package  com.neusoft.jiami;

import  java.io.File;
import  java.io.FileOutputStream;
import  java.security.SecureRandom;
import  javax.crypto.KeyGenerator;
import  javax.crypto.SecretKey;

class  Key  {

    private String keyName;

    public Key(String keyName) {
        this.keyName = keyName;
    }

    public void createKey(String keyName) throws Exception {

        // 创建一个可信任的随机数源，DES算法需要
        SecureRandom sr = new SecureRandom();
        // 用DES算法创建一个KeyGenerator对象
        KeyGenerator kg = KeyGenerator.getInstance("DES");
        // 初始化此密钥生成器,使其具有确定的密钥长度
        kg.init(sr);
        // 生成密匙
        SecretKey key = kg.generateKey();
        // 获取密钥数据
        byte rawKeyData[] = key.getEncoded();
        // 将获取到密钥数据保存到文件中，待解密时使用
        FileOutputStream fo = new FileOutputStream(new File(keyName));
        fo.write(rawKeyData);
    }

    public static void main(String args[]) {
        try {
            new Key("key.txt");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

第二步，对我们所要进行加密的类文件进行加密。

    比如我有一个DigestPass类，已经被正常编译好生成DigestPass.class文件。此时，这个类文件是任何人都可以用的。因为系统的类加载器可以自动的加载它。那么下一步，我们要做的就是把这个类文件加密。使系统的类加载器无法读取到正确的字节码文件。参考代码如下：

package  com.neusoft.jiami;

import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.security.SecureRandom;

import  javax.crypto.Cipher;
import  javax.crypto.SecretKey;
import  javax.crypto.SecretKeyFactory;
import  javax.crypto.spec.DESKeySpec;

public   class  JiaMi  {

    public static void main(String[] args) throws Exception {

        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();
        // 获得密匙数据
        FileInputStream fi = new FileInputStream(new File("key.txt"));
        byte rawKeyData[] = new byte[fi.available()];
        fi.read(rawKeyData);
        fi.close();
        // 从原始密匙数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(rawKeyData);
        // 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
        SecretKey key = SecretKeyFactory.getInstance("DES").generateSecret(dks);
        // Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance("DES");
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, key, sr);
        // 现在，获取要加密的文件数据
        FileInputStream fi2 = new FileInputStream(new File("DigestPass.class"));
        byte data[] = new byte[fi2.available()];
        fi2.read(data);
        fi2.close();
        // 正式执行加密操作
        byte encryptedData[] = cipher.doFinal(data);
        // 用加密后的数据覆盖原文件
        FileOutputStream fo = new FileOutputStream(new File("DigestPass.class"));
        fo.write(encryptedData);
        fo.close();
    }
}

第三步，用自定义的CLASSLOADER进行加载。参考代码如下：

package  com.neusoft.jiami;

import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.security.SecureRandom;

import  javax.crypto.Cipher;
import  javax.crypto.SecretKey;
import  javax.crypto.SecretKeyFactory;
import  javax.crypto.spec.DESKeySpec;
import  com.neusoft.classloader.MyClassLoader;

public   class  JieMi  {

    public static void main(String[] args) throws Exception {

        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();
        // 获得密匙数据
        FileInputStream fi = new FileInputStream(new File("key.txt"));
        byte rawKeyData[] = new byte[fi.available()];// = new byte[5];
        fi.read(rawKeyData);
        fi.close();
        // 从原始密匙数据创建一个DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(rawKeyData);
        // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成一个SecretKey对象
        SecretKey key = SecretKeyFactory.getInstance("DES").generateSecret(dks);
        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance("DES");
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, key, sr);
        // 现在，获取数据并解密
        FileInputStream fi2 = new FileInputStream(new File("DigestPass.class"));
        byte encryptedData[] = new byte[fi2.available()];
        fi2.read(encryptedData);
        fi2.close();
        // 正式执行解密操作
        byte decryptedData[] = cipher.doFinal(encryptedData);
        // 这时把数据还原成原有的类文件
        // FileOutputStream fo = new FileOutputStream(new
        // File("DigestPass.class"));
        // fo.write(decryptedData);
        // 用解密后的数据加载类并应用
        MyClassloader mcl = new MyClassloader("E:/");
        Class cl = mcl.loadClass(decryptedData, "com.neusoft.jiami.DigestPass");
        DigestPass dp = cl.newInstance();
    }
}

这样，我们就完成了类的加密解密。这个过程留给我们修改的空间还很多。我也在理解过程中。

总结

自定义的类加载器能够灵活的控制类的加载过程。从而可以实现一些我们所要的功能。

     但是，即使是这样的加密技术，对于某些高手来说，依然是脆弱的。我们所需要做的就是，理解这其中的过程，掌握这样的技术，最终能够应用到我们自己的实际项目中来。

一、java实现DES加密算法
为了实现一对密钥对整个项目所有加密解密文件都适用的方法,采用先生成一对密钥.保存到xml文件中,以后获得私匙和公钥只需要从xml文件中取得就可以了.
/**
* 把成生的一对密钥保存到DesKey.xml文件中
*/
public static void saveDesKey(){     
    try {
        SecureRandom sr = new SecureRandom();
        //为我们选择的DES算法生成一个KeyGenerator对象
        KeyGenerator kg = KeyGenerator.getInstance ("DES" );
        kg.init (sr);
        FileOutputStream fos = new FileOutputStream("C:/DesKey.xml");
      ObjectOutputStream oos = new ObjectOutputStream(fos);
        //生成密钥
        Key key = kg.generateKey();
      oos.writeObject(key);
      oos.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
}




获取密钥方法如下:

/**
* 获得DES加密的密钥。在交易处理的过程中应该定时更
* 换密钥。需要JCE的支持，如果jdk版本低于1.4，则需要
* 安装jce-1_2_2才能正常使用。
* @return   Key 返回对称密钥
*/
    public static Key getKey() {
        Key kp = null;
        try {
              String fileName = "conf/DesKey.xml";
              InputStream is = DesUtil.class.getClassLoader()
                      .getResourceAsStream(fileName);
              ObjectInputStream oos = new ObjectInputStream(is);
              kp = (Key) oos.readObject();
              oos.close();
        } catch (Exception e) {
              e.printStackTrace();
        }
        return kp;
    }


文件采用DES算法加密文件

/**
* 文件file进行加密并保存目标文件destFile中

* @param file
*         要加密的文件 如c:/test/srcFile.txt
* @param destFile
*         加密后存放的文件名 如c:/加密后文件.txt
*/

public static void encrypt(String file, String destFile) throws Exception {

        Cipher cipher = Cipher.getInstance("DES");

        cipher.init(Cipher.ENCRYPT_MODE, getKey());

        InputStream is = new FileInputStream(file);

        OutputStream out = new FileOutputStream(dest);

        CipherInputStream cis = new CipherInputStream(is, cipher);

        byte[] buffer = new byte[1024];

        int r;

        while ((r = cis.read(buffer)) > 0) {

              out.write(buffer, 0, r);

        }

        cis.close();

        is.close();

        out.close();

    }


文件采用DES算法解密文件


/**
* 文件file进行加密并保存目标文件destFile中

* @param file
*         已加密的文件 如c:/加密后文件.txt
* @param destFile
*         解密后存放的文件名 如c:/ test/解密后文件.txt
*/

public static void decrypt(String file, String dest) throws Exception {
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(Cipher.DECRYPT_MODE, getKey());
        InputStream is = new FileInputStream(file);
        OutputStream out = new FileOutputStream(dest);
        CipherOutputStream cos = new CipherOutputStream(out, cipher);
        byte[] buffer = new byte[1024];
        int r;
        while ((r = is.read(buffer)) >= 0) {
              cos.write(buffer, 0, r);
        }
        cos.close();
        out.close();
        is.close();
    }