//package com.ylzb.fjsdermyy.modules.settleaccounts.util;
//
//import sun.misc.BASE64Decoder;
//import sun.misc.BASE64Encoder;
//
//import javax.crypto.BadPaddingException;
//import javax.crypto.Cipher;
//import javax.crypto.IllegalBlockSizeException;
//import javax.crypto.NoSuchPaddingException;
//import javax.crypto.spec.SecretKeySpec;
//import java.io.IOException;
//import java.io.UnsupportedEncodingException;
//import java.security.InvalidKeyException;
//import java.security.NoSuchAlgorithmException;
//
///**
// * @Description: AES算法封装
// */
//public class AesUtil {
//
//    /**
//     * 加密算法
//     */
//    private static final String ENCRY_ALGORITHM = "AES";
//
//    /**
//     * 加密算法/加密模式/填充类型
//     * 本例采用AES加密，ECB加密模式，PKCS5Padding填充
//     */
//    private static final String CIPHER_MODE = "AES/CBC/PKCS5Padding";
//
//    /**
//     * 设置iv偏移量
//     * 本例采用ECB加密模式，不需要设置iv偏移量
//     */
//    private static final String IV_ = "0102030405060708";
//
//    /**
//     * 设置加密字符集
//     * 本例采用 UTF-8 字符集
//     */
//    private static final String CHARACTER = "UTF-8";
//
//    /**
//     * 设置加密密码处理长度。
//     * 不足此长度补0；
//     */
//    private static final int PWD_SIZE = 16;
//
//    /**
//     * 密码处理方法
//     * 如果加解密出问题，
//     * 请先查看本方法，排除密码长度不足填充0字节,导致密码不一致
//     * @param password 待处理的密码
//     * @return
//     * @throws UnsupportedEncodingException
//     */
//    private static byte[] pwdHandler(String password) throws UnsupportedEncodingException {
//        byte[] data = null;
//        if (password != null) {
//            byte[] bytes = password.getBytes(CHARACTER);
//            if (password.length() < PWD_SIZE) {
//                System.arraycopy(bytes, 0, data = new byte[PWD_SIZE], 0, bytes.length);
//            } else {
//                data = bytes;
//            }
//        }
//        return data;
//    }
//
//    //======================>原始加密<======================
//
//    /**
//     * 原始加密
//     * @param clearTextBytes 明文字节数组，待加密的字节数组
//     * @param pwdBytes 加密密码字节数组
//     * @return 返回加密后的密文字节数组，加密错误返回null
//     */
//    public static byte[] encrypt(byte[] clearTextBytes, byte[] pwdBytes) {
//        try {
//            // 1 获取加密密钥
//            SecretKeySpec keySpec = new SecretKeySpec(pwdBytes, ENCRY_ALGORITHM);
//
//            // 2 获取Cipher实例
//            Cipher cipher = Cipher.getInstance(CIPHER_MODE);
//
//            // 查看数据块位数 默认为16（byte） * 8 =128 bit
////            System.out.println("数据块位数(byte)：" + cipher.getBlockSize());
//
//            // 3 初始化Cipher实例。设置执行模式以及加密密钥
//            cipher.init(Cipher.ENCRYPT_MODE, keySpec);
//
//            // 4 执行
//            byte[] cipherTextBytes = cipher.doFinal(clearTextBytes);
//
//            // 5 返回密文字符集
//            return cipherTextBytes;
//
//        } catch (NoSuchPaddingException e) {
//            e.printStackTrace();
//        } catch (NoSuchAlgorithmException e) {
//            e.printStackTrace();
//        } catch (BadPaddingException e) {
//            e.printStackTrace();
//        } catch (IllegalBlockSizeException e) {
//            e.printStackTrace();
//        } catch (InvalidKeyException e) {
//            e.printStackTrace();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return null;
//    }
//
//    /**
//     * 原始解密
//     * @param cipherTextBytes 密文字节数组，待解密的字节数组
//     * @param pwdBytes 解密密码字节数组
//     * @return 返回解密后的明文字节数组，解密错误返回null
//     */
//    public static byte[] decrypt(byte[] cipherTextBytes, byte[] pwdBytes) {
//
//        try {
//            // 1 获取解密密钥
//            SecretKeySpec keySpec = new SecretKeySpec(pwdBytes, ENCRY_ALGORITHM);
//
//            // 2 获取Cipher实例
//            Cipher cipher = Cipher.getInstance(CIPHER_MODE);
//
//            // 查看数据块位数 默认为16（byte） * 8 =128 bit
////            System.out.println("数据块位数(byte)：" + cipher.getBlockSize());
//
//            // 3 初始化Cipher实例。设置执行模式以及加密密钥
//            cipher.init(Cipher.DECRYPT_MODE, keySpec);
//
//            // 4 执行
//            byte[] clearTextBytes = cipher.doFinal(cipherTextBytes);
//
//            // 5 返回明文字符集
//            return clearTextBytes;
//
//        } catch (NoSuchAlgorithmException e) {
//            e.printStackTrace();
//        } catch (InvalidKeyException e) {
//            e.printStackTrace();
//        } catch (NoSuchPaddingException e) {
//            e.printStackTrace();
//        } catch (BadPaddingException e) {
//            e.printStackTrace();
//        } catch (IllegalBlockSizeException e) {
//            e.printStackTrace();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        // 解密错误 返回null
//        return null;
//    }
//
//    //======================>BASE64<======================
//
//    /**
//     * BASE64加密
//     * @param clearText 明文，待加密的内容
//     * @param password 密码，加密的密码
//     * @return 返回密文，加密后得到的内容。加密错误返回null
//     */
//    public static String encryptBase64(String clearText, String password) {
//        try {
//            // 1 获取加密密文字节数组
//            byte[] cipherTextBytes = encrypt(clearText.getBytes(CHARACTER), pwdHandler(password));
//
//            // 2 对密文字节数组进行BASE64 encoder 得到 BASE6输出的密文
//            BASE64Encoder base64Encoder = new BASE64Encoder();
//            String cipherText = base64Encoder.encode(cipherTextBytes);
//
//            // 3 返回BASE64输出的密文
//            return cipherText;
//        } catch (UnsupportedEncodingException e) {
//            e.printStackTrace();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        // 加密错误 返回null
//        return null;
//    }
//
//    /**
//     * BASE64解密
//     * @param cipherText 密文，带解密的内容
//     * @param password 密码，解密的密码
//     * @return 返回明文，解密后得到的内容。解密错误返回null
//     */
//    public static String decryptBase64(String cipherText, String password) {
//        try {
//            // 1 对 BASE64输出的密文进行BASE64 decodebuffer 得到密文字节数组
//            BASE64Decoder base64Decoder = new BASE64Decoder();
//            byte[] cipherTextBytes = base64Decoder.decodeBuffer(cipherText);
//
//            // 2 对密文字节数组进行解密 得到明文字节数组
//            byte[] clearTextBytes = decrypt(cipherTextBytes, pwdHandler(password));
//
//            // 3 根据 CHARACTER 转码，返回明文字符串
//            return new String(clearTextBytes, CHARACTER);
//        } catch (UnsupportedEncodingException e) {
//            e.printStackTrace();
//        } catch (IOException e) {
//            e.printStackTrace();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        // 解密错误返回null
//        return null;
//    }
//
//    //======================>HEX<======================
//
//    /**
//     * HEX加密
//     * @param clearText 明文，待加密的内容
//     * @param password 密码，加密的密码
//     * @return 返回密文，加密后得到的内容。加密错误返回null
//     */
//    public static String encryptHex(String clearText, String password) {
//        try {
//            // 1 获取加密密文字节数组
//            byte[] cipherTextBytes = encrypt(clearText.getBytes(CHARACTER), pwdHandler(password));
//
//            // 2 对密文字节数组进行 转换为 HEX输出密文
//            String cipherText = byte2hex(cipherTextBytes);
//
//            // 3 返回 HEX输出密文
//            return cipherText;
//        } catch (UnsupportedEncodingException e) {
//            e.printStackTrace();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        // 加密错误返回null
//        return null;
//    }
//
//    /**
//     * HEX解密
//     * @param cipherText 密文，带解密的内容
//     * @param password 密码，解密的密码
//     * @return 返回明文，解密后得到的内容。解密错误返回null
//     */
//    public static String decryptHex(String cipherText, String password) {
//        try {
//            // 1 将HEX输出密文 转为密文字节数组
//            byte[] cipherTextBytes = hex2byte(cipherText);
//
//            // 2 将密文字节数组进行解密 得到明文字节数组
//            byte[] clearTextBytes = decrypt(cipherTextBytes, pwdHandler(password));
//
//            // 3 根据 CHARACTER 转码，返回明文字符串
//            return new String(clearTextBytes, CHARACTER);
//        } catch (UnsupportedEncodingException e) {
//            e.printStackTrace();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        // 解密错误返回null
//        return null;
//    }
//
//    /*字节数组转成16进制字符串  */
//    public static String byte2hex(byte[] bytes) { // 一个字节的数，
//        StringBuffer sb = new StringBuffer(bytes.length * 2);
//        String tmp = "";
//        for (int n = 0; n < bytes.length; n++) {
//            // 整数转成十六进制表示
//            tmp = (java.lang.Integer.toHexString(bytes[n] & 0XFF));
//            if (tmp.length() == 1) {
//                sb.append("0");
//            }
//            sb.append(tmp);
//        }
//        return sb.toString().toUpperCase(); // 转成大写
//    }
//
//    /*将hex字符串转换成字节数组 */
//    private static byte[] hex2byte(String str) {
//        if (str == null || str.length() < 2) {
//            return new byte[0];
//        }
//        str = str.toLowerCase();
//        int l = str.length() / 2;
//        byte[] result = new byte[l];
//        for (int i = 0; i < l; ++i) {
//            String tmp = str.substring(2 * i, 2 * i + 2);
//            result[i] = (byte) (Integer.parseInt(tmp, 16) & 0xFF);
//        }
//        return result;
//    }
//
//    public static void main(String[] args) {
//        String test = encryptHex("test", "1234567800000000");
//        System.out.println(test);
//
//        System.out.println(decryptHex(test, "1234567800000000"));
//    }
//}


package com.yihu.jw.utils;

/**
 * Created by hdwang on 2019/1/17.
 */
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;


/**
 *  加密工具类
 */
public class AesUtil {
    private static final Logger logger = LoggerFactory.getLogger(AesUtil.class);

    private static final String KEY_ALGORITHM = "AES";
    /**
     * 默认的加密算法
     */
    public static final String DEFAULT_CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";

    /**
     * AES 加密操作
     *
     * @param content 待加密内容
     * @param password 加密密码
     * @param iv 使用CBC模式，需要一个向量iv，可增加加密算法的强度
     * @return 加密数据
     */
    public static String encrypt(String content, String password, String iv) {
        try {
            //创建密码器
            Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

            //密码key(超过16字节即128bit的key，需要替换jre中的local_policy.jar和US_export_policy.jar，否则报错：Illegal key size)
            SecretKeySpec keySpec = new SecretKeySpec(password.getBytes("utf-8"),KEY_ALGORITHM);

            //向量iv
            IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes("utf-8"));

            //初始化为加密模式的密码器
            cipher.init(Cipher.ENCRYPT_MODE,keySpec,ivParameterSpec);

            //加密
            byte[] byteContent = content.getBytes("utf-8");
            byte[] result = cipher.doFinal(byteContent);

            // 2 对密文字节数组进行 转换为 HEX输出密文
            String cipherText = byte2hex(result);

            return cipherText;
        } catch (Exception ex) {
            logger.error(ex.getMessage(),ex);
        }

        return null;
    }

    /**
     * AES 解密操作
     *
     * @param content 密文
     * @param password 密码
     * @param iv 使用CBC模式，需要一个向量iv，可增加加密算法的强度
     * @return 明文
     */
    public static String decrypt(byte[] content, String password, String iv) {

        try {
            //创建密码器
            Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

            //密码key
            SecretKeySpec keySpec = new SecretKeySpec(password.getBytes("utf-8"),KEY_ALGORITHM);

            //向量iv
            IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes("utf-8"));

            //初始化为解密模式的密码器
            cipher.init(Cipher.DECRYPT_MODE,keySpec,ivParameterSpec);

            //执行操作
            byte[] result = cipher.doFinal(content);

            return new String(result,"utf-8");
        } catch (Exception ex) {
            logger.error(ex.getMessage(),ex);
        }

        return null;
    }

    /**
     * 字节数组转成16进制字符串,不转为大写
     * @param bytes
     * @return
     */
    public static String byte2hex(byte[] bytes) {
        // 一个字节的数
        StringBuffer sb = new StringBuffer(bytes.length * 2);
        String tmp = "";
        for (int n = 0; n < bytes.length; n++) {
            // 整数转成十六进制表示
            tmp = (Integer.toHexString(bytes[n] & 0XFF));
            if (tmp.length() == 1) {
                sb.append("0");
            }
            sb.append(tmp);
        }
        return sb.toString();
    }

    /*将hex字符串转换成字节数组 */
    public static byte[] hex2byte(String str) {
        if (str == null || str.length() < 2) {
            return new byte[0];
        }
        str = str.toLowerCase();
        int l = str.length() / 2;
        byte[] result = new byte[l];
        for (int i = 0; i < l; ++i) {
            String tmp = str.substring(2 * i, 2 * i + 2);
            result[i] = (byte) (Integer.parseInt(tmp, 16) & 0xFF);
        }
        return result;
    }

    /**
     * Convert hex string to byte[]
     *
     * @param hexString the hex string
     * @return byte[]
     */
    public static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }

    public static byte charToByte(char c) {
        return (byte)"0123456789ABCDEF".indexOf(c);
    }
}