信息摘要算法 MessageDigestUtil

package com.xgh.message.digest.test;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.SecureRandom;

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

import junit.framework.TestCase;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/***
 * 单向加密方法    
 *   
 * MessageDigest 类提供【信息摘要算法】的功能，
 * 如HMAC、MD2、MD4、MD5、SHA-1、SHA-256、RIPEMD128、RIPEMD160。
 * 信息摘要是安全的单向哈希函数，它接收任意大小的数据，并输出固定长度的哈希值。 
 * @author xgh
 * 
 *==================================================
 *速度排名：MD4 > MD5 > RIPEMD-128 > SHA-1 > REPEMD-160
 *按照《应用密码学手册》提供的表格数据为：
 *MD4 长度 128 相对速度 1
 *MD5 长度 128 相对速度 0.68
 *REPEMD-128 长度 128 相对速度 0.39
 *SHA-1 长度 160 相对速度 0.29
 *REPEMD-160 长度 160 相对速度 0.24
 *==================================================
 *结论：
 *又要安全又要速度，选择MD5
 *追求安全，不在意速度，相信传说，不相信阴谋论，选择SHA系列
 *追求速度，安全次之，可以选择MD4。
 *==================================================
 */
public class MessageDigestUtil  extends TestCase{

	
	/***
	 * MD5摘要生成
	 * MD5 -- message-digest algorithm 5 （信息-摘要算法）缩写
	 * md5摘要算法算返回的数据长度为128个位，即16个字节。
	 * @throws Exception
	 */
	public void testEncryptMD5() throws Exception { 
		String message ="Hell，在我心中，也许";
		MessageDigest md5 = MessageDigest.getInstance("MD5");
		md5.update(message.getBytes());
		//md5摘要算法算返回的数据长度为128个位，即16个字节。
		byte[] digestbytes = md5.digest();
		System.out.println("md5摘要原数据:"+message);
		System.out.println("信息摘要长度:"+(digestbytes.length*8)+"位");
		System.out.println("摘要BigInteger结果:"+new BigInteger(digestbytes));
		System.out.println("摘要Base64结果:"+new BASE64Encoder().encode(digestbytes));
		System.out.println("--------------md5 end-----------------------");
	}

	/***
	 * SHA摘要生成
	 * SHA(Secure Hash Algorithm，安全散列算法），
	 * sha摘要算法算返回的数据长度为160个位，即20个字节。
	 * @throws Exception
	 */
	public void testEncryptSHA() throws Exception { 
		String message ="Hell，在我心中，也许";
		MessageDigest md5 = MessageDigest.getInstance("SHA");
		md5.update(message.getBytes());
		//md5摘要算法算返回的数据长度为128个位，即16个字节。
		byte[] digestbytes = md5.digest();
		System.out.println("sha摘要原数据:"+message);
		System.out.println("信息摘要长度:"+(digestbytes.length*8)+"位");
		System.out.println("摘要BigInteger结果:"+new BigInteger(digestbytes));
		System.out.println("摘要Base64结果:"+new BASE64Encoder().encode(digestbytes));
		System.out.println("--------------sha end-----------------------");
	}
	
	/***
	 * SHA1摘要生成
	 * SHA(Secure Hash Algorithm，安全散列算法），
	 * sha1摘要算法算返回的数据长度为160个位，即20个字节。
	 * @throws Exception
	 */
	public void testEncryptSHA1() throws Exception { 
		String message ="Hell，在我心中，也许";
		MessageDigest md5 = MessageDigest.getInstance("SHA-1");
		md5.update(message.getBytes());
		//md5摘要算法算返回的数据长度为128个位，即16个字节。
		byte[] digestbytes = md5.digest();
		System.out.println("sha1摘要原数据:"+message);
		System.out.println("信息摘要长度:"+(digestbytes.length*8)+"位");
		System.out.println("摘要BigInteger结果:"+new BigInteger(digestbytes));
		System.out.println("摘要Base64结果:"+new BASE64Encoder().encode(digestbytes));
		System.out.println("--------------sha1 end-----------------------");
	}
	
	/***
	 * SHA256摘要生成
	 * SHA(Secure Hash Algorithm，安全散列算法），
	 * sha256摘要算法算返回的数据长度为160个位，即20个字节。
	 * @throws Exception
	 */
	public void testEncryptSHA256() throws Exception { 
		String message ="Hell，在我心中，也许";
		MessageDigest md5 = MessageDigest.getInstance("SHA-256");
		md5.update(message.getBytes());
		//md5摘要算法算返回的数据长度为128个位，即16个字节。
		byte[] digestbytes = md5.digest();
		System.out.println("sha265摘要原数据:"+message);
		System.out.println("信息摘要长度:"+(digestbytes.length*8)+"位");
		System.out.println("摘要BigInteger结果:"+new BigInteger(digestbytes));
		System.out.println("摘要Base64结果:"+new BASE64Encoder().encode(digestbytes));
		System.out.println("--------------sha256 end-----------------------");
	}
	
	/***
	 * SHA512摘要生成
	 * SHA(Secure Hash Algorithm，安全散列算法），
	 * sha512摘要算法算返回的数据长度为160个位，即20个字节。
	 * @throws Exception
	 */
	public void testEncryptSHA512() throws Exception { 
		String message ="Hell，在我心中，也许";
		MessageDigest md5 = MessageDigest.getInstance("SHA-512");
		md5.update(message.getBytes());
		//md5摘要算法算返回的数据长度为128个位，即16个字节。
		byte[] digestbytes = md5.digest();
		System.out.println("sha512摘要原数据:"+message);
		System.out.println("信息摘要长度:"+(digestbytes.length*8)+"位");
		System.out.println("摘要BigInteger结果:"+new BigInteger(digestbytes));
		System.out.println("摘要Base64结果:"+new BASE64Encoder().encode(digestbytes));
		System.out.println("--------------sha512 end-----------------------");
	}
	
	/***
	 * Md5摘要后，将字节摘要字节组转16进制数组
	 * @param input
	 * @return
	 */
	public String testMD5ToHex() throws Exception{ 
		String data = "sfs有桂林地村要地wecllo";
		// 获得MD5摘要算法的 MessageDigest 对象             
	     MessageDigest mdInst = MessageDigest.getInstance("MD5");             
	     // 使用指定的字节更新摘要             
	     mdInst.update(data.getBytes());             
	     // 获得摘要密文             
	     byte[] md = mdInst.digest();             
	     // 把密文转换成十六进制的字符串形式             
	     StringBuffer hexString = new StringBuffer();             
	     // 字节数组转换为 十六进制 数             
	     for (int i = 0; i < md.length; i++) {                 
	     String shaHex = Integer.toHexString(md[i] & 0xFF);   
	       if (shaHex.length() < 2) {//不足2位16进制位，则补0,一个字节是2位16进制位                                   
	          hexString.append(0);                 
	       }                 
	       hexString.append(shaHex);             
	     }             
	     return hexString.toString(); 
	}
	
	/***
	 * SHA-1摘要后，将字节摘要字节组转16进制数组
	 * @param input
	 * @return
	 */
	public String testSHA1ToHex() throws Exception{ 
		String data = "sfs有桂林地村要地wecllo";
		// 获得MD5摘要算法的 MessageDigest 对象             
	     MessageDigest mdInst = MessageDigest.getInstance("SHA-1");             
	     // 使用指定的字节更新摘要             
	     mdInst.update(data.getBytes());             
	     // 获得摘要密文             
	     byte[] md = mdInst.digest();             
	     // 把密文转换成十六进制的字符串形式             
	     StringBuffer hexString = new StringBuffer();             
	     // 字节数组转换为 十六进制 数             
	     for (int i = 0; i < md.length; i++) {                 
	       int r = md[i] & 0xf;   
	       if (r <= 0xf) {//不足2位16进制位，则补0,一个字节是2位16进制位                    
	          hexString.append(0);                 
	       }                 
	       hexString.append(Integer.toHexString(r));             
	     }             
	     return hexString.toString(); 
	}
	
	/***
	 * HMAC摘要生成  单向加密算法
	 * HMAC摘要算法算返回的数据长度为128个位，即16个字节。
	 * HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。
	 * 消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个标识鉴别消息的完整性。
	 * 使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证等。
	 * @throws Exception
     * HMAC算法可选以下多种算法   :
     *   HmacMD5   
     *   HmacSHA1   
     *   HmacSHA256   
     *   HmacSHA384   
     *   HmacSHA512  
     * 
     */  

	public void testEncryptHMAC() throws Exception { 
		 String message ="Hell，在我心中，也许";
		 KeyGenerator keyGenerator = KeyGenerator.getInstance("HmacSHA1");  
         SecretKey secretKey1 = keyGenerator.generateKey();  
         //Mac密钥
		 String key =  new BASE64Encoder().encode((secretKey1.getEncoded()));  
		 System.out.println("Mac密钥："+key);
         
		 SecretKey secretKey2 = new SecretKeySpec(new BASE64Decoder().decodeBuffer(key), "HmacSHA1");   
		 //返回此密钥编码格式的名称。
		 //System.out.println(secretKey1.getFormat());
		 Mac mac = Mac.getInstance(secretKey2.getAlgorithm());   
		 mac.init(secretKey2);   
		 byte[] digestbytes = mac.doFinal(message.getBytes());   

		System.out.println("HMAC摘要原数据:"+message);
		System.out.println("信息摘要长度:"+(digestbytes.length*8)+"位");
		System.out.println("摘要BigInteger结果:"+new BigInteger(digestbytes));
		System.out.println("摘要Base64结果:"+new BASE64Encoder().encode(digestbytes));
		System.out.println("--------------HMAC end-----------------------");
		
	}
	 
	/***
	 * AES 双向加密算法
	 * @param content   待加密内容 
	 * @param password  加密密钥
	 * @return
	 */
	public  byte[] testEncryptAES() throws Exception{ 
		String content = "Hello,明天天气不错";
		String password = "123456";
		KeyGenerator kgen = KeyGenerator.getInstance("AES");
		kgen.init(128, new SecureRandom(password.getBytes()));
		SecretKey secretKey = kgen.generateKey();
		byte[] enCodeFormat = secretKey.getEncoded();
		SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
		Cipher cipher = Cipher.getInstance("AES");// 创建密码器
		byte[] byteContent = content.getBytes("utf-8");
		cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化
		byte[] result = cipher.doFinal(byteContent);
		System.out.println("AES加密后的Base64结果:");
		System.out.println(new BASE64Encoder().encode(result));
		return result; // 加密
	}
	
	/***
	 *  AES 双向加密算法
	 * @param content  待解密内容 
	 * @param password 解密密钥
	 * @return
	 */
	public  byte[] testDecryptAES() throws Exception{
		String content = "2M8d6HQ0qtXqSSuL83ILs348ls6C8JlZnfu0UFgCkOw=";
		String password = "123456";
		byte[] contentbyte = new BASE64Decoder().decodeBuffer(content);
		KeyGenerator kgen = KeyGenerator.getInstance("AES");
		kgen.init(128, new SecureRandom(password.getBytes()));
		SecretKey secretKey = kgen.generateKey();
		byte[] enCodeFormat = secretKey.getEncoded();
		SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
		Cipher cipher = Cipher.getInstance("AES");// 创建密码器
		cipher.init(Cipher.DECRYPT_MODE, key);// 初始化
		byte[] result = cipher.doFinal(contentbyte);
		System.out.println("解密结果:");
		System.out.println(new String(result,"UTF-8"));
		return result; // 加密
	}
}