以下两个类可以很方便的完成字符串的加密和解密

加密 CryptHelper encrypt（password）

解密 CrypHelper decrypt（password）

代码如下

CryptUtils java

[java]

package gdie lab crypt

import java io IOException

import javax crypto Cipher

import javax crypto KeyGenerator

import javax crypto SecretKey

import apache xerces internal impl dv util Base

public class CryptUtils {

private static String Algorithm = DES

private static byte[] DEFAULT_KEY=new byte[] { }

private static String VALUE_ENCODING= UTF

/**

* 生成密钥

*

* @return byte[] 返回生成的密钥

* @throws exception

*             扔出异常

*/

public static byte[] getSecretKey（） throws Exception {

KeyGenerator keygen = KeyGenerator getInstance（Algorithm）

SecretKey deskey = keygen generateKey（）

// if （debug ） System out println （ 生成密钥 +byte hex （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 （ 加密前的二进串 +byte hex （input ））

// System out println （ 加密前的字符串 +new String （input ））

//

// }

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher ENCRYPT_MODE deskey）

byte[] cipherByte = c doFinal（input）

// if （debug ） System out println （ 加密后的二进串 +byte hex （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 （ 解密前的信息 +byte hex （input ））

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher DECRYPT_MODE deskey）

byte[] clearByte = c doFinal（input）

// if （debug ）

// {

// System out println （ 解密后的二进串 +byte hex （clearByte ））

// System out println （ 解密后的字符串 +（new String （clearByte ）））

//

// }

return clearByte

}

public static byte[] decryptData（byte[] input） throws Exception {

return decryptData（input DEFAULT_KEY）

}

/**

* 字节码转换成 进制字符串

*

* @param byte[] b 输入要转换的字节码

* @return String 返回转换后的 进制字符串

*/

public static String byte hex（byte[] bytes） {

StringBuilder hs = new StringBuilder（）

for（byte b : bytes）

hs append（String format（ % $ X b））

return hs toString（）

}

public static byte[] hex byte（String content） {

int l=content length（）》

byte[] result=new byte[l]

for（int i= i<li++） {

int j=i《

String s=content substring（j j+ ）

result[i]=Integer valueOf（s ） byteValue（）

}

return result

}

/**

* 将字节数组转换为base 编码字符串

* @param buffer

* @return

*/

public static String bytesToBase （byte[] buffer） {

//BASE Encoder en=new BASE Encoder（）

return Base encode（buffer）

//      return encoder encode（buffer）

}

/**

* 将base 编码的字符串解码为字节数组

* @param value

* @return

* @throws IOException

*/

public static byte[] base ToBytes（String value） throws IOException {

//return Base decodeToByteArray（value）

//      System out println（decoder decodeBuffer（value））

//      return decoder decodeBuffer（value）

return Base decode（value）

}

/**

* 加密给定的字符串

* @param value

* @return 加密后的base 字符串

*/

public static String encryptString（String value） {

return encryptString（value DEFAULT_KEY）

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 以BASE 形式存在的密钥

* @return 加密后的base 字符串

* @throws IOException

*/

public static String encryptString（String value String key） throws IOException {

return encryptString（value base ToBytes（key））

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 字节数组形式的密钥

* @return 加密后的base 字符串

*/

public static String encryptString（String value byte[] key） {

try {

byte[] data=value getBytes（VALUE_ENCODING）

data=CryptUtils encryptData（data key）

return bytesToBase （data）

} catch （Exception e） {

// TODO Auto generated catch block

e printStackTrace（）

return null

}

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @return 明文

*/

public static String decryptString（String value） {

return decryptString（value DEFAULT_KEY）

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key base 形式存在的密钥

* @return 明文

* @throws IOException

*/

public static String decryptString（String value String key） throws IOException {

String s=decryptString（value base ToBytes（key））

return s

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key 字节数据形式存在的密钥

* @return 明文

*/

public static String decryptString（String value byte[] key） {

try {

byte[] data=base ToBytes（value）

data=CryptUtils decryptData（data key）

return new String（data VALUE_ENCODING）

}catch（Exception e） {

e printStackTrace（）

return null

}

}

}

package gdie lab crypt

import java io IOException

import javax crypto Cipher

import javax crypto KeyGenerator

import javax crypto SecretKey

import apache xerces internal impl dv util Base

public class CryptUtils {

private static String Algorithm = DES

private static byte[] DEFAULT_KEY=new byte[] { }

private static String VALUE_ENCODING= UTF

/**

* 生成密钥

*

* @return byte[] 返回生成的密钥

* @throws exception

*             扔出异常

*/

public static byte[] getSecretKey（） throws Exception {

KeyGenerator keygen = KeyGenerator getInstance（Algorithm）

SecretKey deskey = keygen generateKey（）

// if （debug ） System out println （ 生成密钥 +byte hex （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 （ 加密前的二进串 +byte hex （input ））

// System out println （ 加密前的字符串 +new String （input ））

//

// }

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher ENCRYPT_MODE deskey）

byte[] cipherByte = c doFinal（input）

// if （debug ） System out println （ 加密后的二进串 +byte hex （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 （ 解密前的信息 +byte hex （input ））

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher DECRYPT_MODE deskey）

byte[] clearByte = c doFinal（input）

// if （debug ）

// {

// System out println （ 解密后的二进串 +byte hex （clearByte ））

// System out println （ 解密后的字符串 +（new String （clearByte ）））

//

// }

return clearByte

}

public static byte[] decryptData（byte[] input） throws Exception {

return decryptData（input DEFAULT_KEY）

}

/**

* 字节码转换成 进制字符串

*

* @param byte[] b 输入要转换的字节码

* @return String 返回转换后的 进制字符串

*/

public static String byte hex（byte[] bytes） {

StringBuilder hs = new StringBuilder（）

for（byte b : bytes）

hs append（String format（ % $ X b））

return hs toString（）

}

public static byte[] hex byte（String content） {

int l=content length（）》

byte[] result=new byte[l]

for（int i= i<li++） {

int j=i《

String s=content substring（j j+ ）

result[i]=Integer valueOf（s ） byteValue（）

}

return result

}

/**

* 将字节数组转换为base 编码字符串

* @param buffer

* @return

*/

public static String bytesToBase （byte[] buffer） {

//BASE Encoder en=new BASE Encoder（）

return Base encode（buffer）

//  return encoder encode（buffer）

}

/**

* 将base 编码的字符串解码为字节数组

* @param value

* @return

* @throws IOException

*/

public static byte[] base ToBytes（String value） throws IOException {

//return Base decodeToByteArray（value）

//  System out println（decoder decodeBuffer（value））

//  return decoder decodeBuffer（value）

return Base decode（value）

}

/**

* 加密给定的字符串

* @param value

* @return 加密后的base 字符串

*/

public static String encryptString（String value） {

return encryptString（value DEFAULT_KEY）

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 以BASE 形式存在的密钥

* @return 加密后的base 字符串

* @throws IOException

*/

public static String encryptString（String value String key） throws IOException {

return encryptString（value base ToBytes（key））

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 字节数组形式的密钥

* @return 加密后的base 字符串

*/

public static String encryptString（String value byte[] key） {

try {

byte[] data=value getBytes（VALUE_ENCODING）

data=CryptUtils encryptData（data key）

return bytesToBase （data）

} catch （Exception e） {

// TODO Auto generated catch block

e printStackTrace（）

return null

}

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @return 明文

*/

public static String decryptString（String value） {

return decryptString（value DEFAULT_KEY）

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key base 形式存在的密钥

* @return 明文

* @throws IOException

*/

public static String decryptString（String value String key） throws IOException {

String s=decryptString（value base ToBytes（key））

return s

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key 字节数据形式存在的密钥

* @return 明文

*/

public static String decryptString（String value byte[] key） {

try {

byte[] data=base ToBytes（value）

data=CryptUtils decryptData（data key）

return new String（data VALUE_ENCODING）

}catch（Exception e） {

e printStackTrace（）

return null

}

}

}

CryptHelper java

[java]

package gdie lab crypt

import javax crypto Cipher

import javax crypto SecretKey

import javax crypto SecretKeyFactory

import javax crypto spec DESKeySpec

import javax crypto spec IvParameterSpec

import springframework util DigestUtils

public class CryptHelper{

private static String CRYPT_KEY = zhongqian

//加密

private static Cipher ecip

//解密

private static Cipher dcip

static {

try {

String KEY = DigestUtils md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）

KEY = KEY substring（ ）

byte[] bytes = KEY getBytes（）

DESKeySpec ks = new DESKeySpec（bytes）

SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）

SecretKey sk = skf generateSecret（ks）

IvParameterSpec iv = new IvParameterSpec（bytes）

ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）

ecip init（Cipher ENCRYPT_MODE sk iv ）

dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）

dcip init（Cipher DECRYPT_MODE sk iv ）

}catch（Exception ex） {

ex printStackTrace（）

}

}

public static String encrypt（String content） throws Exception {

byte[] bytes = ecip doFinal（content getBytes（ ascii ））

return CryptUtils byte hex（bytes）

}

public static String decrypt（String content） throws Exception {

byte[] bytes  = CryptUtils hex byte（content）

bytes = dcip doFinal（bytes）

return new String（bytes ascii ）

}

//test

public static void main（String[] args） throws Exception {

String password = gly

String en = encrypt（password）

System out println（en）

System out println（decrypt（en））

}

}

package gdie lab crypt

import javax crypto Cipher

import javax crypto SecretKey

import javax crypto SecretKeyFactory

import javax crypto spec DESKeySpec

import javax crypto spec IvParameterSpec

import springframework util DigestUtils

public class CryptHelper{

private static String CRYPT_KEY = zhongqian

//加密

private static Cipher ecip

//解密

private static Cipher dcip

static {

try {

String KEY = DigestUtils md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）

KEY = KEY substring（ ）

byte[] bytes = KEY getBytes（）

DESKeySpec ks = new DESKeySpec（bytes）

SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）

SecretKey sk = skf generateSecret（ks）

IvParameterSpec iv = new IvParameterSpec（bytes）

ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）

ecip init（Cipher ENCRYPT_MODE sk iv ）

dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）

dcip init（Cipher DECRYPT_MODE sk iv ）

}catch（Exception ex） {

ex printStackTrace（）

}

}

public static String encrypt（String content） throws Exception {

byte[] bytes = ecip doFinal（content getBytes（ ascii ））

return CryptUtils byte hex（bytes）

}

public static String decrypt（String content） throws Exception {

byte[] bytes  = CryptUtils hex byte（content）

bytes = dcip doFinal（bytes）

return new String（bytes ascii ）

}

//test

public static void main（String[] args） throws Exception {

String password = gly

String en = encrypt（password）

System out println（en）

System out println（decrypt（en））

}

lishixinzhi/Article/program/Java/hx/201311/26449

Java基本的单向加密算法：

1.BASE64 严格地说，属于编码格式，而非加密算法

2.MD5(Message Digest algorithm 5，信息摘要算法)

3.SHA(Secure Hash Algorithm，安全散列算法)

4.HMAC(Hash Message Authentication Code，散列消息鉴别码)

按 照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计用来把任意序列的8位字节描述为一种不易被人直接识别的形式。（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）

常见于邮件、http加密，截取http信息，你就会发现登录操作的用户名、密码字段通过BASE64加密的。

主要就是BASE64Encoder、BASE64Decoder两个类，我们只需要知道使用对应的方法即可。另，BASE加密后产生的字节位数是8的倍数，如果不够位数以=符号填充。

MD5

MD5 -- message-digest algorithm 5 （信息-摘要算法）缩写，广泛用于加密和解密技术，常用于文件校验。校验？不管文件多大，经过MD5后都能生成唯一的MD5值。好比现在的ISO校验，都 是MD5校验。怎么用？当然是把ISO经过MD5后产生MD5的值。一般下载linux-ISO的朋友都见过下载链接旁边放着MD5的串。就是用来验证文 件是否一致的。

HMAC

HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个 标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证 等。

简单的Java加密算法有：

第一种. BASE

Base是网络上最常见的用于传输Bit字节代码的编码方式之一，大家可以查看RFC～RFC，上面有MIME的详细规范。Base编码可用于在HTTP环境下传递较长的标识信息。例如，在Java Persistence系统Hibernate中，就采用了Base来将一个较长的唯一标识符（一般为-bit的UUID）编码为一个字符串，用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中，也常常需要把二进制数据编码为适合放在URL（包括隐藏表单域）中的形式。此时，采用Base编码具有不可读性，即所编码的数据不会被人用肉眼所直接看到。

第二种. MD

MD即Message-Digest Algorithm （信息-摘要算法），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD的前身有MD、MD和MD。广泛用于加密和解密技术，常用于文件校验。校验？不管文件多大，经过MD后都能生成唯一的MD值。好比现在的ISO校验，都是MD校验。怎么用？当然是把ISO经过MD后产生MD的值。一般下载linux-ISO的朋友都见过下载链接旁边放着MD的串。就是用来验证文件是否一致的。

MD算法具有以下特点：

压缩性：任意长度的数据，算出的MD值长度都是固定的。

容易计算：从原数据计算出MD值很容易。

抗修改性：对原数据进行任何改动，哪怕只修改个字节，所得到的MD值都有很大区别。

弱抗碰撞：已知原数据和其MD值，想找到一个具有相同MD值的数据（即伪造数据）是非常困难的。

强抗碰撞：想找到两个不同的数据，使它们具有相同的MD值，是非常困难的。

MD的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩”成一种保密的格式（就是把一个任意长度的字节串变换成一定长的十六进制数字串）。除了MD以外，其中比较有名的还有sha-、RIPEMD以及Haval等。

第三种.SHA

安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于^位的消息，SHA会产生一个位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善，并被广泛使用。该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。

SHA-与MD的比较

因为二者均由MD导出，SHA-和MD彼此很相似。相应的，他们的强度和其他特性也是相似，但还有以下几点不同：

对强行攻击的安全性：最显著和最重要的区别是SHA-摘要比MD摘要长 位。使用强行技术，产生任何一个报文使其摘要等于给定报摘要的难度对MD是^数量级的操作，而对SHA-则是^数量级的操作。这样，SHA-对强行攻击有更大的强度。

对密码分析的安全性：由于MD的设计，易受密码分析的攻击，SHA-显得不易受这样的攻击。

速度：在相同的硬件上，SHA-的运行速度比MD慢。

第四种.HMAC

HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证等。

---