简述

DES 算法的弊端显现之后，征集了一个新的分组密码算法 Rijndael ，而它后来被称作 AES 算法。

AES 的代码稍微比 DES 复杂一些，重要的是加解密的过程是不一样的，而且加解密时密钥的使用顺序相同。个人认为其中最难的是有限域 GF(28)GF(2^8) 上的二元运算，就是列混合操作，这部分代码我是直接搬来的xd

实现的是 AES-128 算法：

  • 分组长度为 128 位，明文密文长度相同都为 128 位
  • 密钥长度 128 位
  • 10 轮迭代
  • 明文密钥大于 128 位只取前 128 位

加密

  • 初始轮密钥加
  • 前 9 次迭代
    • 字节代换
    • 行移位
    • 列混合
    • 轮密钥加
  • 第 10 次迭代
    • 字节代换
    • 行移位
    • 轮密钥加

解密

  • 初始轮密钥加
  • 前 9 次迭代
    • 逆行移位
    • 逆字节代换
    • 轮密钥加
    • 逆列混合
  • 第 10 次迭代
    • 逆行移位
    • 逆字节代换
    • 轮密钥加

AES 动画演示

实验代码

AES 算法的具体过程参考：AES加密算法的详细介绍与实现

aes.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#pragma once

#include <iostream>
#include<iomanip>
using namespace std;

// 子密钥
int subkey[44][4];

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

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

// 轮常量
int RC[10] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36 };

aes.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
#include "aes.h"

/************** 共用函数 **************/
// 乘以0x02
int x02(int n) {
	// 左移一位
	int temp;
	temp = n << 1;
	// 判断a7是否为1，0x80 (1000 0000)
	if (n & 0x80) {
		// 与0x1b (0001 1011)异或
		temp = temp ^ 0x1b;
	}
	return temp;
}
// 循环相乘
int mix(int m, int n)
{
	int temp;
	for (temp = m, m = 0; n; n = n >> 1)
	{
		if (n & 1)
		{
			m = m ^ temp;
		}
		temp = x02(temp);
	}
	return m & 0xff;
}

// 异或
int* XOR(int *key1, int *key2) {
	int *newkey = new int[4];
	for (int i = 0; i < 4; i++) {
		newkey[i] = key1[i] ^ key2[i];
	}
	return newkey;
}

// T函数
int* T(int* w, int round) {
	int *newkey = new int[4];
	int shift_w[4];
	int i;
	// 循环左移一个字节
	for (i = 0; i < 4; i++) {
		shift_w[i] = w[(i + 1) % 4];
	}
	//字节代换，S盒
	for (i = 0; i < 4; i++) {
		int row = shift_w[i] / 16 % 16;
		int col = shift_w[i] % 16;
		newkey[i] = S[row][col];
	}
	// 轮常量异或
	newkey[0] = newkey[0] ^ RC[round - 1];
	for (i = 1; i < 4; i++) {
		newkey[i] = newkey[i] ^ 0x00;
	}
	return newkey;
}

// 生成子密钥
void GenerateSubkeys(string k) {
	// 将初始密钥转化为状态矩阵
	int i, j;
	for (i = 0; i < 4; i++) {
		for (j = 0; j < 4; j++) {
			subkey[i][j] = k[j + i * 4];
		}
	}
	// 生成40个密钥，总计44个
	int *newkey = new int[4];
	for (; i < 44; i++) {
		if (i % 4 == 0) {
			newkey = XOR(subkey[i - 4], T(subkey[i - 1], i / 4));
		}
		else {
			newkey = XOR(subkey[i - 4], subkey[i - 1]);
		}
		for (j = 0; j < 4; j++) {
			subkey[i][j] = newkey[j];
		}
	}
}

/************** 加密函数 **************/
// 字节代换，S盒
// 可逆的非线性字节代换
int** ByteSub(int** plain) {
	int i, j;
	int** newplain = new int *[4];
	for (i = 0; i < 4; i++) {
		newplain[i] = new int[4];
		for (j = 0; j < 4; j++) {
			int row = plain[i][j] / 16 % 16;
			int col = plain[i][j] % 16;
			newplain[i][j] = S[row][col];
		}
	}
	return newplain;
}

// 行移变换
int** ShiftRow(int** plain) {
	int i, j;
	int** newplain = new int *[4];
	for (i = 0; i < 4; i++) {
		newplain[i] = new int[4];
		for (j = 0; j < 4; j++) {
			newplain[i][j] = plain[i][(j + i) % 4];
		}
	}
	return newplain;
}

// 列混合变换
int** MixColumn(int** plain) {
	int i, j;
	int** newplain = new int *[4];
	for (i = 0; i < 4; i++)
		newplain[i] = new int[4];
	for (j = 0; j < 4; j++) {
		newplain[0][j] = mix(plain[0][j], 0x02) ^ mix(plain[1][j],0x03) ^ plain[2][j] ^ plain[3][j];
		newplain[1][j] = plain[0][j] ^ mix(plain[1][j],0x02) ^ mix(plain[2][j],0x03) ^ plain[3][j];
		newplain[2][j] = plain[0][j] ^ plain[1][j] ^ mix(plain[2][j],0x02) ^ mix(plain[3][j],0x03);
		newplain[3][j] = mix(plain[0][j], 0x03) ^ plain[1][j] ^ plain[2][j] ^ mix(plain[3][j], 0x02);
	}
	return newplain;
}

// 密钥加变换
int** AddRoundKey(int** plain, int round) {
	int i, j;
	int** newplain = new int *[4];
	for (i = 0; i < 4; i++)
		newplain[i] = new int[4];
	for (i = 0; i < 4; i++) {
		for (j = 0; j < 4; j++) {
			newplain[j][i] = plain[j][i] ^ subkey[4 * round + i][j];
		}
	}
	return newplain;
}

// AES加密算法,128位明文转128位密文
int* aes(string s, string k) {
	// 对数据块做预处理
	int i, j;
	int** plain = new int*[4];
	for (i = 0; i < 4; i++)
		plain[i] = new int[4];
	for (i = 0; i < 4; i++) {
		for (j = 0; j < 4; j++) {
			plain[j][i] = s[i * 4 + j];
		}
	}
	// 生成子密钥
	GenerateSubkeys(k);
	// 初始轮密钥加
	plain = AddRoundKey(plain, 0);
	// 确定算法轮数，10轮
	for (i = 1; i < 10; i++) {
		// 字节代换
		plain = ByteSub(plain);
		// 行移位
		plain = ShiftRow(plain);
		// 列混合
		plain = MixColumn(plain);
		// 轮密钥加
		plain = AddRoundKey(plain, i);
	}
	// 最后一轮没有列混合操作
	plain = ByteSub(plain);
	plain = ShiftRow(plain);
	plain = AddRoundKey(plain, i);
	// 返回
	int* cipher = new int[16];
	for (i = 0; i < 4; i++) {
		for (j = 0; j < 4; j++) {
			cipher[i * 4 + j] = plain[j][i];
		}
	}
	return cipher;

}


/************** 解密函数 **************/
// 字节代换，逆S盒
// 可逆的非线性字节代换
int** RE_ByteSub(int** cipher) {
	int i, j;
	int** newcipher = new int *[4];
	for (i = 0; i < 4; i++) {
		newcipher[i] = new int[4];
		for (j = 0; j < 4; j++) {
			int row = cipher[i][j] / 16 % 16;
			int col = cipher[i][j] % 16;
			newcipher[i][j] = S_1[row][col];
		}
	}
	return newcipher;
}

// 逆行移变换
int** RE_ShiftRow(int** cipher) {
	int i, j;
	int** newcipher = new int *[4];
	for (i = 0; i < 4; i++) {
		newcipher[i] = new int[4];
		for (j = 0; j < 4; j++) {
			newcipher[i][j] = cipher[i][(j - i + 4) % 4];
		}
	}
	return newcipher;
}

// 逆列混合变换
int** RE_MixColumn(int** cipher) {
	int i, j;
	int** newcipher = new int *[4];
	for (i = 0; i < 4; i++)
		newcipher[i] = new int[4];
	for (j = 0; j < 4; j++) {
		newcipher[0][j] = mix(cipher[0][j], 0x0e) ^ mix(cipher[1][j], 0x0b) ^ mix(cipher[2][j], 0x0d) ^ mix(cipher[3][j], 0x09);
		newcipher[1][j] = mix(cipher[0][j], 0x09) ^ mix(cipher[1][j], 0x0e) ^ mix(cipher[2][j], 0x0b) ^ mix(cipher[3][j], 0x0d);
		newcipher[2][j] = mix(cipher[0][j], 0x0d) ^ mix(cipher[1][j], 0x09) ^ mix(cipher[2][j], 0x0e) ^ mix(cipher[3][j], 0x0b);
		newcipher[3][j] = mix(cipher[0][j], 0x0b) ^ mix(cipher[1][j], 0x0d) ^ mix(cipher[2][j], 0x09) ^ mix(cipher[3][j], 0x0e);
	}
	return newcipher;
}

// AES解密算法,128位密文转128位明文
int* re_aes(int *s, string k) {
	// 对数据块做预处理
	int i, j;
	int** cipher = new int*[4];
	for (i = 0; i < 4; i++)
		cipher[i] = new int[4];
	for (i = 0; i < 4; i++) {
		for (j = 0; j < 4; j++) {
			cipher[j][i] = s[i * 4 + j];
		}
	}
	// 生成子密钥
	//GenerateSubkeys(k);
	// 初始轮密钥加
	cipher = AddRoundKey(cipher, 10);
	// 确定算法轮数，10轮
	for (i = 9; i > 0; i--) {
		// 逆行移位
		cipher = RE_ShiftRow(cipher);
		// 逆字节代换
		cipher = RE_ByteSub(cipher);
		// 轮密钥加
		cipher = AddRoundKey(cipher, i);
		// 逆列混合
		cipher = RE_MixColumn(cipher);		
	}
    // 没有逆列混合
	cipher = RE_ShiftRow(cipher);
	cipher = RE_ByteSub(cipher);
	cipher = AddRoundKey(cipher, i);
	// 返回
	int* plain = new int[16];
	for (i = 0; i < 4; i++) {
		for (j = 0; j < 4; j++) {
			plain[i * 4 + j] = cipher[j][i];
		}
	}
	return plain;
}


/************** 入口 **************/
int main() {
	string s = "helloworld123456";
	string k = "jckjckjckjckjckj";

	int *cipher = new int[16];
	cipher = aes(s, k);
	cout << "密钥" << endl;
	cout << k.c_str() << endl;
	for (int i = 0; i < 16; i++)
		cout <<  hex << int(k[i]) << " ";
	
	cout << endl << endl;
	cout << "明文" << endl;
	cout << s.c_str() << endl;
	for (int i = 0; i < 16; i++)
		cout <<  hex << int(s[i]) << " ";
	
	cout << endl << endl;
	cout << "密文" << endl;
	for (int i = 0; i < 16; i++)
		cout << hex<< cipher[i] << " ";

	int *plain = new int[16];
	plain = re_aes(cipher, k);
	cout << endl << endl;
	cout << "解密后明文" << endl;
	for (int i = 0; i < 16; i++)
		cout << char(plain[i]);
	cout << endl;
	for (int i = 0; i < 16; i++)
		cout <<hex << plain[i] << " ";

	cout << endl;

	return 0;
}

结语

又是一篇基本上只有代码的文章，难怪密码学是我分数最低的专业课（？）