简介

高级加密标准(AES)是最常见的对称加密算法，即加密和解密都用相同的密钥

AES的解密函数为D，P=D(K,C)其中C为密文，K为密钥，P为明文。实际上一般是通过RSA加密密钥，传给接收方，接收方再解密得到AES密钥，然后两方通过密钥来通信。

基本结构

AES是分组密码，是将明文分为一组一组进行加密，每组长度相同，直到加密完整组明文，在AES中，分组长度只能是128位，也就是说，每组长度16个字节，而密钥可以是128位，192位，256位，密钥长度不同，推荐加密轮数也不同

轮数在下面介绍，这里实现的是AES-128，也就是密钥的长度为128位，加密轮数为10轮。
上面说到，AES的加密公式为C = E(K,P)，在加密函数E中，会执行一个轮函数，并且执行10次这个轮函数，这个轮函数的前9次执行的操作是一样的，只有第10次(没有列混合)有所不同。也就是说，一个明文分组会被加密10轮。AES的核心就是实现一轮中的所有操作。

AES的处理单位是字节，128位的输入明文分组P和输入密钥K都被分成16个字节，分别记为P = P0 P1 … P15 和 K = K0 K1 … K15。如，明文分组为P = abcdefghijklmnop,其中的字符a对应P0，p对应P15。一般地，明文分组用字节为单位的正方形矩阵描述，称为状态矩阵。在算法的每一轮中，状态矩阵的内容不断发生变化，最后的结果作为密文输出。该矩阵中字节的排列顺序为从上到下、从左至右依次排列，如下图所示：

我们也可以将矩阵的每一列作为一个元素，每一列被称为1个32位比特字，被扩展成一个44字组成的序列W[0],W[1]…,前四个元素W[0],W[1],W[2],W[3]是原始密钥

AES的整体结构如下，加密操作包括：字节代换，行位移，列混合和轮密钥加，最后一轮迭代不执行列混合，另外在第一轮迭代之前，先将明文和原始密钥进行一次异或加密操作

AES的四个操作都可逆，下面介绍四个操作:

1.字节代换

AES字节代换就是一个查表操作，定义了一个S盒和逆S盒
S盒：

在输出字节时，把该字节的高4位作为行值，低4位作为列值(先将字节化为二进制，前面四个数字为高4位，后面为低4位，0x12=0001 0010，所以行为1，列为2)取出S盒或逆S盒作为输出，例如输出字节为S1为0x12，则查S盒的0x01行和0x02列，得到0xc9，然后替换S1原有的0x12为0xc9，如下：

字节代换逆操作

逆字节代换就是查逆S盒：

行/列	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
0	0x52	0x09	0x6a	0xd5	0x30	0x36	0xa5	0x38	0xbf	0x40	0xa3	0x9e	0x81	0xf3	0xd7	0xfb
1	0x7c	0xe3	0x39	0x82	0x9b	0x2f	0xff	0x87	0x34	0x8e	0x43	0x44	0xc4	0xde	0xe9	0xcb
2	0x54	0x7b	0x94	0x32	0xa6	0xc2	0x23	0x3d	0xee	0x4c	0x95	0x0b	0x42	0xfa	0xc3	0x4e
3	0x08	0x2e	0xa1	0x66	0x28	0xd9	0x24	0xb2	0x76	0x5b	0xa2	0x49	0x6d	0x8b	0xd1	0x25
4	0x72	0xf8	0xf6	0x64	0x86	0x68	0x98	0x16	0xd4	0xa4	0x5c	0xcc	0x5d	0x65	0xb6	0x92
5	0x6c	0x70	0x48	0x50	0xfd	0xed	0xb9	0xda	0x5e	0x15	0x46	0x57	0xa7	0x8d	0x9d	0x84
6	0x90	0xd8	0xab	0x00	0x8c	0xbc	0xd3	0x0a	0xf7	0xe4	0x58	0x05	0xb8	0xb3	0x45	0x06
7	0xd0	0x2c	0x1e	0x8f	0xca	0x3f	0x0f	0x02	0xc1	0xaf	0xbd	0x03	0x01	0x13	0x8a	0x6b
8	0x3a	0x91	0x11	0x41	0x4f	0x67	0xdc	0xea	0x97	0xf2	0xcf	0xce	0xf0	0xb4	0xe6	0x73
9	0x96	0xac	0x74	0x22	0xe7	0xad	0x35	0x85	0xe2	0xf9	0x37	0xe8	0x1c	0x75	0xdf	0x6e
A	0x47	0xf1	0x1a	0x71	0x1d	0x29	0xc5	0x89	0x6f	0xb7	0x62	0x0e	0xaa	0x18	0xbe	0x1b
B	0xfc	0x56	0x3e	0x4b	0xc6	0xd2	0x79	0x20	0x9a	0xdb	0xc0	0xfe	0x78	0xcd	0x5a	0xf4
C	0x1f	0xdd	0xa8	0x33	0x88	0x07	0xc7	0x31	0xb1	0x12	0x10	0x59	0x27	0x80	0xec	0x5f
D	0x60	0x51	0x7f	0xa9	0x19	0xb5	0x4a	0x0d	0x2d	0xe5	0x7a	0x9f	0x93	0xc9	0x9c	0xef
E	0xa0	0xe0	0x3b	0x4d	0xae	0x2a	0xf5	0xb0	0xc8	0xeb	0xbb	0x3c	0x83	0x53	0x99	0x61
F	0x17	0x2b	0x04	0x7e	0xba	0x77	0xd6	0x26	0xe1	0x69	0x14	0x63	0x55	0x21	0x0c	0x7d

2.行位移

行位移是一个简单的左循环移位操作，当密钥长度为128比特时，第0行左移0字节，第1行左移1字节，以此类推:

行位移的逆变换

行位移的逆变换是将状态矩阵中的每一行执行相反的移位操作，即左移变右移。

3.列混合

1.列混合操作

列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵，如下图公式：
状态矩阵的第j列的列混合可以表示为：

其中，矩阵元素的乘法和加法都是定义于GF(2^8)上的二元运算,并不是通常意义上的乘法和加法。这里涉及到一些信息安全上的数学知识，不过不懂这些知识也行。其实这种二元运算的加法等价于两个字节的异或，乘法则复杂一点。对于一个8位的二进制数来说，使用域上的乘法乘以(00000010)等价于左移1位(低位补0)后，再根据情况同(00011011)进行异或运算，设S1 = (a7 a6 a5 a4 a3 a2 a1 a0)，刚0x02 * S1如下图所示：

也就是说如果a7为1，进行异或运算，否则不进行。
类似地，乘以(00000100)可以拆分成两次乘以(00000010)的运算:

乘以(00000011)可以拆分成先分别乘以(0000 0001)和(0000 0010)再将两个乘积异或:

所以，我们只需要实现乘以2的函数，其他数值的乘法都可以通过组合来实现
下面举个具体的例子，输入的状态矩阵如下:

然后进行列混合计算:

得到新矩阵为:

2.列混合逆运算

逆向列混合计算,也是和一个固定矩阵相乘:

逆变换矩阵同正变换矩阵相乘就是单位矩阵

4.轮密钥加

轮密钥加是将128位轮密钥Ki同状态矩阵中的数据进行逐位异或操作，如下图所示，其中密钥Ki中每个字W[4i],W[4i+1],W[4i+2],W[4i+3]为32位比特字，包含4个字节，他们的生成算法会放在下面，轮密钥加可以看作是字逐位异或的结果，也可以看成字节级别或者位级别的操作，也就是说，可以看成S0,S1,S2,S3组成的32位字与W[4i]的异或运算。

轮密钥加的逆运算同正向的轮密钥加运算完全一致，这是因为异或的逆操作是其自身。轮密钥加非常简单，但却能影响S数组中的每一位

密钥扩展

AES首先将初始密钥输入到一个4*4的矩阵中：

这个矩阵的每一列的4个字节组成一个字，矩阵4列的4个字一次命名为W[0],W[1],W[2].W[3],它们构成了一个以字为单位的数组W。比如，K=abcdefghijklmnop，K0=a,K1=b,K2=c,K3=d,W[0]=abcd
接着对W数组进行扩充，扩充40个新列，新列以递归方式产生:
1.如果i不是4的倍数，那么第i列由如下等式确定：
W[i]=W[i-4]⨁W[i-1]
2.如果i是4的倍数，那么第i列由如下等式确定：
W[i]=W[i-4]⨁T(W[i-1])
其中，T是一个有点复杂的函数。
其中，T是一个有点复杂的函数。
函数T由3部分组成：字循环、字节代换和轮常量异或，这3部分的作用分别如下。
a.字循环：将1个字中的4个字节循环左移1个字节。即将输入字[b0, b1, b2, b3]变换成[b1,b2,b3,b0]。
b.字节代换：对字循环的结果使用S盒进行字节代换。
c.轮常量异或：将前两步的结果同轮常量Rcon[j]进行异或，其中j表示轮数。
轮常量Rcon[j]是一个字，其值见下表。

下面举个例子：
设初始的128位密钥为：
3C A1 0B 21 57 F0 19 16 90 2E 13 80 AC C1 07 BD
那么4个初始值为：
W[0] = 3C A1 0B 21
W[1] = 57 F0 19 16
W[2] = 90 2E 13 80
W[3] = AC C1 07 BD
下面求扩展的第1轮的子密钥(W[4],W[5],W[6],W[7])。
由于4是4的倍数，所以：
W[4] = W[0] ⨁ T(W[3])
T(W[3])的计算步骤如下：

1.循环地将W[3]的元素移位：AC C1 07 BD变成C1 07 BD AC;

2.将 C1 07 BD AC 作为S盒的输入，输出为78 C5 7A 91;

3.将78 C5 7A 91与第一轮轮常量Rcon[1]进行异或运算，将得到79 C5 7A 91，因此，T(W[3])=79 C5 7A 91，故
W[4] = 3C A1 0B 21 ⨁ 79 C5 7A 91 = 45 64 71 B0
其余的3个子密钥段的计算如下：
W[5] = W[1] ⨁ W[4] = 57 F0 19 16 ⨁ 45 64 71 B0 = 12 94 68 A6
W[6] = W[2] ⨁ W[5] =90 2E 13 80 ⨁ 12 94 68 A6 = 82 BA 7B 26
W[7] = W[3] ⨁ W[6] = AC C1 07 BD ⨁ 82 BA 7B 26 = 2E 7B 7C 9B
所以，第一轮的密钥为 45 64 71 B0 12 94 68 A6 82 BA 7B 26 2E 7B 7C 9B。

AES解密

具体就是通过将加密流程中的步骤由正变换变为逆变换

AES加密代码实现:

import base64
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
secret = "123456789123456789123456789123"             #由用户输入的16位或24位或32位长的初始密码字符串
print('密钥长度：',len(secret))
#密钥处理,16的整数倍
def add_to_16(text):
    while len(text)%16 !=0:
        text+='\0'
    return (text)
secret=add_to_16(secret)
print('不做任何填充，但是要求密钥必须是16字节的整数倍:',secret)

#cipher = AES.new(secret.encode('utf-8'),AES.MODE_ECB)      #通过AES.MODE_ECB处理初始密码字符串，并返回cipher对象
iv=get_random_bytes(16)  #随机获取16位变量
cipher = AES.new(secret.encode('utf-8'),AES.MODE_CBC,iv)
data="flag{I_love_CS2}"
#明文处理
def add_to_16(text):
    while len(text)%16 !=0:
        text+='\0'
    return (text)
data=add_to_16(data)
print('明文：',data)
encrypt_data= cipher.encrypt(data.encode('utf-8'))     #输入需要加密的字符串，注意字符串长度要是16的倍数。16,32,48..
print ('密文',encrypt_data)                                              #输出加密后的字符串
encrypt_data = base64.b64encode(encrypt_data)
print ('密文的base64编码:',base64.b64encode(encrypt_data))             #输出加密后的字符串的base64编码。
encrypt_data = base64.b64decode(encrypt_data)
print('密文的base64编码的解码:',encrypt_data)
cipher = AES.new(secret.encode('utf-8'),AES.MODE_CBC,iv)
decrypt_data = cipher.decrypt(encrypt_data)
decrypt_data=decrypt_data.decode('utf-8')
print('明文:',decrypt_data)