通用加密方法

import java.security.Key;
import java.security.MessageDigest;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CryptoUtil {
    private static Logger logger = LoggerFactory.getLogger(CryptoUtil.class);

    public CryptoUtil() {
    }

    private static SecretKeySpec getDesKey(byte[] a) {
        byte[] byteArr = new byte[8];

        for(int i = 0; i < a.length && i < byteArr.length; ++i) {
            byteArr[i] = a[i];
        }

        SecretKeySpec key = new SecretKeySpec(byteArr, "DES");
        return key;
    }

    public static String desEncode(String key, String data) throws CryptoUtil.CryptException {
        try {
            byte[] bytes = desEncode(key, data.getBytes());
            return bytes2Hex(bytes);
        } catch (Exception var3) {
            logger.error(var3.getLocalizedMessage(), var3);
            throw new CryptoUtil.CryptException(var3);
        }
    }

    public static String desEncode(String key, String data, String charset) throws CryptoUtil.CryptException {
        try {
            byte[] bytes = desEncode(key, data.getBytes(charset));
            return bytes2Hex(bytes);
        } catch (Exception var4) {
            logger.error(var4.getLocalizedMessage(), var4);
            throw new CryptoUtil.CryptException(var4);
        }
    }

    public static byte[] desEncode(String strKey, byte[] data) throws CryptoUtil.CryptException {
        try {
            Key key = getDesKey(strKey.getBytes());
            Cipher encryptCipher = Cipher.getInstance("DES");
            encryptCipher.init(1, key, SecureRandom.getInstance("SHA1PRNG"));
            byte[] bytes = encryptCipher.doFinal(data);
            return bytes;
        } catch (Exception var5) {
            logger.error(var5.getLocalizedMessage(), var5);
            throw new CryptoUtil.CryptException(var5);
        }
    }

    public static byte[] desDecode(String strKey, byte[] data) throws CryptoUtil.CryptException {
        try {
            Key key = getDesKey(strKey.getBytes());
            Cipher decryptCipher = Cipher.getInstance("DES");
            decryptCipher.init(2, key, SecureRandom.getInstance("SHA1PRNG"));
            return decryptCipher.doFinal(data);
        } catch (Exception var4) {
            logger.error(var4.getLocalizedMessage(), var4);
            throw new CryptoUtil.CryptException(var4);
        }
    }

    public static String desDecode(String sKey, String data) throws CryptoUtil.CryptException {
        try {
            byte[] datas = desDecode(sKey, hex2Bytes(data));
            return new String(datas);
        } catch (Exception var3) {
            logger.error(var3.getLocalizedMessage(), var3);
            throw new CryptoUtil.CryptException(var3);
        }
    }

    public static String desDecode(String sKey, String data, String charset) throws CryptoUtil.CryptException {
        try {
            byte[] datas = desDecode(sKey, hex2Bytes(data));
            return new String(datas, charset);
        } catch (Exception var4) {
            logger.error(var4.getLocalizedMessage(), var4);
            throw new CryptoUtil.CryptException(var4);
        }
    }

    public static String sha1Encode(String data, String charset) throws CryptoUtil.CryptException {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA1");
            md.update(data.getBytes(charset));
            byte[] output = md.digest();
            return bytes2Hex(output);
        } catch (Exception var4) {
            logger.error(var4.getLocalizedMessage(), var4);
            throw new CryptoUtil.CryptException(var4);
        }
    }

    public static String sha1Encode(String data) throws CryptoUtil.CryptException {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA1");
            md.update(data.getBytes());
            byte[] output = md.digest();
            return bytes2Hex(output);
        } catch (Exception var3) {
            logger.error(var3.getLocalizedMessage(), var3);
            throw new CryptoUtil.CryptException(var3);
        }
    }

    public static String md5Encode(String data) throws CryptoUtil.CryptException {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(data.getBytes());
            byte[] output = md.digest();
            return bytes2Hex(output);
        } catch (Exception var3) {
            logger.error(var3.getLocalizedMessage(), var3);
            throw new CryptoUtil.CryptException(var3);
        }
    }

    public static String md5Encode(String data, String charset) throws CryptoUtil.CryptException {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(data.getBytes(charset));
            byte[] output = md.digest();
            return bytes2Hex(output);
        } catch (Exception var4) {
            logger.error(var4.getLocalizedMessage(), var4);
            throw new CryptoUtil.CryptException(var4);
        }
    }

    private static SecretKeySpec getAesKey(String sKey) {
        byte[] raw = sKey.getBytes();
        byte[] byteArr = new byte[16];

        for(int i = 0; i < raw.length && i < byteArr.length; ++i) {
            byteArr[i] = raw[i];
        }

        SecretKeySpec skeySpec = new SecretKeySpec(byteArr, "AES");
        return skeySpec;
    }

    public static byte[] aesEncode(String sKey, byte[] data) throws CryptoUtil.CryptException {
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            IvParameterSpec iv = new IvParameterSpec("0102030405060708".getBytes());
            cipher.init(1, getAesKey(sKey), iv);
            byte[] result = cipher.doFinal(data);
            return result;
        } catch (Exception var5) {
            logger.error(var5.getLocalizedMessage(), var5);
            throw new CryptoUtil.CryptException(var5);
        }
    }

    public static String aesEncode(String sKey, String data) throws CryptoUtil.CryptException {
        try {
            byte[] bytes = aesEncode(sKey, data.getBytes());
            return bytes2Hex(bytes);
        } catch (Exception var3) {
            logger.error(var3.getLocalizedMessage(), var3);
            throw new CryptoUtil.CryptException(var3);
        }
    }

    public static String aesEncode(String sKey, String data, String charset) throws CryptoUtil.CryptException {
        try {
            byte[] bytes = aesEncode(sKey, data.getBytes(charset));
            return bytes2Hex(bytes);
        } catch (Exception var4) {
            logger.error(var4.getLocalizedMessage(), var4);
            throw new CryptoUtil.CryptException(var4);
        }
    }

    public static byte[] aesDecode(String sKey, byte[] data) throws CryptoUtil.CryptException {
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            IvParameterSpec iv = new IvParameterSpec("0102030405060708".getBytes());
            cipher.init(2, getAesKey(sKey), iv);
            byte[] result = cipher.doFinal(data);
            return result;
        } catch (Exception var5) {
            logger.error(var5.getLocalizedMessage(), var5);
            throw new CryptoUtil.CryptException(var5);
        }
    }

    public static String aesDecode(String sKey, String data) throws CryptoUtil.CryptException {
        try {
            byte[] bytes = hex2Bytes(data);
            return new String(aesDecode(sKey, bytes));
        } catch (Exception var3) {
            logger.error(var3.getLocalizedMessage(), var3);
            throw new CryptoUtil.CryptException(var3);
        }
    }

    public static String aesDecode(String sKey, String data, String charset) throws CryptoUtil.CryptException {
        try {
            byte[] bytes = hex2Bytes(data);
            return new String(aesDecode(sKey, bytes), charset);
        } catch (Exception var4) {
            logger.error(var4.getLocalizedMessage(), var4);
            throw new CryptoUtil.CryptException(var4);
        }
    }

    public static String bytes2Hex(byte[] b) {
        char[] hexDigit = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        StringBuffer buf = new StringBuffer();
        byte[] var3 = b;
        int var4 = b.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            byte element = var3[var5];
            buf.append(hexDigit[element >> 4 & 15]);
            buf.append(hexDigit[element & 15]);
        }

        return buf.toString();
    }

    public static byte[] hex2Bytes(String hexStr) {
        if (hexStr.length() % 2 != 0) {
            throw new IllegalArgumentException("长度不是偶数");
        } else {
            byte[] res = new byte[hexStr.length() / 2];
            char[] chs = hexStr.toCharArray();
            int i = 0;

            for(int c = 0; i < chs.length; ++c) {
                res[c] = (byte)Integer.parseInt(new String(chs, i, 2), 16);
                i += 2;
            }

            return res;
        }
    }

    public static class CryptException extends RuntimeException {
        private static final long serialVersionUID = 1L;

        public CryptException(String msg) {
            super(msg);
        }

        public CryptException(Throwable e) {
            super(e);
        }

        public CryptException(String msg, Throwable e) {
            super(msg, e);
        }
    }
}