java 对称加密字节流 java实现对称加密

1 下面用DES对称加密算法（设定一个密钥，然后对所有的数据进行加密）来简单举个例子。
  2 
  3 首先，生成一个密钥KEY。
  4 我把它保存到key.txt中。这个文件就象是一把钥匙。谁拥有它，谁就能解开我们的类文件。代码参考如下：
  5 package com.neusoft.jiami;
  6 import Java.io.File;
  7 import java.io.FileOutputStream;
  8 import java.security.SecureRandom;
  9 import javax.crypto.KeyGenerator;
 10 import javax.crypto.SecretKey;
 11 class Key {
 12     private String keyName;
 13     public Key(String keyName) {
 14         this.keyName = keyName;
 15      }
 16     public void createKey(String keyName) throws Exception {
 17         // 创建一个可信任的随机数源，DES算法需要
 18          SecureRandom sr = new SecureRandom();
 19         // 用DES算法创建一个KeyGenerator对象
 20          KeyGenerator kg = KeyGenerator.getInstance("DES");
 21         // 初始化此密钥生成器,使其具有确定的密钥长度
 22          kg.init(sr);
 23         // 生成密匙
 24          SecretKey key = kg.generateKey();
 25         // 获取密钥数据
 26         byte rawKeyData[] = key.getEncoded();
 27         // 将获取到密钥数据保存到文件中，待解密时使用
 28          FileOutputStream fo = new FileOutputStream(new File(keyName));
 29          fo.write(rawKeyData);
 30      }
 31     public static void main(String args[]) {
 32         try {
 33             new Key("key.txt");
 34          } catch (Exception e) {
 35              e.printStackTrace();
 36          }
 37      }
 38 }
 39 第二步，对我们所要进行加密的类文件进行加密。
 40     比如我有一个DigestPass类，已经被正常编译好生成DigestPass.class文件。此时，这个类文件是任何人都可以用的。因为系统的类加载器可以自动的加载它。那么下一步，我们要做的就是把这个类文件加密。使系统的类加载器无法读取到正确的字节码文件。参考代码如下：
 41 package com.neusoft.jiami;
 42 import java.io.File;
 43 import java.io.FileInputStream;
 44 import java.io.FileOutputStream;
 45 import java.security.SecureRandom;
 46 import javax.crypto.Cipher;
 47 import javax.crypto.SecretKey;
 48 import javax.crypto.SecretKeyFactory;
 49 import javax.crypto.spec.DESKeySpec;
 50 public class JiaMi {
 51     public static void main(String[] args) throws Exception {
 52         // DES算法要求有一个可信任的随机数源
 53          SecureRandom sr = new SecureRandom();
 54         // 获得密匙数据
 55          FileInputStream fi = new FileInputStream(new File("key.txt"));
 56         byte rawKeyData[] = new byte[fi.available()];
 57          fi.read(rawKeyData);
 58          fi.close();
 59         // 从原始密匙数据创建DESKeySpec对象
 60          DESKeySpec dks = new DESKeySpec(rawKeyData);
 61         // 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
 62          SecretKey key = SecretKeyFactory.getInstance("DES").generateSecret(dks);
 63         // Cipher对象实际完成加密操作
 64          Cipher cipher = Cipher.getInstance("DES");
 65         // 用密匙初始化Cipher对象
 66          cipher.init(Cipher.ENCRYPT_MODE, key, sr);
 67         // 现在，获取要加密的文件数据
 68          FileInputStream fi2 = new FileInputStream(new File("DigestPass.class"));
 69         byte data[] = new byte[fi2.available()];
 70          fi2.read(data);
 71          fi2.close();
 72         // 正式执行加密操作
 73         byte encryptedData[] = cipher.doFinal(data);
 74         // 用加密后的数据覆盖原文件
 75          FileOutputStream fo = new FileOutputStream(new File("DigestPass.class"));
 76          fo.write(encryptedData);
 77          fo.close();
 78      }
 79 }
 80 第三步，用自定义的CLASSLOADER进行加载。参考代码如下：
 81 package com.neusoft.jiami;
 82 import java.io.File;
 83 import java.io.FileInputStream;
 84 import java.io.FileOutputStream;
 85 import java.security.SecureRandom;
 86 import javax.crypto.Cipher;
 87 import javax.crypto.SecretKey;
 88 import javax.crypto.SecretKeyFactory;
 89 import javax.crypto.spec.DESKeySpec;
 90 import com.neusoft.classloader.MyClassLoader;
 91 public class JieMi {
 92     public static void main(String[] args) throws Exception {
 93         // DES算法要求有一个可信任的随机数源
 94          SecureRandom sr = new SecureRandom();
 95         // 获得密匙数据
 96          FileInputStream fi = new FileInputStream(new File("key.txt"));
 97         byte rawKeyData[] = new byte[fi.available()];// = new byte[5];
 98          fi.read(rawKeyData);
 99          fi.close();
100         // 从原始密匙数据创建一个DESKeySpec对象
101          DESKeySpec dks = new DESKeySpec(rawKeyData);
102         // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成一个SecretKey对象
103          SecretKey key = SecretKeyFactory.getInstance("DES").generateSecret(dks);
104         // Cipher对象实际完成解密操作
105          Cipher cipher = Cipher.getInstance("DES");
106         // 用密匙初始化Cipher对象
107          cipher.init(Cipher.DECRYPT_MODE, key, sr);
108         // 现在，获取数据并解密
109          FileInputStream fi2 = new FileInputStream(new File("DigestPass.class"));
110         byte encryptedData[] = new byte[fi2.available()];
111          fi2.read(encryptedData);
112          fi2.close();
113         // 正式执行解密操作
114         byte decryptedData[] = cipher.doFinal(encryptedData);
115         // 这时把数据还原成原有的类文件
116         // FileOutputStream fo = new FileOutputStream(new
117         // File("DigestPass.class"));
118         // fo.write(decryptedData);
119         // 用解密后的数据加载类并应用
120          MyClassloader mcl = new MyClassloader("E:/");
121          Class cl = mcl.loadClass(decryptedData, "com.neusoft.jiami.DigestPass");
122          DigestPass dp = cl.newInstance();
123      }
124 }