package com.common.util;

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;

import com.common.exception.PasswordException;


/**
 * 字符串加密工具类。
 * 
 * @author tgl
 */
public class PasswordUtil {
	/**
	 * 使用3Des进行加密。
	 * 
	 * @param string 待加密的字符串
	 * @param key 密钥
	 * @return 加密后的字符串
	 * @throws PasswordException 如果发送错误
	 */
	public static String tripleEncrypt(String string, String key) throws PasswordException {
		if (key.length() >= 48) {
			byte[] bytK1 = StringUtil.hexString2byteArray(key.substring(0, 16));
			byte[] bytK2 = StringUtil.hexString2byteArray(key.substring(16, 32));
			byte[] bytK3 = StringUtil.hexString2byteArray(key.substring(32, 48));

			byte[] bytP = string.getBytes();
			byte[] ep = encrypt(encrypt(encrypt(bytP, bytK1), bytK2), bytK3);

			return StringUtil.byteArray2HexString(ep);
		} else {
			throw new PasswordException("密钥长度错误，无法进行3DES加密");
		}
	}

	/**
	 * 使用3Des进行解密。
	 * 
	 * @param string 待解密的字符串
	 * @param key 密钥
	 * @return 解密后的字符串
	 * @throws PasswordException 如果发送错误
	 */
	public static String tripleDecrypt(String string, String key) throws PasswordException {
		if (key.length() >= 48) {
			byte[] bytK1 = StringUtil.hexString2byteArray(key.substring(0, 16));
			byte[] bytK2 = StringUtil.hexString2byteArray(key.substring(16, 32));
			byte[] bytK3 = StringUtil.hexString2byteArray(key.substring(32, 48));

			byte[] bytP = StringUtil.hexString2byteArray(string);
			byte[] dp = decrypt(decrypt(decrypt(bytP, bytK3), bytK2), bytK1);

			return new String(dp);
		} else {
			throw new PasswordException("密钥长度错误，无法进行3DES加密");
		}
	}

	/**
	 * 用密钥进行DES加密。
	 *
	 * @param bytE 待加密的字节数组
	 * @param key 密钥
	 * @return 加密以后的字节数组
	 * @throws PasswordException 如果发送错误
	 */
	public static byte[] encrypt(byte[] bytP, byte[] key) throws PasswordException {
		return crypt(bytP, key, Cipher.ENCRYPT_MODE);
	}

	/**
	 * 用密钥进行DES解密。
	 *
	 * @param bytE 待解密的字节数组
	 * @param key 密钥
	 * @return 解密以后的字节数组
	 * @throws PasswordException 如果发送错误
	 */
	public static byte[] decrypt(byte[] bytE, byte[] key) throws PasswordException {
		return crypt(bytE, key, Cipher.DECRYPT_MODE);
	}

	/**
	 * 用密钥进行DES加密解密。
	 *
	 * @param bytE 待加密解密的字节数组
	 * @param key 密钥
	 * @param mode 加密或者解密控制符
	 * @return 加密解密以后的字节数组
	 * @throws PasswordException 如果发送错误
	 */
	private static byte[] crypt(byte[] bytP, byte[] key, int mode) throws PasswordException {
		try {
			Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
			DESKeySpec desKeySpec = new DESKeySpec(key);
			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
			SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
			IvParameterSpec iv = new IvParameterSpec(key);
			cipher.init(mode, secretKey, iv);
			return cipher.doFinal(bytP);
		} catch (NoSuchAlgorithmException e) {
			throw new PasswordException(e);
		} catch (NoSuchPaddingException e) {
			throw new PasswordException(e);
		} catch (InvalidKeyException e) {
			throw new PasswordException(e);
		} catch (InvalidKeySpecException e) {
			throw new PasswordException(e);
		} catch (InvalidAlgorithmParameterException e) {
			throw new PasswordException(e);
		} catch (BadPaddingException e) {
			throw new PasswordException(e);
		} catch (IllegalBlockSizeException e) {
			throw new PasswordException(e);
		}
	}

}