【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";

/**

* 生成密钥