AES加解密（对称加密算法）

AES（Advanced Encryption Standard）意思是高级加密标准，是一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。

那么为什么原来的DES会被取代呢，原因就在于其使用56位**，比较容易被**。而AES可以使用128、192、和256位**，并且用128位分组加密和解密数据，相对来说安全很多。

 完善的加密算法在理论上是无法**的，除非使用穷尽法。使用穷尽法****长度在128位以上的加密数据是不现实的，仅存在理论上的可能性。统计显示，即使使用目前世界上运算速度最快的计算机，穷尽128位**也要花上几十亿年的时间，更不用说去**采用256位**长度的AES算法了。

AES是一种对称加密算法，也就是加密和解密使用的是同一把秘钥。

Java实现AES：

import org.apache.commons.codec.binary.Hex;
import org.apache.commons.lang3.StringUtils;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;


public class AESUtil {
    private static final String KEY_ALGORITHM = "AES";
    private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";

    /**
     * 指定随机字符串（密码）生成** ：
     *
     * @param randomKey 加解密的密码
     * @return byte[] **
     * @throws Exception
     */
    public static byte[] getSecretKey(String randomKey) {
        //返回生成指定算法的**的 KeyGenerator 对象
        KeyGenerator keyGenerator = null;
        try {
            keyGenerator = KeyGenerator.getInstance(KEY_ALGORITHM);

            //初始化此**生成器，指定AES的秘钥长度为128
            if (StringUtils.isBlank(randomKey)) {   //不指定密码
                keyGenerator.init(128);
            } else {    //指定密码
                SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
                random.setSeed(randomKey.getBytes());
                keyGenerator.init(128, random);
            }
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return new byte[0];
        }

        SecretKey secretKey = keyGenerator.generateKey();   //生成**
        return secretKey.getEncoded();
    }

    /**
     * 转换**
     *
     * @param key 二进制**
     * @return **
     */
    public static Key toKey(byte[] key) {
        return new SecretKeySpec(key, KEY_ALGORITHM);   //生成**
    }


    /**
     * 加密
     *
     * @param data 待加密数据
     * @param key  **
     * @return byte[]   加密数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, Key key) throws Exception {
        return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
    }


    /**
     * 加密
     *
     * @param data 待加密数据
     * @param key  二进制**
     * @return byte[]   加密数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
        return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
    }


    /**
     * 加密
     *
     * @param data            待加密数据
     * @param key             二进制**
     * @param cipherAlgorithm 加密算法/工作模式/填充方式
     * @return byte[]   加密数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
        Key k = toKey(key);
        return encrypt(data, k, cipherAlgorithm);
    }


    /**
     * 加密
     *
     * @param data            待加密数据
     * @param key             **
     * @param cipherAlgorithm 加密算法/工作模式/填充方式
     * @return byte[]   加密数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
        Cipher cipher = Cipher.getInstance(cipherAlgorithm);    //获取算法
        cipher.init(Cipher.ENCRYPT_MODE, key);                  //设置加密模式，并指定秘钥
        return cipher.doFinal(data);                            //加密数据
    }


    /**
     * 解密
     *
     * @param data 待解密数据
     * @param key  二进制**
     * @return byte[]   解密数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
        return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
    }


    /**
     * 解密
     *
     * @param data 待解密数据
     * @param key  **
     * @return byte[]   解密数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, Key key) throws Exception {
        return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
    }


    /**
     * 解密
     *
     * @param data            待解密数据
     * @param key             二进制**
     * @param cipherAlgorithm 加密算法/工作模式/填充方式
     * @return byte[]   解密数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
        Key k = toKey(key);
        return decrypt(data, k, cipherAlgorithm);
    }


    /**
     * 解密
     *
     * @param data            待解密数据
     * @param key             **
     * @param cipherAlgorithm 加密算法/工作模式/填充方式
     * @return byte[]   解密数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
        Cipher cipher = Cipher.getInstance(cipherAlgorithm);     //获取算法
        cipher.init(Cipher.DECRYPT_MODE, key);                   //设置解密模式，并指定秘钥
        return cipher.doFinal(data);                             //解密数据
    }


    private static String showByteArray(byte[] data) {
        if (null == data) {
            return null;
        }

        

        StringBuilder sb = new StringBuilder("[");
        for (byte b : data) {
            sb.append(b).append(", ");
        }
        sb.deleteCharAt(sb.length() - 2);
        sb.append("]");
        return sb.toString();
    }


    /**
     * 使用示例
     *
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        String password = "123456";
        byte[] key = getSecretKey(password);
        System.out.println("key：" + showByteArray(key));

        Key k = toKey(key);

        String data = "AES数据";
        System.out.println("加密前数据: string:" + data);
        System.out.println("加密前数据: byte[]:" + showByteArray(data.getBytes()));
        System.out.println();

        byte[] encryptData = encrypt(data.getBytes(), k);
        String tmp = Hex.encodeHexString(encryptData);
        System.out.println("加密后数据: byte[]:" + showByteArray(encryptData));
        System.out.println("加密后数据: hexStr:" + tmp);
        System.out.println("加密后数据: hexStr:" + showByteArray(Hex.decodeHex(tmp.toCharArray())));
        System.out.println("加密后数据: hexStr:" + Hex.encodeHexString(Hex.decodeHex(tmp.toCharArray())));

        System.out.println();

        byte[] decryptData = decrypt(Hex.decodeHex(tmp.toCharArray()), k);
        System.out.println("解密后数据: byte[]:" + showByteArray(decryptData));
        System.out.println("解密后数据: string:" + new String(decryptData));
    }
}