【java密码加密与解密】
以下两个类可以很方便的完成字符串的加密和解密：
加密：CryptHelper.encrypt（password）
解密：CrypHelper.decrypt（password）
代码如下：
CryptUtils.java
[java]
package com.gdie.lab.crypt;
import java.io.IOException;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
public class CryptUtils {
private static String Algorithm = "DES";
private static byte[] DEFAULT_KEY=new byte[] {-53, 122, -42, -88, -110, -123, -60, -74};
private static String VALUE_ENCODING="UTF-8";
/**
* 生成密钥
*
* @return byte[] 返回萝卜家园系统下载生成的密钥
* @throws exception
* 扔出异常。
*/
public static byte[] getSecretKey（） throws Exception {
KeyGenerator keygen = KeyGenerator.getInstance（Algorithm）；
SecretKey deskey = keygen.generateKey（）；
// if （debug ） System.out.println （"生成密钥："+byte2hex （deskey.getEncoded
// （）））；
return deskey.getEncoded（）；
}
/**
* 将指定的数据根据提供的密钥进行加密
*
* @param input
* 需要加密的数据
* @param key
* 密钥
* @return byte[] 加密后的数据
* @throws Exception
*/
public static byte[] encryptData（byte[] input, byte[] key） throws Exception {
SecretKey deskey = new javax.crypto.spec.SecretKeySpec（key, Algorithm）；
// if （debug ）
// {
// System.out.println （"加密前的二进串："+byte2hex （input ））；
// System.out.println （"加密前的字符串："+new String （input ））；
//
// }
Cipher c1 = Cipher.getInstance（Algorithm）；
c1.init（Cipher.ENCRYPT_MODE, deskey）；
byte[] cipherByte = c1.doFinal（input）；
// if （debug ） System.out.println （"加密后的二进串："+byte2hex （cipherByte ））；
return cipherByte;
}
public static byte[] encryptData（byte[] input） throws Exception {
return encryptData（input, DEFAULT_KEY）；
}
/**
* 将给定的已加密的数据通过指定的密钥进行解密
*
* @param input
* 待解密的数据
* @param key
* 密钥
* @return byte[] 解密后的数据
* @throws Exception
*/
public static byte[] decryptData（byte[] input, byte[] key） throws Exception {
SecretKey deskey = new javax.crypto.spec.SecretKeySpec（key, Algorithm）；
// if （debug ） System.out.println （"解密前的信息："+byte2hex （input ））；
Cipher c1 = Cipher.getInstance（Algorithm）；
c1.init（Cipher.DECRYPT_MODE, deskey）；
byte[] clearByte = c1.doFinal（input）；
// if （debug ）
// {
// System.out.println （"解密后的二进串："+byte2hex （clearByte ））；
// System.out.println （"解密后的字符串："+（new String （clearByte ）））；
//
// }
return clearByte;
}
public static byte[] decryptData（byte[] input） throws Exception {
return decryptData（input, DEFAULT_KEY）；
}
/**
* 字节码转换成16进制字符串
*
* @param byte[] b 输入要转换的字节码
* @return String 返回转换后的16进制字符串
*/
public static String byte2hex（byte[] bytes） {
StringBuilder hs = new StringBuilder（）；
for（byte b : bytes）
hs.append（String.format（"%1$02X", b））；
return hs.toString（）；
}
public static byte[] hex2byte（String content） {
int l=content.length（）》1;
byte[] result=new byte[l];
for（int i=0;i<l;i++） {
int j=i《1;
String s=content.substring（j, j+2）；
result[i]=Integer.valueOf（s, 16）。byteValue（）；
}
return result;
}
/**
* 将字节数组转换为base64编码字符串
* @param buffer
* @return
*/
public static String bytesToBase64（byte[] buffer） {
//BASE64Encoder en=new BASE64Encoder（）；
return Base64.encode（buffer）；
// return encoder.encode（buffer）；
}
/**
* 将base64编码的字符串解码为字节数组
* @param value
* @return
* @throws IOException
*/
public static byte[] base64ToBytes（String value） throws IOException {
//return Base64.decodeToByteArray（value）；
// System.out.println（decoder.decodeBuffer（value））；
// return decoder.decodeBuffer（value）；
return Base64.decode（value）；
}
/**
* 加密给定的字符串
* @param value
* @return 加密后的base64字符串
*/
public static String encryptString（String value） {
return encryptString（value, DEFAULT_KEY）；
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 以BASE64形式存在的密钥
* @return 加密后的base64字符串
* @throws IOException
*/
public static String encryptString（String value, String key） throws IOException {
return encryptString（value, base64ToBytes（key））；
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 字节数组形式的密钥
* @return 加密后的base64字符串
*/
public static String encryptString（String value, byte[] key） {
try {
byte[] data=value.getBytes（VALUE_ENCODING）；
data=CryptUtils.encryptData（data, key）；
return bytesToBase64（data）；
} catch （Exception e） {
// TODO Auto-generated catch block
e.printStackTrace（）；
return null;
}
}
/**
* 解密字符串
* @param value base64形式存在的密文
* @return 明文
*/
public static String decryptString（String value） {
return decryptString（value, DEFAULT_KEY）；
}
/**
* 解密字符串
* @param value base64形式存在的密文
* @param key base64形式存在的密钥
* @return 明文
* @throws IOException
*/
public static String decryptString（String value, String key） throws IOException {
String s=decryptString（value, base64ToBytes（key））；
return s;
}
/**
* 解密字符串
* @param value base64形式存在的密文
* @param key 字节数据形式存在的密钥
* @return 明文
*/
public static String decryptString（String value, byte[] key） {
try {
byte[] data=base64ToBytes（value）；
data=CryptUtils.decryptData（data, key）；
return new String（data, VALUE_ENCODING）；
}catch（Exception e） {
e.printStackTrace（）；
return null;
}
}
}
package com.gdie.lab.crypt;
import java.io.IOException;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
public class CryptUtils {
private static String Algorithm = "DES";
private static byte[] DEFAULT_KEY=new byte[] {-53, 122, -42, -88, -110, -123, -60, -74};
private static String VALUE_ENCODING="UTF-8";
/**
* 生成密钥
