DES加解密及生成token工具类

import java.io.IOException;
import java.security.SecureRandom;


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


import com.taagoo.util.pub.StringUtil;


//import sun.misc.BASE64Decoder;


/**
 * 加解密工具类
 * @ClassName: DESUtil
 * @Description:加解密工具类
 * @author: 王钧
 * @date 2015-11-15
 */
public class DESUtil {

private final static String DES = "DES";

/**
* 加密
* @Title: encrypt
* @Description: 加密
* @author: 王钧
* @date 2015-11-15
* @param src  数据源
* @param key 密钥，长度必须是8的倍数
* @return byte[]
* @throws Exception
*/
public static byte[] encrypt(byte[] src, byte[] key) throws Exception {
// DES算法要求有一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 从原始密匙数据创建DESKeySpec对象
DESKeySpec dks = new DESKeySpec(key);
// 创建一个密匙工厂，然后用它把DESKeySpec转换成
// 一个SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey securekey = keyFactory.generateSecret(dks);
// Cipher对象实际完成加密操作
Cipher cipher = Cipher.getInstance(DES);
// 用密匙初始化Cipher对象
cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
// 现在，获取数据并加密
// 正式执行加密操作
return cipher.doFinal(src);
}

/**
* 加密
* @Title: encrypt
* @Description: 加密
* @author: 王钧
* @date 2015-11-15
* @param src  数据源
* @param key 密钥，长度必须是8的倍数
* @return String
* @throws Exception
*/
public final static String encrypt(String data, String key) {
if (data != null)
try {
return byte2hex(encrypt(data.getBytes(), key.getBytes()));
} catch (Exception e) {
throw new RuntimeException(e);
}
return null;
}


/**
* 解密
* @Title: decrypt
* @Description: 解密
* @author: 王钧
* @date 2015-11-15
* @param src  数据源
* @param key 密钥，长度必须是8的倍数
* @return 返回解密后的原始数据
* @throws Exception
*/
public static byte[] decrypt(byte[] src, byte[] key) throws Exception {
// DES算法要求有一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 从原始密匙数据创建一个DESKeySpec对象
DESKeySpec dks = new DESKeySpec(key);
// 创建一个密匙工厂，然后用它把DESKeySpec对象转换成
// 一个SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey securekey = keyFactory.generateSecret(dks);
// Cipher对象实际完成解密操作
Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");
// 用密匙初始化Cipher对象
cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
// 现在，获取数据并解密
// 正式执行解密操作
return cipher.doFinal(src);
}


/**
* 解密
* @Title: decrypt
* @Description: 解密
* @author: 王钧
* @date 2015-11-15
* @param src  数据源
* @param key 密钥，长度必须是8的倍数
* @return 返回解密后的原始数据
* @throws Exception
*/
public final static String decrypt(String data, String key)
throws Exception {
return new String(decrypt(hex2byte(data.getBytes()), key.getBytes())).trim();
}


/**
* 二进制转字符串
* @Title: byte2hex
* @Description: 二进制转字符串
* @author: 王钧
* @date 2015-11-15
* @param b  数据源
* @return 字符串
*/
public static String byte2hex(byte[] b) {
StringBuilder hs = new StringBuilder();
String stmp;
for (int n = 0; b != null && n < b.length; n++) {
stmp = Integer.toHexString(b[n] & 0XFF);
if (stmp.length() == 1)
hs.append('0');
hs.append(stmp);
}
return hs.toString().toUpperCase();
}


/**
* 字符byte[]转二进制
* @Title: hex2byte
* @Description: 字符byte[]转二进制
* @author: 王钧
* @date 2015-11-15
* @param b  数据源
* @return byte[]
*/
public static byte[] hex2byte(byte[] b) {
if ((b.length % 2) != 0)
throw new IllegalArgumentException();
byte[] b2 = new byte[b.length / 2];
for (int n = 0; n < b.length; n += 2) {
String item = new String(b, n, 2);
b2[n / 2] = (byte) Integer.parseInt(item, 16);
}
return b2;
}

/**
* 将byte数组以Base64方式编码为字符串
* @Title: encode
* @Description: 将byte数组以Base64方式编码为字符串
* @author: 王钧
* @date 2015-11-17
* @param bytes    bytes 待编码的byte数组
* @return String  编码后的字符串
* @throws
*/
public static String encode(byte[] bytes){
return null;//new sun.misc.BASE64Encoder().encode(bytes);
}


/**
* 将以Base64方式编码的字符串解码为byte数组
* @Title: decode
* @Description: 将以Base64方式编码的字符串解码为byte数组
* @author: 王钧
* @date 2015-1-22 上午10:13:51
* @param encodeStr   待解码的字符串
* @return            解码后的byte数组
* @throws IOException 
*/
public static byte[] decode(String encodeStr) throws IOException{
        byte[] bt = null;  
//        BASE64Decoder decoder = new BASE64Decoder();  
//        bt = decoder.decodeBuffer(encodeStr);
        return bt;
}

/**
* 根据源数据生成token
* @Title: generateToken
* @Description: 根据源数据生成token
* @author: 王钧
* @date 2015-11-17
* @param userName   用户名
* @param pwd           密码
* @param loginTime   登录时间(YYYYMMDDHHMMSS)
* @return            64位token
* @throws Exception
*/
public static String generateToken(String userName,String pwd,String loginTime) throws Exception{
String tokenSrcData = null;
String tokenSrcKey = null;

tokenSrcData = userName + pwd + loginTime + StringUtil.generateRandomNumber(6);
tokenSrcKey = pwd + loginTime + StringUtil.generateRandomNumber(6);

return generateToken(tokenSrcData, tokenSrcKey);
}

/**
* 根据token源数据和密钥源数据生成token
* @Title: generateToken
* @Description: 根据token源数据和密钥源数据生成token
* 密钥加密算法：Md5（密钥原始串）
* token加密算法：
* 1、DES算法加密
* 2、base64编码
* 3、Md5
* 4、将该Md5码和密钥间隔混编
* @author: 王钧
* @date 2015-11-17
* @param tokenSrcData   token源数据串，构成：用户名+密码+登录时间(YYYYMMDDHHMMSS)+6位随机干扰码
* @param tokenSrcKey    密钥源数据串，构成：密码+登录时间(YYYYMMDDHHMMSS)+6位随机干扰码
* @return            64位token
* @throws Exception
*/
public static String generateToken(String tokenSrcData,String tokenSrcKey) throws Exception{
//密钥：Md5（密钥原始串）
String tokenKey = Md5Util.md5(tokenSrcKey);
/**
* 加密算法：
* 1、DES算法加密
* 2、base64编码
* 3、Md5
* 4、将该Md5码和密钥间隔混编
*/
String desStr = DESUtil.encrypt(tokenSrcData,tokenKey);
String base64Str = DESUtil.encode(desStr.getBytes("UTF-8"));
String base64Md5Str = Md5Util.md5(base64Str);
byte[] bBase64 = base64Md5Str.getBytes("UTF-8");
byte[] bKey = tokenKey.getBytes("UTF-8");//存放于奇数下标
int aryLen = bKey.length;
byte[] allAry = new byte[2*aryLen];


for (int i=0;i<allAry.length;i++){
if (i%2==0){
allAry[i]=bBase64[i/2];
}else{
allAry[i]=bKey[i-(i/2+1)];
}
}
String tokenStr = new String(allAry,"UTF-8");
// System.out.println(tokenStr);
return tokenStr;
}

/**
* 从token中获取tokenId
* @Title: getTokenIdByToken
* @Description: 从token中获取tokenId
* @author: 王钧
* @date 2015-11-17
* @param token   token字符串
* @return            32位tokenId
* @throws Exception 
*/
public static String getTokenIdByToken(String token) throws Exception{
byte[] aryToken = token.getBytes("UTF-8");
byte[] aryB64 = new byte[aryToken.length/2];
for (int i=0;i<aryToken.length;i++){
if (i%2==0){
aryB64[i/2]=aryToken[i];
}
}
return new String(aryB64,"UTF-8");
}

/**
* 从token中获取DES密钥
* @Title: getDesKeyByToken
* @Description: 从token中获取DES密钥
* @author: 王钧
* @date 2015-11-17
* @param token   token字符串
* @return            32位DES密钥
* @throws Exception 
*/
public static String getDesKeyByToken(String token) throws Exception{
byte[] aryToken = token.getBytes("UTF-8");
byte[] aryKey = new byte[aryToken.length/2];
for (int i=0;i<aryToken.length;i++){
if (i%2>0){
aryKey[i-(i/2+1)]=aryToken[i];
}
}
return new String(aryKey,"UTF-8");
}


public static void main(String[] args) throws Exception {
// try {
// String loginTime = DateUtil.getNow(DateUtil.YMDHMS);
// //原始串：用户名+密码+登录时间(YYYYMMDDHHMMSS)+6随机干扰码
// String dataStr = "wangjun@taagoo.com"+Md5Util.md5("testpwd") + loginTime + StringUtil.generateRandomNumber(6);
// //密钥原始串：密码+登录时间(YYYYMMDDHHMMSS)+6随机干扰码
// String srcKey = Md5Util.md5("testpwd")+ loginTime + StringUtil.generateRandomNumber(6);
//
// String userName = "wangjun@taagoo.com";
// String pwd = Md5Util.md5("testpwd");
//
// System.out.println("==========token================");
// String token = DESUtil.generateToken(userName, pwd, loginTime);
// System.out.println(token);
// System.out.println("==========取出base64Md5================");
// System.out.println(DESUtil.getTokenIdByToken(token));
// System.out.println("==========取出密钥================");
// System.out.println(DESUtil.getDesKeyByToken(token));
//
// System.out.println("***********************验证输出****************************");
// //密钥：Md5（密钥原始串）
// String key = Md5Util.md5(srcKey);
// System.out.println("==========key================");
// System.out.println(key);
/**
* 加密算法：
* 1、DES算法加密
* 2、base64编码
* 3、Md5
* 4、将该Md5码和密钥间隔混编
*/
//String desStr = DESUtil.encrypt(dataStr,key);
// System.out.println("==========DES================");
// System.out.println(desStr);
// System.out.println("==========base64================");
//String base64Str = DESUtil.encode(desStr.getBytes("UTF-8"));
// System.out.println(base64Str);
// System.out.println("==========srcMd5================");
// System.out.println(Md5Util.md5(desStr));
// System.out.println("==========base64Md5================");
//String base64Md5Str = Md5Util.md5(base64Str);
// System.out.println(base64Md5Str);

// System.out.println("==========将base64Md5和密钥间隔混编后作为token================");
// byte[] bBase64 = base64Md5Str.getBytes("UTF-8");
// byte[] bKey = key.getBytes();//存放于奇数下标
// int aryLen = bKey.length;
// byte[] allAry = new byte[2*aryLen];
//
// for (int i=0;i<allAry.length;i++){
// if (i%2==0){
// allAry[i]=bBase64[i/2];
// }else{
// allAry[i]=bKey[i-(i/2+1)];
// }
// }
// String tokenStr = new String(allAry,"UTF-8");
// System.out.println(tokenStr);
// System.out.println("==========取出base64Md5================");
// byte[] aryToken = tokenStr.getBytes("UTF-8");
// byte[] aryB64 = new byte[aryToken.length/2];
// for (int i=0;i<aryToken.length;i++){
// if (i%2==0){
// aryB64[i/2]=aryToken[i];
// }
// }
// System.out.println(new String(aryB64,"UTF-8"));
// System.out.println("==========取出密钥================");
// byte[] aryKey = new byte[aryToken.length/2];
// for (int i=0;i<aryToken.length;i++){
// if (i%2>0){
// aryKey[i-(i/2+1)]=aryToken[i];
// }
// }
// System.out.println(new String(aryKey,"UTF-8"));
// System.out.println("==========解码================");
// System.out.println(DESUtil.decrypt(desStr,key));
//
// } catch (Exception e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }

// 数组1：0123
// 数组2：4567
//     期待结果：0=0;1=4;2=1;3=5;4=2;5=6;6=3;7=7
// 04152637
// String[] bBase64 = new String[]{"0","1","2","3"};
// String[] bKey = new String[]{"4","5","6","7"};
// int aryLen = bKey.length;
// String[] allAry = new String[2*aryLen];
//
// for (int i=0;i<allAry.length;i++){
// if (i%2==0){
// allAry[i]=bBase64[i/2];
// }else{
// allAry[i]=bKey[i-(i/2+1)];
// }
// System.out.print(";"+i+"="+allAry[i]);
// }
// System.out.println();
// for (int i=0;i<allAry.length;i++){
// System.out.print(allAry[i]);
// }

String desStr = DESUtil.encrypt("96E79218965EB72C92A549DD5A330112","4D66BF40CDF94E7156511A763B80C1DD");
System.out.println("==========DES================");
System.out.println(desStr);

String dcStr = DESUtil.decrypt(desStr, "4D66BF40CDF94E7156511A763B80C1DD");
System.out.println(dcStr);
}
}