AES,BigInteger,MD5加密

http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

package cn.com.gome.cashier.web;

import java.lang.reflect.Method;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Arrays;

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

import org.apache.commons.codec.binary.Base64;
import org.junit.Test;

import cn.com.gome.common.security.base64.Base64Util;

/**
 * javax.crypto.spec.SecretKeySpec(implements KeySpec,SecretKey)
 * java.security.spec.KeySpec, javax.crypto.SecretKey（extends java.security.Key）
 * java.security.Key
 */
public class MyTestDemo {
	private static String charset = "utf-8";

	/**
	 * HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议
	 */
	@Test
	public void test2(){
		String str = "12345678901234567890qwqqq";
		String encr = encrypt(str, "qazwsxedcrfvtgby");
		String encr2 = encrypt16no(str, "qazwsxedcrfvtgby");
		String encr3 = encrypt16(str, "qazwsxedcrfvtgby");
		System.out.println("加密："+encr);
		System.out.println("加密："+encr2);
		System.out.println("加密："+encr3);
		String dec = decrypt(encr, "qazwsxedcrfvtgby");
		System.out.println("解密：" + dec);

	}
	//AES对称加密 kgen.init()加不加keySize的区别 SecureRandom new与setSeed的区别
	private static String encrypt(String password, String securityKey) {
		byte[] crypted = null;
		try {
			KeyGenerator kgen = KeyGenerator.getInstance("AES");//实例化一个用AES加密算法的密钥生成器
			SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG","SUN");
			secureRandom.setSeed(securityKey.getBytes());
			kgen.init(secureRandom);

			SecretKey secretKey = kgen.generateKey();
			Cipher cipher = Cipher.getInstance("AES");
			cipher.init(Cipher.ENCRYPT_MODE, secretKey);
			crypted= cipher.doFinal(password.getBytes(charset));
		} catch (Exception e) {
			System.out.println(e.toString());
		}
		try {
			return new String(encodeBase64(crypted)).replace(" ", "");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return "";
	}
//

AES算法在windows下可以正常加密、解密，上传到服务器之后，无法正常工作，每次加密的结果都是随机的

经检查发现，是加密的密钥在Linux下随机生成造成的,  不建议使用

	private static String encrypt16no(String password, String securityKey) {
		byte[] crypted = null;
		try {
			// 秘钥位数没限制
			KeyGenerator kgen = KeyGenerator.getInstance("AES");//实例化一个用AES加密算法的密钥生成器
			kgen.init(128, new SecureRandom(securityKey.getBytes()));//使用用户提供的password初始化此密钥生成器，使其具有确定的密钥大小128字节

                        SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG","SUN"); 建议使用该方式
			secureRandom.setSeed(securityKey.getBytes());
			kgen.init(secureRandom);

			SecretKey secretKey = kgen.generateKey();//生成一个密钥。
			byte[] enCodeFormat = secretKey.getEncoded();//返回基本编码格式的密钥，如果此密钥不支持编码，则返回 null
			SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");//根据给定的enCodeFormat字节数组构造一个用AES算法加密的密钥。
			Cipher cipher = Cipher.getInstance("AES");// 创建密码器
			cipher.init(Cipher.ENCRYPT_MODE, key);// 可以用 secretKey  以加密的方式用密钥初始化此 Cipher。
			crypted = cipher.doFinal(password.getBytes("utf-8"));
		} catch (Exception e) {
			System.out.println(e.toString());
		}
		try {
			return new String(encodeBase64(crypted)).replace(" ", "");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return "";
	}
	private static String encrypt16(String password, String securityKey) {
		byte[] crypted = null;
		try {
			// 秘钥必须为16位
			 SecretKeySpec keys = new SecretKeySpec(securityKey.getBytes(),
			 "AES");
			 Cipher.getInstance("AES/ECB/PKCS5Padding");//调用静态工厂方法得到Cipher对象
			 Cipher cipher = Cipher.getInstance("AES");
			 cipher.init(Cipher.ENCRYPT_MODE, keys);// ENCRYPT_MODE,加密数据
			 crypted = cipher.doFinal(password.getBytes());
		} catch (Exception e) {
			System.out.println(e.toString());
		}
		try {
			return new String(encodeBase64(crypted)).replace(" ", "");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return "";
	}
	private static String decrypt(String input, String securityKey) {
		byte[] output = null;
		try {
			KeyGenerator kgen = KeyGenerator.getInstance("AES");
			kgen.init(128, new SecureRandom(securityKey.getBytes()));
			SecretKey secretKey = kgen.generateKey();
			byte[] enCodeFormat = secretKey.getEncoded();
			SecretKeySpec keys = new SecretKeySpec(enCodeFormat, "AES");
			Cipher cipher = Cipher.getInstance("AES");

			// SecretKeySpec keys = new SecretKeySpec(securityKey.getBytes(),
			// "AES");
			// Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");

			// Cipher cipher = Cipher.getInstance("AES");

			cipher.init(Cipher.DECRYPT_MODE, secretKey);// DECRYPT_MODE,解密数据
			output = cipher.doFinal(decodeBase64(input));
		} catch (Exception e) {
			System.out.println(e.toString());
			return "";
		}
		return new String(output);
	}

	/**
	 * BigInteger位运算   对称加解密,A、B的位运算为C，则C、B的位运算为A，C、A的位运算为B
	 */
	//@Test
	public void testBigInteger(){
		String str = "asd";
		System.out.println(Arrays.toString(str.getBytes()));
		String es = encrypt(str);
		System.out.println("密文："+es);
		System.out.println(decrypt(es));

		//i=15转成二进制是1111，j=2转成二进制是0010，根据异或的运算规则得到的是1101，转成十进制就是13   两个操作数的位中，相同则结果为0，不同则结果为1  this ^ val
		BigInteger i = (new BigInteger("15")).xor( (new BigInteger("2")));
		System.out.println(i+" "+i.toString(10));//10进制表示
		i = (new BigInteger("13")).xor( (new BigInteger("2")));
		System.out.println(i+" "+i.toString(10));//10进制表示
	}
	private static final int RADIX = 16;
	private static final String SEED = "0933910847463829232312312";
	private static final String encrypt(String password) {
		BigInteger bi_passwd = new BigInteger(password.getBytes());// 将包含 BigInteger 的二进制补码表示形式的 byte 数组转换为 BigInteger
		BigInteger bi_seed = new BigInteger(SEED);
		BigInteger bi_resu = bi_seed.xor(bi_passwd);// 位运算，种子在外、密码在内，按位运算符 异或
		System.out.println("bi_passwd: "+bi_passwd);
		System.out.println("bi_seed:"+bi_seed);
		System.out.println("bi_resu:"+bi_resu);
		return bi_resu.toString(RADIX);//返回16进制表示形式
	}
	private static final String decrypt(String encrypted) {
		BigInteger bi_confuse = new BigInteger(SEED);
		try {
			BigInteger bi_r1 = new BigInteger(encrypted, RADIX);//将16进制密文转换为BigInteger
			BigInteger bi_r0 = bi_r1.xor(bi_confuse);// 位运算，种子在内、密码在外
			System.out.println("bi_r1:"+bi_r1);
			System.out.println("bi_r0:"+bi_r0);
			return new String(bi_r0.toByteArray());//将结果转换为字节数组，进而转换为字符串
		} catch (Exception e) {
			return "";
		}
	}

	/**
	 *信息-摘要算法,为计算机安全领域广泛使用的一种散列函数，用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法）
	 *1、压缩性：任意长度的数据，算出的MD5值长度都是固定的。
	  2、容易计算：从原数据计算出MD5值很容易。
	  3、抗修改性：对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大区别。
	  4、强抗碰撞：已知原数据和其MD5值，想找到一个具有相同MD5值的数据（即伪造数据）是非常困难的。
	      遗留：SHA
	 */
	//@Test
	public void testMd5(){
		String str = "是地方萨芬撒大哥啊啊sdfasdasdfasdff34r4433333335v4ffffffffffffffffffffffffffffffff";
		try {
			String str1 = encodeMessage(str);
			System.out.println(str1);

			//以上代码就可以实现MD5摘要了。由于摘要的结果是字节数组，并不是我们常见的字符串，所以还有工作要做。字节数组转字符串，还不简单
			MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            byte[] md5Bytes = messageDigest.digest(str.getBytes(Charset.forName("UTF-8")));
	        for (byte b : md5Bytes) {
	            System.out.print(b);
	        }
	        //MD5摘要的结果是一个128bit的大整数
			System.out.println(toHex2(md5Bytes));
			System.out.println(BytesConvertToHexString(md5Bytes));

		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	//MD5摘要字节转换为字符串
	private static String toHex2(byte[] bytes) {
	    final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();
	    StringBuilder ret = new StringBuilder(bytes.length * 2);
	    for (int i=0; i<bytes.length; i++) {
	        ret.append(HEX_DIGITS[(bytes[i] >> 4) & 0x0f]);
	        ret.append(HEX_DIGITS[bytes[i] & 0x0f]);
	    }
	    return ret.toString();
	}
	//MD5摘要字节转换为16进制字符串
	private static String BytesConvertToHexString(byte [] bytes) {
          StringBuffer sb = new StringBuffer();
          for (byte aByte : bytes) {
            String s=Integer.toHexString(0xff & aByte);
              if(s.length()==1){
                  sb.append("0"+s);
              }else{
                  sb.append(s);
              }
          }
          return sb.toString();
     }

	private static String encodeMessage(String data) throws Exception {
		MessageDigest md5 = MessageDigest.getInstance("MD5");
		md5.update(data.getBytes());
		return toHex(md5.digest());
	}

	private static String toHex(byte[] buffer) {
		byte[] result = new byte[buffer.length * 2];
		for (int i = 0; i < buffer.length; i++) {
			byte[] temp = getHexValue(buffer[i]);
			result[(i * 2)] = temp[0];
			result[(i * 2 + 1)] = temp[1];
		}
		return new String(result).toUpperCase();
	}

	private static byte[] getHexValue(byte b) {
		int value = b;
		if (value < 0) {
			value = 256 + b;
		}
		String s = Integer.toHexString(value);
		if (s.length() == 1) {
			return new byte[] { 48, (byte) s.charAt(0) };
		}
		return new byte[] { (byte) s.charAt(0), (byte) s.charAt(1) };
	}

	/**
	 * 以下为base64编码   base64只能算是一个编码算法，对数据内容进行编码来适合传输
	 */
	//@Test
	public void testBase64() {
			String str = "1qazxsw23edcqwertyuiopfdgdgdfgdsgergsdfgfhrtsdf";
			String de = encode(str.getBytes());
			System.out.println(de);
			byte[] b = decode(de.getBytes());
			System.out.println(new String(b));

			String de2 = encodes(str.getBytes());
			System.out.println(de2);
			byte[] b2 = decodes(de2);
			System.out.println(new String(b2));

    }

	private static String encodeBase64(byte[] input) throws Exception {
		Class clazz = Class
				.forName("com.sun.org.apache.xerces.internal.impl.dv.util.Base64");
		Method mainMethod = clazz.getMethod("encode", byte[].class);
		mainMethod.setAccessible(true);
		Object retObj = mainMethod.invoke(null, new Object[] { input });
		return (String) retObj;
	}
	private static byte[] decodeBase64(String input) throws Exception {
		Class clazz = Class
				.forName("com.sun.org.apache.xerces.internal.impl.dv.util.Base64");
		Method mainMethod = clazz.getMethod("decode", String.class);
		mainMethod.setAccessible(true);
		Object retObj = mainMethod.invoke(null, input);
		return (byte[]) retObj;
	}

	private static String encode(final byte[] bytes) {
		return new String(Base64.encodeBase64(bytes));
	}
	private static byte[] decode(final byte[] bytes) {
		return Base64.decodeBase64(bytes);
	}

	private static String encodes(byte[] bstr) {
		return new sun.misc.BASE64Encoder().encode(bstr);
	}
	private static byte[] decodes(String str) {
		byte[] bt = null;
		try {
			sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
			bt = decoder.decodeBuffer(str);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return bt;
	}
}