从零实现AES核心算法：深入CTF密码学实战与Python代码剖析-尧图网络科技

1. 项目概述与核心价值

最近在带新人入门CTF（Capture The Flag）时，发现很多朋友对AES（高级加密标准）这个“老熟人”既熟悉又陌生。熟悉是因为在各种Web、Crypto（密码学）题目里它频繁登场，陌生则是因为一旦题目稍微绕点弯子，比如给个错误的IV（初始化向量），或者玩点CBC（密码分组链接）模式的比特翻转，大家就容易卡壳。正好，我在复盘一个经典的Educoder平台上的AES题目时，觉得其设计非常精妙，它没有停留在“调用库函数加解密”的层面，而是引导你亲手用Python复现AES加解密流程中的关键步骤，比如字节代换（SubBytes）、行移位（ShiftRows）和列混淆（MixColumns）。这个过程，对于真正理解AES的“内脏”是如何工作的，以及后续在CTF中灵活应对各种变形攻击，有着不可替代的价值。

所以，这篇内容我就想围绕“从CTF实战看AES”这个核心，带你一起用Python复现那道题目的精髓。这不是一个简单的库函数调用教程，而是一次深入到算法内部的“外科手术”。我们会从AES的基本概念和CTF中的常见考察点聊起，然后一步步用代码构建S盒、实现状态矩阵的变换，最后将这些模块组合起来，去解决题目中设置的那些小关卡。无论你是正在入门CTF密码学方向，还是已经有一定基础但想更透彻地理解AES，亦或是单纯对用Python实现经典算法感兴趣，我相信跟着走完这一趟，你都会有实实在在的收获。我们不止于“知其然”，更要“知其所以然”，明白每一个步骤背后的数学原理和设计意图，这样在赛场上遇到“魔改AES”时，你才能心中有底，快速找到突破口。

2. AES核心概念与CTF常见考点解析

在深入代码之前，我们必须先打好地基，清晰理解AES是什么，以及在CTF竞赛中，出题人最喜欢在它的哪些环节上“做文章”。

2.1 AES算法简介与工作模式

AES是一种对称分组密码算法，意味着加密和解密使用同一把密钥。它处理的数据块大小固定为128位（16字节），密钥长度则可以是128、192或256位。我们最常打交道的，也是CTF题目中最常见的，是AES-128。AES的加密过程可以看作是对一个4x4的字节矩阵（称为“状态State”）进行多轮（10, 12或14轮，取决于密钥长度）的变换。每一轮都包含四个基本步骤（最后一轮略有不同）：

字节代换（SubBytes）：通过一个非线性的S盒（Substitution-box）替换状态中的每一个字节。这是AES提供混淆（Confusion）的主要来源，能有效抵抗线性密码分析。
行移位（ShiftRows）：将状态矩阵的每一行进行循环左移，第0行不移，第1行左移1字节，第2行左移2字节，第3行左移3字节。这一步提供了扩散（Diffusion）。
列混淆（MixColumns）：将状态矩阵的每一列视为在有限域GF(2^8)上的一个多项式，并与一个固定的多项式进行模乘运算。这是AES中计算最复杂的一步，提供了极强的列间扩散。
轮密钥加（AddRoundKey）：将当前的状态与当前轮的轮密钥（由初始密钥通过密钥扩展算法得到）进行简单的按位异或（XOR）操作。

在CTF中，单纯的AES算法实现很少直接考察，更多的是考察其工作模式和使用方式。最常见的工作模式包括：

ECB（电子密码本）：最简单的模式，每个数据块独立加密。致命弱点是相同的明文块会加密成相同的密文块，如果数据有规律（比如图像），密文中会保留明文的模式。CTF中常利用这一点，通过观察密文块重复来推断信息或构造攻击。
CBC（密码分组链接）：当前明文块在加密前，会先与前一个密文块（或初始向量IV）进行XOR。这是CTF中的“明星考点”。因为解密时，当前密文块先解密，再与前一个密文块XOR得到明文。这导致了一个重要特性：篡改前一个密文块（C[i-1]），会影响下一个明文块（P[i]）的解密结果，而当前密文块（C[i]）的篡改，会影响当前明文块（P[i]）的解密结果。这就是“CBC字节翻转攻击”的基础。
CTR（计数器）：将计数器加密后与明文XOR。它实际上将分组密码变成了流密码。在CTF中可能考察其并行性、不可重复的计数器等特性。

注意：很多CTF题目不会直接告诉你模式，需要你根据提供的代码、交互方式或已知信息去判断。例如，如果题目给了iv参数，那大概率是CBC模式。

2.2 CTF中AES题目的典型套路与破局点

理解了基础，我们来看看实战中题目怎么出，又该怎么想。

弱密钥或密钥硬编码：这是最简单的类型。题目源码或附件中直接包含了加密密钥。你的任务就是从源码、内存dump或逆向工程中找到它。解题关键在于代码审计或静态分析。
CBC字节翻转攻击（Bit Flipping）：这是必考题型。题目通常提供一个加密后的数据（如Cookie、Token）给你，并且服务端会解密后检查其中某个字段（如"admin":0）。你无法得知密钥，但可以修改密文（或IV）并提交，服务端会解密并返回错误信息（如Padding Error）或部分结果。攻击的目标是，通过精心修改前一个密文块中的特定字节，使得在解密下一个明文块时，能够将目标字符（如从0变成1）成功翻转。
- 攻击原理：回忆CBC解密公式：P[i] = Decrypt(C[i]) XOR C[i-1]。如果我们想改变P[i]的第j个字节，我们可以修改C[i-1]的第j个字节。因为解密过程是：P‘[i][j] = Decrypt(C[i])[j] XOR C‘[i-1][j]。如果我们令C‘[i-1][j] = C[i-1][j] XOR P[i][j] XOR Target，那么解密后得到的P‘[i][j]就会是我们想要的Target值。
- 实操难点：通常需要结合Padding Oracle（填充提示）攻击。服务端在解密后发现填充不正确时会返回错误，利用这个“差异”我们可以逐个字节地推断出中间值Decrypt(C[i])，从而精确构造出我们想要的C‘[i-1]。
Padding Oracle攻击：如上所述，这种攻击不直接恢复密钥，而是利用服务器对填充有效性的不同反馈（错误信息、响应时间差异等），来逐步推导出明文或构造出任意明文的合法密文。它是CBC模式下的一个经典攻击。
ECB模式攻击：由于ECB模式缺乏扩散，攻击方法多样。
- 字典攻击/重排攻击：如果加密的内容由已知的、可重复的短块组成（比如"admin"，"user"），攻击者可以在不知道密钥的情况下，通过观察密文块，识别、删除或重排这些块来伪造消息。
- 字节替换攻击：在某些场景下（如加密user=xxx&role=user），攻击者可以截取role=admin对应的密文块，去替换自己密文中role=user的块。
侧信道与实现漏洞：较难的题目可能考察算法实现本身的漏洞，比如查表实现的时序攻击（但Python层面较少），或者题目故意提供一个有缺陷的AES实现（比如S盒错误、MixColumns系数错误），要求你利用这个缺陷进行攻击或恢复密钥。

我们这次要复现的Educoder题目，其高明之处在于它避开了上述这些“应用层”的攻击，而是深入到算法内部，考察你对AES核心变换步骤的理解和实现能力。它要求你补全SubBytes、ShiftRows、MixColumns等函数的代码。这相当于让你亲手搭建起AES的引擎，对于后续理解更高级的攻击（比如差分分析、线性分析的概念基础）有莫大好处。

3. 用Python构建AES核心模块

现在，我们开始动手。我们将使用纯Python（仅依赖copy等基础库）来实现AES-128加解密的核心步骤。我们会遵循自底向上的顺序，先实现最基础的有限域运算和S盒，再搭建状态矩阵变换函数。

3.1 有限域GF(2^8)上的运算基础

AES的MixColumns和S盒生成都依赖于在伽罗瓦域GF(2^8)上的运算。这个域可以理解为所有系数在0或1上的、次数小于8的多项式的集合。一个字节（8位）b7b6b5b4b3b2b1b0就对应一个多项式。例如，字节0x57（二进制01010111）对应多项式x^6 + x^4 + x^2 + x + 1。

我们需要实现两个核心操作：

加法：在GF(2^8)中，加法就是按位异或（XOR）。因为系数模2，1+1=0。
乘法：乘法是模一个不可约多项式m(x) = x^8 + x^4 + x^3 + x + 1（对应十六进制0x11b）的多项式乘法。

def gf256_add(a, b): """GF(2^8)加法，即异或。""" return a ^ b def gf256_mul(a, b): """GF(2^8)乘法，模不可约多项式0x11b。""" p = 0 for _ in range(8): if b & 1: # 如果b的最低位是1 p ^= a # 则将a加到p上（异或） high_bit_set = a & 0x80 # 判断a的最高位是否为1 a <<= 1 # a左移一位 if high_bit_set: a ^= 0x11b # 如果溢出，则模0x11b b >>= 1 # b右移一位 return p # 测试一下 print(f"0x57 + 0x83 = {hex(gf256_add(0x57, 0x83))}") # 应为 0xd4 print(f"0x57 * 0x83 = {hex(gf256_mul(0x57, 0x83))}") # 应为 0xc1

实操心得：有限域乘法的这个实现是经典的“移位-判断-异或”方法。理解它的关键在于：多项式乘法a(x) * b(x)可以分解为a(x)乘以b(x)的每一位。循环中，我们检查b的最低位，如果是1，就把当前的a累加到结果p上。然后a左移（相当于乘以x），如果最高位溢出（即原a的x^7系数为1），就需要减去（在GF(2)上就是异或）不可约多项式m(x)，即0x11b。这个过程和整数乘法的竖式计算很像，只不过加法换成了XOR，进位规则变成了模0x11b。

3.2 S盒（Substitution-box）的生成与使用

AES的S盒是一个16x16的查找表，用于将输入字节xy（高4位为x，低4位为y）映射到一个输出字节。它由两个变换复合而成：首先在GF(2^8)上求乘法逆元（0映射到自身），然后进行一个仿射变换。

def generate_sbox(): """生成AES的S盒。""" sbox = [0] * 256 # 首先计算GF(2^8)上的乘法逆元 for i in range(256): if i == 0: # 0的逆元定义为0 inv = 0 else: # 在GF(2^8)中，一个非零元素的逆元是满足 a * inv = 1 的元素 # 由于域很小，我们可以暴力查找。更高效的方法是用扩展欧几里得算法，这里为清晰起见用暴力法。 inv = 0 for j in range(256): if gf256_mul(i, j) == 1: inv = j break # 对逆元进行仿射变换 b = inv # 仿射变换: b' = M * b + c，其中M是一个8x8的矩阵，c是常数0x63 # 可以展开为位运算 b_transformed = b for _ in range(4): # 这个循环是仿射变换矩阵乘法的展开形式 b_transformed = ((b_transformed << 1) & 0xFF) ^ ((b_transformed >> 7) * 0x1B) b_transformed ^= 0x63 sbox[i] = b_transformed & 0xFF return sbox def generate_inv_sbox(sbox): """根据S盒生成逆S盒。""" inv_sbox = [0] * 256 for i in range(256): inv_sbox[sbox[i]] = i return inv_sbox # 生成并验证 SBOX = generate_sbox() INV_SBOX = generate_inv_sbox(SBOX) print(f"SBOX[0x00] = {hex(SBOX[0])}") # 应为 0x63 print(f"SBOX[0x53] = {hex(SBOX[0x53])}") # 可以查标准表验证 print(f"INV_SBOX[{hex(SBOX[0x53])}] = {hex(INV_SBOX[SBOX[0x53]])}") # 应返回0x53

注意事项：在实际解题或工程中，我们几乎不会在运行时动态计算S盒，而是直接使用预定义好的常量表，因为这样速度极快。这里手动生成是为了理解其数学本质。Educoder的题目很可能就是给你一个不完整的S盒生成函数让你补全，或者直接给你S盒数组让你应用。

3.3 状态矩阵与基础变换实现

AES处理的数据块是16字节，在内部表示为4x4的状态矩阵，按列优先顺序排列。即字节B0, B1, B2, B3, B4, ... B15对应矩阵：

[ B0, B4, B8, B12 ] [ B1, B5, B9, B13 ] [ B2, B6, B10, B14 ] [ B3, B7, B11, B15 ]

我们先实现一些辅助函数来处理这个状态矩阵。

def bytes_to_state(data): """将16字节的数组转换为4x4状态矩阵（列优先）。""" if len(data) != 16: raise ValueError("Input data must be exactly 16 bytes long.") state = [[0 for _ in range(4)] for _ in range(4)] for i in range(4): for j in range(4): state[j][i] = data[i * 4 + j] # 注意：列优先，所以行索引j变化快 return state def state_to_bytes(state): """将4x4状态矩阵转换回16字节数组（列优先）。""" data = [0] * 16 for i in range(4): for j in range(4): data[i * 4 + j] = state[j][i] return bytes(data) def print_state(state, label=""): """以十六进制形式打印状态矩阵，便于调试。""" if label: print(label) for row in state: print(' '.join([f'{x:02x}' for x in row])) print()

现在，实现核心的变换步骤：

def sub_bytes(state, sbox): """字节代换：使用提供的S盒替换状态矩阵中的每个字节。""" for i in range(4): for j in range(4): state[i][j] = sbox[state[i][j]] return state def inv_sub_bytes(state, inv_sbox): """逆字节代换。""" return sub_bytes(state, inv_sbox) # 逻辑相同，只是S盒不同 def shift_rows(state): """行移位：第0行不移，第1行左移1位，第2行左移2位，第3行左移3位。""" # 第1行 state[1][0], state[1][1], state[1][2], state[1][3] = state[1][1], state[1][2], state[1][3], state[1][0] # 第2行 state[2][0], state[2][1], state[2][2], state[2][3] = state[2][2], state[2][3], state[2][0], state[2][1] # 第3行 state[3][0], state[3][1], state[3][2], state[3][3] = state[3][3], state[3][0], state[3][1], state[3][2] return state def inv_shift_rows(state): """逆行移位：即右移。""" # 第1行右移1位 state[1][0], state[1][1], state[1][2], state[1][3] = state[1][3], state[1][0], state[1][1], state[1][2] # 第2行右移2位 state[2][0], state[2][1], state[2][2], state[2][3] = state[2][2], state[2][3], state[2][0], state[2][1] # 第3行右移3位 state[3][0], state[3][1], state[3][2], state[3][3] = state[3][1], state[3][2], state[3][3], state[3][0] return state

MixColumns是最复杂的一步。它把状态的每一列看作GF(2^8)上的一个四次多项式，并与固定多项式c(x) = 0x03*x^3 + 0x01*x^2 + 0x01*x + 0x02进行模x^4 + 1乘法。这可以表示为一个矩阵乘法：

[02 03 01 01] [s0,c] [01 02 03 01] * [s1,c] [01 01 02 03] [s2,c] [03 01 01 02] [s3,c]

其中乘法是GF(2^8)乘法。我们可以为每一列单独计算。

def mix_columns(state): """列混淆变换。""" new_state = [[0 for _ in range(4)] for _ in range(4)] # 固定矩阵 mix_matrix = [ [0x02, 0x03, 0x01, 0x01], [0x01, 0x02, 0x03, 0x01], [0x01, 0x01, 0x02, 0x03], [0x03, 0x01, 0x01, 0x02] ] for col in range(4): # 取出当前列 col_vec = [state[row][col] for row in range(4)] for row in range(4): # 计算点积 val = 0 for i in range(4): val ^= gf256_mul(mix_matrix[row][i], col_vec[i]) new_state[row][col] = val return new_state def inv_mix_columns(state): """逆列混淆变换。使用逆矩阵。""" new_state = [[0 for _ in range(4)] for _ in range(4)] # 逆矩阵 inv_mix_matrix = [ [0x0e, 0x0b, 0x0d, 0x09], [0x09, 0x0e, 0x0b, 0x0d], [0x0d, 0x09, 0x0e, 0x0b], [0x0b, 0x0d, 0x09, 0x0e] ] for col in range(4): col_vec = [state[row][col] for row in range(4)] for row in range(4): val = 0 for i in range(4): val ^= gf256_mul(inv_mix_matrix[row][i], col_vec[i]) new_state[row][col] = val return state

核心原理解读：为什么MixColumns的逆矩阵系数这么复杂（0x0e, 0x0b等）？这是因为在GF(2^8)上，c(x)的逆多项式d(x)的系数就是这些值。c(x) * d(x) = 1 mod (x^4+1)。这个逆矩阵确保了MixColumns和InvMixColumns互为逆操作，是解密正确性的关键。在CTF中，如果题目要求你实现解密，而你只记得加密的MixColumns，那么你必须能正确实现或查找这个逆矩阵。

4. 密钥扩展与完整加解密流程组装

有了核心变换，我们还需要从初始密钥生成每一轮使用的轮密钥。对于AES-128，我们需要11个轮密钥（第0轮是初始密钥加，然后10轮加密每轮一个）。

4.1 密钥扩展算法实现

密钥扩展算法也涉及S盒和轮常数Rcon。

def key_expansion(key): """将16字节的密钥扩展为44个字（176字节）的轮密钥列表。""" # AES-128密钥为4个字（16字节） key_size = 16 # 轮数 n_rounds = 10 # 总字数为 (轮数+1) * 4 = 44 expanded_key = [0] * (4 * (n_rounds + 1)) # 轮常数表 Rcon[i] = [rc(i), 0x00, 0x00, 0x00] rcon = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36] # 1. 将初始密钥拷贝到扩展密钥的前4个字 for i in range(4): expanded_key[i] = (key[4*i] << 24) | (key[4*i+1] << 16) | (key[4*i+2] << 8) | key[4*i+3] # 2. 生成后续的字 for i in range(4, 4 * (n_rounds + 1)): temp = expanded_key[i-1] if i % 4 == 0: # 对temp进行RotWord、SubWord、异或Rcon操作 # RotWord: 循环左移一个字节 temp = ((temp << 8) & 0xFFFFFFFF) | (temp >> 24) # SubWord: 对每个字节应用S盒 byte0 = (temp >> 24) & 0xFF byte1 = (temp >> 16) & 0xFF byte2 = (temp >> 8) & 0xFF byte3 = temp & 0xFF temp = (SBOX[byte0] << 24) | (SBOX[byte1] << 16) | (SBOX[byte2] << 8) | SBOX[byte3] # 异或Rcon temp ^= (rcon[i//4 - 1] << 24) # 生成新字： W[i] = W[i-4] XOR temp expanded_key[i] = expanded_key[i-4] ^ temp # 将字数组转换为轮密钥列表，每轮一个状态矩阵（16字节） round_keys = [] for round in range(n_rounds + 1): round_key = [[0 for _ in range(4)] for _ in range(4)] base = round * 4 for i in range(4): word = expanded_key[base + i] round_key[0][i] = (word >> 24) & 0xFF round_key[1][i] = (word >> 16) & 0xFF round_key[2][i] = (word >> 8) & 0xFF round_key[3][i] = word & 0xFF round_keys.append(round_key) return round_keys

4.2 轮密钥加与完整加密/解密单轮实现

def add_round_key(state, round_key): """轮密钥加：状态矩阵与轮密钥矩阵按位异或。""" for i in range(4): for j in range(4): state[i][j] ^= round_key[i][j] return state

现在，我们可以组装完整的AES-128加密和解密函数了。注意，解密是加密的逆过程，步骤顺序相反，并且InvMixColumns需要使用逆矩阵。

def aes_encrypt_block(plaintext, key): """AES-128加密一个16字节的数据块。""" # 1. 密钥扩展 round_keys = key_expansion(key) # 2. 初始状态 state = bytes_to_state(plaintext) # 3. 初始轮密钥加 state = add_round_key(state, round_keys[0]) # 4. 进行9轮标准轮函数 for round_num in range(1, 10): state = sub_bytes(state, SBOX) state = shift_rows(state) state = mix_columns(state) state = add_round_key(state, round_keys[round_num]) # 5. 最后一轮（无MixColumns） state = sub_bytes(state, SBOX) state = shift_rows(state) state = add_round_key(state, round_keys[10]) # 6. 返回密文 ciphertext = state_to_bytes(state) return ciphertext def aes_decrypt_block(ciphertext, key): """AES-128解密一个16字节的数据块。""" round_keys = key_expansion(key) state = bytes_to_state(ciphertext) # 解密第一轮（对应加密的最后一轮） state = add_round_key(state, round_keys[10]) state = inv_shift_rows(state) state = inv_sub_bytes(state, INV_SBOX) # 中间9轮 for round_num in range(9, 0, -1): state = add_round_key(state, round_keys[round_num]) state = inv_mix_columns(state) state = inv_shift_rows(state) state = inv_sub_bytes(state, INV_SBOX) # 最后轮密钥加 state = add_round_key(state, round_keys[0]) plaintext = state_to_bytes(state) return plaintext

4.3 测试我们的实现

让我们用一个标准测试向量来验证我们的实现是否正确。

# 来自NIST的测试向量： AES-128 # Key: 2b7e151628aed2a6abf7158809cf4f3c # Plaintext: 3243f6a8885a308d313198a2e0370734 # Ciphertext: 3925841d02dc09fbdc118597196a0b32 key = bytes.fromhex('2b7e151628aed2a6abf7158809cf4f3c') plaintext = bytes.fromhex('3243f6a8885a308d313198a2e0370734') expected_ciphertext = bytes.fromhex('3925841d02dc09fbdc118597196a0b32') print("测试AES-128加密...") ciphertext = aes_encrypt_block(plaintext, key) print(f"计算密文: {ciphertext.hex()}") print(f"期望密文: {expected_ciphertext.hex()}") print(f"加密测试: {'通过' if ciphertext == expected_ciphertext else '失败'}") print("\n测试AES-128解密...") decrypted = aes_decrypt_block(ciphertext, key) print(f"解密结果: {decrypted.hex()}") print(f"原始明文: {plaintext.hex()}") print(f"解密测试: {'通过' if decrypted == plaintext else '失败'}")

如果一切正确，你应该能看到“通过”的输出。这证明我们从头实现的AES核心逻辑是正确的。

5. 模拟Educoder题目实战与扩展思考

现在，我们有了完整的AES实现，可以回过头来模拟Educoder那类题目的解题过程。题目通常不会让你实现整个加密，而是聚焦于某个或某几个关键函数。

5.1 题目场景模拟与分步破解

假设题目给出如下框架和提示：

“请补全以下AES加密函数中的sub_bytes和mix_columns函数，使得程序能够正确加密给定的明文。”

题目可能会提供一个不完整的Python文件，以及一组测试用例（输入、密钥、期望输出）。你的任务就是像我们上面做的那样，根据AES标准算法描述，补全缺失的函数。

解题步骤：

理解上下文：仔细阅读题目给出的代码框架，确定它使用的是AES-128，以及数据存储方式（很可能是4x4状态矩阵，列优先）。
定位缺失部分：找到需要补全的函数，查看其输入输出格式。例如，mix_columns函数接收一个状态矩阵，返回处理后的状态矩阵。
回忆算法细节：
- 对于sub_bytes：遍历状态矩阵的每个字节，通过S盒（题目可能直接给出S盒列表SBOX）进行替换。
- 对于mix_columns：这是难点。需要回忆或推导那个固定的矩阵（[ [2,3,1,1], ... ]），并实现GF(2^8)上的乘法（题目可能提供gf_mul(a,b)函数，也可能需要你自己写）。
实现与测试：在本地或题目环境中补全代码，用题目给的简单测试用例验证。例如，先测试sub_bytes对一个已知状态的处理结果是否正确。
提交验证：将补全的代码提交到平台，平台会用更全面的测试用例来验证你的实现是否正确。

一个具体的例子：题目可能只给了shift_rows，让你补全mix_columns。你补全后，发现加密结果还是不对。这时你需要检查：你的mix_columns是按列处理吗？GF(2^8)乘法实现了吗？矩阵系数对吗？状态矩阵的索引[row][col]对吗？通过打印中间状态，与标准算法中间结果对比，可以快速定位问题。

5.2 从底层实现到高层攻击的思维跨越

亲手实现一遍AES后，你对CTF中那些AES相关题目的理解会深刻得多。

面对CBC字节翻转：你现在清楚地知道，密文块在解密时，会先经过AES解密算法（包括InvShiftRows,InvSubBytes,InvMixColumns,AddRoundKey）变成一个中间状态，再与前一密文块XOR。当你尝试翻转前一密文块的某个字节时，你实际上是在影响这个XOR操作。因为AES解密算法是确定的，所以Decrypt(C[i])是固定的。你的攻击就是在解这个方程：C‘[i-1] = C[i-1] XOR P[i] XOR P‘[i]。理解了AES内部结构，你会更清楚这个“固定值”是怎么来的。
面对Padding Oracle：你会明白，为什么错误的填充会导致服务器返回错误。因为PKCS#7等填充规则在解密后会被验证。你也更能理解攻击如何利用服务器的错误响应，逐字节地推算出Decrypt(C[i])，进而推算出明文或伪造密文。
面对魔改AES：这是最体现价值的场景。题目可能修改了S盒，或者调整了MixColumns的矩阵，甚至改变了行移位的规则。如果你对标准AES的每一步都了如指掌，你就能快速识别出哪里被改了。然后，你可以根据修改后的算法，要么尝试寻找新的弱点（比如S盒线性度变高），要么就老老实实用修改后的算法去加密/解密来解题。你甚至可以直接把题目给的“魔改”函数替换掉我们上面实现的标准函数，快速搭建一个解题工具。

5.3 常见问题与调试技巧实录

在实现和解题过程中，你肯定会遇到各种bug。下面是我踩过的一些坑和解决方法：

状态矩阵索引搞反：这是最常见的问题。AES标准文档和很多代码使用state[row][col]，且是列优先存储。但在循环时，i和j哪个代表行哪个代表列很容易混淆。一个记忆方法是：外循环i遍历列（0到3），内循环j遍历行（0到3），那么state[j][i]就是正确的列优先存储。在mix_columns中，我们固定一列col，然后计算该列所有行row的新值。
GF(2^8)乘法错误：自己实现的gf256_mul函数一定要用标准测试向量验证。一个常见的错误是在判断最高位和模0x11b时出错。记住，0x11b的二进制是100011011，它对应多项式x^8 + x^4 + x^3 + x + 1。当左移后a的最高位（第8位，即0x100）为1时，才需要异或0x11b。
S盒或逆S盒不匹配：确保加密用SBOX，解密用INV_SBOX。并且要验证SBOX[INV_SBOX[x]] == x对所有x成立。如果题目直接给S盒数组，要确认它是16x16的一维列表，索引是(row<<4)|col。
最后一轮忘记省略MixColumns：加密的第1到第9轮有MixColumns，第10轮没有。解密则相反，第1轮（对应加密第10轮）没有InvMixColumns。这个顺序千万不能错。
密钥扩展的轮常数索引错误：Rcon[i]中的i是从1开始的，对应第一轮扩展。在代码中，我们使用rcon[i//4 - 1]，因为i是字索引，每4个字（即每轮）用一次Rcon。
字节序问题：当密钥或明文以十六进制字符串给定时，bytes.fromhex()是正确的。但如果题目给的是整数数组或别的格式，要小心处理字节顺序。我们的实现假设输入是字节串（bytes object），内部按大端序处理字（(b0<<24)|(b1<<16)...）。

调试建议：

单元测试：对每个小函数（gf256_mul,sub_bytes等）单独编写测试，与已知值对比。
打印中间状态：在加密函数中，每轮结束后打印state，与标准算法中间结果对比（网上可以找到AES的逐步计算示例）。
使用已知库交叉验证：用pycryptodome或cryptography库加密同样的数据，对比结果。但注意，这些库通常处理的是完整的数据和模式（如CBC），要确保你比较的是单个分块的ECB模式结果。
利用在线工具：有一些网站提供AES每一步的详细计算过程，可以输入你的中间值进行比对。

最后，我想说的是，密码学在CTF中之所以有趣，就是因为它结合了严谨的数学和灵活的攻击思维。通过这次从零实现AES核心步骤的练习，我希望你获得的不仅仅是一段可以运行的代码，更是一种“透视”加密算法的能力。下次再遇到AES相关的黑盒或白盒题目，你可以自信地打开调试器，或者拿起笔，从最基本的S盒和行移位开始分析。真正的安全高手，都是从理解基础原理开始的。