Day-171-密钥管理与PKI

# Day 185: 密钥管理与 PKI

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

---

## 清单 目录

1. [密钥管理概述](#密钥管理概述)
2. [密钥生命周期](#密钥生命周期)
3. [密钥存储方案](#密钥存储方案)
4. [密钥派生与协商](#密钥派生与协商)
5. [PKI 公钥基础设施](#pki 公钥基础设施)
6. [X.509 证书](#x509 证书)
7. [证书链与验证](#证书链与验证)
8. [证书吊销](#证书吊销)
9. [实战应用](#实战应用)
10. [安全实践](#安全实践)
11. [总结与思考](#总结与思考)
12. [参考资料](#参考资料)

---

## 密钥管理概述

### 为什么需要密钥管理

**密钥管理的重要性**：

```
┌─────────────────────────────────────────────────────────────┐
│                  密钥管理重要性                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Kerckhoffs 原则（1883 年）：                                 │
│  "密码系统的安全性应仅依赖于密钥的保密，而非算法的保密"    │
│                                                             │
│  含义：                                                      │
│  ├── 算法可以公开                                           │
│  ├── 密钥必须保密                                           │
│  └── 密钥管理是安全的核心                                   │
│                                                             │
│  现实问题：                                                  │
│  ├── 密钥泄露 = 系统完全被攻破                             │
│  ├── 密钥丢失 = 数据永久丢失                               │
│  ├── 密钥管理不当 = 合规违规                               │
│  └── 据统计 60% 的安全事件与密钥管理不当有关                │
│                                                             │
│  Schneier 定律：                                             │
│  "任何人设计的密码系统，如果密钥管理很糟糕，那么它就是     │
│   不安全的"                                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 密钥管理挑战

```
┌─────────────────────────────────────────────────────────────┐
│                  密钥管理挑战                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  技术挑战：                                                  │
│  ├── 安全存储：防止未授权访问                               │
│  ├── 安全传输：防止中间人攻击                               │
│  ├── 密钥轮换：定期更新密钥                                 │
│  └── 密钥销毁：安全删除密钥                                 │
│                                                             │
│  运营挑战：                                                  │
│  ├── 密钥数量：大规模系统有数万密钥                        │
│  ├── 密钥类型：加密密钥、签名密钥、认证密钥等              │
│  ├── 密钥策略：不同密钥有不同生命周期                      │
│  └── 密钥审计：追踪密钥使用                                 │
│                                                             │
│  合规挑战：                                                  │
│  ├── 法规要求：PCI-DSS、GDPR、等保 2.0                      │
│  ├── 审计要求：密钥使用记录                                 │
│  └── 行业标准：NIST、ISO 27001                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 密钥生命周期

### 完整生命周期

```
┌─────────────────────────────────────────────────────────────┐
│                  密钥完整生命周期                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. 密钥生成 (Generation)                                   │
│     ├── 使用 CSPRNG（密码学安全随机数生成器）              │
│     ├── 足够密钥长度                                        │
│     ├── 符合算法要求                                        │
│     └── 记录生成时间、用途                                  │
│                                                             │
│  2. 密钥存储 (Storage)                                      │
│     ├── HSM（硬件安全模块）                                 │
│     ├── KMS（密钥管理系统）                                 │
│     ├── 加密存储                                            │
│     └── 访问控制                                            │
│                                                             │
│  3. 密钥分发 (Distribution)                                 │
│     ├── 安全通道传输                                        │
│     ├── 密钥协商协议（DH/ECDH）                            │
│     ├── 密钥封装（RSA-KEM）                                │
│     └── PKI 证书分发                                        │
│                                                             │
│  4. 密钥使用 (Usage)                                        │
│     ├── 访问控制                                            │
│     ├── 使用审计                                            │
│     ├── 最小权限                                            │
│     └── 使用期限                                            │
│                                                             │
│  5. 密钥更新 (Update)                                       │
│     ├── 定期轮换（基于时间或使用次数）                      │
│     ├── 泄露后更新                                          │
│     ├── 员工离职更新                                        │
│     └── 算法升级更新                                        │
│                                                             │
│  6. 密钥撤销 (Revocation)                                   │
│     ├── 证书撤销列表（CRL）                                 │
│     ├── 在线证书状态协议（OCSP）                            │
│     └── 立即生效                                            │
│                                                             │
│  7. 密钥备份 (Backup)                                       │
│     ├── 安全备份                                            │
│     ├── 异地存储                                            │
│     ├── 访问控制                                            │
│     └── 定期测试恢复                                        │
│                                                             │
│  8. 密钥恢复 (Recovery)                                     │
│     ├── 密钥恢复代理                                        │
│     ├── 秘密共享（Shamir's Secret Sharing）                │
│     └── 紧急访问程序                                        │
│                                                             │
│  9. 密钥销毁 (Destruction)                                  │
│     ├── 安全删除（多次覆盖）                                │
│     ├── 物理销毁（HSM）                                     │
│     ├── 销毁记录                                            │
│     └── 第三方见证                                          │
│                                                             │
│  10. 密钥归档 (Archiving)                                   │
│      ├── 历史数据解密需要                                   │
│      ├── 法律合规要求                                       │
│      ├── 安全存储                                           │
│      └── 有限访问                                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 密钥轮换策略

**密钥轮换最佳实践**：

```
┌─────────────────────────────────────────────────────────────┐
│                  密钥轮换策略                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  轮换触发条件：                                              │
│  ├── 时间到期：达到预设有效期                               │
│  ├── 使用次数：达到最大使用次数                            │
│  ├── 安全事件：疑似或确认泄露                              │
│  ├── 人员变更：密钥持有者离职                              │
│  └── 算法升级：使用更强算法                                 │
│                                                             │
│  轮换周期建议（2024 年）：                                   │
│  ┌────────────────┬───────────────────────────────────────┐ │
│  │   密钥类型     │          轮换周期                     │ │
│  ├────────────────┼───────────────────────────────────────┤ │
│  │ TLS 服务器密钥  │ 1-2 年（配合证书）                     │ │
│  │ API 密钥       │ 90 天                                  │ │
│  │ 数据库密码     │ 90 天                                  │ │
│  │ 加密密钥       │ 1-2 年                                 │ │
│  │ 签名密钥       │ 2-3 年                                 │ │
│  │ 根 CA 密钥      │ 10-20 年（离线存储）                   │ │
│  │ 会话密钥       │ 每次会话                               │ │
│  └────────────────┴───────────────────────────────────────┘ │
│                                                             │
│  轮换最佳实践：                                              │
│  ✓ 自动化轮换（减少人为错误）                               │
│  ✓ 无缝轮换（不影响业务）                                   │
│  ✓ 密钥版本管理（支持回滚）                                 │
│  ✓ 审计日志（记录轮换历史）                                 │
│  ✓ 测试验证（轮换后验证功能）                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 密钥存储方案

### 企业级存储

**HSM（硬件安全模块）**：

```
┌─────────────────────────────────────────────────────────────┐
│                  HSM 硬件安全模块                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  定义：                                                      │
│  专用硬件设备，用于安全生成、存储和管理密钥                 │
│                                                             │
│  安全特性：                                                  │
│  ├── 物理安全：防篡改外壳、防探测                          │
│  ├── 逻辑安全：访问控制、认证                              │
│  ├── 密钥隔离：密钥永不离开 HSM                            │
│  ├── 审计日志：所有操作记录                                │
│  └── 合规认证：FIPS 140-2/3 Level 3+                       │
│                                                             │
│  主要厂商：                                                  │
│  ├── Thales（原 Gemalto）                                  │
│  ├── Entrust（原 nCipher）                                 │
│  ├── Utimaco                                               │
│  ├── YubiHSM（小型 HSM）                                   │
│  └── AWS CloudHSM（云 HSM）                                │
│                                                             │
│  应用场景：                                                  │
│  ├── 根 CA 密钥存储                                         │
│  ├── 金融交易密钥                                           │
│  ├── 代码签名密钥                                           │
│  └── 数据库 TDE 密钥                                        │
│                                                             │
│  优势：                                                      │
│  ✓ 最高安全级别                                             │
│  ✓ 合规支持好                                               │
│  ✓ 高性能密码运算                                           │
│  ✗ 成本高（数十万到数百万）                                 │
│  ✗ 部署复杂                                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

**云 KMS**：

```
┌─────────────────────────────────────────────────────────────┐
│                  云密钥管理服务                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  AWS KMS：                                                   │
│  ├── 密钥类型：客户管理密钥 (CMK)、AWS 管理密钥             │
│  ├── 存储：多租户 HSM 集群                                  │
│  ├── 集成：与 AWS 服务深度集成                             │
│  ├── 功能：密钥轮换、审计、策略                            │
│  └── 合规：FIPS 140-2 Level 2                              │
│                                                             │
│  Azure Key Vault：                                           │
│  ├── 软件密钥：标准层                                       │
│  ├── HSM 密钥：高级层（FIPS 140-2 Level 2）               │
│  ├── 功能：密钥、证书、秘密管理                            │
│  └── 集成：Azure 服务集成                                   │
│                                                             │
│  GCP Cloud KMS：                                             │
│  ├── 密钥类型：软件、HSM、Autokey                          │
│  ├── 功能：密钥管理、加密操作                              │
│  └── 合规：FIPS 140-2 Level 2/3                            │
│                                                             │
│  阿里云 KMS：                                                 │
│  ├── 密钥类型：普通密钥、HSM 密钥                           │
│  ├── 合规：国密支持（SM2/SM3/SM4）                         │
│  └── 集成：阿里云服务                                       │
│                                                             │
│  优势：                                                      │
│  ✓ 无需自建基础设施                                         │
│  ✓ 按需付费                                                 │
│  ✓ 自动扩展                                                 │
│  ✓ 与云服务集成                                             │
│  ✗ 依赖云厂商                                               │
│  ✗ 数据出境问题（跨国企业）                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 应用级存储

**密钥分层存储**：

```
┌─────────────────────────────────────────────────────────────┐
│                  密钥分层存储模型                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  层次结构：                                                  │
│                                                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  根密钥 (Root Key)                                   │   │
│  │  - 长期存储（年）                                    │   │
│  │  - HSM 保护                                          │   │
│  │  - 用于加密密钥加密密钥 (KEK)                       │   │
│  └─────────────────────────────────────────────────────┘   │
│                          ↓                                  │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  密钥加密密钥 (KEK - Key Encryption Key)            │   │
│  │  - 中期存储（月/年）                                 │   │
│  │  - KMS 保护                                          │   │
│  │  - 用于加密数据密钥 (DEK)                           │   │
│  └─────────────────────────────────────────────────────┘   │
│                          ↓                                  │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  数据密钥 (DEK - Data Encryption Key)               │   │
│  │  - 短期存储（小时/天）                               │   │
│  │  - 内存存储                                          │   │
│  │  - 用于加密实际数据                                  │   │
│  │  - 定期轮换                                          │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  信封加密 (Envelope Encryption)：                           │
│  1. 生成 DEK（数据密钥）                                    │
│  2. 使用 DEK 加密数据                                        │
│  3. 使用 KEK 加密 DEK                                        │
│  4. 存储：加密数据 + 加密 DEK                               │
│  5. 解密：KEK 解密 DEK → DEK 解密数据                       │
│                                                             │
│  优势：                                                      │
│  ✓ 根密钥/KEK 不需要频繁访问                               │
│  ✓ DEK 可以快速轮换                                         │
│  ✓ 支持大规模数据加密                                       │
│  ✓ 符合合规要求                                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

**代码示例**：

```python
# ============= 信封加密示例 =============
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
import os

class EnvelopeEncryption:
    """信封加密实现"""
    
    def __init__(self, master_key: bytes):
        """初始化，master_key 来自 KMS/HSM"""
        self.master_key = master_key  # KEK
    
    def encrypt(self, plaintext: bytes) -> tuple:
        """信封加密"""
        # 1. 生成数据密钥 (DEK)
        dek = os.urandom(32)  # 256 位 AES 密钥
        nonce = os.urandom(12)  # GCM nonce
        
        # 2. 使用 DEK 加密数据
        aesgcm = AESGCM(dek)
        ciphertext = aesgcm.encrypt(nonce, plaintext, None)
        
        # 3. 使用 KEK 加密 DEK（简化示例，实际使用 KMS）
        encrypted_dek = self._wrap_key(dek)
        
        # 4. 返回：加密数据 + 加密 DEK + nonce
        return ciphertext, encrypted_dek, nonce
    
    def decrypt(self, ciphertext: bytes, encrypted_dek: bytes, 
                nonce: bytes) -> bytes:
        """信封解密"""
        # 1. 使用 KEK 解密 DEK
        dek = self._unwrap_key(encrypted_dek)
        
        # 2. 使用 DEK 解密数据
        aesgcm = AESGCM(dek)
        plaintext = aesgcm.decrypt(nonce, ciphertext, None)
        
        return plaintext
    
    def _wrap_key(self, dek: bytes) -> bytes:
        """密钥封装（简化）"""
        # 实际应使用 KMS API
        from cryptography.hazmat.primitives.ciphers.aead import AESGCM
        nonce = os.urandom(12)
        aesgcm = AESGCM(self.master_key)
        encrypted = aesgcm.encrypt(nonce, dek, None)
        return nonce + encrypted
    
    def _unwrap_key(self, encrypted_dek: bytes) -> bytes:
        """密钥解封（简化）"""
        nonce = encrypted_dek[:12]
        ciphertext = encrypted_dek[12:]
        from cryptography.hazmat.primitives.ciphers.aead import AESGCM
        aesgcm = AESGCM(self.master_key)
        return aesgcm.decrypt(nonce, ciphertext, None)

# 使用示例
if __name__ == "__main__":
    # 主密钥（实际来自 KMS/HSM）
    master_key = os.urandom(32)
    
    # 创建加密器
    encryptor = EnvelopeEncryption(master_key)
    
    # 加密
    data = b"Sensitive data to encrypt"
    ciphertext, encrypted_dek, nonce = encryptor.encrypt(data)
    
    print(f"原文：{data}")
    print(f"密文：{ciphertext.hex()[:32]}...")
    print(f"加密 DEK: {encrypted_dek.hex()[:32]}...")
    
    # 解密
    decrypted = encryptor.decrypt(ciphertext, encrypted_dek, nonce)
    print(f"解密：{decrypted}")
    print(f"✓ 加解密成功：{data == decrypted}")
```

---

## 密钥派生与协商

### 密钥派生函数

**KDF（Key Derivation Function）**：

```
┌─────────────────────────────────────────────────────────────┐
│                  密钥派生函数                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  用途：                                                      │
│  ├── 从密码派生密钥（密码哈希）                             │
│  ├── 从主密钥派生子密钥                                     │
│  ├── 密钥扩展（扩展密钥材料）                               │
│  └── 密钥协商后派生会话密钥                                 │
│                                                             │
│  PBKDF2（Password-Based Key Derivation Function 2）：       │
│  ├── 标准：RFC 8018                                        │
│  ├── 原理：多次迭代 HMAC                                   │
│  ├── 参数：密码、盐、迭代次数、输出长度                    │
│  ├── 推荐：迭代 600000+（NIST 2023）                       │
│  └── 缺点：易受 GPU/ASIC 攻击                               │
│                                                             │
│  bcrypt：                                                    │
│  ├── 设计：Provos & Mazières (1999)                        │
│  ├── 原理：基于 Blowfish 的自适应哈希                      │
│  ├── 参数：成本因子（2^rounds）                            │
│  ├── 推荐：rounds=12+                                      │
│  └── 优势：抗 GPU 攻击                                      │
│                                                             │
│  scrypt：                                                    │
│  ├── 设计：Percival (2009)                                 │
│  ├── 原理：内存困难函数                                     │
│  ├── 参数：N（CPU/内存）、r（块大小）、p（并行）          │
│  ├── 推荐：N=2^14, r=8, p=1                                │
│  └── 优势：抗 ASIC 攻击                                     │
│                                                             │
│  Argon2：                                                    │
│  ├── 设计：密码哈希竞赛获胜者 (2015)                       │
│  ├── 类型：Argon2d（数据依赖）、Argon2i（指令依赖）、     │
│  │        Argon2id（混合，推荐）                          │
│  ├── 参数：内存、时间、并行度                              │
│  ├── 推荐：64MB 内存，3 次迭代，4 并行                        │
│  └── 优势：抗 GPU/ASIC 攻击，最安全                         │
│                                                             │
│  HKDF（HMAC-based Key Derivation）：                       │
│  ├── 标准：RFC 5869                                        │
│  ├── 用途：从密钥材料派生密钥                               │
│  ├── 阶段：Extract（提取）+ Expand（扩展）                │
│  └── 应用：TLS 1.3、IKEv2                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 密钥协商

**密钥协商协议**：

```
┌─────────────────────────────────────────────────────────────┐
│                  密钥协商协议                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Diffie-Hellman (DH)：                                      │
│  ├── 原理：基于离散对数问题                                 │
│  ├── 参数：大素数 p、生成元 g                              │
│  ├── 安全：2048 位+                                         │
│  └── 应用：TLS、IPsec、SSH                                 │
│                                                             │
│  Elliptic Curve DH (ECDH)：                                 │
│  ├── 原理：基于椭圆曲线离散对数                            │
│  ├── 曲线：P-256、X25519（推荐）                          │
│  ├── 安全：256 位（相当于 RSA 3072）                       │
│  └── 优势：密钥短、性能好                                   │
│                                                             │
│  协议流程（ECDH）：                                         │
│  Alice                          Bob                         │
│    │  私钥 a                        │  私钥 b               │
│    │  公钥 A = aG                    │  公钥 B = bG         │
│    │                              │                         │
│    │─────── 交换公钥 ─────────────▶│                         │
│    │                              │                         │
│    │  共享密钥 S = aB              │  共享密钥 S = bA       │
│    │           = abG               │           = baG        │
│    │                              │                         │
│    │  ✓ S 相同 ✓                   │                         │
│    │                              │                         │
│                                                             │
│  后量子密钥协商：                                            │
│  ├── CRYSTALS-Kyber（NIST 标准化）                        │
│  ├── 基于格密码学                                           │
│  ├── 密钥大小：公钥 800 字节，密文 768 字节                 │
│  └── 应用：混合部署（ECDH + Kyber）                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## PKI 公钥基础设施

### PKI 概述

**PKI 组成要素**：

```
┌─────────────────────────────────────────────────────────────┐
│              PKI 公钥基础设施组成                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  核心组件：                                                  │
│                                                             │
│  1. 证书颁发机构 (CA - Certificate Authority)               │
│     ├── 根 CA（Root CA）                                    │
│     │   - 自签名证书                                        │
│     │   - 离线存储                                          │
│     │   - 长期有效（10-20 年）                              │
│     │   - 签发中间 CA 证书                                  │
│     │                                                       │
│     ├── 中间 CA（Intermediate CA）                          │
│     │   - 由根 CA 签发                                       │
│     │   - 在线运营                                          │
│     │   - 中期有效（5-10 年）                               │
│     │   - 签发终端实体证书                                  │
│     │                                                       │
│     └── 签发 CA（Issuing CA）                               │
│         - 由中间 CA 签发                                     │
│         - 日常签发证书                                      │
│         - 短期有效（1-2 年）                                │
│                                                             │
│  2. 注册机构 (RA - Registration Authority)                  │
│     ├── 验证证书申请者身份                                   │
│     ├── 收集申请信息                                         │
│     └── 向 CA 提交签发请求                                   │
│                                                             │
│  3. 证书存储库 (Certificate Repository)                     │
│     ├── 存储已签发证书                                       │
│     ├── 存储 CRL（证书吊销列表）                            │
│     └── 提供查询服务                                         │
│                                                             │
│  4. 终端实体 (End Entity)                                   │
│     ├── 服务器证书                                          │
│     ├── 客户端证书                                          │
│     ├── 代码签名证书                                        │
│     └── 邮件证书                                            │
│                                                             │
│  5. 证书吊销系统                                            │
│     ├── CRL（证书吊销列表）                                 │
│     └── OCSP（在线证书状态协议）                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 信任模型

**PKI 信任模型**：

```
┌─────────────────────────────────────────────────────────────┐
│                  PKI 信任模型                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  层次模型（Hierarchical）：                                  │
│  ┌─────────────────────────────────────────────────────┐   │
│  │              根 CA (信任锚)                          │   │
│  │                    │                                 │   │
│  │         ┌──────────┼──────────┐                     │   │
│  │         │          │          │                     │   │
│  │    中间 CA   中间 CA   中间 CA                    │   │
│  │         │          │          │                     │   │
│  │    ┌────┴────┐ ┌────┴────┐ ┌────┴────┐            │   │
│  │    │ 终端实体 │ │ 终端实体 │ │ 终端实体 │            │   │
│  │    └─────────┘ └─────────┘ └─────────┘            │   │
│  └─────────────────────────────────────────────────────┘   │
│  特点：单信任根、结构清晰、广泛使用                        │
│                                                             │
│  网状模型（Mesh）：                                          │
│  ┌─────────────────────────────────────────────────────┐   │
│  │    CA1 ◄────► CA2                                   │   │
│  │      ╲       ╱                                      │   │
│  │        ╲   ╱                                        │   │
│  │          CA3                                        │   │
│  └─────────────────────────────────────────────────────┘   │
│  特点：多信任根、交叉认证、复杂                            │
│                                                             │
│  Web of Trust（信任网）：                                    │
│  ├── PGP/GPG 使用                                           │
│  ├── 用户互相签名认证                                       │
│  └── 去中心化信任                                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## X.509 证书

### 证书结构

**X.509 v3 证书格式**：

```
┌─────────────────────────────────────────────────────────────┐
│                  X.509 v3 证书结构                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  TBSCertificate (To Be Signed Certificate)：                │
│  ├── version：版本号（v3 = 2）                             │
│  ├── serialNumber：序列号（唯一标识）                      │
│  ├── signature：签名算法标识                               │
│  ├── issuer：颁发者名称（DN 格式）                         │
│  ├── validity：有效期                                      │
│  │   ├── notBefore：生效时间                              │
│  │   └── notAfter：过期时间                               │
│  ├── subject：主体名称（DN 格式）                          │
│  ├── subjectPublicKeyInfo：主体公钥信息                    │
│  │   ├── algorithm：公钥算法                              │
│  │   └── subjectPublicKey：公钥                           │
│  └── extensions：扩展（v3 特有）                            │
│      ├── keyUsage：密钥用途                                │
│      ├── extendedKeyUsage：扩展密钥用途                    │
│      ├── subjectAltName：主体备用名称                      │
│      ├── basicConstraints：基本约束（CA/终端）            │
│      ├── authorityKeyIdentifier：颁发者密钥标识            │
│      ├── subjectKeyIdentifier：主体密钥标识                │
│      ├── cRLDistributionPoints：CRL 分发点                 │
│      ├── authorityInfoAccess：颁发者信息访问               │
│      └── certificatePolicies：证书策略                     │
│                                                             │
│  signatureAlgorithm：签名算法                               │
│  signatureValue：签名值（CA 私钥签名）                     │
│                                                             │
│  DN（Distinguished Name）格式示例：                         │
│  C=CN, ST=Beijing, L=Beijing, O=Company, CN=example.com   │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 证书类型

**常见证书类型**：

```
┌─────────────────────────────────────────────────────────────┐
│                  X.509 证书类型                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  服务器证书（TLS/SSL）：                                     │
│  ├── 用途：HTTPS 服务器身份认证                             │
│  ├── 主体：域名（CN 或 SAN）                               │
│  ├── 有效期：1-2 年（CA/B 论坛限制）                       │
│  └── 类型：DV（域名验证）、OV（组织验证）、EV（扩展验证） │
│                                                             │
│  客户端证书：                                                │
│  ├── 用途：客户端身份认证                                   │
│  ├── 主体：用户/设备标识                                    │
│  └── 应用：双向 TLS、VPN 访问                               │
│                                                             │
│  代码签名证书：                                              │
│  ├── 用途：软件发布者认证                                   │
│  ├── 主体：公司名称                                         │
│  └── 应用：Windows Authenticode、macOS Notarization       │
│                                                             │
│  邮件证书（S/MIME）：                                        │
│  ├── 用途：邮件加密和签名                                   │
│  ├── 主体：邮箱地址                                         │
│  └── 应用：Outlook、Thunderbird                           │
│                                                             │
│  根 CA 证书：                                                 │
│  ├── 用途：信任锚                                           │
│  ├── 自签名                                                 │
│  └── 预装在操作系统/浏览器中                                │
│                                                             │
│  中间 CA 证书：                                               │
│  ├── 用途：签发终端实体证书                                 │
│  ├── 由根 CA 签发                                            │
│  └── 包含在证书链中                                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 代码操作

**Python 证书操作**：

```python
from cryptography import x509
from cryptography.x509.oid import NameOID, ExtensionOID
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.backends import default_backend
from datetime import datetime, timedelta

# ============= 生成自签名证书 =============
def generate_self_signed_cert():
    """生成自签名证书（用于测试）"""
    # 生成密钥对
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048,
        backend=default_backend()
    )
    
    # 证书主体信息
    subject = issuer = x509.Name([
        x509.NameAttribute(NameOID.COUNTRY_NAME, "CN"),
        x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "Beijing"),
        x509.NameAttribute(NameOID.LOCALITY_NAME, "Beijing"),
        x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Test Org"),
        x509.NameAttribute(NameOID.COMMON_NAME, "localhost"),
    ])
    
    # 构建证书
    cert = x509.CertificateBuilder().subject_name(
        subject
    ).issuer_name(
        issuer
    ).public_key(
        private_key.public_key()
    ).serial_number(
        x509.random_serial_number()
    ).not_valid_before(
        datetime.utcnow()
    ).not_valid_after(
        datetime.utcnow() + timedelta(days=365)
    ).add_extension(
        x509.SubjectAlternativeName([x509.DNSName("localhost")]),
        critical=False,
    ).add_extension(
        x509.BasicConstraints(ca=False, path_length=None),
        critical=True,
    ).sign(private_key, hashes.SHA256(), default_backend())
    
    # 导出证书
    cert_pem = cert.public_bytes(serialization.Encoding.PEM)
    key_pem = private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    )
    
    print("=== 自签名证书 ===")
    print(f"主题：{cert.subject}")
    print(f"颁发者：{cert.issuer}")
    print(f"有效期：{cert.not_valid_before} - {cert.not_valid_after}")
    print(f"序列号：{cert.serial_number}")
    
    return cert_pem, key_pem

# ============= 解析证书 =============
def parse_certificate(cert_pem: bytes):
    """解析证书信息"""
    cert = x509.load_pem_x509_certificate(cert_pem, default_backend())
    
    print("\n=== 证书信息 ===")
    print(f"版本：{cert.version}")
    print(f"主题：{cert.subject}")
    print(f"颁发者：{cert.issuer}")
    print(f"有效期：{cert.not_valid_before} - {cert.not_valid_after}")
    print(f"序列号：{cert.serial_number}")
    print(f"签名算法：{cert.signature_algorithm_oid}")
    
    # 扩展
    try:
        san = cert.extensions.get_extension_for_oid(
            ExtensionOID.SUBJECT_ALTERNATIVE_NAME
        )
        print(f"备用名称：{san.value}")
    except x509.ExtensionNotFound:
        pass
    
    try:
        bc = cert.extensions.get_extension_for_oid(
            ExtensionOID.BASIC_CONSTRAINTS
        )
        print(f"CA: {bc.value.ca}, 路径长度：{bc.value.path_length}")
    except x509.ExtensionNotFound:
        pass

if __name__ == "__main__":
    cert_pem, key_pem = generate_self_signed_cert()
    parse_certificate(cert_pem)
```

---

## 证书链与验证

### 证书链

**证书链验证流程**：

```
┌─────────────────────────────────────────────────────────────┐
│                  证书链验证                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  证书链示例：                                                │
│                                                             │
│  根 CA (Self-Signed)                                       │
│    │                                                        │
│    ▼                                                        │
│  中间 CA 1 (Signed by Root CA)                             │
│    │                                                        │
│    ▼                                                        │
│  中间 CA 2 (Signed by Intermediate CA 1)                   │
│    │                                                        │
│    ▼                                                        │
│  终端实体证书 (Signed by Intermediate CA 2)                │
│    (example.com)                                           │
│                                                             │
│  验证流程：                                                  │
│  1. 验证终端实体证书签名（使用中间 CA 2 公钥）              │
│  2. 验证中间 CA 2 证书签名（使用中间 CA 1 公钥）            │
│  3. 验证中间 CA 1 证书签名（使用根 CA 公钥）                │
│  4. 验证根 CA 证书（信任锚，自签名）                       │
│  5. 检查有效期（所有证书）                                  │
│  6. 检查吊销状态（CRL/OCSP）                               │
│  7. 检查名称约束、策略约束等扩展                            │
│                                                             │
│  验证成功条件：                                              │
│  ✓ 所有签名有效                                             │
│  ✓ 所有证书在有效期内                                       │
│  ✓ 所有证书未被吊销                                         │
│  ✓ 证书链完整                                               │
│  ✓ 主体名称匹配                                             │
│  ✓ 扩展约束满足                                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 证书验证代码

```python
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from datetime import datetime

def verify_certificate_chain(cert_chain: list):
    """
    验证证书链
    cert_chain: [终端实体证书，中间 CA 证书，..., 根 CA 证书]
    """
    print("=== 证书链验证 ===")
    
    # 1. 验证证书链签名
    for i in range(len(cert_chain) - 1):
        cert = cert_chain[i]
        issuer_cert = cert_chain[i + 1]
        
        # 验证签名
        try:
            issuer_public_key = issuer_cert.public_key()
            issuer_public_key.verify(
                cert.signature,
                cert.tbs_certificate_bytes,
                cert.signature_algorithm_parameters
            )
            print(f"✓ 证书 {i+1} 签名验证通过")
        except Exception as e:
            print(f"✗ 证书 {i+1} 签名验证失败：{e}")
            return False
    
    # 2. 验证有效期
    now = datetime.utcnow()
    for i, cert in enumerate(cert_chain):
        if now < cert.not_valid_before:
            print(f"✗ 证书 {i+1} 尚未生效")
            return False
        if now > cert.not_valid_after:
            print(f"✗ 证书 {i+1} 已过期")
            return False
        print(f"✓ 证书 {i+1} 有效期验证通过")
    
    # 3. 验证根证书是自签名的
    root_cert = cert_chain[-1]
    if root_cert.subject != root_cert.issuer:
        print(f"✗ 根证书不是自签名的")
        return False
    print(f"✓ 根证书是自签名的")
    
    # 4. 验证根证书签名（自签名验证）
    try:
        root_public_key = root_cert.public_key()
        root_public_key.verify(
            root_cert.signature,
            root_cert.tbs_certificate_bytes,
            root_cert.signature_algorithm_parameters
        )
        print(f"✓ 根证书自签名验证通过")
    except Exception as e:
        print(f"✗ 根证书自签名验证失败：{e}")
        return False
    
    print("\n✓ 证书链验证成功")
    return True
```

---

## 证书吊销

### 吊销机制

**证书吊销方法**：

```
┌─────────────────────────────────────────────────────────────┐
│                  证书吊销机制                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  CRL（Certificate Revocation List）：                       │
│  ├── 定义：证书吊销列表                                     │
│  ├── 发布：CA 定期发布（通常每天/每周）                    │
│  ├── 格式：签名列表，包含已吊销证书序列号                  │
│  ├── 验证：客户端下载并检查证书是否在列表中                │
│  ├── 优点：简单、可缓存                                     │
│  └── 缺点：                                                  │
│      ✗ 吊销延迟（下次发布才生效）                          │
│      ✗ 列表可能很大                                          │
│      ✗ 带宽消耗                                              │
│                                                             │
│  OCSP（Online Certificate Status Protocol）：               │
│  ├── 定义：在线证书状态协议                                 │
│  ├── 原理：实时查询 CA 获取证书状态                         │
│  ├── 响应：Good（有效）、Revoked（吊销）、Unknown（未知） │
│  ├── 优点：实时、带宽小                                     │
│  └── 缺点：                                                  │
│      ✗ 隐私问题（CA 知道用户访问的网站）                   │
│      ✗ 性能问题（需要实时查询）                            │
│      ✗ 单点故障                                              │
│                                                             │
│  OCSP Stapling：                                            │
│  ├── 定义：OCSP 装订                                        │
│  ├── 原理：服务器定期获取 OCSP 响应并"装订"到 TLS 握手中    │
│  ├── 优点：                                                  │
│      ✓ 保护隐私（CA 不知道具体用户）                       │
│      ✓ 性能好（无需客户端查询）                            │
│      ✓ 可靠（不依赖 OCSP 服务器可用性）                     │
│  └── 应用：现代 TLS 服务器默认启用                          │
│                                                             │
│  CRLite：                                                    │
│  ├── 定义：基于布隆过滤器的吊销系统                        │
│  ├── 原理：使用布隆过滤器压缩 CRL                          │
│  ├── 优点：高效、低带宽                                     │
│  └── 应用：Firefox 使用                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 实战应用

### TLS 证书部署

**Nginx TLS 配置**：

```nginx
# HTTPS 配置示例
server {
    listen 443 ssl http2;
    server_name example.com;
    
    # 证书配置
    ssl_certificate /etc/nginx/ssl/example.com.crt;
    ssl_certificate_key /etc/nginx/ssl/example.com.key;
    
    # 证书链（可选，现代浏览器可自动获取）
    ssl_trusted_certificate /etc/nginx/ssl/chain.crt;
    
    # TLS 协议
    ssl_protocols TLSv1.2 TLSv1.3;
    
    # 密码套件
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
    ssl_prefer_server_ciphers off;
    
    # OCSP Stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=300s;
    resolver_timeout 5s;
    
    # HSTS
    add_header Strict-Transport-Security "max-age=63072000" always;
    
    location / {
        proxy_pass http://backend;
    }
}
```

### 证书管理自动化

**Let's Encrypt 自动续期**：

```bash
#!/bin/bash
# Let's Encrypt 证书自动续期脚本

CERT_DOMAIN="example.com"
EMAIL="admin@example.com"
WEBROOT="/var/www/html"

# 安装 certbot
# apt-get install certbot python3-certbot-nginx

# 首次获取证书
certbot certonly \
    --webroot \
    -w $WEBROOT \
    -d $CERT_DOMAIN \
    -d www.$CERT_DOMAIN \
    --email $EMAIL \
    --agree-tos \
    --non-interactive

# 配置自动续期（cron）
# 添加到 crontab：
# 0 3 * * * certbot renew --quiet --post-hook "systemctl reload nginx"

# 测试续期
certbot renew --dry-run

# 查看证书信息
certbot certificates
```

---

## 安全实践

### 最佳实践

```
┌─────────────────────────────────────────────────────────────┐
│                  密钥与证书安全实践                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  密钥管理：                                                  │
│  ✓ 使用 HSM/KMS 存储根密钥和 KEK                            │
│  ✓ 实施密钥分层（根密钥→KEK→DEK）                         │
│  ✓ 定期轮换密钥（根据密钥类型）                            │
│  ✓ 使用信封加密保护数据密钥                                 │
│  ✓ 审计密钥使用                                             │
│  ✗ 不要硬编码密钥                                           │
│  ✗ 不要将密钥提交到版本控制                                 │
│  ✗ 不要使用弱随机数生成密钥                                 │
│                                                             │
│  证书管理：                                                  │
│  ✓ 使用受信任的 CA 签发证书                                 │
│  ✓ 启用 OCSP Stapling                                       │
│  ✓ 监控证书过期（提前 30 天告警）                           │
│  ✓ 实施证书吊销检查                                         │
│  ✓ 使用证书透明度（CT）日志                                 │
│  ✗ 不要使用自签名证书（生产环境）                          │
│  ✗ 不要使用过期证书                                          │
│  ✗ 不要忽略证书验证错误                                     │
│                                                             │
│  密钥长度建议（2024 年）：                                   │
│  ├── RSA：最低 2048 位，推荐 3072 位                         │
│  ├── ECC：P-256 或 X25519/Ed25519                          │
│  ├── AES：256 位                                            │
│  └── SHA：SHA-256 或 SHA-3                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 总结与思考

### 核心要点回顾

**密钥管理与 PKI 知识框架**：

```
┌─────────────────────────────────────────────────────────────┐
│              密钥管理与 PKI 知识框架                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  密钥管理：                                                  │
│  ├── 生命周期：生成→存储→分发→使用→更新→销毁              │
│  ├── 存储方案：HSM、KMS、分层存储                          │
│  ├── 密钥派生：PBKDF2、bcrypt、scrypt、Argon2、HKDF       │
│  └── 密钥协商：DH、ECDH、后量子                            │
│                                                             │
│  PKI 体系：                                                  │
│  ├── 组成：CA、RA、证书存储库、终端实体                    │
│  ├── 证书：X.509 v3 结构、类型、扩展                       │
│  ├── 信任模型：层次、网状、信任网                          │
│  └── 吊销：CRL、OCSP、OCSP Stapling                       │
│                                                             │
│  实战应用：                                                  │
│  ├── TLS 证书部署                                           │
│  ├── 代码签名                                               │
│  ├── 文档签名                                               │
│  └── 自动化管理                                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 参考资料

### 标准与规范

```
- NIST SP 800-57: 密钥管理指南
- RFC 5280: X.509 证书和 CRL
- RFC 6960: OCSP 协议
- CA/Browser Forum Baseline Requirements
```

### 工具与平台

```
- OpenSSL: https://www.openssl.org/
- Let's Encrypt: https://letsencrypt.org/
- HashiCorp Vault: https://www.vaultproject.io/
- AWS KMS: https://aws.amazon.com/kms/
```

---

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

> 密钥管理是密码系统的核心。再强的算法，如果密钥管理不当，也是不安全的。

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

---

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

*密码学系列继续！*