Java 加密解密之消息摘要算法（MD5 SHA MAC）

Java 加密解密基础Java byte数组与十六进制字符串互转Java BASE64加密解密Java 加密解密之消息摘要算法（MD5 SHA MAC）Java 加密解密之对称加密算法DESJava 加密解密之对称加密算法DESedeJava 加密解密之对称加密算法AESJava 加密解密之对称加密算法PBEJava 加密解密之消息摘要算法（MD5 SHA MAC）消息摘要消息摘要（Message Digest）又称为数字摘要(Digital Digest)。它是一个唯一对应一个消息或文本的固定长度的值，它由一个单向Hash加密函数对消息进行作用而产生。如果消息在途中改变了，则接收者通过对收到消息的新产生的摘要与原摘要比较，就可知道消息是否被改变了。因此消息摘要保证了消息的完整性。消息摘要采用单向Hash 函数将需加密 的明文"摘要"成一串128bit的密文，这一串密文亦称为数字指纹(Finger Print)，它有固定的长度，且不同的明文摘要成密文，其结果总是不同的，而同样的明文其摘要必定一致 。这样这串摘要便可成为验证明文是否是"真身"的"指纹"了。HASH函数的抗冲突性使得如果一段明文稍有变化，哪怕只更改该段落的一个字母，通过哈希算法作用后都将产生不同的值。而HASH算法的单向性使得要找到到哈希值相同的两个不 同的输入消息，在计算上是不可能的。所以数据的哈希值，即消息摘要，可以检验数据的完整性。哈希函数的这种对不同的输入能够生成不同的值的特性使得无法找到两个具有相同哈希值的输入。因此，如果两个文档经哈希转换后成为相同的值，就可以肯定它们是同一文档。 所以，当希望有效地比较两个数据块时，就可以比较它们的哈希值。例如，可以通过比较邮件发送前和发送后的哈希值来验证该邮件在传递时是否修改。消息摘要算法消息摘要算法的主要特征是加密过程不需要密钥，并且经过加密的数据无法被解密，只有输入相同的明文数据经过相同的消息摘要算法才能得到相同的密文。消息摘要算法不存在 密钥的管理与分发问题，适合于分布式网络相同上使用。由于其加密计算的工作量相当可观，所以以前的这种算法通常只用于数据量有限的情况下的加密，例如计算机的口令就是 用不可逆加密算法加密的。近年来，随着计算机相同性能的飞速改善，加密速度不再成为限制这种加密技术发展的桎梏，因而消息摘要算法应用的领域不断增加。消息摘要算法的特点：① 无论输入的消息有多长，计算出来的消息摘要的长度总是固定的。② 消息摘要看起来是“随机的”。这些比特看上去是胡乱的杂凑在一起的。③ 一般地，只要输入的消息不同，对其进行摘要以后产生的摘要消息也必不相同；但相同的输入必会产生相同的输出。④ 消息摘要函数是无陷门的单向函数，即只能进行正向的信息摘要，而无法从摘要中恢复出任何的消息，甚至根本就找不到任何与原信息相关的信息。⑤ 好的摘要算法，无法找到两条消息，是它们的摘要相同。现有的消息摘要算法消息摘要算法包含MD、SHA和MAC三大系列，常用于验证数据的完整性，是数据签名算法的核心算法。MAC与MD和SHA不同，MAC是含有密钥的散列函数算法，我们也常把MAC称为HMAC。JDK对消息摘要算法的支持JDK6支持MD2/MD5/SHA/SHA256/SHA384/SHA512/HmacMD5/HmacSHA1/ HmacSHA256/HmacSHA384/HmacSHA512使用到 十六进制工具类Hex.java 见： java byte数组与十六进制字符串互转MD和SHA系列的java实现：DigestUtils.javaJava代码

package com.test;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DateFormat;
import java.util.Date;

/**
* reference apache commons <a
* href="http://commons.apache.org/codec/">http://commons.apache.org/codec/</a>
*
* support MD2/MD5/SHA/SHA256/SHA384/SHA512
* @author Aub
*
*/
public class DigestUtils {

/**
* 根据给定摘要算法创建一个消息摘要实例
*
* @param algorithm
*            摘要算法名
* @return 消息摘要实例
* @see MessageDigest#getInstance(String)
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
static MessageDigest getDigest(String algorithm) {
try {
return MessageDigest.getInstance(algorithm);
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e.getMessage());
}
}

/**
* 获取 MD5 消息摘要实例
*
* @return MD5 消息摘要实例
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
private static MessageDigest getMd5Digest() {
return getDigest("MD5");
}

/**
* 获取 SHA-1 消息摘要实例
*
* @return SHA-1 消息摘要实例
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
private static MessageDigest getShaDigest() {
return getDigest("SHA");
}

/**
* 获取 SHA-256 消息摘要实例
*
* @return SHA-256 消息摘要实例
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
private static MessageDigest getSha256Digest() {
return getDigest("SHA-256");
}

/**
* 获取 SHA-384 消息摘要实例
*
* @return SHA-384 消息摘要实例
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
private static MessageDigest getSha384Digest() {
return getDigest("SHA-384");
}

/**
* 获取 SHA-512 消息摘要实例
*
* @return SHA-512 消息摘要实例
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
private static MessageDigest getSha512Digest() {
return getDigest("SHA-512");
}

/**
* 使用MD5消息摘要算法计算消息摘要
*
* @param data
*            做消息摘要的数据
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeMD5(byte[] data) {
return getMd5Digest().digest(data);
}

/**
* 使用MD5消息摘要算法计算消息摘要
*
* @param data
*            做消息摘要的数据
* @return 消息摘要（长度为32的十六进制字符串）
*/
public static String encodeMD5Hex(byte[] data) {
return Hex.byte2HexStr(encodeMD5(data));
}

/**
* 使用SHA-1消息摘要算法计算消息摘要
*
* @param data
*            做消息摘要的数据
* @return SHA-1消息摘要（长度为20的字节数组）
*/
public static byte[] encodeSHA(byte[] data) {
return getShaDigest().digest(data);
}

/**
* 使用SHA-1消息摘要算法计算消息摘要
*
* @param data
*            做消息摘要的数据
* @return SHA-1消息摘要（长度为40的十六进制字符串）
*/
public static String encodeSHAHex(byte[] data) {
return Hex.byte2HexStr(getShaDigest().digest(data));
}

/**
* 使用SHA-256消息摘要算法计算消息摘要
*
* @param data
*            做消息摘要的数据
* @return SHA-256消息摘要（长度为32的字节数组）
*/
public static byte[] encodeSHA256(byte[] data) {
return getSha256Digest().digest(data);
}

/**
* 使用SHA-256消息摘要算法计算消息摘要
*
* @param data
*            做消息摘要的数据
* @return SHA-256消息摘要（长度为64的十六进制字符串）
*/
public static String encodeSHA256Hex(byte[] data) {
return Hex.byte2HexStr(encodeSHA256(data));
}

/**
* 使用SHA-384消息摘要算法计算消息摘要
*
* @param data
*            做消息摘要的数据
* @return SHA-384消息摘要（长度为43的字节数组）
*/
public static byte[] encodeSHA384(byte[] data) {
return getSha384Digest().digest(data);
}

/**
* 使用SHA-384消息摘要算法计算消息摘要
*
* @param data
*            做消息摘要的数据
* @return SHA-384消息摘要（长度为86的十六进制字符串）
*/
public static String encodeSHA384Hex(byte[] data) {
return Hex.byte2HexStr(encodeSHA384(data));
}

/**
* 使用SHA-512消息摘要算法计算消息摘要
*
* @param data
*            做消息摘要的数据
* @return SHA-512消息摘要（长度为64的字节数组）
*/
public static byte[] encodeSHA512(byte[] data) {
return getSha512Digest().digest(data);
}

/**
* 使用SHA-512消息摘要算法计算消息摘要
*
* @param data
*            做消息摘要的数据
* @return SHA-512消息摘要（长度为128的十六进制字符串）
*/
public static String encodeSHA512Hex(byte[] data) {
return Hex.byte2HexStr(encodeSHA512(data));
}

public static void main(String[] args) {
// TODO Auto-generated method stub
String time = "helloword";
String result = encodeSHAHex(time.getBytes());
System.out.println(time);
System.out.println(result);

}
}

Hex.java

/*
*    Copyright 2012-2013 The Haohui Network Corporation
*/
package com.test;

/**
* <pre>
* 16进制值与String/Byte之间的转换
* @author JerryLi
* @email lijian@dzs.mobi
* @data 2011-10-16
* http://blog.csdn.net/hzbigdog/article/details/6877712 *
* http://www.blogjava.net/lijinglin/archive/2011/11/02/362567.html * </pre>
*
* @project baidamei
* @author cevencheng <cevencheng@gmail.com>
* @create 2012-11-14 下午5:53:14
*/
public class Hex {
/**
* 字符串转换成十六进制字符串
*
* @param String
*            str 待转换的ASCII字符串
* @return String 每个Byte之间空格分隔，如: [61 6C 6B]
*/
public static String str2HexStr(String str) {

char[] chars = "0123456789ABCDEF".toCharArray();
StringBuilder sb = new StringBuilder("");
byte[] bs = str.getBytes();
int bit;

for (int i = 0; i < bs.length; i++) {
bit = (bs[i] & 0x0f0) >> 4;
sb.append(chars[bit]);
bit = bs[i] & 0x0f;
sb.append(chars[bit]);
sb.append(' ');
}
return sb.toString().trim();
}

/**
* 十六进制转换字符串
*
* @param String
*            str Byte字符串(Byte之间无分隔符 如:[616C6B])
* @return String 对应的字符串
*/
public static String hexStr2Str(String hexStr) {
String str = "0123456789ABCDEF";
char[] hexs = hexStr.toCharArray();
byte[] bytes = new byte[hexStr.length() / 2];
int n;

for (int i = 0; i < bytes.length; i++) {
n = str.indexOf(hexs[2 * i]) * 16;
n += str.indexOf(hexs[2 * i + 1]);
bytes[i] = (byte) (n & 0xff);
}
return new String(bytes);
}

/**
* bytes转换成十六进制字符串
*
* @param byte[] b byte数组
* @return String 每个Byte值之间空格分隔
*/
public static String byte2HexStr(byte[] b) {
String stmp = "";
StringBuilder sb = new StringBuilder("");
for (int n = 0; n < b.length; n++) {
stmp = Integer.toHexString(b
& 0xFF);
sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
//			sb.append(" ");
}
return sb.toString().toUpperCase().trim();
}

/**
* bytes字符串转换为Byte值
*
* @param String
*            src Byte字符串，每个Byte之间没有分隔符
* @return byte[]
*/
public static byte[] hexStr2Bytes(String src) {
int m = 0, n = 0;
int l = src.length() / 2;
System.out.println(l);
byte[] ret = new byte[l];
for (int i = 0; i < l; i++) {
m = i * 2 + 1;
n = m + 1;
ret[i] = Byte.decode("0x" + src.substring(i * 2, m) + src.substring(m, n));
}
return ret;
}

/**
* String的字符串转换成unicode的String
*
* @param String
*            strText 全角字符串
* @return String 每个unicode之间无分隔符
* @throws Exception
*/
public static String strToUnicode(String strText) throws Exception {
char c;
StringBuilder str = new StringBuilder();
int intAsc;
String strHex;
for (int i = 0; i < strText.length(); i++) {
c = strText.charAt(i);
intAsc = (int) c;
strHex = Integer.toHexString(intAsc);
if (intAsc > 128)
str.append("\\u" + strHex);
else
// 低位在前面补00
str.append("\\u00" + strHex);
}
return str.toString();
}

/**
* unicode的String转换成String的字符串
*
* @param String
*            hex 16进制值字符串 （一个unicode为2byte）
* @return String 全角字符串
*/
public static String unicodeToString(String hex) {
int t = hex.length() / 6;
StringBuilder str = new StringBuilder();
for (int i = 0; i < t; i++) {
String s = hex.substring(i * 6, (i + 1) * 6);
// 高位需要补上00再转
String s1 = s.substring(2, 4) + "00";
// 低位直接转
String s2 = s.substring(4);
// 将16进制的string转为int
int n = Integer.valueOf(s1, 16) + Integer.valueOf(s2, 16);
// 将int转换为字符
char[] chars = Character.toChars(n);
str.append(new String(chars));
}
return str.toString();
}

public static void main(String[] args) {

String hex = "ef2c71b29202f3e642f2abd8d518f367ec3fbf6a6a61beb678ae0c871ee368ac";
System.out.println(Hex.hexStr2Str(hex));
}
}

MAC系列的java实现Hmac.javaJava代码

import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;

import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**
* Hmac<br/>
* algorithm HmacMD5/HmacSHA/HmacSHA256/HmacSHA384/HmacSHA512
* @author Aub
*/
public class Hmac {

/**
* 根据给定密钥生成算法创建密钥
*
* @param algorithm
*            密钥算法
* @return 密钥
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
private static byte[] getHmacKey(String algorithm){
//初始化KeyGenerator
KeyGenerator keyGenerator = null;
try {
keyGenerator = KeyGenerator.getInstance(algorithm);
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e.getMessage());
}
//产生密钥
SecretKey secretKey = keyGenerator.generateKey();
//获得密钥
return secretKey.getEncoded();
}

/**
* 获取 HmaMD5的密钥
*
* @return  HmaMD5的密钥
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
public static byte[] getHmaMD5key(){
return getHmacKey("HmacMD5");
}

/**
* 获取 HmaSHA的密钥
*
* @return  HmaSHA的密钥
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
public static byte[] getHmaSHAkey(){
return getHmacKey("HmacSHA1");
}

/**
* 获取 HmaSHA256的密钥
*
* @return  HmaSHA256的密钥
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
public static byte[] getHmaSHA256key(){
return getHmacKey("HmacSHA256");
}

/**
* 获取 HmaSHA384的密钥
*
* @return  HmaSHA384的密钥
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
public static byte[] getHmaSHA384key(){
return getHmacKey("HmacSHA384");
}

/**
* 获取 HmaSHA512的密钥
*
* @return  HmaSHA384的密钥
* @throws RuntimeException
*             当 {@link java.security.NoSuchAlgorithmException} 发生时
*/
public static byte[] getHmaSHA512key(){
return getHmacKey("HmacSHA512");
}

/**
* 转换密钥
*
* @param key	二进制密钥
* @param algorithm	密钥算法
* @return 密钥
*/
private static Key toKey(byte[] key,String algorithm){
//生成密钥
return new SecretKeySpec(key, algorithm);
}

/**
* 使用HmacMD5消息摘要算法计算消息摘要
*
* @param data 做消息摘要的数据
* @param key 密钥
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeHmacMD5(byte[] data, Key key){
Mac mac = null;
try {
mac = Mac.getInstance("HmacMD5");
mac.init(key);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return new byte[0];
}catch (InvalidKeyException e) {
e.printStackTrace();
return new byte[0];
}
return mac.doFinal(data);
}

/**
* 使用HmacMD5消息摘要算法计算消息摘要
*
* @param data 做消息摘要的数据
* @param key 密钥
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeHmacMD5(byte[] data, byte[] key){
Key k = toKey(key, "HmacMD5");
return encodeHmacMD5(data, k);
}

/**
* 使用HmacSHA消息摘要算法计算消息摘要
*
* @param data 做消息摘要的数据
* @param key 密钥
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeHmacSHA(byte[] data, Key key){
Mac mac = null;
try {
mac = Mac.getInstance("HmacSHA1");
mac.init(key);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return new byte[0];
}catch (InvalidKeyException e) {
e.printStackTrace();
return new byte[0];
}
return mac.doFinal(data);
}

/**
* 使用HmacSHA消息摘要算法计算消息摘要
*
* @param data 做消息摘要的数据
* @param key 密钥
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeHmacSHA(byte[] data, byte[] key){
Key k = toKey(key, "HmacSHA1");
return encodeHmacSHA(data, k);
}

/**
* 使用HmacSHA256消息摘要算法计算消息摘要
*
* @param data 做消息摘要的数据
* @param key 密钥
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeHmacSHA256(byte[] data, Key key){
Mac mac = null;
try {
mac = Mac.getInstance("HmacSHA256");
mac.init(key);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return new byte[0];
}catch (InvalidKeyException e) {
e.printStackTrace();
return new byte[0];
}
return mac.doFinal(data);
}

/**
* 使用HmacSHA256消息摘要算法计算消息摘要
*
* @param data 做消息摘要的数据
* @param key 密钥
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeHmacSHA256(byte[] data, byte[] key){
Key k = toKey(key, "HmacSHA256");
return encodeHmacSHA256(data, k);
}

/**
* 使用HmacSHA384消息摘要算法计算消息摘要
*
* @param data 做消息摘要的数据
* @param key 密钥
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeHmacSHA384(byte[] data, Key key){
Mac mac = null;
try {
mac = Mac.getInstance("HmacSHA384");
mac.init(key);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return new byte[0];
}catch (InvalidKeyException e) {
e.printStackTrace();
return new byte[0];
}
return mac.doFinal(data);
}

/**
* 使用HmacSHA384消息摘要算法计算消息摘要
*
* @param data 做消息摘要的数据
* @param key 密钥
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeHmacSHA384(byte[] data, byte[] key){
Key k = toKey(key, "HmacSHA384");
return encodeHmacSHA384(data, k);
}

/**
* 使用HmacSHA512消息摘要算法计算消息摘要
*
* @param data 做消息摘要的数据
* @param key 密钥
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeHmacSHA512(byte[] data, Key key){
Mac mac = null;
try {
mac = Mac.getInstance("HmacSHA512");
mac.init(key);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return new byte[0];
}catch (InvalidKeyException e) {
e.printStackTrace();
return new byte[0];
}
return mac.doFinal(data);
}

/**
* 使用HmacSHA512消息摘要算法计算消息摘要
*
* @param data 做消息摘要的数据
* @param key 密钥
* @return 消息摘要（长度为16的字节数组）
*/
public static byte[] encodeHmacSHA512(byte[] data, byte[] key){
Key k = toKey(key, "HmacSHA512");
return encodeHmacSHA512(data, k);
}

private static String  showByteArray(byte[] data){
if(null == data){
return null;
}
StringBuilder sb = new StringBuilder("{");
for(byte b:data){
sb.append(b).append(",");
}
sb.deleteCharAt(sb.length()-1);
sb.append("}");
return sb.toString();
}

public static void main(String[] args) {
//		byte[] key = getHmaMD5key();
//		byte[] key = getHmaSHAkey();
//		byte[] key = getHmaSHA256key();
//		byte[] key = getHmaSHA384key();
byte[] key = getHmaSHA512key();

System.out.println("加密密钥: byte[]:"+showByteArray(key).length());

String data = "Mac数据";
System.out.println("加密前数据: string:"+data);
System.out.println("加密前数据: byte[]:"+showByteArray(data.getBytes()));
System.out.println();
//		byte[] encodeData = encodeHmacMD5(data.getBytes(), key);
//		byte[] encodeData = encodeHmacSHA(data.getBytes(), key);
//		byte[] encodeData = encodeHmacSHA256(data.getBytes(), key);
//		byte[] encodeData = encodeHmacSHA384(data.getBytes(), key);
byte[] encodeData = encodeHmacSHA512(data.getBytes(), key);
System.out.println("加密后数据: byte[]:"+showByteArray(encodeData).length());
System.out.println("加密后数据: byte[]:"+encodeData.length);
System.out.println("加密后数据: hexStr:"+Hex.encodeHexStr(encodeData));
System.out.println();
}
}

另一种加密解密的方法

转自：/article/3784515.html

package com.test;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.security.*;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;/*** 加密解密** @author shy.qiu* @since  http://blog.csdn.net/qiushyfm */public class CryptUtil {/*** 进行MD5加密** @param info*            要加密的信息* @return String 加密后的字符串*/public String encryptToMD5(String info) {byte[] digesta = null;try {// 得到一个md5的消息摘要MessageDigest alga = MessageDigest.getInstance("MD5");// 添加要进行计算摘要的信息alga.update(info.getBytes());// 得到该摘要digesta = alga.digest();} catch (NoSuchAlgorithmException e) {e.printStackTrace();}// 将摘要转为字符串String rs = byte2hex(digesta);return rs;}/*** 进行SHA加密** @param info*            要加密的信息* @return String 加密后的字符串*/public String encryptToSHA(String info) {byte[] digesta = null;try {// 得到一个SHA-1的消息摘要MessageDigest alga = MessageDigest.getInstance("SHA-1");// 添加要进行计算摘要的信息alga.update(info.getBytes());// 得到该摘要digesta = alga.digest();} catch (NoSuchAlgorithmException e) {e.printStackTrace();}// 将摘要转为字符串String rs = byte2hex(digesta);return rs;}// ///////////////////////////////////////////////////////////////////////////*** 创建密匙** @param algorithm*            加密算法,可用 DES,DESede,Blowfish* @return SecretKey 秘密（对称）密钥*/public SecretKey createSecretKey(String algorithm) {// 声明KeyGenerator对象KeyGenerator keygen;// 声明 密钥对象SecretKey deskey = null;try {// 返回生成指定算法的秘密密钥的 KeyGenerator 对象keygen = KeyGenerator.getInstance(algorithm);// 生成一个密钥deskey = keygen.generateKey();} catch (NoSuchAlgorithmException e) {e.printStackTrace();}// 返回密匙return deskey;}/*** 根据密匙进行DES加密** @param key*            密匙* @param info*            要加密的信息* @return String 加密后的信息*/public String encryptToDES(SecretKey key, String info) {// 定义 加密算法,可用 DES,DESede,BlowfishString Algorithm = "DES";// 加密随机数生成器 (RNG),(可以不写)SecureRandom sr = new SecureRandom();// 定义要生成的密文byte[] cipherByte = null;try {// 得到加密/解密器Cipher c1 = Cipher.getInstance(Algorithm);// 用指定的密钥和模式初始化Cipher对象// 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)c1.init(Cipher.ENCRYPT_MODE, key, sr);// 对要加密的内容进行编码处理,cipherByte = c1.doFinal(info.getBytes());} catch (Exception e) {e.printStackTrace();}// 返回密文的十六进制形式return byte2hex(cipherByte);}/*** 根据密匙进行DES解密** @param key*            密匙* @param sInfo*            要解密的密文* @return String 返回解密后信息*/public String decryptByDES(SecretKey key, String sInfo) {// 定义 加密算法,String Algorithm = "DES";// 加密随机数生成器 (RNG)SecureRandom sr = new SecureRandom();byte[] cipherByte = null;try {// 得到加密/解密器Cipher c1 = Cipher.getInstance(Algorithm);// 用指定的密钥和模式初始化Cipher对象c1.init(Cipher.DECRYPT_MODE, key, sr);// 对要解密的内容进行编码处理cipherByte = c1.doFinal(hex2byte(sInfo));} catch (Exception e) {e.printStackTrace();}// return byte2hex(cipherByte);return new String(cipherByte);}// //////////////////////////////////////////////////////////////////////////////*** 创建密匙组，并将公匙，私匙放入到指定文件中** 默认放入mykeys.bat文件中*/public void createPairKey() {try {// 根据特定的算法一个密钥对生成器KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");// 加密随机数生成器 (RNG)SecureRandom random = new SecureRandom();// 重新设置此随机对象的种子random.setSeed(1000);// 使用给定的随机源（和默认的参数集合）初始化确定密钥大小的密钥对生成器keygen.initialize(512, random);// keygen.initialize(512);// 生成密钥组KeyPair keys = keygen.generateKeyPair();// 得到公匙PublicKey pubkey = keys.getPublic();// 得到私匙PrivateKey prikey = keys.getPrivate();// 将公匙私匙写入到文件当中doObjToFile("mykeys.bat", new Object[] { prikey, pubkey });} catch (NoSuchAlgorithmException e) {e.printStackTrace();}}/*** 利用私匙对信息进行签名 把签名后的信息放入到指定的文件中** @param info*            要签名的信息* @param signfile*            存入的文件*/public void signToInfo(String info, String signfile) {// 从文件当中读取私匙PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);// 从文件中读取公匙PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);try {// Signature 对象可用来生成和验证数字签名Signature signet = Signature.getInstance("DSA");// 初始化签署签名的私钥signet.initSign(myprikey);// 更新要由字节签名或验证的数据signet.update(info.getBytes());// 签署或验证所有更新字节的签名，返回签名byte[] signed = signet.sign();// 将数字签名,公匙,信息放入文件中doObjToFile(signfile, new Object[] { signed, mypubkey, info });} catch (Exception e) {e.printStackTrace();}}/*** 读取数字签名文件 根据公匙，签名，信息验证信息的合法性** @return true 验证成功 false 验证失败*/public boolean validateSign(String signfile) {// 读取公匙PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);// 读取签名byte[] signed = (byte[]) getObjFromFile(signfile, 1);// 读取信息String info = (String) getObjFromFile(signfile, 3);try {// 初始一个Signature对象,并用公钥和签名进行验证Signature signetcheck = Signature.getInstance("DSA");// 初始化验证签名的公钥signetcheck.initVerify(mypubkey);// 使用指定的 byte 数组更新要签名或验证的数据signetcheck.update(info.getBytes());System.out.println(info);// 验证传入的签名return signetcheck.verify(signed);} catch (Exception e) {e.printStackTrace();return false;}}/*** 将二进制转化为16进制字符串** @param b*            二进制字节数组* @return String*/public String byte2hex(byte[] b) {String hs = "";String stmp = "";for (int n = 0; n < b.length; n++) {stmp = (java.lang.Integer.toHexString(b& 0XFF));if (stmp.length() == 1) {hs = hs + "0" + stmp;} else {hs = hs + stmp;}}return hs.toUpperCase();}/*** 十六进制字符串转化为2进制** @param hex* @return*/public byte[] hex2byte(String hex) {byte[] ret = new byte[8];byte[] tmp = hex.getBytes();for (int i = 0; i < 8; i++) {ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);}return ret;}/*** 将两个ASCII字符合成一个字节； 如："EF"--> 0xEF** @param src0*            byte* @param src1*            byte* @return byte*/public static byte uniteBytes(byte src0, byte src1) {byte _b0 = Byte.decode("0x" + new String(new byte[] { src0 })).byteValue();_b0 = (byte) (_b0 << 4);byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 })).byteValue();byte ret = (byte) (_b0 ^ _b1);return ret;}/*** 将指定的对象写入指定的文件** @param file*            指定写入的文件* @param objs*            要写入的对象*/public void doObjToFile(String file, Object[] objs) {ObjectOutputStream oos = null;try {FileOutputStream fos = new FileOutputStream(file);oos = new ObjectOutputStream(fos);for (int i = 0; i < objs.length; i++) {oos.writeObject(objs[i]);}} catch (Exception e) {e.printStackTrace();} finally {try {oos.close();} catch (IOException e) {e.printStackTrace();}}}/*** 返回在文件中指定位置的对象** @param file*            指定的文件* @param i*            从1开始* @return*/public Object getObjFromFile(String file, int i) {ObjectInputStream ois = null;Object obj = null;try {FileInputStream fis = new FileInputStream(file);ois = new ObjectInputStream(fis);for (int j = 0; j < i; j++) {obj = ois.readObject();}} catch (Exception e) {e.printStackTrace();} finally {try {ois.close();} catch (IOException e) {e.printStackTrace();}}return obj;}/*** 测试** @param args*/public static void main(String[] args) {CryptUtil jiami = new CryptUtil();// 执行MD5加密"Hello world!"System.out.println("Hello经过MD5:" + jiami.encryptToMD5("Hello"));// 生成一个DES算法的密匙SecretKey key = jiami.createSecretKey("DES");// 用密匙加密信息"Hello world!"String str1 = jiami.encryptToDES(key, "Hello");System.out.println("使用des加密信息Hello为:" + str1);// 使用这个密匙解密String str2 = jiami.decryptByDES(key, str1);System.out.println("解密后为：" + str2);// 创建公匙和私匙jiami.createPairKey();// 对Hello world!使用私匙进行签名jiami.signToInfo("Hello", "mysign.bat");// 利用公匙对签名进行验证。if (jiami.validateSign("mysign.bat")) {System.out.println("Success!");} else {System.out.println("Fail!");}}}