AES对称加密算法原理

可视化演示

AES是美国标准对称加密算法，采用分组密码与多轮替换置换结构。本文详解AES的分组结构、SubBytes字节替... 切换模式查看不同维度。

1. AES概述：魔法搅拌机的身世

你的果汁铺开业后生意火爆，可问题是：市面上有几十种“搅拌机”，有的水果丁越搅越碎却能被轻松还原，有的机器本身就有后门。于是你决定认准一款由美国国家标准与技术研究院（NIST）在 2001 年公开海选出的冠军机型——Rijndael，官方命名为 AES。它的最大特点是：菜谱完全公开，全世界密码学家围观了二十年都没找出漏洞；而安全的关键，全在那瓶只有你有的秘制底料（密钥）上。

AES 属于分组密码（block cipher）：它一次只处理固定长度的一盒水果丁——128 位，也就是 16 个字节。如果明文很长，就切成很多个 16 字节小块，一块一块放进搅拌机。同时它是对称加密：榨汁（加密）和还原（解密）用的是同一把钥匙。这就像你店里的配方锁箱——同一个密码既能锁上也能打开，简单高效，适合大量数据。

AES 支持三种规格的密钥：128 位、192 位、256 位。密钥越长，搅拌机内部设计的“轮数”就越多，暴力破解的难度也指数级上升。但别误会，不是钥匙越长就一定更好——128 位在现代算力下已经足够安全，256 位更多是为了应对未来量子计算机的威胁。

2. 整体框架：把水果丁码进冰格

开工前，你得先把 16 个字节的明文“码”进一只 4×4 的冰格里，密码学里叫状态矩阵（State）。第 0 个字节放第 0 行第 0 列，第 1 个字节放第 1 行第 0 列……按列填满。为什么用矩阵而不是一长条？因为后面四道工序——换皮、重排、混匀、加料——全都要基于“行”和“列”来操作。

整体流程像一份标准 sOP。先做一次“加料”（AddRoundKey）作为前奏，然后进入主循环：SubBytes → ShiftRows → MixColumns → AddRoundKey，这四步合称轮函数。每一轮结束后，矩阵里的每个字节都已经被其他字节“影响”过，这就是密码学追求的雪崩效应——哪怕只改一个比特，密文也会面目全非。

轮数由密钥长度决定：

其中 $N_k$ 是密钥的“字数”（每字 32 位：128 位密钥 $N_k=4$，192 位 $N_k=6$，256 位 $N_k=8$），$N_b=4$ 是状态矩阵的列数。

所以你手里的 128 位密钥，对应 10 轮搅拌。整体框架理解之后，我们逐一走进每一道工序。

3. SubBytes：给每颗水果换一张皮

第一道工序叫字节替换，AES 里写作 SubBytes。这一步做什么？把状态矩阵里的每一个字节，通过一张名叫 S 盒（S-box） 的 256 格查表，换成另一个完全不同的字节。就像你给每一颗水果丁换皮：苹果变橙子，橙子变猕猴桃，猕猴桃变火龙果——皮相全变，但“这个位置有一颗粒子”的事实没变。

这一步的关键词是非线性。如果所有工序都是“线性”的（像乘一个数、加一个数），那攻击者就能列出一堆线性方程，用代数方法直接解出密钥。而 S 盒就像一张没有规律的“魔术贴纸”，让输入和输出之间不存在简单的数学关系，把线性攻击的路彻底堵死。

这一步想说明白：换皮只是“一对一换妆”，位置没动。真正让信息开始“串门”的，是下一道工序。

4. ShiftRows：把冰格的行错位推一推

第二道工序叫行移位（ShiftRows）。请想象你把冰格端起来，把每一行像推麻将牌一样向左错开：第一行不动，第二行向左推 1 格，第三行向左推 2 格，第四行向左推 3 格。被推出去的水果丁从左边冒出来，绕回右边补位。这样一来，原本竖着排成一列的 4 个字节，就被打散到了四个不同的列里。

为什么要这么做？因为下一步 MixColumns 是按“列”混合的。如果列里的字节都是同一列的“老熟人”，攻击者可以逐列破解；而 ShiftRows 让每一列都凑齐来自四行的“陌生人”，为列混淆提供跨行扩散的素材。

解密时方向相反，每行向右移回去即可，完美可逆。

5. MixColumns：把四杯果汁倒一起打匀

第三道工序列混淆（MixColumns）是四道工序里最“数学”的一步。规则是：取出状态矩阵的每一列（4 个字节），让它与一个固定的 4×4 矩阵相乘，得到一列新的 4 字节。这里的乘法和加法不是普通算术，而是伽罗瓦域 $GF(2^8)$ 里的运算——你可以把它想象成一种特殊的“螺旋搅拌规则”，保证结果仍然落在 0~255 之间。

效果上，列混淆就是“充分混匀”：原来一列里某一个字节的任何细微变化，经过混合后会扩散到这一列的全部 4 个字节中。ShiftRows 已经让每列凑齐了四个方向的字节，MixColumns 再让它们彼此“串味”——这就是 AES 扩散性的核心来源。

注意最后一行的公式里 $2S$ 表示 $GF(2^8)$ 乘法，不是普通乘法。解密时使用另一张“逆向矩阵”即可还原。

6. AddRoundKey：撒入这一轮的神秘调料

最后一道工序轮密钥加（AddRoundKey），是把状态矩阵与这一轮专属的 16 字节轮密钥做按位异或（XOR）。异或的规则很直白：两个比特相同得 0，不同得 1。这就像在果汁里撒入这一轮的秘制调料——调料配方（轮密钥）来自你那瓶底料，搅拌机每转一轮就换一种调料。

异或有一个绝妙性质：自己异或自己等于 0。所以在解密时，只要把同样的轮密钥再异或一次，状态就原样恢复了。这保证了 AES 解密流程可以精准“倒放”，而不需要发明另一套运算。

到这里，一轮搅拌完成。但一个关键问题出现了：每一轮的“调料”从哪来？ 不可能 10 轮都用同一把钥匙——那样攻击者只需要猜一次钥匙就够了。

7. 密钥扩展：一瓶底料兑出十种腌料

AES 的密钥扩展算法要从你手里那瓶种子密钥（比如 128 位 = 16 字节）出发，生成一轮接一轮不同的轮密钥。过程可以这样理解：种子密钥先被切成 4 个“字”（每个字 4 字节），然后像调配腌料一样不断往序列里添加新字。

每新增 4 个字（凑成下一轮 16 字节轮密钥）时，规则是：正常情况下，新的字等于它前面第 $N_k$ 个字的旧兄弟异或前一个字；但每组的第一个字，要先经过一个“调料加工”函数 $f$——先把前一个字循环左移一字节（RotWord），再逐字节查 S 盒（SubWord），最后异或上轮常数 Rcon。轮常数的存在是防止各组轮密钥出现对称性。

第 $r$ 轮的轮密钥就是第 $r$ 组 4 个字。由于每一轮的调料都不同，攻击者就算截获部分轮密钥，也无法推出种子密钥。

8. 工作模式：一盒水果丁怎么分批榨

AES 一次只能处理 16 字节，那 1MB 的文件怎么办？答案是工作模式：定义如何把长消息切块，以及各块之间如何关联。三种最经典的模式如下。

ECB（电子密码本模式）：每个 16 字节块独立用同一把密钥加密。像把水果丁按 16 颗一份，每份各自搅拌。缺点是：相同的明文块永远得到相同的密文块——如果加密一张企鹅图片，密文里还能看出企鹅轮廓，信息安全里著名的“ECB 企鹅漏洞”就是这个。

CBC（密码分组链接模式）：每个明文块先与上一块的密文异或，再加密。像流水线上每一杯果汁都要掺入前一勺成品，因此相同明文块在不同位置会得到不同密文，安全得多，但也必须串行处理。

CTR（计数器模式）：不直接加密明文，而是用计数器值（counter）作为输入，加密后得到一串伪随机密钥流，再与明文异或。这个模式可以并行计算，还能随机读取某一块密文而不影响其他块，因此广泛用于磁盘加密和无线网络。

实际工程中，CTR 模式还会搭配认证机制（如 GCM），防止攻击者篡改密文。选对工作模式，比选对算法本身更考验工程师的功力。

AI 应用场景

Python 演示

# AES 教学版: 演示四个轮操作与简化密钥扩展# 注意: 为便于阅读, 已简化 GF(2^8) 乘法与轮数, 正式加密请使用 PyCryptodome # 简化 S 盒: 非线性映射, 保证每个输入字节都有唯一输出SBOX = [(i * 7 + 1) % 256 for i in range(256)] def show(name, state):    print(name)    for row in state:        print(" ".join("%02x" % b for b in row))    print() def sub_bytes(state):    # 逐字节查 S 盒替换    return [[SBOX[state[r][c]] for c in range(4)] for r in range(4)] def shift_rows(state):    # 第 r 行循环左移 r 位    new = [row[:] for row in state]    for r in range(1, 4):        new[r] = new[r][r:] + new[r][:r]    return new def mix_columns(state):    # 简化列混合: 每个新字节混合本列相邻字节    new = [[0] * 4 for _ in range(4)]    for c in range(4):        a = state[0][c]; b = state[1][c]        d = state[2][c]; e = state[3][c]        new[0][c] = (a + b + e) % 256        new[1][c] = (a + b + d) % 256        new[2][c] = (a + d + e) % 256        new[3][c] = (b + d + e) % 256    return new def add_round_key(state, rk):    # 状态与轮密钥逐字节异或    return [[state[r][c] ^ rk[r][c] for c in range(4)] for r in range(4)] def key_expansion(key):    # 简化密钥扩展: 每轮轮密钥 = 种子密钥加轮号    rounds = []    for r in range(10):        rk = [[(key[r][c] + r * 17) % 256 for c in range(4)] for r in range(4)]        rounds.append(rk)    return rounds def encrypt_block(block, key_rounds):    state = [row[:] for row in block]    show("初态", state)    state = add_round_key(state, key_rounds[0])    show("AddRoundKey 前奏", state)    for r in range(1, 3):  # 演示两轮        state = sub_bytes(state)        show("SubBytes 第%d轮" % r, state)        state = shift_rows(state)        show("ShiftRows 第%d轮" % r, state)        state = mix_columns(state)        show("MixColumns 第%d轮" % r, state)        state = add_round_key(state, key_rounds[r])        show("AddRoundKey 第%d轮" % r, state)    return state if __name__ == "__main__":    block = [[0x00, 0x11, 0x22, 0x33],             [0x44, 0x55, 0x66, 0x77],             [0x88, 0x99, 0xaa, 0xbb],             [0xcc, 0xdd, 0xee, 0xff]]    keys = key_expansion(block)    print("=== AES 教学版演示 ===")    encrypt_block(block, keys)

1. SBOX = [(i * 7 + 1) % 256 for i in range(256)]生成一个简单的非线性 S 盒，保证字节替换不可被线性方程描述。
2. new[r] = new[r][r:] + new[r][:r]实现 ShiftRows 的行循环左移，$r$ 等于行号。
3. (a + b + e) % 256简化版列混淆，让一列中相邻字节互相“串味”，演示扩散效果。
4. state[r][c] ^ rk[r][c]逐字节异或，正是 AddRoundKey 的核心运算。
5. (key[r][c] + r * 17) % 256简化密钥扩展，用轮号扰动种子密钥，生成每轮不同的轮密钥。
6. state = add_round_key(state, key_rounds[0])主流程先做一次“前奏加料”，然后进入多轮循环。
7. if __name__ == "__main__":可执行入口，直接运行会看到每一道工序后的矩阵变化。

常见误区

面试题