Day-175-随机数生成与熵源

# Day 190: 随机数生成与熵源

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

---

## 清单 目录

1. [随机数概述](#随机数概述)
2. [熵与熵源](#熵与熵源)
3. [真随机数生成器](#真随机数生成器)
4. [伪随机数生成器](#伪随机数生成器)
5. [密码学安全 PRNG](#密码学安全 prng)
6. [随机数测试](#随机数测试)
7. [实战应用](#实战应用)
8. [安全实践](#安全实践)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## 随机数概述

### 随机数重要性

**为什么随机数对密码学至关重要**：

```
┌─────────────────────────────────────────────────────────────┐
│              随机数在密码学中的重要性                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  关键应用：                                                  │
│  ├── 密钥生成：密钥必须是不可预测的随机数                  │
│  ├── 初始化向量（IV）：每次加密必须唯一                    │
│  ├── 盐（Salt）：密码哈希必须唯一                          │
│  ├── Nonce：认证加密必须唯一                               │
│  ├── 挑战值：认证协议必须不可预测                          │
│  └── 盲化因子：隐私保护协议                                │
│                                                             │
│  随机数失败的后果：                                          │
│  ├── 2012 年：Debian OpenSSL 漏洞                          │
│  │   └── 随机数生成器被削弱，SSH 密钥可预测                 │
│  │   └── 影响：数百万密钥不安全                            │
│  │                                                          │
│  ├── 2013 年：Android Bitcoin 钱包漏洞                     │
│  │   └── 随机数重复使用，私钥可计算                        │
│  │   └── 损失：数百万美元比特币                            │
│  │                                                          │
│  ├── 2016 年：台湾电子投票系统                             │
│  │   └── 随机数可预测，投票可被操纵                        │
│  │   └── 影响：选举结果受质疑                              │
│  │                                                          │
│  └── 2019 年：IoT 设备随机数问题                           │
│      └── 大量设备使用相同随机种子                          │
│      └── 影响：TLS 证书私钥可预测                          │
│                                                             │
│  结论：                                                      │
│  "密码学系统的安全性取决于最弱的一环，                    │
│   而随机数生成往往是最弱的一环。"                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 随机数分类

**随机数类型**：

```
┌─────────────────────────────────────────────────────────────┐
│                  随机数分类                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  真随机数（TRNG - True Random Number Generator）：          │
│  ├── 来源：物理过程（热噪声、放射性衰变等）                │
│  ├── 特点：真正随机，不可预测                              │
│  ├── 优点：理论上不可破解                                   │
│  ├── 缺点：速度慢、需要专用硬件                            │
│  └── 应用：种子生成、高安全场景                            │
│                                                             │
│  伪随机数（PRNG - Pseudo Random Number Generator）：        │
│  ├── 来源：确定性算法                                      │
│  ├── 特点：看似随机，实际可预测（如果知道种子）            │
│  ├── 优点：速度快、无需专用硬件                            │
│  ├── 缺点：种子泄露则全部可预测                            │
│  └── 应用：一般用途、游戏、模拟                            │
│                                                             │
│  密码学安全伪随机数（CSPRNG）：                             │
│  ├── 来源：密码学算法                                      │
│  ├── 特点：即使知道部分输出，也无法预测后续输出            │
│  ├── 要求：                                                  │
│  │   - 通过统计随机性测试                                  │
│  │   - 抵抗状态泄露扩展攻击                                │
│  │   - 抵抗已知输出攻击                                    │
│  └── 应用：密钥生成、加密、签名                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 熵与熵源

### 熵的概念

**信息熵定义**：

```
┌─────────────────────────────────────────────────────────────┐
│                  熵的概念                                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  定义（香农熵）：                                            │
│  H(X) = -Σ p(x) × log2(p(x))                               │
│                                                             │
│  含义：                                                      │
│  ├── 衡量随机变量的不确定性                                 │
│  ├── 单位：比特（bit）                                      │
│  └── 熵越高，不确定性越大，越随机                          │
│                                                             │
│  示例：                                                      │
│  ├── 公平硬币：H = 1 bit（最随机）                         │
│  ├── 有偏硬币：H < 1 bit（可预测性更高）                   │
│  └── 确定事件：H = 0 bit（完全可预测）                     │
│                                                             │
│  密码学中的熵：                                              │
│  ├── 种子熵：决定随机数生成器的安全性                       │
│  ├── 密钥熵：决定密钥的强度                                 │
│  └── 要求：至少 128 位熵（现代标准）                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 熵源

**常见熵源**：

```
┌─────────────────────────────────────────────────────────────┐
│                  常见熵源                                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  硬件熵源：                                                  │
│  ├── 热噪声：电阻热噪声                                     │
│  ├── 振荡器抖动：时钟频率微小变化                          │
│  ├── 亚稳态：触发器亚稳态                                   │
│  ├── 光电效应：光子检测                                     │
│  ├── 放射性衰变：盖革计数器                                 │
│  └── 混沌电路：混沌振荡器                                   │
│                                                             │
│  软件熵源：                                                  │
│  ├── 中断时间：硬件中断到达时间                            │
│  ├── 键盘输入：按键时间间隔                                 │
│  ├── 鼠标移动：鼠标轨迹                                     │
│  ├── 磁盘 I/O：磁盘访问时间                                 │
│  ├── 网络包：网络包到达时间                                 │
│  └── 系统时间：高精度时间戳                                 │
│                                                             │
│  现代 CPU 熵源：                                             │
│  ├── Intel RDRAND：数字随机数生成器                        │
│  ├── AMD RDRAND：类似 Intel                               │
│  └── ARM TRNG：硬件随机数生成器                            │
│                                                             │
│  熵池（Entropy Pool）：                                      │
│  ├── Linux：/dev/random, /dev/urandom                     │
│  ├── Windows：CryptGenRandom, BCryptGenRandom             │
│  └── macOS：/dev/random, arc4random                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### Linux 随机数

**Linux 随机数设备**：

```
┌─────────────────────────────────────────────────────────────┐
│              Linux 随机数设备                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  /dev/random：                                               │
│  ├── 特点：阻塞式随机数生成器                               │
│  ├── 熵池：当熵池空时阻塞等待                               │
│  ├── 适用：高安全场景（密钥生成）                          │
│  └── 命令：head -c 32 /dev/random | xxd                    │
│                                                             │
│  /dev/urandom：                                              │
│  ├── 特点：非阻塞式随机数生成器                             │
│  ├── 熵池：熵池空时使用 PRNG 扩展                           │
│  ├── 适用：一般密码学用途                                   │
│  └── 命令：head -c 32 /dev/urandom | xxd                   │
│                                                             │
│  熵池管理：                                                  │
│  ├── 查看熵池：cat /proc/sys/kernel/random/entropy_avail │
│  ├── 熵池大小：通常为 1024 位                               │
│  └── 建议：保持熵池充足（>512 位）                          │
│                                                             │
│  现代 Linux（5.6+）：                                        │
│  ├── /dev/random 和 /dev/urandom 行为相同                  │
│  ├── 启动后不再阻塞                                         │
│  └── 使用 ChaCha20 PRNG                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 真随机数生成器

### 硬件 TRNG

**硬件 TRNG 设计**：

```
┌─────────────────────────────────────────────────────────────┐
│              硬件 TRNG 设计                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  典型架构：                                                  │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  熵源 → 放大 → 数字化 → 后处理 → 随机输出          │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  熵源：                                                      │
│  ├── 热噪声：电阻热噪声（Johnson-Nyquist 噪声）           │
│  ├── 亚稳态：触发器亚稳态                                   │
│  └── 振荡器：环形振荡器相位抖动                            │
│                                                             │
│  数字化：                                                    │
│  ├── 比较器：将模拟信号转换为数字信号                      │
│  └── 采样：定期采样熵源输出                                 │
│                                                             │
│  后处理：                                                    │
│  ├── 目的：消除偏差、提高随机性                            │
│  ├── 方法：                                                  │
│  │   - Von Neumann 校正                                    │
│  │   - 哈希函数（SHA-256）                                 │
│  │   - 提取器（Extractor）                                 │
│  └── 输出：高质量随机比特                                   │
│                                                             │
│  商用 TRNG：                                                 │
│  ├── Intel RDRAND：基于热噪声                              │
│  ├── 专用芯片：ID Quantique、QuintessenceLabs             │
│  └── 量子 TRNG：基于光子检测                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 在线随机数服务

**在线随机数服务**：

```
┌─────────────────────────────────────────────────────────────┐
│              在线随机数服务                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  RANDOM.ORG：                                                │
│  ├── 来源：大气噪声                                         │
│  ├── 服务：免费随机数生成                                   │
│  ├── API：https://api.random.org/                          │
│  └── 适用：抽奖、游戏、研究                                 │
│                                                             │
│  ANU QRNG（澳大利亚国立大学）：                              │
│  ├── 来源：量子真空涨落                                     │
│  ├── 服务：量子随机数生成                                   │
│  ├── API：https://qrng.anu.edu.au/API/api-demo.php        │
│  └── 速度：5 Mbps                                           │
│                                                             │
│  注意事项：                                                  │
│  ! 在线服务不适合密码学密钥生成                            │
│  ! 传输过程可能被窃听                                       │
│  ! 服务方可能记录随机数                                     │
│  ✓ 仅适用于非安全场景                                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 伪随机数生成器

### 经典 PRNG

**经典 PRNG 算法**：

```
┌─────────────────────────────────────────────────────────────┐
│                  经典 PRNG 算法                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  线性同余生成器（LCG）：                                     │
│  ├── 公式：X(n+1) = (a × X(n) + c) mod m                  │
│  ├── 参数：a（乘数）、c（增量）、m（模数）                 │
│  ├── 优点：简单、快速                                       │
│  ├── 缺点：可预测、不适合密码学                            │
│  └── 应用：游戏、模拟                                       │
│                                                             │
│  梅森旋转算法（Mersenne Twister）：                         │
│  ├── 周期：2^19937 - 1（非常长）                           │
│  ├── 优点：统计特性好、速度快                              │
│  ├── 缺点：状态大、可预测                                  │
│  └── 应用：Python random 模块、科学计算                   │
│                                                             │
│  Xorshift：                                                  │
│  ├── 原理：异或移位运算                                     │
│  ├── 优点：极快、代码简单                                   │
│  ├── 缺点：统计特性一般、可预测                            │
│  └── 应用：游戏、快速原型                                   │
│                                                             │
│  PCG（Permuted Congruential Generator）：                   │
│  ├── 原理：LCG + 输出置换                                   │
│  ├── 优点：统计特性好、速度快、状态小                      │
│  ├── 缺点：不适合密码学                                     │
│  └── 应用：现代游戏、模拟                                   │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 密码学安全 PRNG

### CSPRNG 要求

**CSPRNG 安全要求**：

```
┌─────────────────────────────────────────────────────────────┐
│              CSPRNG 安全要求                                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本要求：                                                  │
│  ├── 统计随机性：通过 NIST 随机性测试                      │
│  ├── 不可预测性：已知部分输出，无法预测后续输出            │
│  └── 抗状态泄露：即使部分状态泄露，仍能保持安全            │
│                                                             │
│  NIST 测试套件：                                             │
│  ├── 频率测试：0 和 1 的比例                                │
│  ├── 块频率测试：子块中 0 和 1 的比例                        │
│  ├── 游程测试：连续相同比特的长度                          │
│  ├── 长游程测试：最长游程长度                              │
│  ├── 矩阵秩测试：随机矩阵的秩                              │
│  ├── 离散傅里叶变换：周期性特征                            │
│  ├── 模板匹配：特定模式出现频率                            │
│  ├── 熵测试：信息熵                                         │
│  ├── 随机游走：随机游走统计                                 │
│  └── 共 15 项测试                                           │
│                                                             │
│  安全定义：                                                  │
│  ├── 下一位不可预测：给定前 n 位，无法预测第 n+1 位         │
│  ├── 状态泄露扩展抵抗：部分状态泄露，输出仍安全            │
│  └── 种子密钥抵抗：不知道种子，无法区分输出与真随机        │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### CSPRNG 算法

**CSPRNG 算法**：

```
┌─────────────────────────────────────────────────────────────┐
│                  CSPRNG 算法                                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基于哈希的 CSPRNG：                                         │
│  ├── Hash_DRBG（NIST SP 800-90A）                          │
│  │   └── 使用：SHA-256、SHA-512                           │
│  │                                                          │
│  └── HMAC_DRBG（NIST SP 800-90A）                          │
│      └── 使用：HMAC-SHA256、HMAC-SHA512                   │
│      └── 推荐：最广泛使用                                   │
│                                                             │
│  基于分组密码的 CSPRNG：                                     │
│  ├── CTR_DRBG（NIST SP 800-90A）                           │
│  │   └── 使用：AES-128、AES-256                           │
│  │   └── 优点：速度快                                       │
│  │                                                          │
│  └── OFB/CFB 模式                                           │
│      └── 使用：AES、3DES                                   │
│                                                             │
│  基于数论的 CSPRNG：                                         │
│  ├── Blum Blum Shub（BBS）                                 │
│  │   └── 公式：X(n+1) = X(n)^2 mod n                      │
│  │   └── 安全：基于大整数分解                              │
│  │   └── 缺点：速度慢                                       │
│  │                                                          │
│  └── Micali-Schnorr                                         │
│      └── 基于 RSA                                          │
│                                                             │
│  现代 CSPRNG：                                               │
│  ├── ChaCha20（RFC 8439）                                  │
│  │   └── 流密码，速度极快                                   │
│  │   └── 应用：Linux /dev/urandom（5.6+）                 │
│  │                                                          │
│  └── Fortuna：                                               │
│      └── 改进版 Yarrow                                      │
│      └── 多熵池设计                                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 代码实现

**Python CSPRNG**：

```python
import secrets
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

# ============= 安全随机数生成 =============
def secure_random_demo():
    """安全随机数生成演示"""
    print("=== 安全随机数生成 ===")
    
    # 生成随机字节（推荐方式）
    random_bytes = secrets.token_bytes(32)
    print(f"随机字节：{random_bytes.hex()}")
    
    # 生成随机整数
    random_int = secrets.randbelow(1000)
    print(f"随机整数（0-999）：{random_int}")
    
    # 生成随机 URL-safe 字符串
    random_url = secrets.token_urlsafe(32)
    print(f"URL-safe 字符串：{random_url}")
    
    # 生成随机十六进制字符串
    random_hex = secrets.token_hex(16)
    print(f"十六进制字符串：{random_hex}")
    
    return random_bytes

# ============= 密钥生成 =============
def generate_crypto_key():
    """生成密码学密钥"""
    print("\n=== 密码学密钥生成 ===")
    
    # AES-256 密钥
    aes_key = secrets.token_bytes(32)
    print(f"AES-256 密钥：{aes_key.hex()}")
    
    # HMAC 密钥
    hmac_key = secrets.token_bytes(32)
    print(f"HMAC 密钥：{hmac_key.hex()}")
    
    # JWT 密钥
    jwt_secret = secrets.token_urlsafe(64)
    print(f"JWT 密钥：{jwt_secret}")
    
    return aes_key

# ============= 安全 Nonce 生成 =============
def generate_nonce():
    """生成安全 Nonce"""
    print("\n=== Nonce 生成 ===")
    
    # AES-GCM Nonce（12 字节）
    nonce = secrets.token_bytes(12)
    print(f"AES-GCM Nonce: {nonce.hex()}")
    
    # ChaCha20 Nonce（12 字节）
    chacha_nonce = secrets.token_bytes(12)
    print(f"ChaCha20 Nonce: {chacha_nonce.hex()}")
    
    return nonce

# ============= 密码盐生成 =============
def generate_salt():
    """生成密码盐"""
    print("\n=== 密码盐生成 ===")
    
    # bcrypt 盐（16 字节）
    salt = secrets.token_bytes(16)
    print(f"bcrypt 盐：{salt.hex()}")
    
    # Argon2 盐（16 字节）
    argon2_salt = secrets.token_bytes(16)
    print(f"Argon2 盐：{argon2_salt.hex()}")
    
    return salt

if __name__ == "__main__":
    secure_random_demo()
    generate_crypto_key()
    generate_nonce()
    generate_salt()
```

---

## 随机数测试

### 统计测试

**随机数统计测试**：

```
┌─────────────────────────────────────────────────────────────┐
│                  随机数统计测试                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  NIST SP 800-22 测试套件：                                   │
│  ├── 1. 频率测试（Frequency Test）                         │
│  │   └── 检验 0 和 1 的比例是否接近 1:1                    │
│  │                                                          │
│  ├── 2. 块频率测试（Block Frequency Test）                 │
│  │   └── 检验各子块中 0 和 1 的比例                         │
│  │                                                          │
│  ├── 3. 游程测试（Runs Test）                              │
│  │   └── 检验连续相同比特的长度分布                        │
│  │                                                          │
│  ├── 4. 长游程测试（Longest Run of Ones Test）             │
│  │   └── 检验最长连续 1 的长度                              │
│  │                                                          │
│  ├── 5. 矩阵秩测试（Rank Test）                            │
│  │   └── 检验随机矩阵的秩                                  │
│  │                                                          │
│  ├── 6. 离散傅里叶变换（DFT Test）                         │
│  │   └── 检验周期性特征                                    │
│  │                                                          │
│  ├── 7. 模板匹配（Pattern Matching）                       │
│  │   └── 检验特定模式出现频率                              │
│  │                                                          │
│  └── ...（共 15 项测试）                                    │
│                                                             │
│  Dieharder 测试套件：                                        │
│  ├── 生日间隔测试                                           │
│  ├── 停车场测试                                             │
│  ├── 重叠排列测试                                           │
│  └── 共 30+ 项测试                                          │
│                                                             │
│  TestU01 测试套件：                                          │
│  ├── SmallCrush：快速测试                                   │
│  ├── Crush：标准测试                                        │
│  └── BigCrush：严格测试                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 测试工具

**随机数测试工具**：

```python
# 使用 NIST 测试工具
# 安装：pip install nist-sts

from nist_sts import stats

def test_random_sequence(data):
    """测试随机序列"""
    # 频率测试
    freq_result = stats.frequency_test(data)
    print(f"频率测试 p 值：{freq_result.pvalue}")
    
    # 判断是否通过（p > 0.01）
    if freq_result.pvalue > 0.01:
        print("✓ 通过频率测试")
    else:
        print("✗ 未通过频率测试")
    
    return freq_result.pvalue > 0.01

# 使用 ent 工具（命令行）
# ent /dev/urandom
# 输出：
# Entropy = 8.000000 bits per byte（熵）
# Chi-square = 256.00（卡方检验）
# Mean = 127.5（均值）
# Monte Carlo Pi = 3.14（蒙特卡洛π）
# Serial Correlation = 0.00（序列相关）
```

---

## 实战应用

### 密钥生成

**安全密钥生成**：

```python
from cryptography.hazmat.primitives.asymmetric import rsa, ec, ed25519
from cryptography.hazmat.backends import default_backend
import secrets

# ============= RSA 密钥生成 =============
def generate_rsa_key(bits=2048):
    """生成 RSA 密钥对"""
    # 使用系统 CSPRNG
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=bits,
        backend=default_backend()
    )
    return private_key

# ============= ECC 密钥生成 =============
def generate_ec_key():
    """生成 ECC 密钥对"""
    private_key = ec.generate_private_key(
        ec.SECP256R1(),
        backend=default_backend()
    )
    return private_key

# ============= Ed25519 密钥生成 =============
def generate_ed25519_key():
    """生成 Ed25519 密钥对"""
    private_key = ed25519.Ed25519PrivateKey.generate()
    return private_key

# ============= 对称密钥生成 =============
def generate_symmetric_key(algorithm='aes-256'):
    """生成对称密钥"""
    if algorithm == 'aes-128':
        return secrets.token_bytes(16)
    elif algorithm == 'aes-256':
        return secrets.token_bytes(32)
    elif algorithm == 'chacha20':
        return secrets.token_bytes(32)
    else:
        raise ValueError(f"未知算法：{algorithm}")

if __name__ == "__main__":
    print("=== 密钥生成 ===")
    
    # RSA
    rsa_key = generate_rsa_key(2048)
    print(f"RSA-2048 密钥生成：✓")
    
    # ECC
    ec_key = generate_ec_key()
    print(f"ECC P-256 密钥生成：✓")
    
    # Ed25519
    ed25519_key = generate_ed25519_key()
    print(f"Ed25519 密钥生成：✓")
    
    # 对称密钥
    aes_key = generate_symmetric_key('aes-256')
    print(f"AES-256 密钥：{aes_key.hex()[:32]}...")
```

### 会话令牌

**安全会话令牌生成**：

```python
import secrets
import hashlib
import time

class SessionTokenGenerator:
    """安全会话令牌生成器"""
    
    def __init__(self):
        self.secret = secrets.token_bytes(32)
    
    def generate_token(self, user_id):
        """生成会话令牌"""
        # 随机部分
        random_part = secrets.token_bytes(16)
        
        # 时间戳
        timestamp = int(time.time()).to_bytes(8, 'big')
        
        # 用户 ID 哈希
        user_hash = hashlib.sha256(
            f"{user_id}".encode()
        ).digest()[:16]
        
        # 组合
        token_data = self.secret + random_part + timestamp + user_hash
        
        # HMAC 签名
        signature = hashlib.sha256(
            self.secret + token_data
        ).digest()[:16]
        
        # 最终令牌
        token = random_part + timestamp + signature
        
        return token.hex()
    
    def verify_token(self, token_hex, user_id):
        """验证令牌"""
        # 解析令牌
        token = bytes.fromhex(token_hex)
        random_part = token[:16]
        timestamp = token[16:24]
        signature = token[24:40]
        
        # 重建签名
        user_hash = hashlib.sha256(
            f"{user_id}".encode()
        ).digest()[:16]
        
        expected_data = self.secret + random_part + timestamp + user_hash
        expected_signature = hashlib.sha256(
            self.secret + expected_data
        ).digest()[:16]
        
        # 验证
        return secrets.compare_digest(signature, expected_signature)

# 使用示例
if __name__ == "__main__":
    generator = SessionTokenGenerator()
    
    # 生成令牌
    token = generator.generate_token("user123")
    print(f"会话令牌：{token}")
    
    # 验证令牌
    is_valid = generator.verify_token(token, "user123")
    print(f"令牌验证：{'✓ 有效' if is_valid else '✗ 无效'}")
```

---

## 安全实践

### 最佳实践

```
┌─────────────────────────────────────────────────────────────┐
│              随机数安全实践                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  应该做的：                                                  │
│  ✓ 使用 CSPRNG（secrets、/dev/urandom）                   │
│  ✓ 确保足够熵（128 位+）                                    │
│  ✓ 每个密钥使用唯一随机数                                   │
│  ✓ 每次加密使用唯一 Nonce/IV                               │
│  ✓ 每个密码使用唯一盐                                       │
│  ✓ 定期测试随机数生成器                                     │
│  ✓ 监控熵池状态                                             │
│                                                             │
│  不应该做的：                                                │
│  ✗ 使用 random 模块（非密码学安全）                        │
│  ✗ 使用时间戳作为种子                                       │
│  ✗ 重复使用随机数（Nonce、IV）                             │
│  ✗ 使用在线随机数服务生成密钥                               │
│  ✗ 自己设计随机数算法                                       │
│  ✗ 忽略熵池状态                                             │
│                                                             │
│  语言特定建议：                                              │
│  ├── Python：使用 secrets 模块，不用 random                │
│  ├── Java：使用 SecureRandom，不用 Random                  │
│  ├── C/C++：使用 /dev/urandom 或 CryptoGenRandom           │
│  ├── Go：使用 crypto/rand，不用 math/rand                  │
│  └── Node.js：使用 crypto.randomBytes                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 常见错误

**随机数使用错误**：

```python
# ============= 错误 1：使用 random 模块 =============
# ✗ 错误：
import random
key = random.randint(0, 2**256)  # 不安全！

# ✓ 正确：
import secrets
key = secrets.randbits(256)  # 安全

# ============= 错误 2：使用时间戳作为种子 =============
# ✗ 错误：
import random
random.seed(int(time.time()))  # 可预测！

# ✓ 正确：
import secrets
key = secrets.token_bytes(32)  # 不可预测

# ============= 错误 3：重复使用 Nonce =============
# ✗ 错误：
nonce = b'fixed_nonce!!'  # 固定 Nonce！
cipher1 = AES.new(key, AES.MODE_GCM, nonce=nonce)
cipher2 = AES.new(key, AES.MODE_GCM, nonce=nonce)  # 相同 Nonce！

# ✓ 正确：
nonce1 = secrets.token_bytes(12)  # 唯一 Nonce
cipher1 = AES.new(key, AES.MODE_GCM, nonce=nonce1)
nonce2 = secrets.token_bytes(12)  # 唯一 Nonce
cipher2 = AES.new(key, AES.MODE_GCM, nonce=nonce2)

# ============= 错误 4：熵不足 =============
# ✗ 错误（嵌入式系统）：
# 启动时熵池为空，生成弱密钥

# ✓ 正确：
# 等待熵池充足
# 使用硬件 TRNG
# 保存熵池状态到磁盘
```

---

## 总结与思考

### 核心要点回顾

**随机数知识框架**：

```
┌─────────────────────────────────────────────────────────────┐
│                  随机数知识框架                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  随机数类型：                                                │
│  ├── TRNG：真随机数（硬件）                                 │
│  ├── PRNG：伪随机数（算法）                                 │
│  └── CSPRNG：密码学安全伪随机数                            │
│                                                             │
│  熵与熵源：                                                  │
│  ├── 熵：随机性的度量                                       │
│  ├── 硬件熵源：热噪声、振荡器                               │
│  └── 软件熵源：中断、I/O、时间戳                           │
│                                                             │
│  CSPRNG 算法：                                               │
│  ├── Hash_DRBG、HMAC_DRBG                                  │
│  ├── CTR_DRBG（AES）                                       │
│  └── ChaCha20                                              │
│                                                             │
│  安全实践：                                                  │
│  ├── 使用 CSPRNG（secrets、/dev/urandom）                 │
│  ├── 确保足够熵（128 位+）                                  │
│  └── 避免常见错误（重复 Nonce、弱种子）                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 深入思考

**1. 为什么随机数如此重要？**

随机数是密码学的基石。密钥、IV、Nonce、盐——所有这些都依赖于随机数。如果随机数可预测，整个密码学系统就崩溃了。

**2. 真随机 vs 伪随机？**

- 真随机（TRNG）：物理过程，真正随机，但慢
- 伪随机（CSPRNG）：算法生成，快速，密码学安全
- 最佳实践：TRNG 生成种子，CSPRNG 扩展

**3. 如何确保随机数安全？**

- 使用成熟库（secrets、OpenSSL）
- 监控熵池状态
- 测试随机数质量
- 避免自己设计算法

---

## 参考资料

### 标准与规范

```
- NIST SP 800-90A: 随机数生成器建议
- NIST SP 800-22: 随机数统计测试
- RFC 4086: 随机性建议
- RFC 8439: ChaCha20-Poly1305
```

### 工具与库

```
Python:
- secrets: 标准库
- cryptography: 密码学库

Linux:
- /dev/random, /dev/urandom
- haveged: 熵增强守护进程

测试工具:
- NIST STS: 统计测试套件
- Dieharder: 随机数测试
- ent: 熵测试工具
```

### 学习资源

```
- 《Serious Cryptography》- Jean-Philippe Aumasson
- 《Handbook of Applied Cryptography》
- NIST Randomness Beacon: https://beacon.nist.gov/
```

---

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

> 随机数是密码学的基石。没有好的随机数，就没有好的密码学。

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

---

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

*密码学系列 1/3 完成！*