Day-168-对称加密算法详解

# Day 182: 对称加密算法详解

> 密码学系列第 2 天 | 预计阅读时间：45 分钟 | 难度：★★★★☆

---

## 清单 目录

1. [对称加密概述](#对称加密概述)
2. [分组密码原理](#分组密码原理)
3. [AES 算法详解](#aes 算法详解)
4. [AES 工作模式](#aes 工作模式)
5. [ChaCha20 流密码](#chacha20 流密码)
6. [其他对称算法](#其他对称算法)
7. [对称加密实战](#对称加密实战)
8. [性能对比与选型](#性能对比与选型)
9. [安全实践与常见错误](#安全实践与常见错误)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## 对称加密概述

### 基本原理

**对称加密定义**：

```
┌─────────────────────────────────────────────────────────────┐
│                  对称加密基本原理                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  加密过程：                                                 │
│  明文 (P) + 密钥 (K) ──[加密算法 E]──▶ 密文 (C)            │
│  公式：C = E(K, P)                                         │
│                                                             │
│  解密过程：                                                 │
│  密文 (C) + 密钥 (K) ──[解密算法 D]──▶ 明文 (P)            │
│  公式：P = D(K, C)                                         │
│                                                             │
│  核心特性：                                                 │
│  ├── 加密解密使用相同密钥                                   │
│  ├── 算法公开，密钥保密                                     │
│  ├── 加解密速度快（适合大数据）                             │
│  └── 密钥分发是主要挑战                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 算法分类

**对称加密算法分类**：

```
┌─────────────────────────────────────────────────────────────┐
│                  对称加密算法分类                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  分组密码 (Block Cipher)                                    │
│  定义：将明文分成固定长度的分组，逐组加密                   │
│  特点：                                                      │
│  ├── 固定分组长度（如 128 位）                               │
│  ├── 需要工作模式（ECB、CBC、CTR、GCM 等）                   │
│  ├── 应用广泛（AES、SM4、DES）                             │
│  └── 适合文件、数据库加密                                   │
│                                                             │
│  代表算法：                                                  │
│  ├── AES：高级加密标准，最广泛使用                          │
│  ├── SM4：中国国密标准                                      │
│  ├── DES/3DES：已淘汰/逐步淘汰                              │
│  └── Camellia：日本标准，较少使用                           │
│                                                             │
│  流密码 (Stream Cipher)                                     │
│  定义：逐比特或逐字节加密，生成密钥流与明文异或             │
│  特点：                                                      │
│  ├── 无需分组，连续处理                                     │
│  ├── 无需填充，效率高                                       │
│  ├── 适合实时通信（语音、视频）                             │
│  └── 硬件实现简单                                           │
│                                                             │
│  代表算法：                                                  │
│  ├── ChaCha20：现代流密码，TLS 1.3 使用                      │
│  ├── Salsa20：ChaCha20 前身                                 │
│  ├── RC4：已淘汰（WEP 漏洞）                                │
│  └── ZUC：中国国密流密码                                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 应用场景

```
┌─────────────────────────────────────────────────────────────┐
│                  对称加密应用场景                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  数据传输加密                                               │
│  ├── TLS/SSL：HTTPS 通信                                    │
│  ├── SSH：安全远程登录                                      │
│  ├── IPsec：VPN 隧道                                        │
│  └── WiFi：WPA2/WPA3 无线加密                               │
│                                                             │
│  数据存储加密                                               │
│  ├── 磁盘加密：BitLocker、FileVault                         │
│  ├── 文件加密：VeraCrypt、7-Zip                            │
│  ├── 数据库加密：TDE（透明数据加密）                        │
│  └── 云存储加密：S3 SSE、Blob 加密                          │
│                                                             │
│  应用层加密                                                 │
│  ├── 即时通讯：WhatsApp、Signal                            │
│  ├── 密码管理器：1Password、KeePass                        │
│  ├── 支付系统：POS 终端、芯片卡                             │
│  └── DRM：数字版权管理                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 分组密码原理

### 设计结构

**分组密码设计原理**：

```
┌─────────────────────────────────────────────────────────────┐
│                  分组密码设计结构                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Feistel 结构（如 DES）                                      │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  输入：L₀ | R₀  (各 64 位)                             │   │
│  │       ↓                                              │   │
│  │  轮函数 F(R₀, K₁)                                    │   │
│  │       ↓                                              │   │
│  │  L₁ = R₀                                             │   │
│  │  R₁ = L₀ ⊕ F(R₀, K₁)                                 │   │
│  │       ↓                                              │   │
│  │  重复 n 轮...                                         │   │
│  │       ↓                                              │   │
│  │  输出：Lₙ | Rₙ                                        │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  特点：                                                      │
│  ✓ 加密解密结构相似（实现简单）                             │
│  ✓ 轮函数无需可逆                                            │
│  ✓ DES 使用此结构                                           │
│                                                             │
│  SPN 结构（如 AES）                                          │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  输入：State (4x4 字节矩阵)                            │   │
│  │       ↓                                              │   │
│  │  轮密钥加 (AddRoundKey)                              │   │
│  │       ↓                                              │   │
│  │  字节替换 (SubBytes) - 非线性层                      │   │
│  │       ↓                                              │   │
│  │  行移位 (ShiftRows) - 扩散层                         │   │
│  │       ↓                                              │   │
│  │  列混合 (MixColumns) - 扩散层                        │   │
│  │       ↓                                              │   │
│  │  重复 n 轮... (最后一轮无 MixColumns)                 │   │
│  │       ↓                                              │   │
│  │  输出：密文                                          │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  特点：                                                      │
│  ✓ 并行性好（适合硬件）                                     │
│  ✓ 安全性高                                                 │
│  ✓ AES 使用此结构                                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 混淆与扩散

**Shannon 密码学原理**：

```
┌─────────────────────────────────────────────────────────────┐
│              混淆 (Confusion) 与扩散 (Diffusion)            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  混淆 (Confusion)                                           │
│  目的：隐藏明文与密文、密钥之间的关系                        │
│  实现：                                                      │
│  ├── 非线性替换（S 盒）                                      │
│  ├── 复杂密钥调度                                            │
│  └── 使统计分析困难                                          │
│                                                             │
│  扩散 (Diffusion)                                           │
│  目的：使明文的一位变化影响密文的多位                        │
│  实现：                                                      │
│  ├── 置换（P 盒）                                            │
│  ├── 行移位、列混合                                          │
│  └── 雪崩效应                                                │
│                                                             │
│  雪崩效应 (Avalanche Effect)                                │
│  定义：输入变化 1 比特，输出变化约 50% 比特                   │
│  要求：                                                      │
│  ✓ 明文变化 1 位 → 密文变化~50% 位                           │
│  ✓ 密钥变化 1 位 → 密文变化~50% 位                           │
│  ✓ AES 满足此要求                                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## AES 算法详解

### 算法概述

**AES (Advanced Encryption Standard)**：

```
┌─────────────────────────────────────────────────────────────┐
│                      AES 算法概述                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息                                                   │
│  ├── 标准：NIST FIPS 197 (2001 年 12 月)                     │
│  ├── 设计者：Joan Daemen, Vincent Rijmen                   │
│  ├── 原名：Rijndael 算法                                   │
│  ├── 替代：DES（1977-2001）                                 │
│  └── 状态：当前最广泛使用的对称加密算法                     │
│                                                             │
│  算法参数                                                   │
│  ├── 分组长度：128 位（固定）                               │
│  ├── 密钥长度：128/192/256 位（可选）                       │
│  ├── 轮数：10/12/14 轮（对应密钥长度）                      │
│  └── 状态矩阵：4x4 字节（128 位）                            │
│                                                             │
│  安全性                                                     │
│  ├── AES-128：安全，推荐最低标准                            │
│  ├── AES-192：高安全性                                      │
│  ├── AES-256：最高安全性（政府机密级）                      │
│  └── 量子安全：Grover 算法下强度减半（仍安全）              │
│                                                             │
│  性能                                                       │
│  ├── 软件实现：快速（尤其有 AES-NI 指令集）                  │
│  ├── 硬件实现：高效（ASIC、FPGA）                           │
│  ├── 功耗：低（适合移动设备）                               │
│  └── 延迟：低（适合实时应用）                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 加密流程

**AES 加密过程详解**：

```
┌─────────────────────────────────────────────────────────────┐
│                  AES-128 加密流程                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  输入：16 字节明文 → 4x4 状态矩阵                            │
│  ┌────┬────┬────┬────┐                                     │
│  │ S₀ │ S₄ │ S₈ │ S₁₂│   字节按列优先排列                   │
│  ├────┼────┼────┼────┤                                     │
│  │ S₁ │ S₅ │ S₉ │ S₁₃│                                     │
│  ├────┼────┼────┼────┤                                     │
│  │ S₂ │ S₆ │ S₁₀│ S₁₄│                                     │
│  ├────┼────┼────┼────┤                                     │
│  │ S₃ │ S₇ │ S₁₁│ S₁₅│                                     │
│  └────┴────┴────┴────┘                                     │
│                                                             │
│  初始轮密钥加                                               │
│  State = State ⊕ RoundKey[0]                               │
│                                                             │
│  第 1-9 轮（每轮 4 个操作）                                   │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  1. SubBytes（字节替换）                             │   │
│  │     - 使用 S 盒进行非线性替换                         │   │
│  │     - 每个字节独立替换                               │   │
│  │     - 提供混淆                                       │   │
│  │                                                      │   │
│  │  2. ShiftRows（行移位）                              │   │
│  │     - 第 0 行：不移位                                 │   │
│  │     - 第 1 行：左移 1 字节                             │   │
│  │     - 第 2 行：左移 2 字节                             │   │
│  │     - 第 3 行：左移 3 字节                             │   │
│  │     - 提供扩散                                       │   │
│  │                                                      │   │
│  │  3. MixColumns（列混合）                             │   │
│  │     - 每列与固定矩阵相乘                             │   │
│  │     - 在 GF(2⁸) 域上运算                              │   │
│  │     - 提供扩散                                       │   │
│  │                                                      │   │
│  │  4. AddRoundKey（轮密钥加）                          │   │
│  │     - State ⊕ RoundKey[i]                           │   │
│  │     - 简单 XOR 操作                                  │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  第 10 轮（最后一轮，无 MixColumns）                         │
│  SubBytes → ShiftRows → AddRoundKey                        │
│                                                             │
│  输出：16 字节密文                                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 密钥扩展

**AES 密钥扩展算法**：

```
密钥扩展目的：
从原始密钥生成每轮使用的轮密钥

AES-128 密钥扩展（128 位密钥 → 11 个轮密钥）：

输入：16 字节密钥 (K₀, K₁, ..., K₁₅)
输出：176 字节扩展密钥 (11 个 16 字节轮密钥)

扩展过程：
┌─────────────────────────────────────────────────────────────┐
│  W[0-3]  = 原始密钥                                          │
│  W[4]    = W[0] ⊕ SubWord(RotWord(W[3])) ⊕ Rcon[1]        │
│  W[5]    = W[4] ⊕ W[1]                                     │
│  W[6]    = W[5] ⊕ W[2]                                     │
│  W[7]    = W[6] ⊕ W[3]                                     │
│  W[8]    = W[4] ⊕ SubWord(RotWord(W[7])) ⊕ Rcon[2]        │
│  ...                                                       │
│  W[43]   = W[42] ⊕ W[39]                                   │
│                                                             │
│  轮密钥 i = W[4i] | W[4i+1] | W[4i+2] | W[4i+3]            │
└─────────────────────────────────────────────────────────────┘

关键操作：
- RotWord：循环左移 1 字节
- SubWord：S 盒替换
- Rcon：轮常量（每轮不同）

安全性：
✓ 密钥扩展是单向的
✓ 从轮密钥难以恢复原始密钥
✓ 密钥相关性弱
```

### 代码实现

**Python AES 实现示例**：

```python
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad

# ============= AES-128 ECB 模式（仅演示，不推荐实际使用）============
def aes_ecb_demo():
    # 生成密钥（128 位）
    key = get_random_bytes(16)
    
    # 创建 cipher 对象
    cipher = AES.new(key, AES.MODE_ECB)
    
    # 加密（需要填充）
    plaintext = b"Secret message!"
    padded = pad(plaintext, AES.block_size)
    ciphertext = cipher.encrypt(padded)
    
    # 解密
    cipher_dec = AES.new(key, AES.MODE_ECB)
    decrypted = unpad(cipher_dec.decrypt(ciphertext), AES.block_size)
    
    print(f"明文：{plaintext}")
    print(f"密文：{ciphertext.hex()}")
    print(f"解密：{decrypted}")

# ============= AES-256 GCM 模式（推荐）============
def aes_gcm_demo():
    # 生成密钥（256 位）
    key = get_random_bytes(32)
    
    # 创建 cipher 对象（GCM 模式）
    cipher = AES.new(key, AES.MODE_GCM)
    
    # 加密（GCM 无需填充，自带认证）
    plaintext = b"Secret message!"
    ciphertext, tag = cipher.encrypt_and_digest(plaintext)
    
    # 解密（需要 nonce 和 tag）
    cipher_dec = AES.new(key, AES.MODE_GCM, nonce=cipher.nonce)
    decrypted = cipher_dec.decrypt_and_verify(ciphertext, tag)
    
    print(f"明文：{plaintext}")
    print(f"密文：{ciphertext.hex()}")
    print(f"认证标签：{tag.hex()}")
    print(f"解密：{decrypted}")
    print(f"Nonce: {cipher.nonce.hex()}")

# ============= CBC 模式示例============
def aes_cbc_demo():
    key = get_random_bytes(16)
    iv = get_random_bytes(16)  # 初始化向量
    
    cipher = AES.new(key, AES.MODE_CBC, iv)
    plaintext = b"Secret message!"
    padded = pad(plaintext, AES.block_size)
    ciphertext = cipher.encrypt(padded)
    
    # 解密
    cipher_dec = AES.new(key, AES.MODE_CBC, iv)
    decrypted = unpad(cipher_dec.decrypt(ciphertext), AES.block_size)
    
    print(f"IV: {iv.hex()}")
    print(f"密文：{ciphertext.hex()}")
    print(f"解密：{decrypted}")

if __name__ == "__main__":
    print("=== AES ECB 演示 ===")
    aes_ecb_demo()
    print("\n=== AES GCM 演示（推荐）===")
    aes_gcm_demo()
    print("\n=== AES CBC 演示 ===")
    aes_cbc_demo()
```

---

## AES 工作模式

### 模式对比

**AES 工作模式全对比**：

```
┌─────────────────────────────────────────────────────────────┐
│                  AES 工作模式对比                           │
├──────────┬──────────┬──────────┬──────────┬────────────────┤
│   模式   │  安全性  │  性能    │  认证    │    推荐使用    │
├──────────┼──────────┼──────────┼──────────┼────────────────┤
│  ECB     │   ✗ 差   │  快      │  无      │  禁止使用      │
│  CBC     │   △ 中   │  中      │  无      │  可用但非首选  │
│  CFB     │   △ 中   │  中      │  无      │  较少使用      │
│  OFB     │   △ 中   │  中      │  无      │  较少使用      │
│  CTR     │   ✓ 好   │  快      │  无      │  推荐          │
│  GCM     │   ✓✓ 优  │  快      │  有      │  首选推荐      │
│  CCM     │   ✓ 好   │  中      │  有      │  可用          │
│  XTS     │   ✓ 好   │  快      │  无      │  磁盘加密专用  │
└──────────┴──────────┴──────────┴──────────┴────────────────┘
```

### 各模式详解

**ECB (Electronic Codebook)**：

```
┌─────────────────────────────────────────────────────────────┐
│                  ECB 模式 - 不推荐使用                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  原理：每个分组独立加密                                      │
│  ┌─────────┐    ┌─────────┐    ┌─────────┐                │
│  │ 明文 P₁  │───▶│ 加密 E  │───▶│ 密文 C₁  │                │
│  └─────────┘    └─────────┘    └─────────┘                │
│  ┌─────────┐    ┌─────────┐    ┌─────────┐                │
│  │ 明文 P₂  │───▶│ 加密 E  │───▶│ 密文 C₂  │                │
│  └─────────┘    └─────────┘    └─────────┘                │
│                                                             │
│  优点：                                                      │
│  ✓ 简单                                                     │
│  ✓ 可并行处理                                               │
│  ✓ 随机访问                                                 │
│                                                             │
│  缺点：                                                      │
│  ✗ 相同明文产生相同密文（泄露模式）                         │
│  ✗ 不提供完整性保护                                         │
│  ✗ 易受重放攻击                                             │
│                                                             │
│  经典案例：                                                  │
│  Tux 企鹅位图加密后仍可见轮廓（Google 搜索 "ECB penguin"）   │
│                                                             │
│  建议：✗ 永远不要在生产环境中使用 ECB                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

**CBC (Cipher Block Chaining)**：

```
┌─────────────────────────────────────────────────────────────┐
│                  CBC 模式                                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  原理：每个分组与前一个密文分组异或后加密                    │
│                                                             │
│  加密：                                                      │
│  IV ──▶⊕───▶[E]───▶C₁                                      │
│         ▲            │                                      │
│  P₁ ────┘            │                                      │
│                      │                                      │
│  C₁ ──▶⊕───▶[E]───▶C₂                                      │
│         ▲            │                                      │
│  P₂ ────┘            │                                      │
│                                                             │
│  解密：                                                      │
│  [D]───▶⊕───▶P₁     C₁ ──▶[D]───▶⊕───▶P₂                  │
│        ▲            │         ▲                            │
│  IV ───┘            │    C₁ ──┘                            │
│                                                             │
│  特点：                                                      │
│  ✓ 相同明文产生不同密文（取决于 IV）                        │
│  ✓ 串行加密（不可并行）                                     │
│  ✓ 并行解密                                                 │
│  ✗ 需要填充（PKCS#7）                                       │
│  ✗ 易受填充攻击（需配合 MAC）                               │
│  ✗ 传输错误会影响后续分组                                   │
│                                                             │
│  建议：△ 可用，但有更好的选择（GCM、CTR）                   │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

**CTR (Counter)**：

```
┌─────────────────────────────────────────────────────────────┐
│                  CTR 模式                                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  原理：加密计数器生成密钥流，与明文异或                      │
│                                                             │
│  加密/解密（结构相同）：                                     │
│  Nonce+0 ──▶[E]───▶⊕───▶C₁                                 │
│              ▲    ▲                                         │
│  Nonce+1 ────┘    │                                         │
│              ▲    │                                         │
│  Nonce+2 ────┘    │                                         │
│                   │                                         │
│              P₁ ──┘                                         │
│                                                             │
│  特点：                                                      │
│  ✓ 可并行处理（加密解密都可并行）                           │
│  ✓ 无需填充（流密码模式）                                   │
│  ✓ 随机访问（可解密任意分组）                               │
│  ✓ 加密解密结构相同（实现简单）                             │
│  ✗ 需要唯一 nonce（重复使用会泄露信息）                     │
│  ✗ 不提供认证（需配合 HMAC）                                │
│                                                             │
│  应用：                                                      │
│  - WiFi (WPA2)                                             │
│  - SSH                                                     │
│  - 磁盘加密                                                │
│                                                             │
│  建议：✓ 推荐使用（配合认证）                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

**GCM (Galois/Counter Mode)**：

```
┌─────────────────────────────────────────────────────────────┐
│              GCM 模式 - 首选推荐                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  原理：CTR 模式加密 + GMAC 认证                              │
│                                                             │
│  结构：                                                      │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  CTR 部分：                                          │   │
│  │  Nonce+0 ──▶[E]───▶⊕───▶C₁ (密文)                   │   │
│  │  Nonce+1 ──▶[E]───▶⊕───▶C₂                          │   │
│  └─────────────────────────────────────────────────────┘   │
│                           ↓                                 │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  GMAC 部分（GHASH 在 GF(2¹²⁸) 上运算）：                 │   │
│  │  (C₁ | C₂ | ... | AAD | len) × H ──▶ Tag           │   │
│  │  H = E(K, 0)                                        │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  特点：                                                      │
│  ✓ 认证加密（AEAD）                                         │
│  ✓ 可并行处理                                               │
│  ✓ 无需填充                                                 │
│  ✓ 高性能（硬件加速支持好）                                 │
│  ✓ TLS 1.3 默认模式                                         │
│  ✗ 实现复杂                                                 │
│  ✗ nonce 重复使用会完全破坏安全性                           │
│                                                             │
│  输出：                                                      │
│  - 密文（与明文等长）                                       │
│  - 认证标签（通常 128 位）                                   │
│  - Nonce（12 字节，可公开）                                  │
│                                                             │
│  应用：                                                      │
│  - TLS 1.2/1.3                                             │
│  - SSH                                                     │
│  - IPsec                                                   │
│  - 磁盘加密                                                │
│                                                             │
│  建议：✓✓ 首选推荐（新系统默认选择）                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 模式选择指南

```
┌─────────────────────────────────────────────────────────────┐
│                  AES 模式选择指南                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  场景 1: TLS/网络通信                                        │
│  首选：AES-GCM                                             │
│  备选：AES-CCM                                             │
│  理由：认证加密、高性能、标准支持好                         │
│                                                             │
│  场景 2: 文件/磁盘加密                                       │
│  首选：AES-XTS                                             │
│  备选：AES-GCM                                             │
│  理由：XTS 专为存储设计、支持随机访问                        │
│                                                             │
│  场景 3: 数据库加密                                          │
│  首选：AES-GCM-SIV                                         │
│  备选：AES-SIV                                             │
│  理由：抗 nonce 误用、确定性加密                            │
│                                                             │
│  场景 4: 资源受限环境（IoT）                                 │
│  首选：AES-CCM                                             │
│  备选：AES-GCM（如有硬件加速）                             │
│  理由：代码小、内存占用少                                   │
│                                                             │
│  场景 5: 通用加密                                            │
│  首选：AES-256-GCM                                         │
│  理由：安全性高、认证加密、性能好                           │
│                                                             │
│  绝对禁止：                                                  │
│  ✗ AES-ECB（任何场景都不应使用）                            │
│  ✗ AES-CBC（无认证，易受攻击）                              │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## ChaCha20 流密码

### 算法概述

**ChaCha20 简介**：

```
┌─────────────────────────────────────────────────────────────┐
│                  ChaCha20 算法概述                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息                                                   │
│  ├── 设计者：Daniel J. Bernstein (2008 年)                 │
│  ├── 类型：流密码                                           │
│  ├── 密钥长度：256 位（固定）                               │
│  ├── Nonce 长度：96 位（12 字节）                            │
│  ├── 计数器：32 位                                          │
│  └── 轮数：20 轮（标准）                                    │
│                                                             │
│  变体：                                                      │
│  ├── ChaCha20：原始版本（20 轮）                            │
│  ├── ChaCha12：12 轮（更快，安全性略低）                    │
│  ├── ChaCha8：8 轮（最快，仅特定场景）                      │
│  └── XChaCha20：扩展 nonce（192 位）                         │
│                                                             │
│  特点：                                                      │
│  ✓ 软件实现速度快（比 AES 快 3 倍，无硬件加速时）           │
│  ✓ 抗侧信道攻击（恒定时间实现）                             │
│  ✓ 无需查表（无缓存时序攻击风险）                           │
│  ✓ 移动设备友好（低功耗）                                   │
│  ✓ 实现简单（代码量小）                                     │
│                                                             │
│  应用：                                                      │
│  ├── TLS 1.3（ChaCha20-Poly1305）                          │
│  ├── SSH                                                   │
│  ├── WireGuard VPN                                         │
│  ├── Android 设备加密                                       │
│  └── WhatsApp 消息加密                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 算法原理

**ChaCha20 加密流程**：

```
┌─────────────────────────────────────────────────────────────┐
│                  ChaCha20 加密流程                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  输入：                                                      │
│  ├── 密钥：256 位（32 字节）                                 │
│  ├── Nonce: 96 位（12 字节）                                 │
│  ├── 计数器：32 位（初始为 0）                              │
│  └── 明文：任意长度                                         │
│                                                             │
│  状态矩阵（4x4，每元素 32 位）：                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  "expa"  "nd 3"  "2-by"  "te k"  ← 常量             │   │
│  │  K₀     K₁      K₂      K₃       ← 密钥 (0-3)       │   │
│  │  K₄     K₅      K₆      K₇       ← 密钥 (4-7)       │   │
│  │  cnt    N₀      N₁      N₂       ← 计数器+Nonce     │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  轮函数（20 轮，10 个双轮）                                   │
│  每轮包含：                                                  │
│  ├── 列变换（4 次 Quarter Round）                           │
│  │   QR(a,b,c,d):                                           │
│  │   a += b; d ^= a; d <<<= 16;                            │
│  │   c += d; b ^= c; b <<<= 12;                            │
│  │   a += b; d ^= a; d <<<= 8;                             │
│  │   c += d; b ^= c; b <<<= 7;                             │
│  │                                                          │
│  ├── 行变换（4 次 Quarter Round）                           │
│  └── 重复 10 次                                              │
│                                                             │
│  输出：                                                      │
│  ├── 密钥流：状态矩阵 + 初始状态（XOR）                     │
│  ├── 密文：明文 ⊕ 密钥流                                    │
│  └── 认证标签：Poly1305(MAC)                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### ChaCha20-Poly1305

**AEAD 构造**：

```
┌─────────────────────────────────────────────────────────────┐
│              ChaCha20-Poly1305 (AEAD)                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  结构：                                                      │
│  ChaCha20（加密）+ Poly1305（认证）                        │
│                                                             │
│  加密过程：                                                  │
│  1. 使用 ChaCha20 生成密钥流                                 │
│  2. 明文 ⊕ 密钥流 = 密文                                    │
│  3. 使用 Poly1305 计算认证标签                              │
│     - 输入：密文 + AAD（附加认证数据）                      │
│     - 密钥：从 ChaCha20 密钥流派生                          │
│  4. 输出：密文 + 认证标签                                    │
│                                                             │
│  解密过程：                                                  │
│  1. 验证认证标签                                             │
│     - 失败则拒绝解密（防止攻击）                            │
│  2. 使用 ChaCha20 生成密钥流                                 │
│  3. 密文 ⊕ 密钥流 = 明文                                    │
│                                                             │
│  参数：                                                      │
│  ├── 密钥：256 位                                            │
│  ├── Nonce: 96 位（12 字节）                                 │
│  ├── 认证标签：128 位（16 字节）                             │
│  └── AAD：任意长度（可选）                                  │
│                                                             │
│  优势：                                                      │
│  ✓ 认证加密（AEAD）                                         │
│  ✓ 软件性能优异                                             │
│  ✓ 无 AES-NI 时优于 AES-GCM                                 │
│  ✓ 抗侧信道攻击                                             │
│                                                             │
│  标准：                                                      │
│  ├── RFC 8439（原 RFC 7539）                               │
│  └── TLS 1.3 密码套件                                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 代码实现

**Python ChaCha20 实现**：

```python
from Crypto.Cipher import ChaCha20_Poly1305
from Crypto.Random import get_random_bytes

# ============= ChaCha20-Poly1305 示例 =============
def chacha20_poly1305_demo():
    # 生成密钥（256 位）
    key = get_random_bytes(32)
    
    # 创建 cipher 对象
    cipher = ChaCha20_Poly1305.new(key=key)
    
    # 加密
    plaintext = b"Secret message!"
    ciphertext, tag = cipher.encrypt_and_digest(plaintext)
    
    print(f"密钥：{key.hex()}")
    print(f"Nonce: {cipher.nonce.hex()}")
    print(f"密文：{ciphertext.hex()}")
    print(f"认证标签：{tag.hex()}")
    
    # 解密
    cipher_dec = ChaCha20_Poly1305.new(key=key, nonce=cipher.nonce)
    try:
        decrypted = cipher_dec.decrypt_and_verify(ciphertext, tag)
        print(f"解密：{decrypted}")
        print("✓ 认证通过")
    except ValueError as e:
        print(f"✗ 认证失败：{e}")
    
    # 测试篡改检测
    print("\n=== 测试篡改检测 ===")
    tampered_ciphertext = ciphertext[:-1] + bytes([ciphertext[-1] ^ 0x01])
    try:
        cipher_dec.decrypt_and_verify(tampered_ciphertext, tag)
        print("✗ 未检测到篡改（错误）")
    except ValueError:
        print("✓ 检测到篡改（正确）")

if __name__ == "__main__":
    chacha20_poly1305_demo()
```

---

## 其他对称算法

### 国密算法

**SM4 算法**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM4 算法（国密）                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息                                                   │
│  ├── 标准：GM/T 0002-2012                                  │
│  ├── 设计者：中国密码学会                                   │
│  ├── 类型：分组密码                                         │
│  ├── 分组长度：128 位                                       │
│  ├── 密钥长度：128 位                                       │
│  └── 轮数：32 轮                                            │
│                                                             │
│  特点：                                                      │
│  ✓ 中国商用密码标准                                         │
│  ✓ 软件/硬件实现高效                                        │
│  ✓ 安全性与 AES 相当                                        │
│  ✓ 政务、金融系统广泛使用                                   │
│                                                             │
│  工作模式：                                                  │
│  ├── ECB（不推荐）                                          │
│  ├── CBC                                                    │
│  ├── CFB                                                    │
│  ├── OFB                                                    │
│  └── CTR                                                    │
│                                                             │
│  应用：                                                      │
│  ├── 无线局域网（WAPI）                                     │
│  ├── 金融 IC 卡                                             │
│  ├── 电子政务                                               │
│  └── 物联网安全                                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 历史算法

**DES/3DES**：

```
┌─────────────────────────────────────────────────────────────┐
│              DES/3DES（已淘汰/逐步淘汰）                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  DES (Data Encryption Standard)                             │
│  ├── 标准：1977 年 NIST                                     │
│  ├── 密钥长度：56 位（实际）                                │
│  ├── 分组长度：64 位                                        │
│  └── 状态：✗ 已淘汰（密钥太短，可暴力破解）                 │
│                                                             │
│  3DES (Triple DES)                                          │
│  ├── 原理：DES-DES-DES（加密 - 解密 - 加密）                │
│  ├── 密钥长度：112/168 位（有效）                           │
│  ├── 分组长度：64 位                                        │
│  └── 状态：△ 逐步淘汰（NIST 2023 年后禁用）                 │
│                                                             │
│  安全问题：                                                  │
│  ✗ DES：56 位密钥可在数小时内暴力破解                       │
│  ✗ 3DES：Sweet32 攻击（64 位分组碰撞）                      │
│  ✗ 性能慢（相比 AES）                                       │
│                                                             │
│  建议：                                                      │
│  ✗ 不要在新系统中使用                                       │
│  ✓ 现有系统尽快迁移到 AES                                   │
│  ✓ 支付系统等遗留系统使用 3DES 到 2023 年                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 对称加密实战

### 文件加密

**Python 文件加密示例**：

```python
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Protocol.KDF import scrypt
import os

class FileEncryptor:
    """文件加密器（使用 AES-256-GCM）"""
    
    def __init__(self, password: str):
        # 从密码派生密钥（使用 scrypt）
        salt = get_random_bytes(16)
        key = scrypt(password, salt, key_len=32, N=2**14, r=8, p=1)
        self.key = key
        self.salt = salt
    
    def encrypt_file(self, input_path: str, output_path: str):
        """加密文件"""
        # 读取明文
        with open(input_path, 'rb') as f:
            plaintext = f.read()
        
        # 生成 nonce
        nonce = get_random_bytes(12)
        
        # 加密
        cipher = AES.new(self.key, AES.MODE_GCM, nonce=nonce)
        ciphertext, tag = cipher.encrypt_and_digest(plaintext)
        
        # 写入密文文件
        # 格式：salt(16) + nonce(12) + tag(16) + ciphertext
        with open(output_path, 'wb') as f:
            f.write(self.salt)
            f.write(nonce)
            f.write(tag)
            f.write(ciphertext)
        
        print(f"✓ 文件已加密：{output_path}")
    
    def decrypt_file(self, input_path: str, output_path: str):
        """解密文件"""
        # 读取密文
        with open(input_path, 'rb') as f:
            salt = f.read(16)
            nonce = f.read(12)
            tag = f.read(16)
            ciphertext = f.read()
        
        # 验证 salt 匹配
        if salt != self.salt:
            raise ValueError("Salt 不匹配，密码可能错误")
        
        # 解密
        cipher = AES.new(self.key, AES.MODE_GCM, nonce=nonce)
        try:
            plaintext = cipher.decrypt_and_verify(ciphertext, tag)
        except ValueError as e:
            raise ValueError(f"解密失败：{e}")
        
        # 写入明文
        with open(output_path, 'wb') as f:
            f.write(plaintext)
        
        print(f"✓ 文件已解密：{output_path}")

# 使用示例
if __name__ == "__main__":
    password = "my_secure_password"
    
    # 加密
    encryptor = FileEncryptor(password)
    encryptor.encrypt_file("secret.txt", "secret.txt.enc")
    
    # 解密
    decryptor = FileEncryptor(password)
    decryptor.decrypt_file("secret.txt.enc", "secret_decrypted.txt")
```

### 数据库加密

**字段级加密示例**：

```python
from cryptography.fernet import Fernet
from sqlalchemy import Column, String, LargeBinary
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class EncryptedModel(Base):
    """带加密字段的模型"""
    
    __tablename__ = 'users'
    
    id = Column(String, primary_key=True)
    username = Column(String)  # 明文
    email = Column(LargeBinary)  # 加密存储
    ssn = Column(LargeBinary)  # 加密存储（敏感字段）
    
    def __init__(self, id, username, email, ssn):
        self.id = id
        self.username = username
        self.email = encrypt(email)
        self.ssn = encrypt(ssn)

# 加密密钥管理
ENCRYPTION_KEY = Fernet.generate_key()
cipher = Fernet(ENCRYPTION_KEY)

def encrypt(plaintext: str) -> bytes:
    """加密字符串"""
    return cipher.encrypt(plaintext.encode())

def decrypt(ciphertext: bytes) -> str:
    """解密字符串"""
    return cipher.decrypt(ciphertext).decode()
```

---

## 性能对比与选型

### 性能测试

**算法性能对比**：

```
┌─────────────────────────────────────────────────────────────┐
│              对称加密算法性能对比 (MB/s)                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  x86_64 (带 AES-NI):                                        │
│  ┌──────────────┬──────────┬──────────┬──────────┐         │
│  │     算法     │  加密    │  解密    │  认证    │         │
│  ├──────────────┼──────────┼──────────┼──────────┤         │
│  │ AES-128-GCM  │  8000    │  8000    │  ✓       │         │
│  │ AES-256-GCM  │  6000    │  6000    │  ✓       │         │
│  │ ChaCha20     │  4000    │  4000    │  ✓       │         │
│  │ AES-128-CBC  │  5000    │  5000    │  ✗       │         │
│  └──────────────┴──────────┴──────────┴──────────┘         │
│                                                             │
│  ARM (移动设备，无 AES-NI):                                 │
│  ┌──────────────┬──────────┬──────────┬──────────┐         │
│  │     算法     │  加密    │  解密    │  认证    │         │
│  ├──────────────┼──────────┼──────────┼──────────┤         │
│  │ ChaCha20     │  500     │  500     │  ✓       │         │
│  │ AES-128-GCM  │  200     │  200     │  ✓       │         │
│  │ AES-256-GCM  │  150     │  150     │  ✓       │         │
│  └──────────────┴──────────┴──────────┴──────────┘         │
│                                                             │
│  结论：                                                      │
│  ✓ 有 AES-NI：AES-GCM 更快                                  │
│  ✓ 无 AES-NI：ChaCha20 更快                                 │
│  ✓ 移动设备：优先 ChaCha20                                  │
│  ✓ 服务器：优先 AES-GCM                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 选型指南

```
┌─────────────────────────────────────────────────────────────┐
│                  对称加密算法选型指南                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  场景 1: Web 应用（TLS）                                     │
│  首选：AES-256-GCM                                         │
│  备选：ChaCha20-Poly1305（移动客户端）                      │
│  理由：标准支持好、硬件加速、安全性高                       │
│                                                             │
│  场景 2: 移动应用                                            │
│  首选：ChaCha20-Poly1305                                   │
│  备选：AES-128-GCM（如有硬件加速）                          │
│  理由：软件性能好、功耗低                                   │
│                                                             │
│  场景 3: 文件加密                                            │
│  首选：AES-256-GCM                                         │
│  备选：AES-256-XTS（磁盘加密）                              │
│  理由：认证加密、随机访问                                   │
│                                                             │
│  场景 4: 数据库加密                                          │
│  首选：AES-256-GCM-SIV                                     │
│  备选：AES-256-SIV                                         │
│  理由：抗 nonce 误用、确定性加密                            │
│                                                             │
│  场景 5: 中国合规项目                                        │
│  首选：SM4-GCM                                             │
│  理由：符合国密要求                                         │
│                                                             │
│  通用建议：                                                  │
│  ✓ 密钥长度：256 位（长期安全）                              │
│  ✓ 工作模式：GCM 或其他 AEAD 模式                            │
│  ✓ 认证：必须使用认证加密                                   │
│  ✗ 避免：ECB、CBC（无认证）                                │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 安全实践与常见错误

### 最佳实践

```
┌─────────────────────────────────────────────────────────────┐
│                  对称加密安全实践                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ✓ 应该做的                                                 │
│  ├── 使用 AEAD 模式（GCM、CCM、ChaCha20-Poly1305）          │
│  ├── 使用足够长的密钥（AES-256）                            │
│  ├── 每次加密使用唯一 nonce/IV                              │
│  ├── 使用 CSPRNG 生成密钥和 nonce                           │
│  ├── 妥善管理密钥（HSM、KMS）                               │
│  ├── 定期轮换密钥                                            │
│  ├── 验证认证标签（解密前）                                 │
│  └── 使用成熟的密码学库                                     │
│                                                             │
│  ✗ 不应该做的                                               │
│  ├── 不要使用 ECB 模式                                      │
│  ├── 不要重复使用 nonce/IV                                  │
│  ├── 不要硬编码密钥                                          │
│  ├── 不要自己实现密码算法                                    │
│  ├── 不要忽略认证标签                                        │
│  ├── 不要使用弱随机数                                        │
│  └── 不要使用已淘汰的算法（DES、RC4）                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 常见错误

**错误 1：重复使用 Nonce**：

```python
# ✗ 错误：重复使用 nonce
key = get_random_bytes(32)
nonce = b"fixed_nonce!!!"  # 固定 nonce！

cipher1 = AES.new(key, AES.MODE_GCM, nonce=nonce)
ciphertext1 = cipher1.encrypt(b"message1")

cipher2 = AES.new(key, AES.MODE_GCM, nonce=nonce)  # 相同 nonce！
ciphertext2 = cipher2.encrypt(b"message2")

# 后果：攻击者可恢复明文！

# ✓ 正确：每次生成唯一 nonce
cipher1 = AES.new(key, AES.MODE_GCM)
ciphertext1, tag1 = cipher1.encrypt_and_digest(b"message1")

cipher2 = AES.new(key, AES.MODE_GCM)
ciphertext2, tag2 = cipher2.encrypt_and_digest(b"message2")
```

**错误 2：忽略认证**：

```python
# ✗ 错误：只加密不认证
cipher = AES.new(key, AES.MODE_CTR, nonce=nonce)
ciphertext = cipher.encrypt(plaintext)
# 攻击者可篡改密文！

# ✓ 正确：使用 AEAD
cipher = AES.new(key, AES.MODE_GCM, nonce=nonce)
ciphertext, tag = cipher.encrypt_and_digest(plaintext)
# 解密时验证 tag
```

**错误 3：使用 ECB 模式**：

```python
# ✗ 错误：ECB 模式
cipher = AES.new(key, AES.MODE_ECB)
ciphertext = cipher.encrypt(pad(plaintext))
# 相同明文产生相同密文，泄露模式！

# ✓ 正确：使用 GCM 模式
cipher = AES.new(key, AES.MODE_GCM)
ciphertext, tag = cipher.encrypt_and_digest(plaintext)
```

---

## 总结与思考

### 核心要点回顾

**对称加密知识框架**：

```
┌─────────────────────────────────────────────────────────────┐
│                  对称加密知识框架                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  算法类型                                                   │
│  ├── 分组密码：AES、SM4、3DES                              │
│  └── 流密码：ChaCha20、Salsa20                             │
│                                                             │
│  工作模式                                                   │
│  ├── 首选：GCM（AEAD）                                     │
│  ├── 可用：CTR、CCM                                        │
│  ├── 专用：XTS（磁盘）                                     │
│  └── 禁止：ECB                                             │
│                                                             │
│  密钥管理                                                   │
│  ├── 长度：256 位（推荐）                                   │
│  ├── 生成：CSPRNG                                          │
│  ├── 存储：HSM/KMS                                         │
│  └── 轮换：定期更新                                         │
│                                                             │
│  安全实践                                                   │
│  ├── 唯一 nonce                                             │
│  ├── 认证加密                                               │
│  ├── 成熟库                                                 │
│  └── 避免自实现                                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 深入思考

**1. 为什么 AES 如此成功？**

- 公开透明的选拔过程
- 高效的软硬件实现
- 足够的安全性
- 免费使用
- 广泛的标准支持

**2. 为什么还需要 ChaCha20？**

- 软件性能更好（无 AES-NI 时）
- 抗侧信道攻击
- 实现简单
- 作为 AES 的备份（算法多样性）

**3. 量子计算的影响？**

- Grover 算法：对称加密强度减半
- AES-128 → 64 位（不安全）
- AES-256 → 128 位（仍安全）
- 建议：长期使用选择 AES-256

---

## 参考资料

### 标准与规范

```
- NIST FIPS 197: AES
- NIST SP 800-38D: GCM 模式
- RFC 8439: ChaCha20-Poly1305
- GM/T 0002-2012: SM4
```

### 实现库

```
Python:
- pycryptodome: https://www.pycryptodome.org/
- cryptography: https://cryptography.io/

Java:
- Bouncy Castle: https://www.bouncycastle.org/
- JCA: Java Cryptography Architecture

Go:
- crypto/cipher: 标准库
```

### 学习资源

```
- 《Serious Cryptography》- Jean-Philippe Aumasson
- 《Applied Cryptography》- Bruce Schneier
- Coursera: Cryptography I (Stanford)
```

---

*365 天信息安全技术系列 | Day 182 | 密码学系列第 2 篇*

> 对称加密是应用最广泛的密码技术。理解 AES 和 ChaCha20，是理解现代加密的基础。

> 本文内容仅供学习和研究使用，请勿用于非法目的。

---

*本文是 365 天信息安全技术系列的第 182 篇，密码学系列第 2 篇*

*密码学系列继续！*