java密码的加密与解密

 

package com.monitor.util;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Random;

public class SHAEncrypt {

	/**
	 * 生成SALT的数组(86)
	 */
	private final String[] SALT_ARR = { "a", "b", "c", "d", "e", "f", "g", "h",
			"i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u",
			"v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H",
			"I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U",
			"V", "W", "X", "Y", "Z", "1", "2", "3", "4", "5", "6", "7", "8",
			"9", "0", ".", "-", "*", "/", "'", ":", ";", ">", "<", "~", "!",
			"@", "#", "$", "%", "^", "&", "(", ")", "{", "}", "[", "]", "|" };
	/**
	 * 循环加密次数
	 */
	private final int ENCODE_COUNT = 1000;
	/**
	 * 加密算法类型
	 */
	private final String ENCODE_TYPE = "SHA-256";
	/**
	 * SALT长度
	 */
	private final int SALT_LENGTH = 16;
	/**
	 * getBytes时指定使用的字符集
	 */
	private final String CHAR_SET = "UTF-8";

	/**
	 * 对明文密码进行SSHA-256加密，加密步骤如下： <br>
	 * 1. 生成随机salt值 <br>
	 * 2. 明文密码变形：前后各补4位0 <br>
	 * 3. 连接salt值: 将salt分成前8位temp1和剩余部分temp2,以temp2+transformedPwd+temp1的形式连接 <br>
	 * 4. 对连接后的字串进行多次SHA-256加密<br>
	 * 5. 对加密后的密文右移6位<br>
	 * 6. 将salt值转换成字节数组(utf-8)再转换成16进制字符串<br>
	 * 7. 将转换后的salt值作左移4位变形<br>
	 * 8. 连接移位后的密文和移位后的变形salt值字串<br>
	 * 9. 对连接字串右移8位作为最终加密结果<br>
	 * 
	 * @param pwd
	 *            密码明文
	 * @return 加密后的密码
	 */
	public String encryptPwd(String pwd) {
		String ret = "";
		String salt = this.genSalt();
		ret = this.encryptPwdWithSalt(pwd, salt);
		return ret;
	}

	/**
	 * 对明文密码进行SSHA-256加密，加密步骤如下： <br>
	 * 1. 明文密码变形：前后各补4位0 <br>
	 * 2. 连接salt值: 将salt分成前8位temp1和剩余部分temp2,以temp2+transformedPwd+temp1的形式连接 <br>
	 * 3. 对连接后的字串进行多次SHA-256加密<br>
	 * 4. 对加密后的密文右移6位<br>
	 * 5. 将salt值转换成字节数组(utf-8)再转换成16进制字符串<br>
	 * 6. 将转换后的salt值作左移4位变形<br>
	 * 7. 连接移位后的密文和移位后的变形salt值字串<br>
	 * 8. 对连接字串右移8位作为最终加密结果<br>
	 * 
	 * @param pwd
	 *            明文密码
	 * @param salt
	 *            用于加密的salt值
	 * @return
	 */
	private String encryptPwdWithSalt(String pwd, String salt) {
		String ret = "";
		try {
			String transformedPwd = this.transform(pwd, 4);
			// 将salt分成前8位temp1和剩余部分temp2
			// 以temp2+transformedPwd+temp1的形式连接
			String joinStr = this.joinSaltAndPwd(salt, transformedPwd);
			String encodePwd = this.encodeJoinStr(joinStr);
			String rightMovedPwd = this.rightMove(encodePwd, 6);
			String hexStrSalt = this.bytes2Hex(salt.getBytes(CHAR_SET));
			String leftMovedHexStrSalt = this.rightMove(hexStrSalt, -4);
			ret = this.rightMove(rightMovedPwd + leftMovedHexStrSalt, 8);
		} catch (Exception e) {
			ret = "";
			e.printStackTrace();
		}
		return ret;
	}

	/**
	 * 对明文/密文进行验证，检查是否一致 验证步骤如下： <br>
	 * 1. 从原密文中获取通过逆运算获取salt字串 <br>
	 * 2. 对明文密码使用salt字串再次进行加密 <br>
	 * 3. 两个密文是否一致 <br>
	 * 
	 * @param pwd
	 *            明文密码
	 * @param encPwd
	 *            密文密码
	 * @return 校验结果
	 */
	public boolean validatePwd(String pwd, String encPwd) {
		if (null == encPwd) {
			return false;
		}
		boolean ret = false;
		String salt = this.getSaltFromEncryptedPwd(encPwd);
		ret = encPwd.equals(encryptPwdWithSalt(pwd, salt));
		return ret;
	}

	/**
	 * 从密文密码中通过逆运算获取加密时使用到的salt字串 <br>
	 * 获取步骤如下： <br>
	 * 1. 对密文左移8位 <br>
	 * 2. 从尾部截取变形后的salt字串 <br>
	 * 长度为2倍原salt字串长度（因为转为16进制字节数组字串时长度会加倍） <br>
	 * 3. 对salt值的16进制字节数组字符串右移4位 <br>
	 * 4. 将变形后的salt值从16进制字节数组字符串还原成原来的字符串形式 <br>
	 * 
	 * @param encPwd
	 *            密文密码
	 * @return 加密时使用的salt字串，获取出错则返回""
	 */
	private String getSaltFromEncryptedPwd(String encPwd) {
		String ret = "";
		try {
			String leftMoved = this.rightMove(encPwd, -8);
			int hexSaltLength = SALT_LENGTH * 2;
			if(encPwd.length()<hexSaltLength){
				// 加密密码长度比16进制字节数组字串的salt值短，不可能获取得到正确的salt值
				return "";
			}
			String hexSalt = this.rightMove(leftMoved.substring(encPwd.length()
					- hexSaltLength, encPwd.length()), 4);
			ret = new String(this.hex2Bytes(hexSalt), CHAR_SET);
		} catch (Exception e) {
			ret = "";
			e.printStackTrace();
		}
		return ret;
	}

	/**
	 * 
	 * 获得随机SALT值
	 * 
	 * @return 返回一个包含字母、数字、特殊字符的16位随机数
	 */
	private String genSalt() {

		StringBuffer result = new StringBuffer();
		Random r = new Random();
		int temp = 0;
		for (int i = 0; i < this.SALT_LENGTH; i++) {
			temp = r.nextInt(this.SALT_ARR.length);
			result.append(this.SALT_ARR[temp]);
		}
		return result.toString();
	}

	/**
	 * 密码变形（前后补N位0）
	 * 
	 * @param pwd
	 *            密码原文
	 * @param n
	 *            补0的个数
	 * @return 返回一个密码前后补N位0的字符串
	 */
	private String transform(String pwd, int n) {
		String toTransform = null == pwd ? "" : pwd;
		StringBuffer temp = new StringBuffer();
		for (int i = 0; i < n; i++)
			temp.append("0");
		return temp.toString() + toTransform + temp.toString();
	}

	/**
	 * 
	 * 把指定字符串右移N位,若N<0则为左移
	 * 
	 * @param src
	 *            源字符串
	 * @param n
	 *            右移的位数
	 * @return 返回一个右移N位的字符串
	 */
	private String rightMove(String src, int n) {
		if (src == null || src.length() == 0) {
			return src;
		}
		boolean isRight = true;
		int absN = n;
		if (n < 0) {
			isRight = false;
			absN = -n;
		}
		int cnt = absN > src.length() ? absN % src.length() : absN;
		if (0 == cnt) {
			return src;
		}
		if (isRight) {
			// 右移cnt位
			String temp1 = src.substring(src.length() - cnt, src.length());
			String temp2 = src.substring(0, src.length() - cnt);
			return temp1 + temp2;
		} else {
			// 左移cnt位
			String temp1 = src.substring(0, cnt);
			String temp2 = src.substring(cnt, src.length());
			return temp2 + temp1;
		}
	}

	/**
	 * 
	 * 把对应的随机数分成2部分，前半部分8个字符，调换顺序后把变形密码加到中间
	 * 
	 * @param pwd
	 *            变形密码
	 * @param salt
	 *            对应的随机数
	 * @return 返回一个随机数与变形密码连接的字符串
	 */
	private String joinSaltAndPwd(String salt, String pwd) {
		if(salt.length()!=SALT_LENGTH){
			// salt值的长度与给定的不符（校验的时候可能会出现）
			// 返回pwd+salt
			return pwd+salt;
		}
		String temp1 = salt.substring(0, 8);
		String temp2 = salt.substring(8, salt.length());
		return temp2 + pwd + temp1;
	}

	/**
	 * 
	 * 使用加密算法进行多次加密
	 * 
	 * @param joinStr
	 *            连接字符串
	 * @return 返回一个多次加密后的字符串
	 */
	private String encodeJoinStr(String joinStr) {

		if (joinStr == null)
			return null;

		String temp = joinStr;

		for (int i = 0; i < this.ENCODE_COUNT; i++) {

			temp = this.encrypt(temp);
		}
		return temp;
	}

	/**
	 * 把字节数组输出成16进制字符串
	 * 
	 * @param bts
	 * @return
	 */
	private String bytes2Hex(byte[] bts) {
		StringBuffer des = new StringBuffer();
		String tmp = null;
		for (int i = 0; i < bts.length; i++) {
			tmp = (Integer.toHexString(bts[i] & 0xFF));
			if (tmp.length() == 1) {
				des.append("0");
			}
			des.append(tmp);
		}
		return des.toString();
	}

	/**
	 * 把16进制字符串输出成字节数组
	 * 
	 * @param hexStr
	 * @return
	 */
	private byte[] hex2Bytes(String hexStr) {
		if ((hexStr.length() % 2) != 0) {
			return new byte[] {};
		}
		byte[] ret = new byte[hexStr.length() / 2];
		for (int i = 0; i < hexStr.length() / 2; i++) {

			ret[i] = (byte) (Long.decode("0x"
					+ hexStr.substring(i * 2, i * 2 + 2)) & 0xFF);
		}
		return ret;
	}

	/**
	 * 
	 * 利用SHA-256对源字符串进行加密
	 * 
	 * @param src
	 * @return 返回加密串，注：本例中，空串表示加密失败
	 */
	private String encrypt(String src) {

		// 源字符串转换成byte数组
		try {
			byte[] btSource = src.getBytes(CHAR_SET);
			// 此处选择了SHA-256加密算法,实际可选的算法有"MD2、MD5、SHA-1、SHA-256、SHA-384、SHA-512"
			MessageDigest md = MessageDigest.getInstance(this.ENCODE_TYPE);
			md.reset();
			md.update(btSource);
			String result = bytes2Hex(md.digest()); // to HexString
			return result;
		} catch (NoSuchAlgorithmException e) {
			return "";
		} catch (UnsupportedEncodingException e) {
			return "";
		}
	}

	public static void main(String args[]) throws Exception {
		SHAEncrypt demo = new SHAEncrypt();
		String str = "12test中文濲騃";
		long startTime = System.currentTimeMillis();
		String encPwd = demo.encryptPwd(str);
		System.out.println("encrypt time costs:"
				+ (System.currentTimeMillis() - startTime));
		System.out.println("encrypted pwd:" + encPwd + ",length:"
				+ encPwd.length());
		System.out.println(demo.validatePwd(str, encPwd));
		System.out.println(new String(demo.hex2Bytes(encPwd), "UTF-8"));
	}
}