最近在研究java class loading技术，已实现了一个自定义的加载器。对目前自定义加载器的应用，还在探讨中。下面是自定义的classloader在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();
}
}
}
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安全
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(); }}这样，我们就完成了类的加密解密。这个过程留给我们修改的空间还很多。我也在理解过程中。
总结
自定义的类加载器能够灵活的控制类的加载过程。从而可以实现一些我们所要的功能。
但是，即使是这样的加密技术，对于某些高手来说，依然是脆弱的。我们所需要做的就是，理解这其中的过程，掌握这样的技术，最终能够应用到我们自己的实际项目中来。
闽公网安备 35060202000074号