分组加密核心原理与实践解析（AES/SM4）

摘要 (Executive Summary)

本文档旨在为开发者，特别是Go语言开发者，提供一份关于分组加密（Block Cipher）核心原理的全面解析。将从分组加密的基本定义出发，深入其内部的轮式结构（以AES为例），阐述密钥扩展的重要性，并详细剖析多种关键的工作模式（ECB, CBC, CTR, GCM），最终将这些理论知识与Go语言标准库中的加密实现联系起来。本文的目标是让你不仅知其然（会调用API），更知其所以然（理解底层机制），从而能够更安全、更自信地在项目中使用加密技术。

---

1. 核心概念：什么是分组加密？

分组加密是一种对称加密算法，它将任意长度的明文数据分割成固定长度的"块"（Block），然后使用相同的密钥对每一个块进行独立的加密操作。

可以将其理解为一个纯函数，其签名在概念上如下：

func encryptBlock(plaintextBlock, key) -> ciphertextBlock

这个函数有两个关键特性：

1. 固定长度输入/输出 ：它只处理固定大小的数据块。对于现代主流算法如AES（Advanced Encryption Standard）和SM4（国密4号），这个块大小都是 128位（16字节）。无论你的原始数据是1字节还是1GB，在这个核心函数的眼里，世界是由一个个16字节的片段组成的。
2. 确定性：对于相同的明文块和相同的密钥，加密后输出的密文块永远是相同的。这个特性是其根本，但也引出了后续"工作模式"的必要性。

分组加密算法本身（如AES算法）只是一个核心的"加密引擎"，它本身并不能直接用于加密任意长度的真实世界数据。它是一个基础构建模块，我们需要通过"工作模式"来将其能力扩展到实际应用中。

[备注] 对称加密 vs 非对称加密

• 对称加密：加密和解密使用同一个密钥。速度快，适合加密大量数据。本文讨论的AES、SM4均属此类。
• 非对称加密：使用一对密钥，公钥和私钥。公钥加密的数据只能用私钥解密。速度慢，通常用于密钥交换或数字签名，而非加密大量数据。例如RSA、ECC。

---

2. 加密引擎内部：探秘AES的轮式结构

一个16字节的明文块是如何变成一个看起来完全随机的16字节密文块的？这个过程并非一步到位，而是通过一个迭代的过程，即**多轮（Rounds）**运算来完成。这种设计的核心目标是实现两个密码学安全性的基石：

• 混淆 (Confusion)：使密钥与密文之间的关系尽可能复杂，消除统计规律，让攻击者无法通过分析密文来推断密钥的任何信息。
• 扩散 (Diffusion)：让明文中的任何一位（bit）的微小改动，都能尽可能大地影响到最终密文中的更多位，造成"雪崩效应"。

AES-128标准包含10轮这样的运算。每一轮都由四个不同的、可逆的数学变换组成。在AES中，一个16字节的块被视为一个4x4的字节矩阵。

// 4x4 字节矩阵 State
[b0, b4, b8,  b12]
[b1, b5, b9,  b13]
[b2, b6, b10, b14]
[b3, b7, b11, b15]

2.1 一轮操作的四个步骤

以下是AES一轮中的四个核心操作（最后一轮略有不同）：

1. SubBytes (字节替换)

   • 作用 ：主要的混淆层。
   • 原理 ：这是一个非线性的替换操作。AES定义了一个固定的256字节的查找表，称为S-Box。此操作会遍历4x4矩阵中的每一个字节，以该字节的值（0-255）为索引，在S-Box中找到对应的新值并进行替换。因为S-Box是精心设计的非线性表，它能彻底破坏输入和输出之间的线性关系。

2. ShiftRows (行移位)

   • 作用 ：主要的扩散层。
   • 原理 ：这是一个简单的置换操作，目的是将数据在行与行之间进行移动，为下一阶段的列混淆做准备。
     • 第0行：保持不变。
     • 第1行：所有字节向左循环移动1位。
     • 第2行：所有字节向左循环移动2位。
     • 第3行：所有字节向左循环移动3位。
   • 此操作能确保一列中的字节在下一轮可以影响到其他列。

3. MixColumns (列混淆)

   • 作用 ：进一步加强扩散。
   • 原理 ：这是一个在矩阵的每一列上独立进行的数学运算（伽罗瓦域上的矩阵乘法）。你可以将其理解为，将一列的4个字节作为输入，通过一个线性变换，输出4个全新的字节。输出的每一个字节都依赖于输入的全部4个字节。ShiftRows实现了跨列扩散，MixColumns则实现了列内扩散。

4. AddRoundKey (轮密钥加)

   • 作用 ：将密钥引入加密过程，实现混淆。
   • 原理：将当前处理的4x4矩阵与当前轮的"轮密钥"（一个同样大小的4x4矩阵）进行按位**异或（XOR）**操作。这是整个加密过程中唯一使用到密钥的步骤。XOR运算速度极快且完全可逆，是理想的密钥混合方式。

2.2 整体流程图

graph TD A["明文块 Plaintext (16字节)"] --> B{"初始轮密钥加 AddRoundKey(RoundKey 0)"}; B --> C{开始10轮循环}; subgraph Round 1 to 9 C1[SubBytes] --> C2[ShiftRows]; C2 --> C3[MixColumns]; C3 --> C4{"AddRoundKey(RoundKey i)"}; end subgraph "Final Round (Round 10)" D1[SubBytes] --> D2[ShiftRows]; D2 --> D3{"AddRoundKey(RoundKey 10)"}; end C --> C1; C4 --> C; C -- N=10? --> D1; D3 --> E["密文块 Ciphertext (16字节)"]; style C fill:#f9f,stroke:#333,stroke-width:2px

[备注] SPN结构 (Substitution-Permutation Network)

AES和SM4的设计都遵循了经典的SPN结构。SubBytes是S ubstitution（替换）层，提供非线性混淆。ShiftRows和MixColumns共同构成了Permutation（置换）层，提供线性扩散。通过多轮交替执行S和P操作，并用密钥混合，可以高效地达到理想的加密强度。

---

3. 密钥的角色：密钥扩展 (Key Schedule)

我们只提供一个主密钥（如128位/16字节），但AES-128的10轮加密需要11个不同的16字节轮密钥。这些轮密钥由密钥扩展算法生成。

在你调用Go的aes.NewCipher(key)时，该函数内部就会执行这个算法。它以你的主密钥为"种子"，通过一系列固定的、不可逆的运算（包括字节替换、循环移位和XOR），派生出所有轮次所需的轮密钥。这个过程是确定性的，确保了使用相同主密钥的加密方和解密方能生成完全相同的轮密钥序列。

---

4. 从块到流：工作模式 (Modes of Operation)

现在我们有了强大的"加密引擎"，但它一次只能处理16字节。如何用它来加密一个几KB的JSON文件？这就是工作模式要解决的问题。工作模式定义了如何重复使用分组加密引擎来处理任意长度的数据流。

4.1 ECB (Electronic Codebook) - 电子密码本模式

• 原理：最简单直接的模式。将明文切分成多个块，然后用同一个密钥对每个块独立进行加密。
• 优点：可以并行计算，速度快。
• 致命缺陷 ：相同的明文块会产生相同的密文块。这会保留原文的统计规律。例如，一张图片中大面积的相同颜色区域，在ECB加密后，其轮廓依然清晰可见。
• 结论 ：除非有极其特殊的理由，否则永远不要在实践中使用ECB模式。

graph TD subgraph ECB加密 P1[明文块1] --> E1{"加密(Key)"}; P2[明文块2] --> E2{"加密(Key)"}; P3[明文块3] --> E3{"加密(Key)"}; E1 --> C1[密文块1]; E2 --> C2[密文块2]; E3 --> C3[密文块3]; end

4.2 CBC (Cipher Block Chaining) - 密码块链接模式

• 原理 ：为了克服ECB的缺陷，CBC引入了"链接"机制。在加密当前明文块之前，会先将其与前一个密文块 进行XOR运算。对于第一个块，由于没有"前一个密文块"，它会与一个称为初始化向量（IV） 的随机数据块进行XOR。
• 效果：即使明文块相同，但因为与之XOR的前一个密文块不同，送入加密引擎的数据也不同，最终得到的密文块也不同。IV的存在保证了即使使用相同密钥加密相同明文，每次产生的密文也都是不同的。
• 缺点：加密过程是串行的，无法并行。解密可以并行。此外，CBC只保证机密性，不能防止数据被恶意篡改。

graph TD subgraph CBC加密 IV[IV] --> XOR1; P1[明文块1] --> XOR1{XOR}; XOR1 --> E1{"加密(Key)"}; E1 --> C1[密文块1]; C1 --> XOR2; P2[明文块2] --> XOR2{XOR}; XOR2 --> E2{"加密(Key)"}; E2 --> C2[密文块2]; C2 --> XOR3; P3[明文块3] --> XOR3{XOR}; XOR3 --> E3{"加密(Key)"}; E3 --> C3[密文块3]; end

4.3 CTR (Counter) - 计数器模式

• 原理 ：CTR模式将分组加密从一个"块加密器"变成了一个"流加密器"。它不再直接加密明文。而是通过加密一个不断递增的计数器 来生成一个与明文等长的、一次性的密钥流（Keystream）。最后，将明文与这个密钥流进行XOR运算得到密文。
• 计数器块 ：通常由一个称为Nonce（Number used once，只使用一次的数）和实际的计数器（如0, 1, 2...）拼接而成。Nonce必须保证每次加密都唯一。
• 优点 ：
  1. 完全并行化：每个密钥流块的生成都只依赖于计数器和密钥，可以同时计算，速度极快。
  2. 无需填充：如果明文最后不足一个块，只需生成对应长度的密钥流进行XOR即可。
• 缺点：与CBC一样，只保证机密性，不保证完整性。

graph TD subgraph CTR加密 subgraph 密钥流生成 Nonce[Nonce] Counter1[Counter=1] Nonce & Counter1 --> Block1["Nonce|1"] --> E1{"加密(Key)"} --> KS1[密钥流块1] Counter2[Counter=2] Nonce & Counter2 --> Block2["Nonce|2"] --> E2{"加密(Key)"} --> KS2[密钥流块2] end subgraph 异或加密 P1[明文块1] --> XOR1{XOR} KS1 --> XOR1 --> C1[密文块1] P2[明文块2] --> XOR2{XOR} KS2 --> XOR2 --> C2[密文块2] end end

4.4 GCM (Galois/Counter Mode) - 伽罗瓦/计数器模式

• 这是当前业界推荐的黄金标准，属于AEAD（Authenticated Encryption with Associated Data）认证加密模式。

• 原理 ：GCM巧妙地将CTR模式的高效加密 与一种名为GMAC 的高速认证机制结合在了一起。它同时提供：

  1. 机密性 (Confidentiality)：通过CTR模式实现。
  2. 真实性/完整性 (Authenticity/Integrity) ：通过GMAC生成一个认证标签（Authentication Tag） 来确保数据（包括密文和一些无需加密的"附加数据"）未被篡改。

• 工作流程：

  1. 加密：使用CTR模式将明文加密成密文。
  2. 认证 ：并行地，GMAC会处理附加认证数据（AAD） 和上一步生成的密文，通过一种特殊的伽罗瓦域乘法（GHASH）运算，将它们"揉合"成一个唯一的认证标签（Tag）。AAD是那些你希望保护其完整性但无需加密的数据，如协议头。
  3. 输出 ：最终输出由 密文 + 认证标签 组成。

• 解密流程：

  1. 接收方收到 密文 + 认证标签。
  2. 首先进行验证：使用相同的密钥、Nonce和AAD，对收到的密文独立计算一次认证标签。
  3. 比较标签 ：如果计算出的标签与收到的标签完全一致，证明数据可信，未被篡改。然后才执行CTR解密过程。如果不一致，立即拒绝解密，返回错误。

graph TD subgraph "GCM Seal (加密与认证)" direction LR subgraph CTR加密部分 Nonce[Nonce] & Counter[计数器] --> Encrypt{"加密(Key)"} --> Keystream[密钥流] Plaintext[明文] --> XOR_Encrypt{XOR} Keystream --> XOR_Encrypt XOR_Encrypt --> Ciphertext[密文] end subgraph GMAC认证部分 AAD[附加数据] --> GHASH{"GHASH(Key_H)"} Ciphertext --> GHASH GHASH --> Encrypt_Tag{"XOR with Enc(Nonce|1)"} --> Tag[认证标签] end Ciphertext --> FinalOutput[最终输出] Tag --> FinalOutput end

---

5. 最后的拼图：数据填充 (Padding)

对于像CBC这样严格要求输入为完整块的模式，如果最后一组明文数据不足16字节，就需要进行填充。

• PKCS#7 填充 ：这是最常用的标准。如果缺少 N 个字节，就在数据末尾填充 N 个值为 N 的字节。
  • 例：数据 [1, 2, 3] (3字节)，块大小8字节，缺5字节。填充后为 [1, 2, 3, 5, 5, 5, 5, 5]。
  • 如果数据长度恰好是块大小的整数倍，仍需添加一个完整的填充块。例如，对于16字节的块，一个16字节的数据会再添加一个16字节的填充块，每个字节的值都是16。这是为了在解密时能无歧义地移除填充。

[备注] 流模式如CTR和GCM通常不需要填充，因为它们按位/字节操作，可以处理任意长度的数据。

---

6. Go开发者的实践路线图

现在，我们将所有理论与Go标准库 crypto/... 包中的函数对应起来：

1. aes.NewCipher(key)

   • 作用 ：接收你的主密钥（[]byte类型），执行密钥扩展 ，生成所有轮密钥，并返回一个实现了 cipher.Block 接口的对象。
   • cipher.Block ：这就是我们所说的"加密引擎"的抽象。它有 BlockSize() 和 Encrypt()/Decrypt() 方法，一次只能处理一个块。

2. cipher.NewCBCEncrypter(block, iv)

   • 作用 ：选择并初始化CBC工作模式 。它接收一个 cipher.Block 实例（如上一步创建的AES引擎）和一个IV。

3. cipher.NewGCM(block)

   • 作用 ：选择并初始化GCM工作模式 。这是推荐的做法。它返回一个实现了 cipher.AEAD 接口的对象。

4. gcm.Seal(dst, nonce, plaintext, additionalData)

   • 作用：这是GCM模式的"全家桶"函数，一步完成加密和认证。
   • nonce: 对应GCM中的Nonce。
   • plaintext: 你的原始数据。
   • additionalData: 你的附加认证数据 (AAD)。
   • 返回值 ：一个字节切片，包含了密文和认证标签。

5. gcm.Open(dst, nonce, ciphertext, additionalData)

   • 作用：GCM的解密与验证函数。
   • ciphertext: Seal 函数返回的完整数据。
   • 它会先在内部重新计算并验证认证标签 。如果验证失败，会返回一个error，dst中不会有任何解密数据。如果成功，才会执行解密，并将结果写入dst。

结论

分组加密的世界虽然细节繁多，但其核心思想是建立在少数几个坚实的基础之上的。作为开发者，需要理解：

• 分组加密是基础模块：AES/SM4等算法本身只是处理固定大小数据块的工具。
• 轮式结构是安全的保障：通过多轮的替换、置换和密钥混合，实现了混淆和扩散。
• 工作模式是实践的关键：ECB、CBC、CTR、GCM等模式决定了如何使用加密引擎来处理真实数据。
• 现代加密追求认证加密：GCM等AEAD模式是当前的首选，因为它同时解决了数据的保密性和完整性问题，能抵御更广泛的攻击。