AES算法分析

1. AES的结构

AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。

明文分组的长度为128位即16个字节，密钥长度可以是128位（16字节）、192位（24字节）、256位（32字节）。密钥长度不同，加密轮数也不相同。根据密钥的长度，算法被称为AES-128、AES-192或AES-256。具体关系如表1所示：


表1


aes加密js java aes加密后的数据长度_aes加密js java


本文以密钥长度为128位即16字节进行分析，AES的基本结构如图1所示,加密过程图如图2所示：


图1 AES结构图

aes加密js java aes加密后的数据长度_网络协议_02


图2 AES加密过程图


aes加密js java aes加密后的数据长度_网络_03


AES的处理单位是字节，128位的输入明文P和输入密钥K都被分成16个字节，分别记为P = P

0 P

1 … P

15 和 K = K

0 K

1 … K

15。例如，明文为P = “ abcdefghijklmnop ”,其中的字符a对应P

0，p对应P

15。明文分组被描述为4×4的字节方阵，该方阵被复制到状态数组称为状态矩阵。在算法的每一轮中，状态矩阵的内容不断发生变化，最后的结果作为密文输出。该矩阵中字节的排列顺序为从上到下、从左至右依次排列，如图3所示：


图3


aes加密js java aes加密后的数据长度_算法_04


如果明文分组是P = “ abcdefghijklmnop ”，则对应的状态矩阵为图4所示：


图4


aes加密js java aes加密后的数据长度_bc_05


上图中，0x61为字符“ a ”的十六进制表示。可以看到，明文经过AES加密后，已经面目全非。

类似地，128位密钥也是用字节为单位的矩阵表示，矩阵的每一列（4个字节）被称为1个32位比特字（4个字节被称为一个字）。通过密钥编排函数该密钥矩阵被扩展成一个44个字组成的序列W[0]（“ abcd ”）,W[1], … ,W[43],该序列的前4个字W[0],W[1],W[2],W[3]是原始密钥，用于加密运算中的初始密钥加（下面介绍）;后面40个字分为10组，每组4个字（128比特）分别用于10轮加密运算中的轮密钥加，如图5所示：


图5


aes加密js java aes加密后的数据长度_bc_06


上图中，假设K = “abcdefghijklmnop”，则K 

0 = a, K 
15 = p, W[0] = K 
0 K 
1 K 
2 K 
3 = “abcd”。

AES的整体结构如图1所示，其中的W[0,3]是指W[0]、W[1]、W[2]和W[3]串联组成的128位密钥。加密的第1轮到第9轮的轮函数一样，包括4个操作：字节代换、行位移、列混合和轮密钥加。最后一轮迭代不执行列混合。另外，在第一轮迭代之前，先将明文和原始密钥进行一次异或加密操作。

2. AES加密过程

2.1 字节代换

2.1.1 字节代换操作

AES的字节代换其实就是一个简单的查表操作。AES定义了一个S盒和一个逆S盒，如图6是表S盒，图8是逆表S盒。


图6 AES的S盒

aes加密js java aes加密后的数据长度_算法_07


状态矩阵中的元素按照下面的方式映射为一个新的字节：把该字节(把16进制转化为2进制)的高4位作为行值，低4位作为列值，取出S盒或者逆S盒中对应的行的元素作为输出。例如，加密时，输出的字节S1为0x12,则查S盒的第0x01行和0x02列，得到值0xc9,然后替换S1原有的0x12为0xc9，如图7所示： 图7



aes加密js java aes加密后的数据长度_aes加密js java_08

2.1.2 字节代换逆操作

和S盒一样的查表操作。

图8 AES的逆S盒


aes加密js java aes加密后的数据长度_网络协议_09

2.2 行移位

2.2.1 行移位操作

行移位是一个简单的左循环移位操作。当密钥长度为128bit时，状态矩阵的第0行左移0字节，第1行左移1字节，第2行左移2字节，第3行左移3字节，如图9所示：

图9



aes加密js java aes加密后的数据长度_网络协议_10

2.2.2 行移位的逆变换

行移位的逆变换是将状态矩阵中的每一行执行相反的移位操作，例如AES-128中，状态矩阵的第0行右移0字节，第1行右移1字节，第2行右移2字节，第3行右移3字节，如图10所示：

图10


aes加密js java aes加密后的数据长度_aes加密js java_11

2.3 列混合

2.3.1 列混合操作

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

图11



aes加密js java aes加密后的数据长度_网络_12


乘积矩阵里的每个元素均是一行和一列中的对应元素的乘积。这里的乘法和加法都是定义在GF(2

8)上的。状态中单列的列混淆变换表示为：


aes加密js java aes加密后的数据长度_算法_13

列混淆变换的一个例子如下阐述：

aes加密js java aes加密后的数据长度_网络_14


下面验证该列的第一列：先说明一下，两个字节的加操作为对位异或操作，一个字节乘X操作（乘2）等价于左移1位(低位补0)，如果左移前的最高位为1，左移后需同(00011011)进行异或运算。

aes加密js java aes加密后的数据长度_aes加密js java_15

S 0，0‘ = (2 * S 0，0)⊕ (3 * S 1，0)⊕(1 * S 2，0)⊕(1 * S 3，0)
S 1，0‘ = (1 * S 0，0)⊕ (2 * S 1，0)⊕(3 * S 2，0)⊕(1 * S 3，0)
S 2，0‘ = (1 * S 0，0)⊕ (1 * S 1，0)⊕(2 * S 2，0)⊕(3 * S 3，0)
S 3，0‘ = (3 * S 0，0)⊕ (1 * S 1，0)⊕(1 * S 2，0)⊕(2 * S 3，0)

即有：

S 0，0‘ = (2 * 0x87)⊕(3 * 0x6E)⊕(1 * 0x46)⊕(1 * 0xA6) = 0x47
 S 1，0‘ = (1 * 0x87)⊕(2 * 0x6E)⊕(3 * 0x46)⊕(1 * 0xA6)= 0x37
 S 2，0‘ = (1 * 0x87)⊕(1 * 0x6E)⊕(2 * 0x46)⊕(3 * 0xA6) = 0x94
 S 3，0‘ = (3 * 0x87)⊕(1 * 0x6E)⊕(1 * 0x46)⊕(2 * 0xA6) = 0xED对于第一个等式有：
(2 * 10000111)⊕(3 * 01101110)⊕(1 * 01000110)⊕(1*10100110)
 =00010101⊕(3 *01101110 )⊕01000110⊕10100110
 =00010101⊕10110010⊕01000110⊕10100110
 =01000111= 0x47对于第二个等式有：
(1 * 10000111)⊕(2 * 01101110)⊕(3 * 01000110)⊕(1*10100110)
 =10000111⊕11011100⊕(3 * 01000110)⊕10100110
 =10000111⊕11011100⊕11001010⊕10100110
 =001101111=0x37

其余的都类似产生。

2.3.2 列混合逆运算

逆向列混合变换可由下图的矩阵乘法定义：

aes加密js java aes加密后的数据长度_bc_16


从直观上看

aes加密js java aes加密后的数据长度_网络协议_17


等价于

aes加密js java aes加密后的数据长度_网络协议_18

即：逆变换矩阵乘以正向变换矩阵为单位矩阵。

2.4 轮密钥加

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

aes加密js java aes加密后的数据长度_网络协议_19

3. 密钥的扩展

AES密钥算法的输入值是4个字（16个字节），输出值是一个44个字组成（176个字节）的一维线性数组。下面简述这个扩展：

输入密钥直接被复制到扩展密钥数据的前4个字。然后每次用这4个字来填充扩展密钥数组余下的部分。在扩展密钥数组中，每一个新增的字W[ i ]都依赖于W[ i-1 ]和 W[ i-4 ]

aes加密js java aes加密后的数据长度_算法_20

（1）如果i不是4的倍数：

W[ i ] = W[ i-1 ] ⨁ W[ i-4 ]

（2）如果i是4的倍数：

W[ i ] = W[ i-1 ] ) ⨁ g( W[ i-4 ] )

函数g由字循环、字节代换和轮常量异或3步组成：

字循环：将1个字中的4个字节循环左移1个字节；

字节代换：对字循环的结果使用S盒进行字节代换；

轮常量异或：将前两步的结果同轮常量Rcon[ j ]进行异或，其中j表示轮数。

轮常量Rcon[ j ]是一个字，其值见下表：

aes加密js java aes加密后的数据长度_算法_21


例子：

设初始的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 ] ⨁ g(W[ 3 ])

g(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，因此，g(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
    所以，第一轮的密钥为W[ 0,3 ] = 45 64 71 B0 12 94 68 A6 82 BA 7B 26 2E 7B 7C 9B。

4. AES解密

AES解密流程图在本文图1中已给出，过程与加密过程一样，只是密钥的使用顺序相反，第一轮加密使用W [ 40,43 ]，第二轮加密使用 W[ 36,39 ] ，依次类推，第10轮加密使用 W[ 0,3 ]。

相关参考