1. 项目概述：为什么要在C语言里亲手实现AES？
如果你正在学习密码学，或者需要在嵌入式、物联网、高性能服务器等资源受限或对性能有极致要求的场景下使用加密，那么绕开现成的库，从零开始用C语言实现AES（高级加密标准）算法，绝对是一个“知其然更知其所以然”的硬核修炼。市面上库很多，OpenSSL、mbedTLS都很成熟，但直接调用AES_encrypt和看着黑盒没区别。当你的设备内存只有几十KB，或者你需要对加密的每一个时钟周期了如指掌时，自己实现的、经过裁剪和优化的C代码就是唯一的选择。
这个项目就是带你走一遍这个“炼狱”般的旅程。它不仅仅是把标准文档（FIPS-197）翻译成代码，更涉及到如何在C语言这个贴近硬件的环境中，高效、安全地处理位操作、查表和内存管理。你会深刻理解什么是S盒（SubBytes）、行移位（ShiftRows）、列混合（MixColumns）和轮密钥加（AddRoundKey），以及它们如何通过多轮迭代构成一个坚固的加密堡垒。最终，你将获得一个完全受控、可移植、无任何外部依赖的AES-128加密/解密模块，并能清晰地说出每一行代码背后的数学原理和设计考量。
2. AES-128算法核心原理与C语言映射
在动手写代码前，我们必须吃透AES-128的原理。AES-128处理的数据块是128位（16字节），密钥也是128位。其核心流程可以概括为：初始轮密钥加 → 9轮标准轮函数 → 最终轮（略去列混合）。每一轮标准轮函数都包含四个步骤：字节替换（SubBytes）、行移位（ShiftRows）、列混合（MixColumns）、轮密钥加（AddRoundKey）。
2.1 状态矩阵与字节序：内存布局的约定
在C语言中，我们如何表示这16个字节？最直观的方式是定义一个16字节的数组unsigned char state[16]。但AES算法内部是将这16个字节视为一个4x4的矩阵（称为状态State）进行操作的。这里就有一个关键的映射关系：列优先存储。
即：state[0], state[4], state[8], state[12]构成了矩阵的第一列；state[1], state[5], state[9], state[13]是第二列，以此类推。
状态矩阵 (4x4) +----+----+----+----+ | s0 | s4 | s8 | s12| -> 第0行 | s1 | s5 | s9 | s13| -> 第1行 | s2 | s6 | s10| s14| -> 第2行 | s3 | s7 | s11| s15| -> 第3行 +----+----+----+----+ ^ ^ ^ ^ 第0列 第1列 第2列 第3列理解这个内存布局是后续所有行、列操作的基础。很多初学者实现的算法结果不对，第一步就是在这里搞混了行和列。
2.2 轮函数四步拆解与C实现策略
1. SubBytes（字节替换）这是AES中唯一的非线性变换，为算法提供了混淆性。每个字节通过一个预计算的替换表（S-Box）进行映射。这个S-Box是通过在有限域GF(2^8)上求乘法逆，再做一个仿射变换得到的。
实操心得：我们绝对不要在运行时去计算乘法逆和仿射变换，那会慢得无法接受。标准做法是预先计算好一个长度为256的S盒查找表
const unsigned char sbox[256]。加密时，state[i] = sbox[state[i]];一步完成。解密则需要对应的逆S盒inv_sbox。如何生成这个表？你可以根据FIPS-197文档的公式写代码生成，但更常见的做法是直接复制标准附录中已经计算好的数组。这是空间换时间的经典案例。
2. ShiftRows（行移位）这是一个简单的置换操作，用于提供扩散。状态矩阵的每一行进行循环左移：第0行不移，第1行左移1字节，第2行左移2字节，第3行左移3字节。 在C语言中，我们不需要真的去移动内存。因为我们的状态是列优先存储，所以“行”的元素在内存中是不连续的。更高效的做法是在需要访问行元素时，通过计算索引来模拟移位效果。例如，对于第r行第c列的元素，它在状态数组中的原始索引是(c * 4 + r)，经过行移位后，新的列索引是(c + shift_offset[r]) % 4。我们可以在MixColumns等后续步骤中合并这个偏移计算，避免冗余的数据搬移。
3. MixColumns（列混合）这是AES中最复杂的步骤，提供了极强的扩散性。它将状态矩阵的每一列视为GF(2^8)上的一个多项式，与一个固定的多项式c(x) = {03}x^3 + {01}x^2 + {01}x + {02}进行模x^4+1乘法。 对于C语言实现，我们同样采用查表法来优化。但这里不是简单的单字节替换，而是列操作。一种高效实现是使用列混合查找表（T-table），将SubBytes、ShiftRows、MixColumns三个步骤合并为一次查表和异或操作。这是AES软件实现性能优化的关键。但对于教学和清晰度，我们先实现一个直观的版本：按列处理，对每个字节进行有限域上的乘加运算。 有限域乘法GFMul需要单独实现，核心是异或和条件判断（或者基于预计算的log和alog表实现更快）。
4. AddRoundKey（轮密钥加）最简单的一步，将状态矩阵的每个字节与当前轮的扩展密钥（Round Key）的对应字节进行异或（XOR）操作。state[i] ^= round_key[i];。关键在于，我们需要一个密钥扩展算法，从初始的128位主密钥，生成11轮（初始轮+9标准轮+最终轮）所需的轮密钥。
2.3 密钥扩展：从种子密钥到轮密钥
密钥扩展算法（Key Expansion）是AES安全的重要组成部分。它通过Rijndael的密钥编排算法，将输入的128位密钥扩展成一个44个字（每个字32位，即4字节）的密钥调度表w[44]。 核心操作包括：
- RotWord: 对一个4字节的字进行循环左移。
- SubWord: 用S盒对字的每个字节进行替换。
- Rcon: 轮常数，是一个与轮数相关的字，用于消除对称性。 扩展过程有明确的公式，对于AES-128，每4个字（16字节）为一组轮密钥。实现时，我们需要仔细处理数组下标和字节序。
3. 从零构建：AES-128加密的C语言实现
下面，我们将分模块构建一个完整的AES-128加密函数。为了清晰，我们先不使用T-table优化，而是采用最直接的实现方式。
3.1 基础定义与S盒/逆S盒
首先定义一些常量和数据类型，并引入预计算的S盒。
#include <stdint.h> // 使用标准整数类型 // AES-128 常量定义 #define Nb 4 // 状态矩阵列数 (固定为4) #define Nk 4 // 密钥字数 (AES-128为4) #define Nr 10 // 轮数 (AES-128为10) typedef uint8_t state_t[4][4]; // 状态矩阵，[行][列]，注意这里我们为了逻辑清晰，使用二维数组表示。 // 预计算的S盒和逆S盒 (数据来自FIPS-197标准附录) static const uint8_t sbox[256] = { 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, // ... 此处省略中间242个值，实际代码需补全 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; static const uint8_t inv_sbox[256] = { 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, // ... 此处省略中间242个值，实际代码需补全 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };注意：为了代码可读性，这里用
state_t[4][4]表示状态矩阵，其内存布局是“行优先”，即state[0][0], state[0][1], state[0][2], state[0][3], state[1][0]...。这与之前提到的“列优先”一维数组state[16]不同。在函数内部，我们需要处理好输入输出数据与这个二维状态矩阵之间的转换。两种方式都可以，二维数组在理解算法时更直观。
3.2 密钥扩展实现
这是第一个关键函数，它生成所有轮密钥。
// 轮常数数组 Rcon[i] = {rc[i], 0x00, 0x00, 0x00} static const uint8_t Rcon[11] = {0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36}; // 密钥扩展函数 void KeyExpansion(const uint8_t* key, uint8_t* w) { uint8_t temp[4]; int i = 0; // 1. 初始的Nk个字就是原始密钥 while (i < Nk) { w[4*i] = key[4*i]; w[4*i+1] = key[4*i+1]; w[4*i+2] = key[4*i+2]; w[4*i+3] = key[4*i+3]; i++; } // 2. 扩展后续的字 i = Nk; // i从Nk开始 while (i < Nb * (Nr + 1)) { // 临时字 = 前一个字 temp[0] = w[4*(i-1)]; temp[1] = w[4*(i-1)+1]; temp[2] = w[4*(i-1)+2]; temp[3] = w[4*(i-1)+3]; if (i % Nk == 0) { // 对temp进行 RotWord -> SubWord -> 与Rcon异或 // RotWord: 循环左移一个字节 uint8_t tmp = temp[0]; temp[0] = temp[1]; temp[1] = temp[2]; temp[2] = temp[3]; temp[3] = tmp; // SubWord: 用S盒替换每个字节 temp[0] = sbox[temp[0]]; temp[1] = sbox[temp[1]]; temp[2] = sbox[temp[2]]; temp[3] = sbox[temp[3]]; // 与Rcon异或 (仅第一个字节) temp[0] ^= Rcon[i/Nk]; } // AES-256在Nk=8时有额外处理，此处AES-128忽略 // w[i] = w[i-Nk] xor temp w[4*i] = w[4*(i-Nk)] ^ temp[0]; w[4*i+1] = w[4*(i-Nk)+1] ^ temp[1]; w[4*i+2] = w[4*(i-Nk)+2] ^ temp[2]; w[4*i+3] = w[4*(i-Nk)+3] ^ temp[3]; i++; } }关键点解析：
w数组是一个一维数组，长度为4 * Nb * (Nr+1)= 176字节。每4个字节组成一个“字”，对应一轮密钥的一部分。i % Nk == 0的判断是密钥扩展的核心，它引入了非线性（S盒）和轮常数，确保了轮密钥之间的差异性。
3.3 轮函数基础操作实现
接下来实现四个基础步骤。我们先实现一个独立的有限域乘法函数，用于MixColumns。
// 有限域 GF(2^8) 上的乘法，模不可约多项式 m(x) = x^8 + x^4 + x^3 + x + 1 (0x11b) uint8_t GFMul(uint8_t a, uint8_t b) { uint8_t p = 0; uint8_t hi_bit_set; for (int i = 0; i < 8; i++) { if (b & 1) { p ^= a; } hi_bit_set = (a & 0x80); // 判断a的最高位是否为1 a <<= 1; if (hi_bit_set) { a ^= 0x1b; // 0x1b 是 0x11b的低8位表示 } b >>= 1; } return p; }这个函数通过“移位加”的方式实现乘法。在性能要求高的场景，我们会用查表法替代。
现在实现四个步骤：
// SubBytes: 字节替换 void SubBytes(state_t* state) { for (int r = 0; r < 4; ++r) { for (int c = 0; c < 4; ++c) { (*state)[r][c] = sbox[(*state)[r][c]]; } } } // ShiftRows: 行移位 void ShiftRows(state_t* state) { uint8_t temp; // 第0行不移位 // 第1行循环左移1字节 temp = (*state)[1][0]; (*state)[1][0] = (*state)[1][1]; (*state)[1][1] = (*state)[1][2]; (*state)[1][2] = (*state)[1][3]; (*state)[1][3] = temp; // 第2行循环左移2字节 - 相当于交换两对字节 temp = (*state)[2][0]; (*state)[2][0] = (*state)[2][2]; (*state)[2][2] = temp; temp = (*state)[2][1]; (*state)[2][1] = (*state)[2][3]; (*state)[2][3] = temp; // 第3行循环左移3字节 - 相当于循环右移1字节 temp = (*state)[3][3]; (*state)[3][3] = (*state)[3][2]; (*state)[3][2] = (*state)[3][1]; (*state)[3][1] = (*state)[3][0]; (*state)[3][0] = temp; } // MixColumns: 列混合 void MixColumns(state_t* state) { uint8_t t[4]; for (int c = 0; c < 4; ++c) { // 对每一列操作 // 复制当前列 t[0] = (*state)[0][c]; t[1] = (*state)[1][c]; t[2] = (*state)[2][c]; t[3] = (*state)[3][c]; // 矩阵乘法（在GF(2^8)上） (*state)[0][c] = GFMul(0x02, t[0]) ^ GFMul(0x03, t[1]) ^ t[2] ^ t[3]; (*state)[1][c] = t[0] ^ GFMul(0x02, t[1]) ^ GFMul(0x03, t[2]) ^ t[3]; (*state)[2][c] = t[0] ^ t[1] ^ GFMul(0x02, t[2]) ^ GFMul(0x03, t[3]; (*state)[3][c] = GFMul(0x03, t[0]) ^ t[1] ^ t[2] ^ GFMul(0x02, t[3]); } } // AddRoundKey: 轮密钥加 void AddRoundKey(state_t* state, const uint8_t* round_key) { for (int r = 0; r < 4; ++r) { for (int c = 0; c < 4; ++c) { // round_key 是按列优先存储的，所以索引是 c*4 + r (*state)[r][c] ^= round_key[c * 4 + r]; } } }注意事项：
AddRoundKey中轮密钥round_key的索引c*4 + r是关键。因为我们的state是[行][列]，而扩展密钥w是按列优先的一维数组存储的。第round轮的轮密钥起始地址是&w[round * 4 * 4]，共16字节。
3.4 加密主函数整合
现在，我们可以组装完整的加密流程了。
// 将输入字节数组复制到状态矩阵中（列优先顺序） void CopyToState(const uint8_t* in, state_t* state) { for (int r = 0; r < 4; ++r) { for (int c = 0; c < 4; ++c) { (*state)[r][c] = in[c * 4 + r]; } } } // 将状态矩阵复制到输出字节数组（列优先顺序） void CopyFromState(const state_t* state, uint8_t* out) { for (int r = 0; r < 4; ++r) { for (int c = 0; c < 4; ++c) { out[c * 4 + r] = (*state)[r][c]; } } } // AES-128 加密主函数 void AES_Encrypt(const uint8_t* input, const uint8_t* key, uint8_t* output) { state_t state; uint8_t round_key[176]; // 44个字 * 4字节 = 176字节 // 1. 密钥扩展 KeyExpansion(key, round_key); // 2. 初始化：输入复制到状态矩阵 CopyToState(input, &state); // 3. 初始轮密钥加 AddRoundKey(&state, &round_key[0]); // 第0轮密钥 // 4. 前9轮标准轮函数 for (uint8_t round = 1; round < Nr; ++round) { SubBytes(&state); ShiftRows(&state); MixColumns(&state); AddRoundKey(&state, &round_key[round * 16]); // 第round轮密钥 } // 5. 最终轮（无MixColumns） SubBytes(&state); ShiftRows(&state); AddRoundKey(&state, &round_key[Nr * 16]); // 第10轮密钥 // 6. 将状态矩阵复制到输出 CopyFromState(&state, output); }至此，一个完整的、可工作的AES-128加密函数就实现了。你可以用NIST提供的标准测试向量来验证其正确性。
4. 解密流程与逆变换实现
解密是加密的逆过程，但并非简单反向执行。因为AES的设计结构，解密需要用到逆变换：InvSubBytes,InvShiftRows,InvMixColumns，并且轮密钥的使用顺序是反的。
4.1 逆变换实现
InvSubBytes和InvShiftRows比较简单：
void InvSubBytes(state_t* state) { for (int r = 0; r < 4; ++r) { for (int c = 0; c < 4; ++c) { (*state)[r][c] = inv_sbox[(*state)[r][c]]; } } } void InvShiftRows(state_t* state) { uint8_t temp; // 第0行不移位 // 第1行循环右移1字节 (加密是左移) temp = (*state)[1][3]; (*state)[1][3] = (*state)[1][2]; (*state)[1][2] = (*state)[1][1]; (*state)[1][1] = (*state)[1][0]; (*state)[1][0] = temp; // 第2行循环右移2字节 (等价于左移2字节，所以操作同加密) temp = (*state)[2][0]; (*state)[2][0] = (*state)[2][2]; (*state)[2][2] = temp; temp = (*state)[2][1]; (*state)[2][1] = (*state)[2][3]; (*state)[2][3] = temp; // 第3行循环右移3字节 (等价于左移1字节) temp = (*state)[3][0]; (*state)[3][0] = (*state)[3][1]; (*state)[3][1] = (*state)[3][2]; (*state)[3][2] = (*state)[3][3]; (*state)[3][3] = temp; }InvMixColumns是列混合的逆运算，对应的固定矩阵不同。我们需要实现新的有限域乘法系数。
void InvMixColumns(state_t* state) { uint8_t t[4]; for (int c = 0; c < 4; ++c) { t[0] = (*state)[0][c]; t[1] = (*state)[1][c]; t[2] = (*state)[2][c]; t[3] = (*state)[3][c]; // 使用逆矩阵系数 {0x0e, 0x0b, 0x0d, 0x09} (*state)[0][c] = GFMul(0x0e, t[0]) ^ GFMul(0x0b, t[1]) ^ GFMul(0x0d, t[2]) ^ GFMul(0x09, t[3]); (*state)[1][c] = GFMul(0x09, t[0]) ^ GFMul(0x0e, t[1]) ^ GFMul(0x0b, t[2]) ^ GFMul(0x0d, t[3]); (*state)[2][c] = GFMul(0x0d, t[0]) ^ GFMul(0x09, t[1]) ^ GFMul(0x0e, t[2]) ^ GFMul(0x0b, t[3]); (*state)[3][c] = GFMul(0x0b, t[0]) ^ GFMul(0x0d, t[1]) ^ GFMul(0x09, t[2]) ^ GFMul(0x0e, t[3]); } }4.2 解密主函数
解密流程如下：初始轮密钥加（使用最后一轮密钥）→ 执行9轮标准逆轮函数（InvShiftRows, InvSubBytes, AddRoundKey, InvMixColumns）→ 最终逆轮（InvShiftRows, InvSubBytes, AddRoundKey）。注意，AddRoundKey在解密轮函数中的位置与加密不同。
void AES_Decrypt(const uint8_t* input, const uint8_t* key, uint8_t* output) { state_t state; uint8_t round_key[176]; KeyExpansion(key, round_key); // 扩展密钥和加密时一样 CopyToState(input, &state); // 初始轮密钥加 (使用最后一轮密钥) AddRoundKey(&state, &round_key[Nr * 16]); // 前9轮标准逆轮函数 for (uint8_t round = Nr-1; round > 0; --round) { InvShiftRows(&state); InvSubBytes(&state); AddRoundKey(&state, &round_key[round * 16]); // 注意轮密钥顺序 InvMixColumns(&state); } // 最终轮 InvShiftRows(&state); InvSubBytes(&state); AddRoundKey(&state, &round_key[0]); // 使用初始轮密钥 CopyFromState(&state, output); }核心要点：解密时轮密钥的使用顺序是倒序的。并且，在每一轮中，
AddRoundKey在InvMixColumns之前执行。这是因为在伽罗瓦域上，加（异或）和乘是可交换的，但为了与加密过程的结构对应，需要调整顺序。你可以通过数学推导验证这个顺序的正确性。
5. 性能优化与工程化考量
一个基础可用的AES实现完成了，但在实际项目中，这还远远不够。我们需要考虑性能、内存占用和安全性。
5.1 查表法优化：T-table与T-boxes
我们之前实现的MixColumns和SubBytes是分开的，并且MixColumns中调用了缓慢的GFMul函数。工业级的实现会使用预计算表将多个步骤合并。 最著名的是T-table方法。它预先计算一个包含256个32位字的表T[256]，其中T[a]包含了经过S盒替换、并与固定系数相乘后的结果。这样，一轮加密中的SubBytes、ShiftRows、MixColumns可以合并为对4个T-table的查表和异或操作。
// 简化的T-table使用概念（非完整代码） uint32_t T0[256], T1[256], T2[256], T3[256]; // 预计算的4个表 // 一轮加密可以近似为： s0 = T0[a0] ^ T1[a1] ^ T2[a2] ^ T3[a3] ^ round_key[0]; s1 = T0[a1] ^ T1[a2] ^ T2[a3] ^ T3[a0] ^ round_key[1]; // ... 以此类推，其中a0,a1,a2,a3是状态列中的字节索引映射。这种方法将一轮中大量的有限域乘法和字节替换转换为几次内存查表和异或，性能提升一个数量级以上。解密也有对应的逆表Td0~Td3。
5.2 针对嵌入式平台的优化
在内存极小的MCU上，查4个1KB的表（共4KB）可能都嫌奢侈。此时可以采用S盒与列混合合并的紧凑实现，即只存储S盒，但优化MixColumns的计算。或者使用字节级别的优化，利用MCU的指令特性。另一种思路是使用AES-NI指令集（如果硬件支持），这是终极性能方案，但已超出纯C软件实现的范畴。
5.3 工作模式与填充
我们实现的是最基础的ECB（电子密码本）模式，一次加密16字节。实际应用中，需要根据场景选择工作模式，如CBC（密码分组链接）、CTR（计数器）等，以解决ECB模式相同明文块产生相同密文块的安全缺陷。同时，对于非16字节整数倍的数据，需要填充（如PKCS#7）。这些都需要在AES_Encrypt/Decrypt函数外层再封装一层。
5.4 侧信道攻击防御
我们实现的代码是未防御侧信道攻击的。在实际安全产品中，需要考虑：
- 时间攻击：算法运行时间不应依赖于密钥或明文。我们的查表操作如果因为缓存命中与否导致时间差异，就可能泄露信息。对策包括使用常数时间编程、避免分支和查表（改用计算）。
- 功耗分析/电磁分析：在智能卡等场景下，功耗或电磁辐射会泄露操作信息。对策包括添加随机延迟、数据掩码等。 对于大多数学习和非高安全需求的应用，基础实现已足够。但必须清楚其局限性。
6. 测试、验证与常见问题排查
写完代码，验证是重中之重。最权威的测试是使用NIST官方发布的AES Known Answer Test (KAT) 向量。
6.1 使用标准测试向量验证
你可以从NIST官网找到测试文件（如KAT_AES.zip）。里面会给出密钥、明文和对应的密文。我们写一个简单的测试程序：
#include <stdio.h> #include <string.h> int main() { // 测试向量：AES-128, 密钥和明文全为0 uint8_t key[16] = {0}; uint8_t plaintext[16] = {0}; uint8_t ciphertext[16]; uint8_t decrypted[16]; uint8_t expected_cipher[16] = { 0x66, 0xe9, 0x4b, 0xd4, 0xef, 0x8a, 0x2c, 0x3b, 0x88, 0x4c, 0xfa, 0x59, 0xca, 0x34, 0x2b, 0x2e }; AES_Encrypt(plaintext, key, ciphertext); printf("加密结果: "); for(int i=0; i<16; i++) printf("%02x ", ciphertext[i]); printf("\n预期结果: "); for(int i=0; i<16; i++) printf("%02x ", expected_cipher[i]); printf("\n"); if(memcmp(ciphertext, expected_cipher, 16) == 0) { printf("加密测试通过！\n"); } else { printf("加密测试失败！\n"); return -1; } AES_Decrypt(ciphertext, key, decrypted); if(memcmp(decrypted, plaintext, 16) == 0) { printf("解密测试通过！\n"); } else { printf("解密测试失败！\n"); return -1; } return 0; }多跑几组测试向量，包括全0、全F、随机数据等，确保全覆盖。
6.2 常见问题与调试技巧
在实现过程中，你几乎一定会遇到结果不对的情况。以下是几个常见的坑和排查思路：
问题1：加密结果完全不对，输出全是0或乱码。
- 检查密钥扩展：这是最容易出错的地方。重点检查
i % Nk == 0分支里的RotWord、SubWord和Rcon异或。打印出前几轮扩展后的轮密钥，与标准测试向量中的中间密钥对比。 - 检查S盒数据：确保你复制的S盒数组完全正确，一个字节都不能错。可以写个小程序验证几个已知的映射，如
sbox[0x00]应该是0x63。
问题2：加密结果部分正确，部分字节错误。
- 检查状态矩阵的内存布局：这是第二大坑。确认你在
CopyToState、CopyFromState以及AddRoundKey中，关于行、列索引与一维数组下标的换算关系是否正确。记住我们的约定：状态矩阵state[r][c]对应输入字节in[c*4 + r]。 - 检查行移位方向：加密是左移，解密是右移（或等效的左移）。仔细核对
ShiftRows和InvShiftRows中每个元素的移动轨迹。 - 检查列混合系数：加密矩阵是
({02}, {03}, {01}, {01})等，解密矩阵是({0e}, {0b}, {0d}, {09})等。确认GFMul函数计算正确，可以用几个简单值测试，如GFMul(0x57, 0x83)应该等于0xc1。
问题3：加解密能还原，但与其他库（如OpenSSL）的结果不一致。
- 检查工作模式和填充：其他库默认可能使用CBC模式或PKCS#7填充。确保你们在相同的模式下对比（都使用ECB模式和无填充）。
- 检查字节序：有些库或测试用例可能使用大端序表示密钥和数据，而我们的C代码在x86小端序机器上按字节数组处理。确保你输入的测试向量字节顺序是正确的。
问题4：在嵌入式平台运行速度极慢。
- 优化GFMul：用查表法（对数表、指数表）替换循环乘法。
- 启用编译器优化：
-O2或-Os。 - 考虑使用T-table：如果内存允许，这是最大的性能提升点。
- 检查数据类型：在8位MCU上，使用
uint8_t比int快得多。
6.3 进阶测试：蒙特卡洛测试与性能剖析
通过KAT测试后，可以进行更严格的蒙特卡洛测试（多次迭代加密/解密，将输出作为下一轮的输入/密钥）。这能更好地检验算法的正确性。 对于性能，可以使用clock()或平台特定的高精度计时器，测量加密/解密一个数据块或一定量数据所需的时间，计算吞吐量（MB/s）。对比优化前后的差异，感受算法级优化和代码级优化的威力。
7. 项目总结与扩展方向
亲手用C语言实现一遍AES，就像亲手搭建了一座精密的机械钟表。你不仅知道了指针如何走动，更理解了每一个齿轮的咬合、每一个弹簧的力道。这个过程强迫你直面有限域运算、字节操作、查表优化这些底层细节，这是调用现成库永远无法获得的体验。
这个基础实现可以作为一个可靠的起点，向多个方向扩展：
- 支持AES-192和AES-256：主要修改
Nk（密钥字数）和Nr（轮数），并完善密钥扩展算法中Nk > 6时的额外处理逻辑。 - 实现CBC、CTR等工作模式：在外层封装，增加初始化向量（IV）的处理。
- 添加PKCS#7等填充方案：使它能处理任意长度的数据。
- 集成到网络或文件加密工具中：作为一个核心加密模块。
- 进行侧信道攻击防御改造：学习并实现常数时间版本，这是一个更深入的安全编程课题。
最后，关于代码本身，我强烈建议你将所有函数和全局变量（如S盒）放在独立的头文件.h和源文件.c中，并做好封装。例如，提供一个简洁的API：
// aes.h void aes128_encrypt_ecb(const uint8_t* key, const uint8_t* input, uint8_t* output, size_t length); void aes128_decrypt_ecb(const uint8_t* key, const uint8_t* input, uint8_t* output, size_t length);内部处理分组和填充。这样，你的AES模块就更具工程价值了。
踩过这些坑之后，你再看到那些关于加密算法性能对比、侧信道攻击的论文，或者遇到项目中需要裁剪加密库的情况，心里就会有底得多。密码学不再是黑魔法，而是你工具箱里一件可以拆解、打磨的精密工具。