AES

标签（空格分隔）： 未分类

AES大致介绍

AES类型 密钥长度（位） 加密轮数 密钥长度（字节） 需要的子密钥总数
AES-128 128 10 16 11
AES-192 192 12 24 13
AES-256 256 14 32 15

加密流程

1
2
3
          密匙K                        密匙
            |                 传输      |
明文P ->AES加密函数 - > 密文C ------->  解密 ---> 明文

开始加密

开始加密
首先通过将已知明文进行一个判断，由于AES加密只能用16个字节，所以得分块情况进行加密，当进行加密的字节刚好是16字节的话正好，如果是少于16字节就必须要进行一个填充（按照自己的方式进行补充）。

明文处理

明文转化为ASCLL值。
然后再将16字节的明文放到一个状态矩阵里面，具体顺序如下:

1
2
3
4
5
6
7
8
输入字节： b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 b10 b11 b12 b13 b14 b15
 
状态矩阵排列：
      Column 0  Column 1  Column 2  Column 3
Row 0:   b0       b4       b8       b12
Row 1:   b1       b5       b9       b13
Row 2:   b2       b6       b10      b14
Row 3:   b3       b7       b11      b15

密匙拓展

先进行密匙转换为ASCLL值然后再进行排列
例子如下

1
2
3
4
5
密匙16进制:4D 79 53 65 63 72 65 74 4B 65 79 31 32 33 34 35
w[0] = [4D, 79, 53, 65]
w[1] = [63, 72, 65, 74]
w[2] = [4B, 65, 79, 31]
w[3] = [32, 33, 34, 35]

注：这是初始密匙k0

就是4个4个的分组排列。

然后进行判断!!!

如果 i % 4 == 0，执行特殊变换

如果i没有满足的话直接进行异或运算 w [ i ] = w [ i - 4 ] ⊕ w [ i-1 ]可以得到下一步的

特殊变换如下:

循环左移

1
2
原始: [byte0, byte1, byte2, byte3]
循环左移后: [byte1, byte2, byte3, byte0]

沙盒替换

由于1个16进制字节转为2进制就是8个字节，此时用这个16进制转为的2进制字节的高4位为行号（转为整数值进行查询），低四位为列号（转为整数值进行查询）。
如此重复将每个字将查询到的值进行替换。
沙盒数值如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
     0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
00: 63 7C 77 7B F2 6B 6F C5 30 01 67 2B FE D7 AB 76
10: CA 82 C9 7D FA 59 47 F0 AD D4 A2 AF 9C A4 72 C0
20: B7 FD 93 26 36 3F F7 CC 34 A5 E5 F1 71 D8 31 15
30: 04 C7 23 C3 18 96 05 9A 07 12 80 E2 EB 27 B2 75
40: 09 83 2C 1A 1B 6E 5A A0 52 3B D6 B3 29 E3 2F 84
50: 53 D1 00 ED 20 FC B1 5B 6A CB BE 39 4A 4C 58 CF
60: D0 EF AA FB 43 4D 33 85 45 F9 02 7F 50 3C 9F A8
70: 51 A3 40 8F 92 9D 38 F5 BC B6 DA 21 10 FF F3 D2
80: CD 0C 13 EC 5F 97 44 17 C4 A7 7E 3D 64 5D 19 73
90: 60 81 4F DC 22 2A 90 88 46 EE B8 14 DE 5E 0B DB
A0: E0 32 3A 0A 49 06 24 5C C2 D3 AC 62 91 95 E4 79
B0: E7 C8 37 6D 8D D5 4E A9 6C 56 F4 EA 65 7A AE 08
C0: BA 78 25 2E 1C A6 B4 C6 E8 DD 74 1F 4B BD 8B 8A
D0: 70 3E B5 66 48 03 F6 0E 61 35 57 B9 86 C1 1D 9E
E0: E1 F8 98 11 69 D9 8E 94 9B 1E 87 E9 CE 55 28 DF
F0: 8C A1 89 0D BF E6 42 68 41 99 2D 0F B0 54 BB 16

与Rcon[round]异或

Rcon = Round Constant，每轮一个常数。
Rcon[round] 是一个字：[RC[round], 0x00, 0x00, 0x00]

1
2
3
4
SubWord结果: [C3, 18, 96, 23]
Rcon[1]:     [01, 00, 00, 00]
            ⊕  ⊕  ⊕  ⊕
结果:      [C2, 18, 96, 23]

然后再与w[i-4]异或得到w[4]

加密开始

初始轮

初始状态进行异或

1
2
3
4
5
状态矩阵：    轮密钥K0：      异或结果：
48 6F 53 6C  ⊕  4D 63 4B 32  =  05 0C 18 5E
65 20 20 64  ⊕  79 72 65 33  =  1C 52 45 57
6C 41 57 21  ⊕  53 65 79 34  =  3F 24 2E 15
6C 45 6F 72  ⊕  65 74 31 35  =  09 31 5E 47

主循环轮

沙盒替换
和密匙的特殊处理中沙盒的一样

这里就不多进行阐述了

行移位
假设此时为第n行那么字符向右移动n位例子如下

1
2
3
4
5
6
7
第0行：不移位 → [6B, FE, B8, 4A]
 
第1行：左移1字节 → [9C, 6F, 6E, 5B] → [6F, 6E, 5B, 9C]
 
第2行：左移2字节 → [76, 36, 95, 59] → [95, 59, 76, 36]
 
第3行：左移3字节 → [01, C7, 4A, 5B] → [5B, 01, C7, 4A]

列混淆
首先是在进行行移位后的状态表列出来
例子如下：

1
2
3
4
6B FE B8 4A
6F 6E 5B 9C
95 59 76 36
5B 01 C7 4A

然后获得第一列的数值：
6B 6F 95 5B
然后对每一列运用矩阵乘法

1
2
3
4
5
固定矩阵：
02 03 01 01
01 02 03 01
01 01 02 03
03 01 01 02

新行0 = (02·6B) ⊕ (03·6F) ⊕ (01·95) ⊕ (01·5B)
新行1 = (01·6B) ⊕ (02·6F) ⊕ (03·95) ⊕ (01·5B)
新行2 = (01·6B) ⊕ (01·6F) ⊕ (02·95) ⊕ (03·5B)
新行3 = (03·6B) ⊕ (01·6F) ⊕ (01·95) ⊕ (02·5B)
先进行乘法运算然后再进行异或运算得到每一列

随后对每一列重复那样的计算
总结：先提出一列然后对固定矩阵的每一行进行矩阵乘法后得到新列

轮密匙加密
与第n轮的密匙进行异或运算例子如下

1
2
3
4
5
状态：         轮密钥K1：     异或结果：
AF 45 32 8D  ⊕  AD CF F7 E5  =  02 8A C5 68
80 23 9E 4C  ⊕  E1 93 92 D1  =  61 B0 0C 9D
C6 F1 5A B7  ⊕  F6 D7 2B F7  =  30 26 71 40
FB DC 88 29  ⊕  46 77 15 32  =  BD AB 9D 1B

这样一轮便是结束了
如此重复9轮

第10轮
只在前几轮的基础上去掉列混淆
最后输出结果便是加密方式

##总结
大致加密流程可以画成这样

1
2
3
4
明文 → 轮密钥加(K0) 
      → [字节替换 → 行移位 → 列混淆 → 轮密钥加(Ki)] 循环9次
      → 字节替换 → 行移位 → 轮密钥加(K10) 
      → 密文

解密的流程是这样

1
2
3
4
5
密文 → 轮密钥加(K10) 
      → 逆行移位 → 逆字节替换 
      → [轮密钥加(Ki) → 逆列混淆 → 逆行移位 → 逆字节替换] 循环9次
      → 轮密钥加(K0) 
      → 明文