Day-170-哈希函数与数字签名

# Day 184: 哈希函数与数字签名

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

---

## 清单 目录

1. [哈希函数概述](#哈希函数概述)
2. [SHA 家族详解](#sha 家族详解)
3. [哈希函数应用](#哈希函数应用)
4. [数字签名原理](#数字签名原理)
5. [RSA 签名](#rsa 签名)
6. [ECDSA 与 EdDSA](#ecdsa 与 eddsa)
7. [数字签名应用](#数字签名应用)
8. [安全实践](#安全实践)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## 哈希函数概述

### 基本概念

**哈希函数定义**：

```
┌─────────────────────────────────────────────────────────────┐
│                  哈希函数基本概念                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  定义：                                                      │
│  哈希函数 H 将任意长度的输入 m 映射到固定长度的输出 h       │
│  h = H(m)                                                  │
│                                                             │
│  输出长度：                                                  │
│  ├── MD5: 128 位（16 字节）                                 │
│  ├── SHA-1: 160 位（20 字节）                               │
│  ├── SHA-256: 256 位（32 字节）                            │
│  ├── SHA-384: 384 位（48 字节）                            │
│  ├── SHA-512: 512 位（64 字节）                            │
│  └── SHA-3: 可变长度（224/256/384/512 位）                 │
│                                                             │
│  核心特性：                                                  │
│  ├── 单向性（原像抵抗）：给定 h，难以找到 m 使得 H(m)=h     │
│  ├── 第二原像抵抗：给定 m1，难以找到 m2 使得 H(m1)=H(m2)    │
│  ├── 碰撞抵抗：难以找到任意 m1, m2 使得 H(m1)=H(m2)         │
│  ├── 确定性：相同输入总是产生相同输出                       │
│  ├── 雪崩效应：输入微小变化导致输出巨大变化                 │
│  └── 高效性：计算快速                                       │
│                                                             │
│  雪崩效应示例：                                              │
│  SHA-256("hello") = 2cf24dba...                            │
│  SHA-256("hello!") = 7e2a6f... (完全不同)                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 安全要求

**哈希函数安全级别**：

```
┌─────────────────────────────────────────────────────────────┐
│              哈希函数安全要求                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  原像攻击（Preimage Attack）                                │
│  攻击：给定哈希值 h，寻找任意 m 使得 H(m) = h              │
│  难度：2^n 次运算（n 为输出长度）                           │
│  要求：计算上不可行                                         │
│                                                             │
│  第二原像攻击（Second Preimage Attack）                     │
│  攻击：给定 m1，寻找 m2 ≠ m1 使得 H(m1) = H(m2)           │
│  难度：2^n 次运算                                           │
│  要求：计算上不可行                                         │
│                                                             │
│  碰撞攻击（Collision Attack）                               │
│  攻击：寻找任意 m1, m2 使得 H(m1) = H(m2)                 │
│  难度：2^(n/2) 次运算（生日攻击）                           │
│  要求：计算上不可行                                         │
│                                                             │
│  生日悖论：                                                  │
│  ├── 23 人中有 50% 概率生日相同                             │
│  ├── 2^(n/2) 次哈希可找到碰撞                               │
│  └── SHA-256: 2^128 次运算（安全）                          │
│                                                             │
│  安全强度对比：                                              │
│  ┌────────────┬──────────────┬──────────────┐             │
│  │   算法     │  碰撞抵抗   │  原像抵抗   │             │
│  ├────────────┼──────────────┼──────────────┤             │
│  │  MD5       │  已攻破     │  已攻破     │             │
│  │  SHA-1     │  已攻破     │  理论安全   │             │
│  │  SHA-256   │  128 位      │  256 位      │             │
│  │  SHA-384   │  192 位      │  384 位      │             │
│  │  SHA-512   │  256 位      │  512 位      │             │
│  └────────────┴──────────────┴──────────────┘             │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## SHA 家族详解

### SHA-1

**SHA-1 算法**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SHA-1 算法                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 设计者：NSA（1995 年）                                 │
│  ├── 标准：FIPS 180-4                                      │
│  ├── 输出长度：160 位（20 字节）                            │
│  ├── 分组长度：512 位                                       │
│  └── 轮数：80 轮                                            │
│                                                             │
│  状态：                                                      │
│  ✗ 碰撞攻击已攻破（2017 年 SHAttered 攻击）                │
│  ✗ 不应再用于安全目的                                       │
│  △ 可用于非安全校验（如文件去重）                          │
│                                                             │
│  替代方案：                                                  │
│  ✓ SHA-256（推荐）                                          │
│  ✓ SHA-3（备选）                                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### SHA-2 家族

**SHA-256 详解**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SHA-256 算法                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 设计者：NSA（2001 年）                                 │
│  ├── 标准：FIPS 180-4                                      │
│  ├── 输出长度：256 位（32 字节）                            │
│  ├── 分组长度：512 位                                       │
│  └── 轮数：64 轮                                            │
│                                                             │
│  算法结构（Merkle-Damgård）：                                │
│  1. 填充：消息填充到 512 位的倍数                            │
│     - 添加 '1' 比特                                         │
│     - 填充 '0' 比特                                         │
│     - 添加 64 位长度                                         │
│                                                             │
│  2. 初始化：8 个初始哈希值（32 位）                          │
│     H0-H7 = SHA-256 初始常量（前 8 个素数的平方根小数部分）│
│                                                             │
│  3. 处理：每 512 位分组处理                                  │
│     ┌─────────────────────────────────────────────────┐    │
│     │  对于每个分组：                                 │    │
│     │  1. 消息调度：生成 64 个消息字 W0-W63            │    │
│     │  2. 工作变量： a,b,c,d,e,f,g,h = H0-H7         │    │
│     │  3. 64 轮压缩：                                  │    │
│     │     对于 t = 0 到 63:                           │    │
│     │     T1 = h + Σ1(e) + Ch(e,f,g) + Kt + Wt       │    │
│     │     T2 = Σ0(a) + Maj(a,b,c)                     │    │
│     │     h = g, g = f, f = e, e = d + T1            │    │
│     │     d = c, c = b, b = a, a = T1 + T2           │    │
│     │  4. 更新哈希值：Hi = Hi + 工作变量              │    │
│     └─────────────────────────────────────────────────┘    │
│                                                             │
│  4. 输出：连接 H0-H7 得到 256 位哈希值                       │
│                                                             │
│  安全性：                                                    │
│  ✓ 无已知有效攻击                                           │
│  ✓ 碰撞抵抗：128 位安全                                     │
│  ✓ 原像抵抗：256 位安全                                     │
│  ✓ 广泛使用（比特币、TLS、密码存储）                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

**SHA-512**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SHA-512 算法                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 输出长度：512 位（64 字节）                            │
│  ├── 分组长度：1024 位                                      │
│  └── 轮数：80 轮                                            │
│                                                             │
│  与 SHA-256 对比：                                           │
│  ├── 使用 64 位运算（SHA-256 用 32 位）                      │
│  ├── 64 位系统上更快                                        │
│  ├── 更高安全性（256 位碰撞抵抗）                           │
│  └── 输出更长（带宽占用大）                                 │
│                                                             │
│  变体：                                                      │
│  ├── SHA-384：SHA-512 截断（输出 384 位）                   │
│  ├── SHA-512/224：SHA-512 截断（输出 224 位）               │
│  └── SHA-512/256：SHA-512 截断（输出 256 位）               │
│                                                             │
│  应用：                                                      │
│  ├── 高安全性需求                                           │
│  ├── 密码存储（配合 bcrypt/Argon2）                        │
│  └── 数字签名                                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### SHA-3

**SHA-3（Keccak）**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SHA-3 算法                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 设计者：Guido Bertoni 等（2007 年）                    │
│  ├── 标准：FIPS 202（2015 年）                              │
│  ├── 竞赛：NIST SHA-3 竞赛获胜者                            │
│  ├── 结构：海绵结构（不同于 SHA-2 的 Merkle-Damgård）      │
│  └── 优势：抗长度扩展攻击                                   │
│                                                             │
│  海绵结构（Sponge Construction）：                           │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  吸收阶段（Absorbing）：                              │   │
│  │  输入 → XOR → 置换 → XOR → 置换 → ...              │   │
│  │                                                      │   │
│  │  挤压阶段（Squeezing）：                              │   │
│  │  置换 → 输出 → 置换 → 输出 → ...                    │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  状态：1600 位（5x5x64 位三维数组）                          │
│  轮数：24 轮                                                 │
│  轮函数：θρπχι（5 个步骤）                                  │
│                                                             │
│  变体：                                                      │
│  ├── SHA3-224、SHA3-256、SHA3-384、SHA3-512               │
│  ├── SHAKE128、SHAKE256（可变长度输出）                    │
│  └── KangarooTwelve（快速模式）                            │
│                                                             │
│  优势：                                                      │
│  ✓ 与 SHA-2 不同设计（可互为备份）                         │
│  ✓ 抗长度扩展攻击                                           │
│  ✓ 硬件实现高效                                             │
│  ✓ 支持任意长度输出                                         │
│                                                             │
│  应用：                                                      │
│  ├── 新系统首选                                             │
│  ├── 与 SHA-2 混合使用                                      │
│  └── IoT 设备（硬件实现）                                   │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 国密 SM3

**SM3 哈希算法**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM3 算法（国密）                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 标准：GM/T 0004-2012                                  │
│  ├── 设计者：中国密码学会                                   │
│  ├── 输出长度：256 位（32 字节）                            │
│  ├── 分组长度：512 位                                       │
│  └── 轮数：64 轮                                            │
│                                                             │
│  结构：                                                      │
│  ├── Merkle-Damgård 结构（类似 SHA-256）                   │
│  ├── 8 个初始值                                             │
│  ├── 64 轮压缩函数                                         │
│  └── 非线性函数：FF、GG                                    │
│                                                             │
│  安全性：                                                    │
│  ✓ 与 SHA-256 相当                                          │
│  ✓ 无已知有效攻击                                           │
│  ✓ 中国商用密码标准                                         │
│                                                             │
│  应用：                                                      │
│  ├── 数字签名（配合 SM2）                                   │
│  ├── 消息认证                                               │
│  ├── 密码存储                                               │
│  └── 政务、金融系统                                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 哈希函数应用

### 密码存储

**安全密码存储实践**：

```
┌─────────────────────────────────────────────────────────────┐
│                  安全密码存储                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  错误做法：                                                  │
│  ✗ 明文存储                                                 │
│  ✗ MD5(password)                                           │
│  ✗ SHA-256(password)                                       │
│  ✗ MD5(password + salt)                                    │
│                                                             │
│  正确做法：                                                  │
│  ✓ 使用专用密码哈希函数                                     │
│  ✓ 每个密码使用唯一盐                                       │
│  ✓ 使用足够的迭代次数/工作量                                │
│  ✓ 存储盐 + 哈希值                                         │
│                                                             │
│  推荐算法：                                                  │
│  ├── Argon2id（首选）：2015 年密码哈希竞赛获胜者           │
│  │   - 抗 GPU 攻击                                          │
│  │   - 抗 ASIC 攻击                                         │
│  │   - 可调节内存、时间、并行度                            │
│  │                                                          │
│  ├── bcrypt：成熟可靠，广泛支持                            │
│  │   - 自适应成本因子                                      │
│  │   - 内置盐                                               │
│  │   - 广泛部署                                             │
│  │                                                          │
│  ├── scrypt：内存困难                                      │
│  │   - 抗 ASIC 攻击                                         │
│  │   - 内存密集型                                           │
│  │   - 加密货币使用                                         │
│  │                                                          │
│  └── PBKDF2：标准支持好，但较弱                            │
│      - NIST 推荐                                            │
│      - 广泛支持                                             │
│      - 但易受 GPU 攻击                                       │
│                                                             │
│  参数建议（2024 年）：                                       │
│  Argon2id:                                                 │
│  - 内存：64MB                                              │
│  - 迭代：3 次                                               │
│  - 并行度：4                                               │
│                                                             │
│  bcrypt:                                                   │
│  - 成本因子：12+（随硬件提升）                              │
│                                                             │
│  PBKDF2-HMAC-SHA256:                                       │
│  - 迭代：600000+（NIST 建议）                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

**Python 密码存储示例**：

```python
import argon2
import bcrypt

# ============= Argon2 示例 =============
def argon2_password():
    """使用 Argon2 哈希密码"""
    ph = argon2.PasswordHasher(
        time_cost=3,        # 迭代次数
        memory_cost=65536,  # 64MB 内存
        parallelism=4,      # 并行度
        hash_len=32,        # 输出长度
        salt_len=16         # 盐长度
    )
    
    # 哈希密码
    password = "my_secret_password"
    hashed = ph.hash(password)
    print(f"Argon2 哈希：{hashed}")
    
    # 验证密码
    try:
        ph.verify(hashed, password)
        print("✓ 密码正确")
    except argon2.exceptions.VerifyMismatchError:
        print("✗ 密码错误")
    
    # 检查是否需要重新哈希
    if ph.check_needs_rehash(hashed):
        print("! 需要重新哈希（参数已过时）")

# ============= bcrypt 示例 =============
def bcrypt_password():
    """使用 bcrypt 哈希密码"""
    password = b"my_secret_password"
    
    # 生成盐并哈希
    salt = bcrypt.gensalt(rounds=12)
    hashed = bcrypt.hashpw(password, salt)
    print(f"bcrypt 哈希：{hashed}")
    
    # 验证密码
    if bcrypt.checkpw(password, hashed):
        print("✓ 密码正确")
    else:
        print("✗ 密码错误")

if __name__ == "__main__":
    print("=== Argon2 密码哈希 ===")
    argon2_password()
    
    print("\n=== bcrypt 密码哈希 ===")
    bcrypt_password()
```

### 数据完整性

**文件完整性校验**：

```python
import hashlib
from pathlib import Path

def calculate_file_hash(filepath: str, algorithm: str = 'sha256') -> str:
    """计算文件哈希值"""
    hash_func = getattr(hashlib, algorithm)()
    
    with open(filepath, 'rb') as f:
        # 分块读取（适合大文件）
        for chunk in iter(lambda: f.read(8192), b''):
            hash_func.update(chunk)
    
    return hash_func.hexdigest()

def verify_file_integrity(filepath: str, expected_hash: str) -> bool:
    """验证文件完整性"""
    actual_hash = calculate_file_hash(filepath)
    return actual_hash == expected_hash

# 使用示例
if __name__ == "__main__":
    # 计算哈希
    file_hash = calculate_file_hash('important_file.zip')
    print(f"SHA-256: {file_hash}")
    
    # 验证完整性
    is_valid = verify_file_integrity('important_file.zip', file_hash)
    print(f"完整性验证：{'✓ 通过' if is_valid else '✗ 失败'}")
```

### 区块链应用

**比特币中的哈希应用**：

```
┌─────────────────────────────────────────────────────────────┐
│              哈希函数在区块链中的应用                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  交易哈希：                                                  │
│  TXID = SHA-256(SHA-256(transaction))                      │
│  - 唯一标识交易                                             │
│  - 256 位（32 字节）                                         │
│                                                             │
│  区块哈希：                                                  │
│  BlockHash = SHA-256(SHA-256(block_header))                │
│  - 链接区块（每个区块包含前一个区块哈希）                  │
│  - 工作量证明目标                                           │
│                                                             │
│  默克尔树：                                                  │
│  ├── 叶子节点：交易哈希                                     │
│  ├── 中间节点：子节点哈希的 SHA-256(SHA-256(left+right))   │
│  └── 默克尔根：包含在区块头中                              │
│                                                             │
│  工作量证明：                                                │
│  要求：SHA-256(SHA-256(block_header)) < target            │
│  挖矿：暴力搜索 nonce 使区块哈希小于目标                   │
│  难度：自动调整（约 10 分钟一个区块）                       │
│                                                             │
│  地址生成：                                                  │
│  1. 私钥 → ECDSA 公钥                                       │
│  2. 公钥 → SHA-256                                         │
│  3. SHA-256 输出 → RIPEMD-160                              │
│  4. 添加版本字节 + 校验和 → Base58Check 编码               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 数字签名原理

### 基本概念

**数字签名定义**：

```
┌─────────────────────────────────────────────────────────────┐
│                  数字签名基本概念                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  定义：                                                      │
│  数字签名是使用私钥对消息（或消息哈希）进行加密的结果       │
│  用于验证消息的真实性和完整性                               │
│                                                             │
│  签名流程：                                                  │
│  ┌─────────┐                ┌─────────┐                    │
│  │ 发送方  │                │ 接收方  │                    │
│  │ 私钥    │                │ 公钥    │                    │
│  │   +     │  ① 计算哈希    │   +     │                    │
│  │ 消息    │     H(m)       │ 消息    │                    │
│  │         │     ↓          │         │                    │
│  │         │  ② 私钥签名    │         │                    │
│  │         │  s = Sign(H(m))│         │                    │
│  │         │───────────────▶│         │                    │
│  │         │  消息 + 签名   │         │  ③ 计算哈希        │
│  │         │                │     H(m') │                   │
│  │         │                │     ↓     │                   │
│  │         │                │  ④ 公钥验签 │                 │
│  │         │                │  Verify(s) │                 │
│  │         │                │     ↓     │                   │
│  │         │                │  ✓/✗ 结果 │                   │
│  └─────────┘                └─────────┘                    │
│                                                             │
│  安全属性：                                                  │
│  ├── 认证性：确认发送方身份                                 │
│  ├── 完整性：确认消息未被篡改                               │
│  └── 不可否认性：发送方不能否认已签名                       │
│                                                             │
│  与加密的区别：                                              │
│  ├── 加密：公钥加密，私钥解密（保密性）                    │
│  └── 签名：私钥签名，公钥验证（认证性）                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 签名方案

**数字签名方案组成**：

```
┌─────────────────────────────────────────────────────────────┐
│                  数字签名方案组成                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. 密钥生成（KeyGen）                                      │
│     输入：安全参数                                          │
│     输出：(公钥 PK, 私钥 SK)                                │
│                                                             │
│  2. 签名（Sign）                                            │
│     输入：私钥 SK, 消息 m                                   │
│     输出：签名 σ                                            │
│     σ = Sign(SK, m)                                        │
│                                                             │
│  3. 验证（Verify）                                          │
│     输入：公钥 PK, 消息 m, 签名 σ                           │
│     输出：有效/无效                                         │
│     valid = Verify(PK, m, σ)                               │
│                                                             │
│  正确性要求：                                                │
│  Verify(PK, m, Sign(SK, m)) = ✓ (总是有效)                │
│                                                             │
│  安全性要求（EUF-CMA）：                                     │
│  存在性不可伪造（在适应性选择消息攻击下）                  │
│  攻击者无法伪造有效签名（即使可以看到其他消息的签名）      │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## RSA 签名

### PKCS#1 v1.5 签名

**RSA PKCS#1 v1.5 签名**：

```
┌─────────────────────────────────────────────────────────────┐
│              RSA PKCS#1 v1.5 签名                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  签名流程：                                                  │
│  1. 计算消息哈希：h = H(m)                                 │
│  2. 构建 DigestInfo：包含哈希算法 OID 和哈希值             │
│  3. PKCS#1 填充：0x00 || 0x01 || PS || 0x00 || DigestInfo │
│     - PS：至少 8 字节的 0xFF                                 │
│  4. RSA 私钥操作：s = padded^d mod n                       │
│  5. 输出签名：s                                            │
│                                                             │
│  验签流程：                                                  │
│  1. RSA 公钥操作：padded = s^e mod n                        │
│  2. 验证填充格式：0x00 || 0x01 || ...                      │
│  3. 提取 DigestInfo                                        │
│  4. 计算消息哈希：h' = H(m)                                │
│  5. 比较：h == h'                                          │
│                                                             │
│  安全性：                                                    │
│  △ 广泛使用                                                 │
│  △ 存在理论攻击（实际影响有限）                            │
│  ✓ 配合 SHA-256 仍安全                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### RSA-PSS 签名

**RSA-PSS（Probabilistic Signature Scheme）**：

```
┌─────────────────────────────────────────────────────────────┐
│                  RSA-PSS 签名                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  设计目标：                                                  │
│  ├── 可证明安全（随机预言模型）                             │
│  ├── 概率签名（每次签名不同）                               │
│  └── 替代 PKCS#1 v1.5                                      │
│                                                             │
│  签名流程：                                                  │
│  1. 计算消息哈希：h = H(m)                                 │
│  2. 生成随机盐：salt（通常与哈希输出等长）                 │
│  3. MGF1 掩码生成：使用哈希函数生成掩码                     │
│  4. 构建 DB（数据块）：包含盐和哈希                        │
│  5. 应用 MGF1 掩码                                          │
│  6. RSA 私钥操作：s = encoded^d mod n                      │
│  7. 输出签名：s                                            │
│                                                             │
│  参数：                                                      │
│  ├── 哈希函数：SHA-256（推荐）                             │
│  ├── MGF1 哈希：SHA-256                                    │
│  └── 盐长度：32 字节（与 SHA-256 输出等长）                 │
│                                                             │
│  优势：                                                      │
│  ✓ 可证明安全                                               │
│  ✓ 概率签名（增强安全性）                                   │
│  ✓ NIST 推荐                                                │
│  ✓ TLS 1.3 要求                                             │
│                                                             │
│  建议：                                                      │
│  ✓✓ 新系统首选 RSA-PSS                                     │
│  ✗ 避免 PKCS#1 v1.5（除非兼容性要求）                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 代码实现

**Python RSA 签名示例**：

```python
from Crypto.PublicKey import RSA
from Crypto.Signature import pss, pkcs1_15
from Crypto.Hash import SHA256
from Crypto.Random import get_random_bytes

# ============= RSA-PSS 签名 =============
def rsa_pss_sign():
    """RSA-PSS 签名/验签"""
    # 生成密钥对
    key = RSA.generate(2048)
    private_key = key
    public_key = key.publickey()
    
    # 签名
    message = b"Important document to sign"
    h = SHA256.new(message)
    signature = pss.new(private_key).sign(h)
    
    print(f"消息：{message}")
    print(f"签名：{signature.hex()[:64]}...")
    
    # 验签
    try:
        pss.new(public_key).verify(h, signature)
        print("✓ PSS 验签成功")
    except (ValueError, TypeError):
        print("✗ PSS 验签失败")
    
    # 测试篡改检测
    tampered = b"Tampered document"
    h_tampered = SHA256.new(tampered)
    try:
        pss.new(public_key).verify(h_tampered, signature)
        print("✗ 未检测到篡改")
    except (ValueError, TypeError):
        print("✓ 检测到篡改")

# ============= RSA PKCS#1 v1.5 签名 =============
def rsa_pkcs1_sign():
    """RSA PKCS#1 v1.5 签名/验签"""
    # 生成密钥对
    key = RSA.generate(2048)
    private_key = key
    public_key = key.publickey()
    
    # 签名
    message = b"Document with PKCS#1 v1.5 signature"
    h = SHA256.new(message)
    signature = pkcs1_15.new(private_key).sign(h)
    
    print(f"\n消息：{message}")
    print(f"签名：{signature.hex()[:64]}...")
    
    # 验签
    try:
        pkcs1_15.new(public_key).verify(h, signature)
        print("✓ PKCS#1 v1.5 验签成功")
    except (ValueError, TypeError):
        print("✗ PKCS#1 v1.5 验签失败")

if __name__ == "__main__":
    rsa_pss_sign()
    rsa_pkcs1_sign()
```

---

## ECDSA 与 EdDSA

### ECDSA

**ECDSA（椭圆曲线数字签名算法）**：

```
┌─────────────────────────────────────────────────────────────┐
│                  ECDSA 签名                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 基础：椭圆曲线离散对数问题                            │
│  ├── 标准：FIPS 186-4                                      │
│  ├── 曲线：P-256、P-384、secp256k1 等                      │
│  └── 应用：比特币、TLS、SSH                                │
│                                                             │
│  密钥生成：                                                  │
│  1. 选择椭圆曲线参数（p, a, b, G, n, h）                   │
│  2. 选择私钥 d（1 < d < n-1）随机数                        │
│  3. 计算公钥 Q = dG（点乘）                                │
│  4. 公钥：Q                                                │
│  5. 私钥：d                                                │
│                                                             │
│  签名流程：                                                  │
│  1. 计算消息哈希：e = H(m)                                 │
│  2. 选择随机数 k（1 < k < n-1）                            │
│  3. 计算点 (x1, y1) = kG                                   │
│  4. 计算 r = x1 mod n                                      │
│  5. 计算 s = k^(-1)(e + dr) mod n                          │
│  6. 输出签名：(r, s)                                       │
│                                                             │
│  验签流程：                                                  │
│  1. 验证 r, s 在 [1, n-1] 范围内                           │
│  2. 计算 e = H(m)                                          │
│  3. 计算 w = s^(-1) mod n                                  │
│  4. 计算 u1 = ew mod n, u2 = rw mod n                      │
│  5. 计算点 (x1, y1) = u1G + u2Q                            │
│  6. 验证 r == x1 mod n                                     │
│                                                             │
│  安全性注意事项：                                            │
│  ! 随机数 k 必须唯一且保密                                 │
│  ! k 重复使用会泄露私钥（索尼 PS3 漏洞）                   │
│  ! k 必须有足够的随机性                                     │
│                                                             │
│  签名格式：                                                  │
│  ├── DER 编码：0x30 [总长] 0x02 [r 长] r 0x02 [s 长] s     │
│  ├── P1363 编码：r || s（各固定长度）                      │
│  └── 比特币：DER 编码                                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### EdDSA

**EdDSA（Edwards 曲线数字签名算法）**：

```
┌─────────────────────────────────────────────────────────────┐
│                  EdDSA 签名                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 设计者：Daniel J. Bernstein 等（2011 年）             │
│  ├── 曲线：Ed25519（最常用）、Ed448                        │
│  ├── 标准：RFC 8032                                        │
│  └── 特点：确定性签名（无需随机数）                        │
│                                                             │
│  Ed25519 参数：                                              │
│  ├── 曲线：Edwards25519                                    │
│  ├── 安全强度：~128 位                                      │
│  ├── 私钥长度：256 位（32 字节）                            │
│  ├── 公钥长度：256 位（32 字节）                            │
│  └── 签名长度：512 位（64 字节）                            │
│                                                             │
│  签名流程：                                                  │
│  1. 哈希私钥：h = H(private_key)                           │
│  2. 派生 s = h[0:32]（前 32 字节）                          │
│  3. 计算公钥 A = sG                                        │
│  4. 哈希消息：r = H(h[32:64] || message)                   │
│  5. 计算 R = rG                                            │
│  6. 哈希：k = H(R || A || message)                         │
│  7. 计算 S = (r + k*s) mod L                               │
│  8. 输出签名：(R, S)                                       │
│                                                             │
│  优势：                                                      │
│  ✓ 确定性签名（无需随机数，避免 k 重用问题）               │
│  ✓ 抗侧信道攻击                                             │
│  ✓ 高性能（比 ECDSA 快）                                    │
│  ✓ 实现简单                                                 │
│  ✓ 签名短（64 字节）                                        │
│                                                             │
│  应用：                                                      │
│  ├── SSH（Ed25519 密钥）                                   │
│  ├── GPG/PGP                                                │
│  ├── 加密货币（Monero、Cardano 等）                        │
│  └── TLS 1.3（可选）                                        │
│                                                             │
│  建议：                                                      │
│  ✓✓ 新系统首选 Ed25519                                     │
│  ✓ 优于 ECDSA（除非兼容性要求）                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 代码实现

**Python ECDSA/EdDSA 示例**：

```python
from cryptography.hazmat.primitives.asymmetric import ec, ed25519
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.backends import default_backend

# ============= ECDSA 签名 =============
def ecdsa_demo():
    """ECDSA 签名/验签演示"""
    # 生成密钥对（P-256）
    private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
    public_key = private_key.public_key()
    
    # 签名
    message = b"Message signed with ECDSA"
    signature = private_key.sign(message, ec.ECDSA(hashes.SHA256()))
    
    print("=== ECDSA 签名 ===")
    print(f"消息：{message}")
    print(f"签名：{signature.hex()}")
    
    # 验签
    try:
        public_key.verify(signature, message, ec.ECDSA(hashes.SHA256()))
        print("✓ ECDSA 验签成功")
    except Exception as e:
        print(f"✗ ECDSA 验签失败：{e}")
    
    # 测试篡改
    tampered = b"Tampered message"
    try:
        public_key.verify(signature, tampered, ec.ECDSA(hashes.SHA256()))
        print("✗ 未检测到篡改")
    except Exception:
        print("✓ 检测到篡改")

# ============= Ed25519 签名 =============
def ed25519_demo():
    """Ed25519 签名/验签演示"""
    # 生成密钥对
    private_key = ed25519.Ed25519PrivateKey.generate()
    public_key = private_key.public_key()
    
    # 签名
    message = b"Message signed with Ed25519"
    signature = private_key.sign(message)
    
    print("\n=== Ed25519 签名 ===")
    print(f"消息：{message}")
    print(f"签名：{signature.hex()}")
    print(f"签名长度：{len(signature)} 字节")
    
    # 验签
    try:
        public_key.verify(signature, message)
        print("✓ Ed25519 验签成功")
    except Exception as e:
        print(f"✗ Ed25519 验签失败：{e}")
    
    # 测试篡改
    tampered = b"Tampered message"
    try:
        public_key.verify(signature, tampered)
        print("✗ 未检测到篡改")
    except Exception:
        print("✓ 检测到篡改")

# ============= 密钥导出 =============
def key_export_demo():
    """密钥导出演示"""
    # Ed25519
    private_key = ed25519.Ed25519PrivateKey.generate()
    
    # 导出私钥（PEM）
    pem_private = private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    )
    
    # 导出公钥（PEM）
    pem_public = private_key.public_key().public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    
    print("\n=== 密钥导出 ===")
    print(f"私钥 PEM:\n{pem_private.decode()[:100]}...")
    print(f"公钥 PEM:\n{pem_public.decode()[:100]}...")

if __name__ == "__main__":
    ecdsa_demo()
    ed25519_demo()
    key_export_demo()
```

---

## 数字签名应用

### 代码签名

**代码签名应用**：

```
┌─────────────────────────────────────────────────────────────┐
│                  代码签名应用                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  目的：                                                      │
│  ├── 验证软件发布者身份                                     │
│  ├── 确保代码未被篡改                                       │
│  └── 建立用户信任                                           │
│                                                             │
│  平台实现：                                                  │
│  ├── Windows Authenticode                                  │
│  │   - 签名工具：signtool.exe                              │
│  │   - 证书：代码签名证书（CA 颁发）                       │
│  │   - 验证：Windows 自动验证                              │
│  │                                                          │
│  ├── Apple Notarization                                    │
│  │   - 要求：macOS 应用必须公证                            │
│  │   - 流程：签名 → 上传 Apple → 公证 → 下载              │
│  │   - 工具：codesign, notarytool                          │
│  │                                                          │
│  ├── Linux (GPG)                                           │
│  │   - 发行版签名：Debian、Ubuntu 等                       │
│  │   - 工具：gpg --sign                                    │
│  │   - 验证：apt 自动验证                                   │
│  │                                                          │
│  └── Java (JAR 签名)                                        │
│      - 工具：jarsigner                                     │
│      - 验证：Java 自动验证                                  │
│                                                             │
│  最佳实践：                                                  │
│  ✓ 使用 EV 代码签名证书（增强信任）                        │
│  ✓ 时间戳签名（证书过期后仍有效）                          │
│  ✓ 保护私钥（HSM 存储）                                     │
│  ✓ 定期轮换密钥                                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 证书签名

**X.509 证书签名**：

```
┌─────────────────────────────────────────────────────────────┐
│                  X.509 证书签名                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  证书结构：                                                  │
│  ├── 版本号                                                 │
│  ├── 序列号                                                 │
│  ├── 签名算法                                               │
│  ├── 颁发者（Issuer）                                       │
│  ├── 有效期（Validity）                                     │
│  ├── 主体（Subject）                                        │
│  ├── 主体公钥信息                                           │
│  ├── 扩展（Extensions）                                     │
│  └── 颁发者签名                                             │
│                                                             │
│  证书链：                                                    │
│  根 CA → 中间 CA → 终端实体证书                            │
│                                                             │
│  签名过程：                                                  │
│  1. CA 生成证书内容（TBSCertificate）                      │
│  2. CA 计算哈希：H(TBSCertificate)                         │
│  3. CA 私钥签名：Sign(CA_private, hash)                    │
│  4. 签名附加到证书                                          │
│                                                             │
│  验证过程：                                                  │
│  1. 使用 CA 公钥验证签名                                    │
│  2. 验证证书链（到信任根）                                  │
│  3. 检查有效期                                              │
│  4. 检查吊销状态（CRL/OCSP）                               │
│                                                             │
│  签名算法：                                                  │
│  ├── sha256WithRSAEncryption（RSA-SHA256）                │
│  ├── ecdsa-with-SHA256（ECDSA-SHA256）                    │
│  └── ed25519（新兴支持）                                   │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 文档签名

**PDF/Office 文档签名**：

```
┌─────────────────────────────────────────────────────────────┐
│                  文档数字签名                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  PDF 签名：                                                  │
│  ├── 标准：PAdES（PDF Advanced Electronic Signatures）     │
│  ├── 工具：Adobe Acrobat、iText、PyPDF2                    │
│  ├── 签名类型：                                             │
│  │   - 可见签名（带签名域）                                │
│  │   - 不可见签名                                          │
│  │   - 时间戳签名                                          │
│  └── 验证：Adobe Reader 自动验证                           │
│                                                             │
│  Office 文档签名：                                           │
│  ├── 格式：XMLDsig（XML 数字签名）                         │
│  ├── 工具：Microsoft Office                                │
│  ├── 签名显示：签名行                                     │
│  └── 验证：Office 自动验证                                  │
│                                                             │
│  法律效力：                                                  │
│  ├── 电子签名法：多数国家承认                              │
│  ├── 合格电子签名（QES）：欧盟 eIDAS                      │
│  └── 时间戳：确