密码学中的高级加密标准（Advanced Encryption Standard，AES），又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院 （NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。

该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计，结合两位作者的名字，以Rijndael之命名之，投稿高级加密标准的甄选流程。(Rijdael的发音近于 “Rhinedoll”)

AES 是一个新的可以用于保护电子数据的加密算法。明确地说，AES 是一个迭代的、对称密钥分组的密码，它可以使用128、192 和 256 位密钥，并且用 128 位（16字节）分组加密和解密数据。与公共密钥密码使用密钥对不同，对称密钥密码使用相同的密钥加密和解密数据。通过分组密码返回的加密数据的位数与输入数据相同。迭代加密使用一个循环结构，在该循环中重复置换（permutations ）和替换(substitutions）输入数据。Figure 1 显示了 AES 用192位密钥对一个16位字节数据块进行加密和解密的情形。

对称密码体制的发展趋势将以分组密码为重点。分组密码算法通常由密钥扩展算法和加密（解密）算法两部分组成。密钥扩展算法将b字节用户主密钥扩展成r个子密钥。加密算法由一个密码学上的弱函数f与r个子密钥迭代r次组成。混乱和密钥扩散是分组密码算法设计的基本原则。抵御已知明文的差分和线性攻击，可变长密钥和分组是该体制的设计要点。

AES是美国国家标准技术研究所NIST旨在取代DES的21世纪的加密标准。

AES的基本要求是，采用对称分组密码体制，密钥长度的最少支持为128、192、256，分组长度128位，算法应易于各种硬件和软件实现。1998年NIST开始AES第一轮分析、测试和征集，共产生了15个候选算法。1999年3月完成了第二轮AES2的分析、测试。2000年10月2日美国政府正式宣布选中比利时密码学家Joan Daemen 和 Vincent Rijmen 提出的一种密码算法RIJNDAEL 作为 AES.

AES加密数据块大小最大是256bit，但是密钥大小在理论上没有上限。AES加密有很多轮的重复和变换。大致步骤如下：

1. 密钥扩展（KeyExpansion）

2. 初始轮（Initial Round）

3. 重复轮（Rounds），每一轮又包括：SubBytes、ShiftRows、MixColumns、AddRoundKey

4. 最终轮（Final Round），最终轮没有MixColumns。

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.KeyGenerator;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.SecretKey;

import javax.crypto.spec.SecretKeySpec;

import java.io.UnsupportedEncodingException;

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

public abstract class AesHelper {

    /**

    * 加密

    *

    * @param content 需要加密的内容

    * @param salt    加密密码

    * @return

    */

    public static byte[] encrypt(String content, String salt) {

        try {

            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");

            random.setSeed(salt.getBytes());

            KeyGenerator kgen = KeyGenerator.getInstance("AES");

            kgen.init(128, random);

            SecretKey secretKey = kgen.generateKey();

            byte[] enCodeFormat = secretKey.getEncoded();

            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");

            Cipher cipher = Cipher.getInstance("AES");// 创建密码器

            byte[] byteContent = content.getBytes("utf-8");

            cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化

            byte[] result = cipher.doFinal(byteContent);

            return result; // 加密

        } catch (NoSuchAlgorithmException e) {

            e.printStackTrace();

        } catch (NoSuchPaddingException e) {

            e.printStackTrace();

        } catch (InvalidKeyException e) {

            e.printStackTrace();

        } catch (UnsupportedEncodingException e) {

            e.printStackTrace();

        } catch (IllegalBlockSizeException e) {

            e.printStackTrace();

        } catch (BadPaddingException e) {

            e.printStackTrace();

        }

        return null;

    }

    /**

    * 解密

    *

    * @param content 待解密内容

    * @param salt    解密密钥

    * @return

    */

    public static byte[] decrypt(byte[] content, String salt) {

        try {

            KeyGenerator kgen = KeyGenerator.getInstance("AES");

            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");

            secureRandom.setSeed(salt.getBytes());

            kgen.init(128, secureRandom);

            SecretKey secretKey = kgen.generateKey();

            byte[] enCodeFormat = secretKey.getEncoded();

            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");

            Cipher cipher = Cipher.getInstance("AES");// 创建密码器

            cipher.init(Cipher.DECRYPT_MODE, key);// 初始化

            byte[] result = cipher.doFinal(content);

            return result; // 加密

        } catch (NoSuchAlgorithmException e) {

            e.printStackTrace();

        } catch (NoSuchPaddingException e) {

            e.printStackTrace();

        } catch (InvalidKeyException e) {

            e.printStackTrace();

        } catch (IllegalBlockSizeException e) {

            e.printStackTrace();

        } catch (BadPaddingException e) {

            e.printStackTrace();

        }

        return null;

    }

    public static String bytesToHexString(byte[] src) {

        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < src.length; i++) {

            String hex = Integer.toHexString(src[i] & 0xFF);

            if (hex.length() == 1) {

                hex = '0' + hex;

            }

            sb.append(hex.toUpperCase());

        }

        return sb.toString();

    }

    public static String encryptToStr(String content, String password){

        return bytesToHexString(encrypt(content,password));

    }

    public static byte[] decrypt(String content, String keyWord) {

        return decrypt(hexStringToBytes(content), keyWord);

    }

    public static byte[] hexStringToBytes(String hexString) {

        if (hexString.length() < 1)

            return null;

        byte[] result = new byte[hexString.length() / 2];

        for (int i = 0; i < hexString.length() / 2; i++) {

            int high = Integer.parseInt(hexString.substring(i * 2, i * 2 + 1), 16);

            int low = Integer.parseInt(hexString.substring(i * 2 + 1, i * 2 + 2), 16);

            result[i] = (byte) (high * 16 + low);

        }

        return result;

    }

}

public class TestMain {

    public void main(){

        String content = "carl.zhao";

        String Key = "http://www.csdn.net";

        //加密

        String encryptResult = AesHelper.encryptToStr(content, Key);

        //解密

        byte[] decryptResult = AesHelper.decrypt(encryptResult,Key);

        Assert.assertEquals(content, new String(decryptResult));

    }

}

输出结果：

@@eac7cf4369966a656d1355939632cab1611696f7aed973b20f13e8a0e08f1b2ae51d24b41678e12267cd7d8e549674b0fef081fbc0557ec7a7f1eb37bf28e4645a0f6863dae03c2278ea668b03b50102@@