利用DES加密算法保护JAVA源代码
des加密算法java代码
des加密算法java代码1、DES加密算法Java实现（1）导入所需要的包：import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;（2）定义加密算法：public class DesEncrypter {Cipher ecipher;Cipher dcipher;public DesEncrypter(String passPhrase) {try {// Create the keyDESKeySpec keySpec = newDESKeySpec(passPhrase.getBytes('UTF8'));SecretKeyFactory keyFactory =SecretKeyFactory.getInstance('DES');SecretKey key = keyFactory.generateSecret(keySpec); // Create the cipherecipher = Cipher.getInstance('DES');dcipher = Cipher.getInstance('DES');// Initialize the cipher for encryptionecipher.init(Cipher.ENCRYPT_MODE, key);// Initialize the same cipher for decryption dcipher.init(Cipher.DECRYPT_MODE, key);} catch (Exception e) {}}（3）定义加密函数：public String encrypt(String str) {try {// Encode the string into bytes using utf-8 byte[] utf8 = str.getBytes('UTF8');// Encryptbyte[] enc = ecipher.doFinal(utf8);// Encode bytes to base64 to get a stringreturn new sun.misc.BASE64Encoder().encode(enc);} catch (Exception e) {}return null;}（4）定义解密函数：// Decryptpublic String decrypt(String str) {try {// Decode base64 to get bytesbyte[] dec = newsun.misc.BASE64Decoder().decodeBuffer(str);// Decryptbyte[] utf8 = dcipher.doFinal(dec);// Decode using utf-8return new String(utf8, 'UTF8');} catch (Exception e) {}return null;}}（5）定义测试类，测试加密解之密是否正确：public class TestDes {public static void main(String[] args) {try {// Create encrypter/decrypter classDesEncrypter encrypter = new DesEncrypter('your key');// EncryptString encrypted = encrypter.encrypt('Don't tell anybody!');// DecryptString decrypted = encrypter.decrypt(encrypted);// Print out valuesSystem.out.println('Encrypted: ' + encrypted);System.out.println('Decrypted: ' + decrypted);} catch (Exception e) {}}}。
Java使用Cipher类实现加密，包括DES，DES3，AES和RSA加密
Java使⽤Cipher类实现加密，包括DES，DES3，AES和RSA加密⼀、先看⼀个简单加密，解密实现1.1 加密/*** content: 加密内容* slatKey: 加密的盐，16位字符串* vectorKey: 加密的向量，16位字符串*/public String encrypt(String content, String slatKey, String vectorKey) throws Exception {Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);byte[] encrypted = cipher.doFinal(content.getBytes());return Base64.encodeBase64String(encrypted);}1.2 解密/*** content: 解密内容(base64编码格式)* slatKey: 加密时使⽤的盐，16位字符串* vectorKey: 加密时使⽤的向量，16位字符串*/public String decrypt(String base64Content, String slatKey, String vectorKey) throws Exception {Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);byte[] content = Base64.decodeBase64(base64Content);byte[] encrypted = cipher.doFinal(content);return new String(encrypted);}1.3 代码解释上⾯简单实现了AES("AES/CBC/PKCS5Padding")的加密和解密。
DES加密和解密java代码
DES加密和解密java代码在说DES加密算法之前，我们⾸先了解⼏个基本概念：1. 明⽂：明⽂是指没有经过加密的数据。
⼀般⽽⾔，明⽂都是等待传输的数据。
由于没有经过加密，明⽂很容易被识别与破解，因此在传输明⽂之前必须进⾏加密处理。
2. 密⽂：密⽂只是明⽂经过某种加密算法⽽得到的数据，通常密⽂的形式复杂难以识别及理解。
3. 密钥：密钥是⼀种参数，它是在明⽂转换为密⽂或将密⽂转换为明⽂的算法中输⼊的参数。
4. 对称加密：通信双⽅同时掌握⼀个密钥，加密解密都是由⼀个密钥完成的（即加密密钥等于解密密钥，加解密密钥可以相互推倒出来）。
双⽅通信前共同拟定⼀个密钥，不对第三⽅公开。
5. 分组加密：分组密码是将明⽂分成固定长度的组，每⼀组都采⽤同⼀密钥和算法进⾏加密，输出也是固定长度的密⽂。
好了了解这些以后，我们再来说DES加密算法。
DES 算法是⼀种常见的分组加密算法，由IBM公司在1971年提出。
DES 算法是分组加密算法的典型代表，同时也是应⽤最为⼴泛的对称加密算法。
下⾯我们详细介绍下：1.分组长度：DES 加密算法中，明⽂和密⽂为 64 位分组。
密钥的长度为 64 位，但是密钥的每个第⼋位设置为奇偶校验位，因此密钥的实际长度为56位。
2.加密流程：DES 加密算法⼤致分为 4 步：初始置换、⽣成⼦密钥、迭代过程、逆置换。
代码如下：需特别注意：不要使⽤JDK中⾃带的sun.misc.BASE64Decoder类去做BASE64，该类会在最后⾯多加换⾏。
⽽应使⽤apache中的mons.codec.binary.Base64这个类来做base64加密。
（待验证）import javax.crypto.Cipher;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;import javax.crypto.spec.IvParameterSpec;import java.security.Key;import java.security.SecureRandom;import mons.codec.binary.Base64;public class DESUtil {// 偏移变量，固定占8位字节private final static String IV_PARAMETER = "12345678";// 字符编码public static final String CHARSET_UTF8 = "UTF-8";// 加密算法DESpublic static final String DES = "DES";// 电话本模式public static final String DES_ECB = "DES/ECB/PKCS5Padding";// 加密块链模式--推荐public static final String DES_CBC = "DES/CBC/PKCS5Padding";// 测试public static void main(String args[]) {// 待加密内容String str = "false";// 密码，长度要是8的倍数String password = "87654321";String result = DESUtil.encryptCBC(password, str);System.out.println("加密后：" + new String(result));// 直接将如上内容解密try {String decryResult = DESUtil.decryptCBC(password, result);System.out.println("解密后：" + new String(decryResult));} catch (Exception e1) {e1.printStackTrace();}}/*** ⽣成key** @param password* @return* @throws Exception*/private static Key generateKey(String password) throws Exception {DESKeySpec dks = new DESKeySpec(password.getBytes(CHARSET_UTF8));SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);return keyFactory.generateSecret(dks);}/*** DES加密字符串--ECB格式** @param password* 加密密码，长度不能够⼩于8位* @param data* 待加密字符串* @return加密后内容*/public static String encryptECB(String password, String data) {if (password == null || password.length() < 8) {throw new RuntimeException("加密失败，key不能⼩于8位");}if (data == null) {return null;}try {Key secretKey = generateKey(password);Cipher cipher = Cipher.getInstance(DES_ECB);cipher.init(Cipher.ENCRYPT_MODE, secretKey, new SecureRandom());byte[] bytes = cipher.doFinal(data.getBytes(CHARSET_UTF8));// JDK1.8及以上可直接使⽤Base64，JDK1.7及以下可以使⽤BASE64Encoder return new String(Base64.encodeBase64(bytes));} catch (Exception e) {e.printStackTrace();return data;}}/*** DES解密字符串--ECB格式** @param password* 解密密码，长度不能够⼩于8位* @param data* 待解密字符串* @return解密后内容*/public static String decryptECB(String password, String data)throws Exception {Key secretKey = generateKey(password);Cipher cipher = Cipher.getInstance(DES_ECB);cipher.init(Cipher.DECRYPT_MODE, secretKey, new SecureRandom());return new String(cipher.doFinal(Base64.decodeBase64(data.getBytes(CHARSET_UTF8))), CHARSET_UTF8);}/*** DES加密字符串-CBC加密格式** @param password* 加密密码，长度不能够⼩于8位* @param data* 待加密字符串* @return加密后内容*/public static String encryptCBC(String password, String data) {if (password == null || password.length() < 8) {throw new RuntimeException("加密失败，key不能⼩于8位");}if (data == null) {return null;}try {Key secretKey = generateKey(password);Cipher cipher = Cipher.getInstance(DES_CBC);IvParameterSpec spec = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET_UTF8));cipher.init(Cipher.ENCRYPT_MODE, secretKey, spec);byte[] bytes = cipher.doFinal(data.getBytes(CHARSET_UTF8));// JDK1.8及以上可直接使⽤Base64，JDK1.7及以下可以使⽤BASE64Encoder return new String(Base64.encodeBase64(bytes));} catch (Exception e) {e.printStackTrace();return data;}}/*** DES解密字符串--CBC格式** @param password* 解密密码，长度不能够⼩于8位* @param data* 待解密字符串* @return解密后内容*/public static String decryptCBC(String password, String data) throws Exception {Key secretKey = generateKey(password);Cipher cipher = Cipher.getInstance(DES_CBC);IvParameterSpec spec = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET_UTF8));cipher.init(Cipher.DECRYPT_MODE, secretKey, spec);return new String(cipher.doFinal(Base64.decodeBase64(data.getBytes(CHARSET_UTF8))), CHARSET_UTF8); }}。
DES算法实现
DES算法实现：java语言下可以导入org.apache前缀的类库，apache组织给出了org.apache.codec类库，将基本的加密和解密方法打包成现成方法，并且提供了DES算法必备的S盒。
所以这个实现方法会采用org.apache.codec类库，采用结合源代码的方式进行编写。
工程名为ZDESAl即DES Algorithm,下面包含两个类，DESCoder负责生成密钥，DESCoderTest负责进行密钥的左移、置换选择，扩充等操作。
下面给出DESCoder类的设计思路和源代码：import java.security.Key;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;/***DES安全编码组件*@author Hawke7*@version 1.0*/public abstract class DESCoder {/***密钥算法<br>*Java6只支持56位密钥<br>*Bouncy Castle支持64位密钥*/public static final String KEY_ALGORITHM = "DES";/***加密/解密算法/工作模式/填充方式*/public static final String CIPHER_ALGORITHM= "DES/ECB/PKCS5Padding";/***转换密钥*@param key二进制密钥*@return key二进制密钥*@throws Exception*/private static Key toKey(byte[] key) throws Exception {// 实例化DES密钥材料DESKeySpec dks = new DESKeySpec(key);// 实例化秘密密钥工厂SecretKeyFactory keyFactory =SecretKeyFactory.getInstance(KEY_ALGORITHM);// 生成私密密钥SecretKey secretKey = keyFactory.generateSecret(dks);return secretKey;}/***解密*@param data待解密数据*@param key密钥*@return byte[]解密数据*@throws Exception*/public static byte[] decrypt(byte[] data, byte[] key) throws Exception {// 还原密钥Key k = toKey(key);// 实例化Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);// 初始化，设置为解密模式cipher.init(Cipher.DECRYPT_MODE, k);// 执行操作return cipher.doFinal(data);}/***加密*@param data待加密数据*@param key密钥*@return byte[]加密数据*@throws Exception*/public static byte[] encrypt(byte[] data, byte[] key) throws Exception {// 还原密钥Key k = toKey(key);// 实例化Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);// 初始化，设置为解密模式cipher.init(Cipher.ENCRYPT_MODE, k);// 执行操作return cipher.doFinal(data);}/***生成密钥<br>*Java6只支持56位密钥<br>*Bouncy Castle支持64位密钥<br>*@return byte[]二进制密钥*@throws Exception*/public static byte[] initKey() throws Exception {/** 实例化密钥生成器* 若要使用64位密钥注意替换* 将下述代码中的* KeyGenerator.getInstance(CIPHER_ALGORITHM);* 替换为* KeyGenerator.getInstance(CIPHER_ALGORITHM, "BC");*/KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);/** 初始化密钥生成器* 若要使用64位密钥注意替换* 将下面代码kg.init(56)* 替换为kg.init(64)*/kg.init(56);// 生成私密密钥SecretKey secretKey = kg.generateKey();// 获得密钥的二进制编码形式return secretKey.getEncoded();}}首先DESCoder要定义成抽象类，因为其中全部是static静态方法toKey,toKey初始化密钥材料，并且实例化密钥工厂，因为DES算法要进行16轮迭代，所以工厂每一次都要给出不同的密钥，从而增强雪崩效应。
加密Java源代码
Java语言是一种非常适用于网络编程的语言，它的基本结构与C++极为相似，但抛弃了C/C++中指针等内容，同时它吸收了Smalltalk、C++面向对象的编程思想。
它具有简单性、鲁棒性、可移植性、动态性等特点。
这些特点使得Java成为跨平台应用开发的一种规范，在世界范围内广泛流传。
加密Java源码的原因Java源代码经过编译以后在JVM中执行。
由于JVM界面是完全透明的，Java类文件能够很容易通过反编译器重新转换成源代码。
因此，所有的算法、类文件等都可以以源代码的形式被公开，使得软件不能受到保护，为了保护产权，一般可以有以下几种方法：（1）"模糊"类文件，加大反编译器反编译源代码文件的难度。
然而，可以修改反编译器，使之能够处理这些模糊类文件。
所以仅仅依赖"模糊类文件"来保证代码的安全是不够的。
（2）流行的加密工具对源文件进行加密，比如PGP（Pretty Good Privacy）或GPG（GNU Privacy Guard）。
这时，最终用户在运行应用之前必须先进行解密。
但解密之后，最终用户就有了一份不加密的类文件，这和事先不进行加密没有什么差别。
（3）加密类文件，在运行中JVM用定制的类装载器（Class Loader）解密类文件。
Java 运行时装入字节码的机制隐含地意味着可以对字节码进行修改。
JVM每次装入类文件时都需要一个称为ClassLoader的对象，这个对象负责把新的类装入正在运行的JVM。
JVM给ClassLoader一个包含了待装入类（例如ng.Object）名字的字符串，然后由ClassLoader负责找到类文件，装入原始数据，并把它转换成一个Class对象。
用户下载的是加密过的类文件，在加密类文件装入之时进行解密，因此可以看成是一种即时解密器。
由于解密后的字节码文件永远不会保存到文件系统，所以窃密者很难得到解密后的代码。
由于把原始字节码转换成Class对象的过程完全由系统负责，所以创建定制ClassLoader 对象其实并不困难，只需先获得原始数据，接着就可以进行包含解密在内的任何转换。
DES算法源代码
A[i]=A[i+2];
A[26]=n;
A[27]=m;
n=B[0];
m=B[1];
for(i=0;i<26;i++)
B[i]=B[i+2];
B[26]=n;
B[27]=m;
}
for(i=0;i<28;i++) //将A和B合并成56位
{
keyAB[i]=A[i];
}
getchar();
//生成子密钥
printf("请输入8位密钥：\n");
gets(InputKey);
while(InputKey[7]=='\0'||InputKey[8]!='\0')
{
printf("您输入的密钥位数有误，请重新输入8位密钥：\n");
gets(InputKey);
}
for(i=0;i<8;i++) //将密钥转化成64位二进制数放到一维数组key中
14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
{
if(move[t]==1) //按照循环移位表将Ai和Bi分别左移move[t]位
{
n=A[0];
for(i=0;i<27;i++)
java加密解密算法desededesdiffie-hellman的使用
JAVA加密解密算法DESedeDES，Diffie-Hellman的使用DESede/DES对称算法首先生成密钥,并保存(这里并没的保存的代码,可参考DSA 中的方法)KeyGenerator keygen =KeyGenerator.getInstance(Algorithm);SecretKey deskey = keygen.generateKey();用密钥加密明文(myinfo),生成密文(cipherByte)Cipher c1 = Cipher.getInstance(Algorithm);c1.init(Cipher.ENCRYPT_MODE,deskey);byte[] cipherByte=c1.doFinal(myinfo.getBytes());传送密文和密钥,本文没有相应代码可参考DSA .............用密钥解密密文c1 = Cipher.getInstance(Algorithm);c1.init(Cipher.DECRYPT_MODE,deskey);byte[] clearByte=c1.doFinal(cipherByte);相对来说对称密钥的使用是很简单的,对于JCE来讲支技DES,DESede,Blowfish三种加密术对于密钥的保存各传送可使用对象流或者用二进制编码,相关参考代码如下SecretKey deskey =keygen.generateKey(); byte[]desEncode=deskey.getEncoded();javax.crypto.spec.SecretKeySpec destmp=newjavax.crypto.spec.SecretKeySpec(desEncode,Algorithm); SecretKey mydeskey=destmp;相关APIKeyGenerator 在DSA中已经说明,在添加JCE后在instance进可以如下参数DES,DESede,Blowfish,HmacMD5,HmacSHA1javax.crypto.Cipher 加/解密器public static final Cipher getInstance(ng.String transformation)throws java.security.NoSuchAlgorithmException, NoSuchPaddingException返回一个指定方法的Cipher对象参数:transformation 方法名(可用DES,DESede,Blowfish) public final void init(int opmode, java.security.Key key) throws java.security.InvalidKeyException用指定的密钥和模式初始化Cipher对象参数:opmode 方式(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)key 密钥public final byte[] doFinal(byte[] input)throws ng.IllegalStateException, IllegalBlockSizeException,BadPaddingException对input内的串,进行编码处理,返回处理后二进制串,是返回解密文还是加解文由init时的opmode决定注意:本方法的执行前如果有update,是对updat和本次input 全部处理,否则是本inout的内容/*安全程序DESede/DES 测试*/import java.security.*;import javax.crypto.*;public class testdes {public static void main(String[]args){ testdes my=new testdes();my.run(); }public void run() {//添加新安全算法,如果用JCE就要把它添加进去Security.addProvider(newcom.sun.crypto.provider.SunJCE());StringAlgorithm="DES"; //定义加密算法,可用DES,DESede,BlowfishString myinfo="要加密的信息";try { //生成密钥KeyGenerator keygen = KeyGenerator.getInstance(Algorithm); SecretKey deskey = keygen.generateKey(); //加密System.out.println("加密前的二进串:"+byte2hex(myinfo.getBytes())); System.out.println("加密前的信息:"+myinfo); Cipher c1 =Cipher.getInstance(Algorithm);c1.init(Cipher.ENCRYPT_MODE,deskey); byte[] cipherByte=c1.doFinal(myinfo.getBytes());System.out.println("加密后的二进串:"+byte2hex(cipherByte)); //解密c1 =Cipher.getInstance(Algorithm);c1.init(Cipher.DECRYPT_MODE,deskey); byte[] clearByte=c1.doFinal(cipherByte); System.out.println("解密后的二进串:"+byte2hex(clearByte));System.out.println("解密后的信息:"+(newString(clearByte))); } catch(java.security.NoSuchAlgorithmException e1){e1.printStackTrace();} catch(javax.crypto.NoSuchPaddingException e2){e2.printStackTrace();} catch (ng.Exception e3) {e3.printStackTrace();} } public String byte2hex(byte[] b) //二行制转字符串{ String hs=""; String stmp=""; for (int n=0;n2.5. Diffie-Hellman密钥一致协议公开密钥密码体制的奠基人Diffie和Hellman所提出的"指数密钥一致协议"(Exponential Key Agreement Protocol),该协议不要求别的安全性先决条件,允许两名用户在公开媒体上交换信息以生成"一致"的,可以共享的密钥。
DES加密算法代码
DES加密算法代码java实现DES加密1.准备算法所需要的密钥在Java中，DES加密算法需要一个8字节长的密钥，这里使用原始的8字节长的密钥来实现DES加密算法，同时，还有一种是“密钥扩展”，可以将8字节长的密钥扩展为16字节长，只需要多添加8个字节，后面8个字节可以跟前面8字节保持一致即可，即扩展后的密钥和原始密钥共享后八个字节即可。
byte [] keyBytes = {0x11, 0x22, 0x4F, 0x58, (byte) 0x88,0x10, 0x40, 0x38,0x28, 0x25, 0x79, 0x51, (byte) 0xCB, (byte) 0xDD, 0x55, 0x66, 0x77, 0x29, 0x74, (byte) 0x98, 0x30, 0x40, 0x36, (byte)0xE2};下面介绍如何用Java来实现原始的8字节长的密钥：// 生成keyKeyGenerator keyGenerator = KeyGenerator.getInstance("DES");keyGenerator.init(new SecureRandom(keyBytes));SecretKey key = keyGenerator.generateKey(;2. 设置加密模式(Cipher Block Chaining Mode，简称CBC模式)在Java中，DES加密算法可以支持三种不同的加密模式：ECB，CBC，CFB。
其中ECB模式为最原始的模式，它不需要任何附加的参数，而CBC模式需要一个8字节的初始向量(Initial Vector，IV)参数，CFB模式需要一个1字节或8字节的变量参数，它们用来增加加密的强度。
这里，我们使用CBC模式，它是最常用的DES加密模式，下面是设置CBC模式所需要的参数：// 创建Cipher对象,指定其支持的DES算法Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");// 用密匙初始化Cipher对象IvParameterSpec param = new IvParameterSpec(iv);cipher.init(Cipher.ENCRYPT_MODE, key,param);3.加密。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
利用DES加密算法保护Java源代码学术部张亚涛摘要：本文首先分析了Java源代码需要加密的原因，简要介绍了DES算法及Java密码体系和Java密码扩展，最后说明了利用DES加密算法保护Java源代码的方法及步骤。
关键词Java加密DES算法Java语言是一种非常适用于网络编程的语言，它的基本结构与C++极为相似，但抛弃了C/C++中指针等内容，同时它吸收了Smalltalk、C++面向对象的编程思想。
它具有简单性、鲁棒性、可移植性、动态性等特点。
这些特点使得Java成为跨平台应用开发的一种规范，在世界范围内广泛流传。
加密Java源码的原因Java源代码经过编译以后在JVM中执行。
由于JVM界面是完全透明的，Java类文件能够很容易通过反编译器重新转换成源代码。
因此，所有的算法、类文件等都可以以源代码的形式被公开，使得软件不能受到保护，为了保护产权，一般可以有以下几种方法：（1）"模糊"类文件，加大反编译器反编译源代码文件的难度。
然而，可以修改反编译器，使之能够处理这些模糊类文件。
所以仅仅依赖"模糊类文件"来保证代码的安全是不够的。
（2）流行的加密工具对源文件进行加密，比如PGP（Pretty Good Privacy）或GPG（GNU Privacy Guard）。
这时，最终用户在运行应用之前必须先进行解密。
但解密之后，最终用户就有了一份不加密的类文件，这和事先不进行加密没有什么差别。
（3）加密类文件，在运行中JVM用定制的类装载器（Class Loader）解密类文件。
Java运行时装入字节码的机制隐含地意味着可以对字节码进行修改。
JVM每次装入类文件时都需要一个称为ClassLoader的对象，这个对象负责把新的类装入正在运行的JVM。
JVM给ClassLoader一个包含了待装入类（例如ng.Object）名字的字符串，然后由ClassLoader 负责找到类文件，装入原始数据，并把它转换成一个Class对象。
用户下载的是加密过的类文件，在加密类文件装入之时进行解密，因此可以看成是一种即时解密器。
由于解密后的字节码文件永远不会保存到文件系统，所以窃密者很难得到解密后的代码。
由于把原始字节码转换成Class对象的过程完全由系统负责，所以创建定制ClassLoader对象其实并不困难，只需先获得原始数据，接着就可以进行包含解密在内的任何转换。
Java密码体系和Java密码扩展Java密码体系(JCA)和Java密码扩展(JCE)的设计目的是为Java提供与实现无关的加密函数API。
它们都用factory方法来创建类的例程，然后把实际的加密函数委托给提供者指定的底层引擎,引擎中为类提供了服务提供者接口在Java中实现数据的加密/解密，是使用其内置的JCE(Java加密扩展)来实现的。
Java开发工具集1.1为实现包括数字签名和信息摘要在内的加密功能，推出了一种基于供应商的新型灵活应用编程接口。
Java 密码体系结构支持供应商的互操作,同时支持硬件和软件实现。
Java密码学结构设计遵循两个原则:(1)算法的独立性和可靠性。
(2)实现的独立性和相互作用性。
算法的独立性是通过定义密码服务类来获得。
用户只需了解密码算法的概念,而不用去关心如何实现这些概念。
实现的独立性和相互作用性通过密码服务提供器来实现。
密码服务提供器是实现一个或多个密码服务的一个或多个程序包。
软件开发商根据一定接口,将各种算法实现后,打包成一个提供器,用户可以安装不同的提供器。
安装和配置提供器,可将包含提供器的ZIP和JAR文件放在CLASSPATH下,再编辑Java安全属性文件来设置定义一个提供器。
Java运行环境Sun版本时,提供一个缺省的提供器Sun。
下面介绍DES算法及如何利用DES算法加密和解密类文件的步骤。
DES算法简介DES（Data Encryption Standard）是发明最早的最广泛使用的分组对称加密算法。
DES算法的入口参数有三个：Key、Data、Mode。
其中Key 为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密。
DES算法工作流程如下：若Mode为加密模式，则利用Key对数据Data进行加密，生成Data的密码形式（64位）作为DES的输出结果；如Mode为解密模式，则利用Key对密码形式的数据Data进行解密，还原为Data的明码形式（64位）作为DES的输出结果。
在通信网络的两端，双方约定一致的Key，在通信的源点用Key对核心数据进行DES加密，然后以密码形式在公共通信网（如电话网）中传输到通信网络的终点，数据到达目的地后，用同样的Key对密码数据进行解密，便再现了明码形式的核心数据。
这样，便保证了核心数据在公共通信网中传输的安全性和可靠性。
也可以通过定期在通信网络的源端和目的端同时改用新的Key，便能更进一步提高数据的保密性。
利用DES算法加密的步骤（1）生成一个安全密钥。
在加密或解密任何数据之前需要有一个密钥。
密钥是随同被加密的应用程序一起发布的一段数据，密钥代码如下所示。
【生成一个密钥代码】view plaincopy to clipboardprint?//生成一个可信任的随机数源SecureRandom sr=new SecureRandom();//为我们选择的DES算法生成一个KeyGenerator对象KeyGenerator kg=KeyGenerator.getInstance("DES");Kg.init(sr);//生成密钥Secret Key key=kg.generateKey();//将密钥数据保存为文件供以后使用，其中key Filename为保存的文件名Util.writeFile(key Filename,key.getEncoded());//生成一个可信任的随机数源SecureRandom sr=new SecureRandom();//为我们选择的DES算法生成一个KeyGenerator对象KeyGenerator kg=KeyGenerator.getInstance("DES");Kg.init(sr);//生成密钥Secret Key key=kg.generateKey();//将密钥数据保存为文件供以后使用，其中key Filename为保存的文件名Util.writeFile(key Filename,key.getEncoded());（2）加密数据。
得到密钥之后，接下来就可以用它加密数据。
如下所示。
【用密钥加密原始数据】view plaincopy to clipboardprint?//产生一个可信任的随机数源SecureRandom sr=new SecureRandom();//从密钥文件key Filename中得到密钥数据Byte rawKeyData=Util.readFile(key Filename);//从原始密钥数据创建DESKeySpec对象DESKeySpec dks=new DESKeySpec(rawKeyData);//创建一个密钥工厂，然后用它把DESKeySpec转换成Secret Key对象SecretKeyFactory key Factory=SecretKeyFactory.getInstance("DES"); Secret Key key=keyFactory.generateSecret(dks);//Cipher对象实际完成加密操作Cipher cipher=Cipher.getInstance("DES");//用密钥初始化Cipher对象cipher.init(Cipher.ENCRYPT_MODE,key,sr);//通过读类文件获取需要加密的数据Byte data=Util.readFile(filename);//执行加密操作Byte encryptedClassData=cipher.doFinal(data);//保存加密后的文件，覆盖原有的类文件。
Util.writeFile(filename,encryptedClassData);//产生一个可信任的随机数源SecureRandom sr=new SecureRandom();//从密钥文件key Filename中得到密钥数据Byte rawKeyData=Util.readFile(key Filename);//从原始密钥数据创建DESKeySpec对象DESKeySpec dks=new DESKeySpec(rawKeyData);//创建一个密钥工厂，然后用它把DESKeySpec转换成Secret Key对象SecretKeyFactory key Factory=SecretKeyFactory.getInstance("DES"); Secret Key key=keyFactory.generateSecret(dks);//Cipher对象实际完成加密操作Cipher cipher=Cipher.getInstance("DES");//用密钥初始化Cipher对象cipher.init(Cipher.ENCRYPT_MODE,key,sr);//通过读类文件获取需要加密的数据Byte data=Util.readFile(filename);//执行加密操作Byte encryptedClassData=cipher.doFinal(data);//保存加密后的文件，覆盖原有的类文件。
Util.writeFile(filename,encryptedClassData);（3）解密数据。
运行经过加密的程序时，ClassLoader分析并解密类文件。
操作步骤如下所示。
【用密钥解密数据】view plaincopy to clipboardprint?//生成一个可信任的随机数源SecureRandom sr=new SecureRandom();//从密钥文件中获取原始密钥数据Byte rawKeyData=Util.readFile(keyFilename);//创建一个DESKeySpec对象DESKeySpec dks=new DESKeySpec(rawKeyData);//创建一个密钥工厂，然后用它把DESKeySpec对象转换成Secret Key 对象SecretKeyFactory key Factory=SecretKeyFactory.getInstance("DES"); SecretKey key=keyFactory.generateSecret(dks);//Cipher对象实际完成解密操作Cipher cipher=Cipher.getInstance("DES");//用密钥初始化Cipher对象Cipher.init(Cipher.DECRYPT_MODE,key,sr);//获得经过加密的数据Byte encrypted Data=Util.readFile(Filename);//执行解密操作Byte decryptedData=cipher.doFinal(encryptedData);//然后将解密后的数据转化成原来的类文件。