Day-176-椭圆曲线密码学详解

# Day 191: 椭圆曲线密码学详解

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

---

## 清单 目录

1. [椭圆曲线概述](#椭圆曲线概述)
2. [椭圆曲线数学基础](#椭圆曲线数学基础)
3. [椭圆曲线离散对数问题](#椭圆曲线离散对数问题)
4. [常用椭圆曲线](#常用椭圆曲线)
5. [ECC 密钥生成](#ecc 密钥生成)
6. [ECDH 密钥交换](#ecdh 密钥交换)
7. [ECDSA 数字签名](#ecdsa 数字签名)
8. [EdDSA 签名算法](#eddsa 签名算法)
9. [ECC vs RSA](#ecc-vs-rsa)
10. [实战应用](#实战应用)
11. [安全实践](#安全实践)
12. [总结与思考](#总结与思考)
13. [参考资料](#参考资料)

---

## 椭圆曲线概述

### 什么是椭圆曲线密码学

**椭圆曲线密码学（ECC）定义**：

```
┌─────────────────────────────────────────────────────────────┐
│              椭圆曲线密码学（ECC）                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  定义：                                                      │
│  基于椭圆曲线离散对数问题（ECDLP）的公钥密码体制           │
│                                                             │
│  提出时间：                                                  │
│  ├── 1985 年：Neal Koblitz                                 │
│  └── 1985 年：Victor Miller（独立提出）                    │
│                                                             │
│  核心优势：                                                  │
│  ├── 密钥短：256 位 ECC ≈ 3072 位 RSA                       │
│  ├── 计算快：签名和密钥交换速度更快                        │
│  ├── 带宽低：传输数据量小                                   │
│  └── 资源少：适合移动设备和 IoT                            │
│                                                             │
│  应用领域：                                                  │
│  ├── TLS/SSL：HTTPS 加密                                   │
│  ├── 比特币：ECDSA 签名                                    │
│  ├── SSH：密钥交换和认证                                    │
│  ├── 智能卡：资源受限环境                                   │
│  └── 移动通信：5G 安全                                       │
│                                                             │
│  常见算法：                                                  │
│  ├── ECDH：椭圆曲线 Diffie-Hellman 密钥交换                │
│  ├── ECDSA：椭圆曲线数字签名算法                           │
│  ├── EdDSA：Edwards 曲线数字签名算法                       │
│  └── ECIES：椭圆曲线集成加密方案                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### ECC 发展历史

**ECC 发展历程**：

```
┌─────────────────────────────────────────────────────────────┐
│                  ECC 发展历史                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1985 年：理论提出                                           │
│  ├── Koblitz 和 Miller 独立提出 ECC 概念                    │
│  └── 基于椭圆曲线离散对数问题                              │
│                                                             │
│  1992 年：首个实现                                           │
│  └── Scott Vanstone 等人实现第一个 ECC 系统                │
│                                                             │
│  2000 年：标准化开始                                         │
│  ├── ANSI X9.62：ECDSA 标准                                │
│  ├── ANSI X9.63：ECDH 标准                                 │
│  └── IEEE P1363：公钥密码标准                              │
│                                                             │
│  2005 年：NIST 推荐                                          │
│  └── NIST SP 800-56A：推荐 ECC 用于密钥协商                │
│                                                             │
│  2009 年：比特币采用                                         │
│  └── 比特币使用 secp256k1 曲线和 ECDSA 签名                │
│                                                             │
│  2013 年：EdDSA 提出                                         │
│  └── Daniel Bernstein 等人提出 Ed25519                     │
│                                                             │
│  2017 年：Cloudflare 部署                                    │
│  └── Cloudflare 默认使用 ECC 证书                           │
│                                                             │
│  2020 年：TLS 1.3                                            │
│  └── TLS 1.3 强制支持 ECDHE 密钥交换                        │
│                                                             │
│  现状：                                                      │
│  ├── 主流浏览器：默认支持 ECC                               │
│  ├── 证书机构：大量签发 ECC 证书                            │
│  └── 移动设备：硬件加速支持                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 椭圆曲线数学基础

### 椭圆曲线方程

**Weierstrass 方程**：

```
┌─────────────────────────────────────────────────────────────┐
│              椭圆曲线方程                                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  标准 Weierstrass 方程（特征≠2,3）：                        │
│  y² = x³ + ax + b                                          │
│                                                             │
│  参数要求：                                                  │
│  ├── 4a³ + 27b² ≠ 0（非奇异条件）                          │
│  └── a, b ∈ 有限域 Fp                                       │
│                                                             │
│  示例曲线：                                                  │
│  ├── y² = x³ + 7（比特币 secp256k1）                       │
│  │   └── a = 0, b = 7                                     │
│  │                                                          │
│  └── y² = x³ - 3x + b（NIST P-256）                        │
│      └── a = -3, b 特定值                                  │
│                                                             │
│  曲线上的点：                                                │
│  ├── 满足方程的 (x, y) 坐标对                               │
│  └── 无穷远点 O（单位元）                                   │
│                                                             │
│  有限域上的椭圆曲线：                                        │
│  ├── 定义在 Fp 上（p 为大素数）                             │
│  ├── 点的数量有限                                           │
│  └── 形成有限阿贝尔群                                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 群运算

**椭圆曲线群运算**：

```
┌─────────────────────────────────────────────────────────────┐
│              椭圆曲线群运算                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  点加法（P + Q）：                                           │
│  ├── 几何解释：                                              │
│  │   1. 过 P 和 Q 作直线，交曲线于 R                       │
│  │   2. R 关于 x 轴对称得到 P + Q                          │
│  │                                                          │
│  ├── 代数公式（P ≠ Q）：                                    │
│  │   λ = (yQ - yP) / (xQ - xP) mod p                      │
│  │   xR = λ² - xP - xQ mod p                              │
│  │   yR = λ(xP - xR) - yP mod p                           │
│  │                                                          │
│  └── 代数公式（P = Q，点倍）：                              │
│      λ = (3xP² + a) / (2yP) mod p                         │
│      xR = λ² - 2xP mod p                                  │
│      yR = λ(xP - xR) - yP mod p                           │
│                                                             │
│  群性质：                                                    │
│  ├── 封闭性：P + Q 仍在曲线上                               │
│  ├── 结合律：(P + Q) + R = P + (Q + R)                     │
│  ├── 单位元：P + O = P（O 为无穷远点）                     │
│  ├── 逆元：P + (-P) = O（-P 为 P 关于 x 轴对称点）         │
│  └── 交换律：P + Q = Q + P                                 │
│                                                             │
│  标量乘法（k × P）：                                         │
│  ├── 定义：P + P + ... + P（k 次）                         │
│  ├── 计算：双倍 - 加算法（Double-and-Add）                 │
│  └── 应用：公钥 = 私钥 × 基点                               │
│                                                             │
│  双倍 - 加算法示例：                                         │
│  计算 13 × P：                                               │
│  13 = 1101₂                                                 │
│  ├── 1: Q = P                                               │
│  ├── 1: Q = 2Q = 2P, Q = Q + P = 3P                       │
│  ├── 0: Q = 2Q = 6P                                         │
│  └── 1: Q = 2Q = 12P, Q = Q + P = 13P                     │
│  共 3 次加倍，2 次加法                                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 离散对数问题

**椭圆曲线离散对数问题（ECDLP）**：

```
┌─────────────────────────────────────────────────────────────┐
│          椭圆曲线离散对数问题（ECDLP）                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  问题描述：                                                  │
│  给定：                                                      │
│  ├── 椭圆曲线 E 定义在 Fp 上                                │
│  ├── 基点 G（阶为 n）                                       │
│  ├── 点 P = k × G（k 为整数）                              │
│  │                                                          │
│  求解：                                                      │
│  └── 整数 k（0 ≤ k < n）                                    │
│                                                             │
│  困难性：                                                    │
│  ├── 已知 k 和 G，计算 P = k × G：容易（O(log k)）          │
│  └── 已知 P 和 G，求解 k：困难（O(√n)）                    │
│                                                             │
│  最佳已知算法：                                              │
│  ├── Pollard's Rho：O(√n) 群运算                           │
│  ├── Baby-step Giant-step：O(√n) 时间，O(√n) 空间         │
│  └── 指数积分法：不适用于椭圆曲线                          │
│                                                             │
│  安全参数对比：                                              │
│  │ ECC 密钥大小 │ 安全强度 │ RSA 等效大小 │              │
│  │--------------│----------│--------------│              │
│  │    160 位     │   80 位  │   1024 位     │              │
│  │    256 位     │  128 位  │   3072 位     │              │
│  │    384 位     │  192 位  │   7680 位     │              │
│  │    521 位     │  256 位  │  15360 位     │              │
│                                                             │
│  结论：                                                      │
│  "ECC 以短得多的密钥提供相同的安全性，                      │
│   这是 ECC 最大的优势。"                                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 常用椭圆曲线

### NIST 推荐曲线

**NIST 推荐曲线（Fp 素数域）**：

```
┌─────────────────────────────────────────────────────────────┐
│              NIST 推荐曲线                                  │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  P-192（secp192r1）：                                        │
│  ├── 密钥大小：192 位                                       │
│  ├── 安全强度：80 位                                        │
│  ├── 状态：已不推荐（强度不足）                            │
│  └── 用途：遗留系统                                         │
│                                                             │
│  P-256（secp256r1）：                                        │
│  ├── 密钥大小：256 位                                       │
│  ├── 安全强度：128 位                                       │
│  ├── 状态：广泛使用，推荐                                   │
│  ├── 应用：TLS、JWT、Android 密钥库                        │
│  └── 参数：                                                 │
│      p = 2²⁵⁶ - 2²²⁴ + 2¹⁹² + 2⁹⁶ - 1                     │
│      a = -3                                                 │
│      b = 特定常数                                           │
│                                                             │
│  P-384（secp384r1）：                                        │
│  ├── 密钥大小：384 位                                       │
│  ├── 安全强度：192 位                                       │
│  ├── 状态：推荐用于高安全场景                              │
│  └── 应用：TLS、政府系统                                    │
│                                                             │
│  P-521（secp521r1）：                                        │
│  ├── 密钥大小：521 位                                       │
│  ├── 安全强度：256 位                                       │
│  ├── 状态：推荐用于极高安全场景                            │
│  └── 应用：根证书、长期密钥                                 │
│                                                             │
│  争议：                                                      │
│  ! NIST 曲线参数来源不透明（可能包含后门）                 │
│  ! Dual_EC_DRBG 事件影响信任                               │
│  ✓ 建议使用 Curve25519 等透明参数曲线                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### Curve25519

**Curve25519（现代推荐）**：

```
┌─────────────────────────────────────────────────────────────┐
│              Curve25519                                     │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  设计者：Daniel J. Bernstein（2006 年）                     │
│                                                             │
│  曲线类型：Montgomery 曲线                                   │
│  方程：y² = x³ + 486662x² + x（mod 2²⁵⁵-19）               │
│                                                             │
│  特点：                                                      │
│  ├── 参数透明："nothing up my sleeve"数字                  │
│  ├── 速度快：专为快速实现设计                              │
│  ├── 安全：抵抗侧信道攻击                                   │
│  ├── 简单：易于正确实现                                     │
│  └── 无专利：自由使用                                       │
│                                                             │
│  应用：                                                      │
│  ├── X25519：ECDH 密钥交换                                  │
│  ├── Ed25519：数字签名                                     │
│  ├── SSH：默认密钥交换算法                                  │
│  ├── TLS 1.3：支持的曲线之一                                │
│  ├── Signal 协议：即时通讯加密                              │
│  └── WireGuard：VPN 协议                                    │
│                                                             │
│  性能：                                                      │
│  ├── 密钥交换：<1ms（现代 CPU）                            │
│  ├── 签名：<1ms                                             │
│  └── 验证：<3ms                                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### secp256k1

**secp256k1（比特币曲线）**：

```
┌─────────────────────────────────────────────────────────────┐
│              secp256k1                                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  曲线方程：y² = x³ + 7（mod p）                            │
│                                                             │
│  参数：                                                      │
│  ├── p = 2²⁵⁶ - 2³² - 977（特殊形式素数）                 │
│  ├── a = 0                                                  │
│  ├── b = 7                                                  │
│  └── 基点 G：特定坐标                                       │
│                                                             │
│  特点：                                                      │
│  ├── Koblitz 曲线：特殊形式，计算更快                      │
│  ├── 参数简单：a=0, b=7                                    │
│  └── 无已知弱点：安全使用多年                              │
│                                                             │
│  应用：                                                      │
│  ├── 比特币：地址和交易签名                                │
│  ├── 以太坊：账户和交易签名                                │
│  └── 其他加密货币：广泛采用                                 │
│                                                             │
│  密钥格式：                                                  │
│  ├── 私钥：32 字节（256 位）随机数                          │
│  ├── 公钥：64 字节（未压缩）或 33 字节（压缩）              │
│  └── 地址：RIPEMD160(SHA256(公钥))                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## ECC 密钥生成

### 密钥生成流程

**ECC 密钥对生成**：

```
┌─────────────────────────────────────────────────────────────┐
│              ECC 密钥对生成                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  输入：                                                      │
│  ├── 椭圆曲线参数（p, a, b, G, n, h）                      │
│  └── 安全随机数生成器                                       │
│                                                             │
│  步骤：                                                      │
│  1. 选择私钥 d：                                            │
│     ├── 随机选择整数 d                                     │
│     └── 1 ≤ d ≤ n-1（n 为曲线阶）                         │
│                                                             │
│  2. 计算公钥 Q：                                            │
│     ├── Q = d × G                                          │
│     └── G 为基点，× 为标量乘法                             │
│                                                             │
│  3. 输出：                                                  │
│     ├── 私钥：d（保密）                                    │
│     └── 公钥：Q = (x, y)（公开）                           │
│                                                             │
│  安全要求：                                                  │
│  ├── 私钥必须均匀随机选择                                   │
│  ├── 私钥不能为 0 或 n                                      │
│  ├── 使用 CSPRNG 生成私钥                                   │
│  └── 私钥长度应匹配曲线安全强度                            │
│                                                             │
│  示例（P-256）：                                             │
│  ├── 私钥：32 字节随机数                                    │
│  ├── 公钥：64 字节（x, y 各 32 字节）                      │
│  └── 安全强度：128 位                                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 代码实现

**Python ECC 密钥生成**：

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

# ============= 生成 ECC 密钥对 =============
def generate_ecc_keypair(curve='secp256r1'):
    """生成 ECC 密钥对"""
    
    # 选择曲线
    curves = {
        'secp256r1': ec.SECP256R1(),
        'secp384r1': ec.SECP384R1(),
        'secp521r1': ec.SECP521R1(),
        'secp256k1': ec.SECP256K1(),
    }
    
    if curve not in curves:
        raise ValueError(f"不支持的曲线：{curve}")
    
    # 生成密钥对
    private_key = ec.generate_private_key(
        curves[curve],
        backend=default_backend()
    )
    
    # 获取公钥
    public_key = private_key.public_key()
    
    return private_key, public_key

# ============= 密钥序列化 =============
def serialize_keys(private_key, public_key):
    """序列化密钥"""
    from cryptography.hazmat.primitives import serialization
    
    # 私钥 PEM 格式
    private_pem = private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    )
    
    # 公钥 PEM 格式
    public_pem = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    
    # 私钥 DER 格式（二进制）
    private_der = private_key.private_bytes(
        encoding=serialization.Encoding.DER,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    )
    
    # 公钥 DER 格式（二进制）
    public_der = public_key.public_bytes(
        encoding=serialization.Encoding.DER,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    
    return {
        'private_pem': private_pem,
        'public_pem': public_pem,
        'private_der': private_der,
        'public_der': public_der,
    }

# ============= 密钥加载 =============
def load_private_key(pem_data):
    """加载私钥"""
    from cryptography.hazmat.primitives import serialization
    
    private_key = serialization.load_pem_private_key(
        pem_data,
        password=None,
        backend=default_backend()
    )
    
    return private_key

def load_public_key(pem_data):
    """加载公钥"""
    from cryptography.hazmat.primitives import serialization
    
    public_key = serialization.load_pem_public_key(
        pem_data,
        backend=default_backend()
    )
    
    return public_key

if __name__ == "__main__":
    # 生成密钥对
    private_key, public_key = generate_ecc_keypair('secp256r1')
    
    print("=== ECC 密钥对生成 ===")
    print(f"曲线：secp256r1 (P-256)")
    print(f"私钥大小：{private_key.key_size} 位")
    print(f"公钥大小：{public_key.key_size} 位")
    
    # 序列化
    keys = serialize_keys(private_key, public_key)
    print(f"\n私钥 PEM（前 100 字符）：{keys['private_pem'][:100]}...")
    print(f"公钥 PEM（前 100 字符）：{keys['public_pem'][:100]}...")
```

---

## ECDH 密钥交换

### ECDH 原理

**椭圆曲线 Diffie-Hellman（ECDH）**：

```
┌─────────────────────────────────────────────────────────────┐
│              ECDH 密钥交换                                  │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  参与方：Alice 和 Bob                                        │
│                                                             │
│  公共参数：                                                  │
│  ├── 椭圆曲线 E（如 P-256）                                 │
│  └── 基点 G                                                 │
│                                                             │
│  密钥交换流程：                                              │
│                                                             │
│  Alice                          Bob                         │
│  ─────                          ───                         │
│  1. 生成私钥 a                    │                         │
│     计算公钥 A = a × G            │                         │
│  2. 发送 A ─────────────────────> │                         │
│  3. │ <───────────────────── 生成私钥 b                    │
│     │                        计算公钥 B = b × G            │
│  4. │ <───────────────────── 发送 B                        │
│  5. 计算共享密钥：              │ 计算共享密钥：            │
│     S = a × B = a × b × G       │ S = b × A = b × a × G    │
│                                                             │
│  结果：                                                      │
│  ├── Alice 和 Bob 得到相同的 S                              │
│  ├── S 的 x 坐标作为共享密钥                                │
│  └── 窃听者无法从 A 和 B 计算 S（ECDLP 困难）              │
│                                                             │
│  临时 ECDH（ECDHE）：                                        │
│  ├── 每次会话生成新密钥对                                   │
│  ├── 提供前向安全性                                         │
│  └── TLS 1.3 强制使用 ECDHE                                │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### ECDH 代码实现

**Python ECDH 密钥交换**：

```python
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.kdf.hkdf import HKDF

# ============= Alice 生成密钥对 =============
def alice_generate():
    """Alice 生成密钥对"""
    private_key = ec.generate_private_key(
        ec.SECP256R1(),
        backend=default_backend()
    )
    public_key = private_key.public_key()
    
    # 序列化公钥（发送给 Bob）
    public_pem = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    
    return private_key, public_pem

# ============= Bob 生成密钥对并计算共享密钥 =============
def bob_generate_and_derive(alice_public_pem):
    """Bob 生成密钥对并计算共享密钥"""
    # Bob 生成密钥对
    bob_private = ec.generate_private_key(
        ec.SECP256R1(),
        backend=default_backend()
    )
    
    # 加载 Alice 的公钥
    alice_public = serialization.load_pem_public_key(
        alice_public_pem,
        backend=default_backend()
    )
    
    # 计算共享密钥（ECDH）
    shared_key = bob_private.exchange(ec.ECDH(), alice_public)
    
    # 使用 HKDF 派生最终密钥
    derived_key = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=None,
        info=b"ecdhes",
        backend=default_backend()
    ).derive(shared_key)
    
    return bob_private, derived_key

# ============= Alice 计算共享密钥 =============
def alice_derive(alice_private, bob_public_pem):
    """Alice 计算共享密钥"""
    # 加载 Bob 的公钥
    bob_public = serialization.load_pem_public_key(
        bob_public_pem,
        backend=default_backend()
    )
    
    # 计算共享密钥（ECDH）
    shared_key = alice_private.exchange(ec.ECDH(), bob_public)
    
    # 使用 HKDF 派生最终密钥
    derived_key = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=None,
        info=b"ecdhes",
        backend=default_backend()
    ).derive(shared_key)
    
    return derived_key

if __name__ == "__main__":
    print("=== ECDH 密钥交换演示 ===\n")
    
    # Alice 生成密钥对
    alice_private, alice_public_pem = alice_generate()
    print(f"Alice 公钥（前 50 字符）：{alice_public_pem[:50].decode()}...")
    
    # Bob 生成密钥对并计算共享密钥
    bob_private, bob_shared_key = bob_generate_and_derive(alice_public_pem)
    print(f"Bob 计算的共享密钥：{bob_shared_key.hex()}")
    
    # Bob 发送公钥给 Alice（模拟）
    bob_public_pem = bob_private.public_key().public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    print(f"Bob 公钥（前 50 字符）：{bob_public_pem[:50].decode()}...")
    
    # Alice 计算共享密钥
    alice_shared_key = alice_derive(alice_private, bob_public_pem)
    print(f"Alice 计算的共享密钥：{alice_shared_key.hex()}")
    
    # 验证
    print(f"\n✓ 密钥匹配：{alice_shared_key == bob_shared_key}")
```

---

## ECDSA 数字签名

### ECDSA 原理

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

```
┌─────────────────────────────────────────────────────────────┐
│              ECDSA 数字签名                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  签名生成（私钥持有者）：                                    │
│  ├── 输入：消息 m，私钥 d                                   │
│  ├── 步骤：                                                 │
│  │   1. 计算消息哈希：h = H(m)                             │
│  │   2. 随机选择 k：1 ≤ k < n                              │
│  │   3. 计算点 (x, y) = k × G                              │
│  │   4. 计算 r = x mod n                                   │
│  │   5. 计算 s = k⁻¹(h + d × r) mod n                      │
│  │   6. 如果 r=0 或 s=0，重新选择 k                        │
│  │                                                          │
│  └── 输出：签名 (r, s)                                      │
│                                                             │
│  签名验证（公钥持有者）：                                    │
│  ├── 输入：消息 m，签名 (r, s)，公钥 Q                      │
│  ├── 步骤：                                                 │
│  │   1. 验证 r, s 范围：1 ≤ r, s < n                       │
│  │   2. 计算消息哈希：h = H(m)                             │
│  │   3. 计算 w = s⁻¹ mod n                                 │
│  │   4. 计算 u1 = h × w mod n                              │
│  │   5. 计算 u2 = r × w mod n                              │
│  │   6. 计算点 (x, y) = u1 × G + u2 × Q                    │
│  │   7. 验证 r ≡ x (mod n)                                 │
│  │                                                          │
│  └── 输出：有效/无效                                        │
│                                                             │
│  关键安全要求：                                              │
│  ├── k 必须每次签名随机生成                                 │
│  ├── k 必须保密（泄露 k = 泄露私钥）                       │
│  └── k 不能重复使用（重复使用 = 泄露私钥）                 │
│                                                             │
│  历史教训：                                                  │
│  ├── 2010 年：Android Bitcoin 钱包                         │
│  │   └── k 重复使用，私钥泄露，损失比特币                  │
│  │                                                          │
│  └── 2011 年：Sony PS3 签名                                │
│      └── k 固定不变，私钥被破解                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### ECDSA 代码实现

**Python ECDSA 签名**：

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

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

# ============= 签名 =============
def sign_message(private_key, message):
    """使用 ECDSA 签名消息"""
    from cryptography.hazmat.primitives.asymmetric.utils import encode_dss_signature
    
    # 确保消息是字节
    if isinstance(message, str):
        message = message.encode('utf-8')
    
    # 签名
    signature = private_key.sign(
        message,
        ec.ECDSA(hashes.SHA256())
    )
    
    return signature

# ============= 验证 =============
def verify_signature(public_key, message, signature):
    """验证 ECDSA 签名"""
    try:
        # 确保消息是字节
        if isinstance(message, str):
            message = message.encode('utf-8')
        
        # 验证
        public_key.verify(
            signature,
            message,
            ec.ECDSA(hashes.SHA256())
        )
        return True
    except Exception as e:
        print(f"验证失败：{e}")
        return False

# ============= 签名格式转换 =============
def signature_to_der(signature):
    """将签名转换为 DER 格式"""
    # cryptography 库默认返回 DER 格式
    return signature

def signature_to_pem(signature):
    """将签名转换为 PEM 格式"""
    import base64
    
    der = signature_to_der(signature)
    b64 = base64.b64encode(der).decode()
    
    pem = "-----BEGIN SIGNATURE-----\n"
    for i in range(0, len(b64), 64):
        pem += b64[i:i+64] + "\n"
    pem += "-----END SIGNATURE-----\n"
    
    return pem

if __name__ == "__main__":
    print("=== ECDSA 签名演示 ===\n")
    
    # 生成密钥对
    private_key, public_key = generate_keypair()
    print(f"曲线：secp256r1 (P-256)")
    print(f"密钥大小：{private_key.key_size} 位\n")
    
    # 消息
    message = "Hello, ECC World!"
    print(f"原始消息：{message}")
    
    # 签名
    signature = sign_message(private_key, message)
    print(f"签名长度：{len(signature)} 字节")
    print(f"签名（hex）：{signature[:32].hex()}...")
    
    # 验证（正确消息）
    is_valid = verify_signature(public_key, message, signature)
    print(f"\n✓ 验证结果（正确消息）：{'有效' if is_valid else '无效'}")
    
    # 验证（篡改消息）
    tampered_message = "Hello, ECC World!"  # 故意修改
    is_valid = verify_signature(public_key, tampered_message, signature)
    print(f"✓ 验证结果（篡改消息）：{'有效' if is_valid else '无效'}")
```

---

## EdDSA 签名算法

### EdDSA 原理

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

```
┌─────────────────────────────────────────────────────────────┐
│              EdDSA 签名算法                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  设计者：Daniel J. Bernstein 等人（2011 年）                │
│                                                             │
│  曲线：Edwards 曲线（如 Ed25519）                           │
│  方程：x² + y² = 1 + d·x²·y²（mod p）                      │
│                                                             │
│  特点：                                                      │
│  ├── 确定性：不需要随机数 k（避免 ECDSA 的 k 问题）        │
│  ├── 快速：专为速度优化                                     │
│  ├── 安全：抵抗侧信道攻击                                   │
│  ├── 简单：易于正确实现                                     │
│  └── 紧凑：签名固定 64 字节                                 │
│                                                             │
│  Ed25519 参数：                                              │
│  ├── 曲线：Curve25519 的 Edwards 形式                       │
│  ├── 密钥大小：32 字节（256 位）                            │
│  ├── 签名大小：64 字节                                      │
│  ├── 安全强度：128 位                                       │
│  └── 性能：<1ms 签名，<3ms 验证                             │
│                                                             │
│  签名流程（简化）：                                          │
│  ├── 1. 哈希私钥得到前缀和后缀                              │
│  ├── 2. 计算 r = H(前缀 || 消息)                            │
│  ├── 3. 计算 R = r × G                                      │
│  ├── 4. 计算 k = H(R || 公钥 || 消息)                       │
│  └── 5. 计算 s = (r + k × 私钥) mod n                       │
│  签名 = (R, s)                                              │
│                                                             │
│  应用：                                                      │
│  ├── SSH：Ed25519 密钥                                      │
│  ├── GPG：Ed25519 签名                                      │
│  ├── TLS 1.3：Ed25519 证书                                  │
│  ├── Signal：消息签名                                       │
│  └── 区块链：多种加密货币采用                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### EdDSA 代码实现

**Python EdDSA 签名**：

```python
from cryptography.hazmat.primitives.asymmetric.ed25519 import (
    Ed25519PrivateKey,
    Ed25519PublicKey
)
from cryptography.hazmat.primitives import serialization

# ============= 生成密钥对 =============
def generate_ed25519_keypair():
    """生成 Ed25519 密钥对"""
    private_key = Ed25519PrivateKey.generate()
    public_key = private_key.public_key()
    return private_key, public_key

# ============= 签名 =============
def sign_ed25519(private_key, message):
    """使用 Ed25519 签名消息"""
    if isinstance(message, str):
        message = message.encode('utf-8')
    
    signature = private_key.sign(message)
    return signature

# ============= 验证 =============
def verify_ed25519(public_key, message, signature):
    """验证 Ed25519 签名"""
    try:
        if isinstance(message, str):
            message = message.encode('utf-8')
        
        public_key.verify(signature, message)
        return True
    except Exception as e:
        print(f"验证失败：{e}")
        return False

# ============= 密钥序列化 =============
def serialize_ed25519(private_key, public_key):
    """序列化 Ed25519 密钥"""
    # 私钥 PEM
    private_pem = private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    )
    
    # 公钥 PEM
    public_pem = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    
    # 私钥原始字节（32 字节）
    private_bytes = private_key.private_bytes(
        encoding=serialization.Encoding.Raw,
        format=serialization.PrivateFormat.Raw,
        encryption_algorithm=serialization.NoEncryption()
    )
    
    # 公钥原始字节（32 字节）
    public_bytes = public_key.public_bytes(
        encoding=serialization.Encoding.Raw,
        format=serialization.PublicFormat.Raw,
        encryption_algorithm=serialization.NoEncryption()
    )
    
    return {
        'private_pem': private_pem,
        'public_pem': public_pem,
        'private_raw': private_bytes,
        'public_raw': public_bytes,
    }

if __name__ == "__main__":
    print("=== Ed25519 签名演示 ===\n")
    
    # 生成密钥对
    private_key, public_key = generate_ed25519_keypair()
    print(f"算法：Ed25519")
    print(f"密钥大小：256 位")
    print(f"签名大小：64 字节（固定）\n")
    
    # 消息
    message = "Hello, Ed25519!"
    print(f"原始消息：{message}")
    
    # 签名
    signature = sign_ed25519(private_key, message)
    print(f"签名长度：{len(signature)} 字节")
    print(f"签名（hex）：{signature[:32].hex()}...")
    
    # 验证（正确消息）
    is_valid = verify_ed25519(public_key, message, signature)
    print(f"\n✓ 验证结果（正确消息）：{'有效' if is_valid else '无效'}")
    
    # 验证（篡改消息）
    tampered_message = "Hello, Ed25519!"  # 故意修改
    is_valid = verify_ed25519(public_key, tampered_message, signature)
    print(f"✓ 验证结果（篡改消息）：{'有效' if is_valid else '无效'}")
    
    # 序列化
    keys = serialize_ed25519(private_key, public_key)
    print(f"\n私钥原始字节：{keys['private_raw'].hex()}")
    print(f"公钥原始字节：{keys['public_raw'].hex()}")
```

---

## ECC vs RSA

### 性能对比

**ECC 与 RSA 对比**：

```
┌─────────────────────────────────────────────────────────────┐
│              ECC vs RSA 对比                                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  安全强度对比：                                              │
│  ┌──────────────┬────────────┬─────────────┐               │
│  │ ECC 密钥大小  │ 安全强度   │ RSA 等效大小 │               │
│  ├──────────────┼────────────┼─────────────┤               │
│  │    160 位    │   80 位    │   1024 位    │               │
│  │    224 位    │  112 位    │   2048 位    │               │
│  │    256 位    │  128 位    │   3072 位    │               │
│  │    384 位    │  192 位    │   7680 位    │               │
│  │    521 位    │  256 位    │  15360 位    │               │
│  └──────────────┴────────────┴─────────────┘               │
│                                                             │
│  性能对比（相对速度，RSA-2048=1）：                          │
│  ┌────────────────┬─────────────┬──────────────┐           │
│  │     操作       │  RSA-2048   │  ECC P-256   │           │
│  ├────────────────┼─────────────┼──────────────┤           │
│  │ 密钥生成       │     1x      │     5x       │           │
│  │ 签名           │     1x      │    20x       │           │
│  │ 验证           │     1x      │     0.5x     │           │
│  │ 密钥交换       │     1x      │    10x       │           │
│  │ 密钥大小       │  2048 位    │   256 位     │           │
│  │ 签名大小       │  2048 位    │   512 位     │           │
│  └────────────────┴─────────────┴──────────────┘           │
│                                                             │
│  资源消耗对比：                                              │
│  ├── CPU：ECC 计算量更小                                    │
│  ├── 内存：ECC 占用更少                                     │
│  ├── 带宽：ECC 传输数据更少                                 │
│  └── 存储：ECC 密钥和签名更小                               │
│                                                             │
│  适用场景：                                                  │
│  ├── ECC 优势场景：                                         │
│  │   - 移动设备（电池有限）                                │
│  │   - IoT 设备（计算能力弱）                               │
│  │   - 高并发服务器（性能要求高）                          │
│  │   - 低带宽网络（卫星、移动网络）                        │
│  │   - 实时通信（延迟敏感）                                │
│  │                                                          │
│  └── RSA 优势场景：                                         │
│      - 遗留系统兼容                                         │
│      - 需要加密（ECC 加密方案复杂）                        │
│      - 硬件已优化（HSM 支持 RSA）                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 选择建议

**算法选择建议**：

```
┌─────────────────────────────────────────────────────────────┐
│              算法选择建议                                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  推荐选择 ECC 的场景：                                       │
│  ✓ 新项目默认选择                                           │
│  ✓ 移动应用                                                 │
│  ✓ IoT 设备                                                 │
│  ✓ TLS/SSL 证书                                             │
│  ✓ 密钥交换（ECDHE）                                       │
│  ✓ 数字签名（ECDSA/EdDSA）                                 │
│  ✓ 区块链/加密货币                                          │
│  ✓ 即时通讯（Signal 协议）                                 │
│                                                             │
│  仍使用 RSA 的场景：                                         │
│  ! 遗留系统兼容                                             │
│  ! 需要加密功能（ECIES 复杂）                              │
│  ! 特定硬件要求（HSM 只支持 RSA）                          │
│  ! 法规要求（某些行业指定 RSA）                            │
│                                                             │
│  曲线选择：                                                  │
│  ├── 通用场景：P-256（secp256r1）                          │
│  ├── 高安全场景：P-384（secp384r1）                        │
│  ├── 现代推荐：Curve25519 / Ed25519                        │
│  ├── 区块链：secp256k1                                      │
│  └── 避免使用：P-192（强度不足）                           │
│                                                             │
│  迁移建议：                                                  │
│  ├── 评估现有系统 RSA 密钥大小                              │
│  ├── RSA-1024：立即迁移至 ECC                              │
│  ├── RSA-2048：计划迁移至 ECC                              │
│  └── RSA-4096：可继续使用，考虑迁移至 ECC                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 实战应用

### TLS 中的 ECC

**TLS 1.3 中的 ECC**：

```python
# TLS 1.3 强制使用 ECDHE 密钥交换
# 以下为 OpenSSL 配置示例

from cryptography import x509
from cryptography.x509.oid import NameOID
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.backends import default_backend
from datetime import datetime, timedelta

# ============= 生成 ECC 证书 =============
def generate_ecc_certificate():
    """生成 ECC 证书"""
    
    # 生成 ECC 密钥对
    private_key = ec.generate_private_key(
        ec.SECP256R1(),
        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, "Example Corp"),
        x509.NameAttribute(NameOID.COMMON_NAME, "example.com"),
    ])
    
    # 创建证书
    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("example.com"),
            x509.DNSName("www.example.com"),
        ]),
        critical=False,
    ).sign(private_key, hashes.SHA256(), default_backend())
    
    return private_key, cert

if __name__ == "__main__":
    print("=== 生成 ECC 证书 ===")
    private_key, cert = generate_ecc_certificate()
    
    print(f"曲线：secp256r1")
    print(f"证书主题：{cert.subject}")
    print(f"有效期：{cert.not_valid_before} 至 {cert.not_valid_after}")
    print(f"签名算法：{cert.signature_algorithm_oid._name}")
```

### SSH 中的 Ed25519

**SSH Ed25519 密钥**：

```bash
# ============= 生成 Ed25519 SSH 密钥 =============
# 命令：
ssh-keygen -t ed25519 -C "your_email@example.com"

# 输出：
# Generating public/private ed25519 key pair.
# Enter file in which to save the key (/home/user/.ssh/id_ed25519):
# Enter passphrase (empty for no passphrase):
# Enter same passphrase again:
# Your identification has been saved in /home/user/.ssh/id_ed25519
# Your public key has been saved in /home/user/.ssh/id_ed25519.pub

# ============= 查看密钥 =============
# 私钥：
cat ~/.ssh/id_ed25519
# -----BEGIN OPENSSH PRIVATE KEY-----
# b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
# QyNTUxOQAAACB...

# 公钥：
cat ~/.ssh/id_ed25519.pub
# ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI... your_email@example.com

# ============= 添加到 SSH 代理 =============
ssh-add ~/.ssh/id_ed25519

# ============= 复制到服务器 =============
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server

# ============= SSH 配置（强制使用 Ed25519） =============
# /etc/ssh/sshd_config：
# PubkeyAcceptedKeyTypes ssh-ed25519
# HostKeyAlgorithms ssh-ed25519
```

---

## 安全实践

### 最佳实践

```
┌─────────────────────────────────────────────────────────────┐
│              ECC 安全实践                                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  应该做的：                                                  │
│  ✓ 使用现代曲线（Curve25519、Ed25519、P-256）              │
│  ✓ 使用临时密钥（ECDHE）提供前向安全性                     │
│  ✓ 使用 EdDSA 代替 ECDSA（确定性签名）                     │
│  ✓ 验证公钥（防止中间人攻击）                              │
│  ✓ 使用 HKDF 派生密钥                                       │
│  ✓ 定期轮换密钥                                             │
│  ✓ 安全存储私钥（HSM、密钥库）                             │
│                                                             │
│  不应该做的：                                                │
│  ✗ 使用弱曲线（P-192、secp160r1）                          │
│  ✗ 使用静态 ECDH（无前向安全性）                           │
│  ✗ 重复使用随机数 k（ECDSA）                               │
│  ✗ 自己实现椭圆曲线运算（使用成熟库）                      │
│  ✗ 使用有争议的曲线（Dual_EC_DRBG 相关）                   │
│  ✗ 明文传输私钥                                             │
│                                                             │
│  库选择：                                                    │
│  ├── Python：cryptography、PyNaCl                          │
│  ├── Java：Bouncy Castle、Tink                             │
│  ├── C/C++：libsodium、OpenSSL                             │
│  ├── Go：crypto/elliptic、ed25519                          │
│  └── Node.js：crypto 模块、tweetnacl                       │
│                                                             │
│  实现注意事项：                                              │
│  ├── 使用常数时间比较（防止时序攻击）                      │
│  ├── 清除敏感数据（私钥、随机数）                          │
│  ├── 验证输入（点是否在曲线上）                            │
│  └── 使用经过审计的库                                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 常见错误

**ECC 使用错误**：

```python
# ============= 错误 1：使用弱曲线 =============
# ✗ 错误：
from cryptography.hazmat.primitives.asymmetric import ec
private_key = ec.generate_private_key(ec.SECT163R2(), backend)  # 163 位，弱！

# ✓ 正确：
private_key = ec.generate_private_key(ec.SECP256R1(), backend)  # 256 位

# ============= 错误 2：ECDSA 重复使用 k =============
# ✗ 错误：手动实现 ECDSA 且 k 不随机
# 后果：私钥可被计算出来

# ✓ 正确：使用库函数，自动处理 k
signature = private_key.sign(message, ec.ECDSA(hashes.SHA256()))

# ============= 错误 3：不验证公钥 =============
# ✗ 错误：直接使用对方公钥
shared_key = private_key.exchange(ec.ECDH(), unverified_public_key)

# ✓ 正确：验证公钥在曲线上
from cryptography.hazmat.primitives.asymmetric.ec import (
    derive_private_key,
    EllipticCurvePublicNumbers
)
# 库会自动验证，但应用层也应验证身份

# ============= 错误 4：静态 ECDH =============
# ✗ 错误：长期使用同一密钥对
static_private = load_static_private_key()
shared_key = static_private.exchange(ec.ECDH(), peer_public)

# ✓ 正确：每次会话生成新密钥对（ECDHE）
ephemeral_private = ec.generate_private_key(ec.SECP256R1())
shared_key = ephemeral_private.exchange(ec.ECDH(), peer_public)
# 会话结束后删除 ephemeral_private

# ============= 错误 5：自己实现曲线运算 =============
# ✗ 错误：自己写点加法、标量乘法
# 风险：侧信道攻击、实现错误

# ✓ 正确：使用成熟库
from cryptography.hazmat.primitives.asymmetric import ec
# 库经过严格测试和审计
```

---

## 总结与思考

### 核心要点回顾

**ECC 知识框架**：

```
┌─────────────────────────────────────────────────────────────┐
│                  ECC 知识框架                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  数学基础：                                                  │
│  ├── 椭圆曲线方程：y² = x³ + ax + b                        │
│  ├── 群运算：点加法、标量乘法                              │
│  └── ECDLP：离散对数问题（安全基础）                       │
│                                                             │
│  常用曲线：                                                  │
│  ├── NIST 曲线：P-256、P-384、P-521                        │
│  ├── Curve25519：现代推荐                                  │
│  └── secp256k1：比特币曲线                                 │
│                                                             │
│  核心算法：                                                  │
│  ├── ECDH：密钥交换                                         │
│  ├── ECDSA：数字签名                                        │
│  └── EdDSA：改进签名（确定性）                             │
│                                                             │
│  优势对比：                                                  │
│  ├── 密钥短：256 位 ECC ≈ 3072 位 RSA                       │
│  ├── 计算快：签名和密钥交换更快                            │
│  └── 资源少：适合移动和 IoT                                 │
│                                                             │
│  安全实践：                                                  │
│  ├── 使用现代曲线（Curve25519、Ed25519）                   │
│  ├── 使用 ECDHE（前向安全性）                              │
│  └── 使用成熟库（不自己实现）                              │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 深入思考

**1. 为什么 ECC 没有被更早采用？**

- 专利问题：早期 ECC 专利限制了应用
- 实现复杂：比 RSA 更难正确实现
- 信任问题：NIST 曲线参数来源不透明
- 现状：专利过期，Curve25519 等透明曲线出现

**2. ECC 会被量子计算破解吗？**

- 会：Shor 算法可以在量子计算机上破解 ECC
- 时间：需要数千量子比特，目前技术达不到
- 应对：后量子密码学（PQC）正在标准化
- NIST PQC：CRYSTALS-Kyber（密钥交换）、CRYSTALS-Dilithium（签名）

**3. 应该选择哪条曲线？**

- 通用场景：P-256（广泛支持）
- 新项目：Curve25519 / Ed25519（现代、快速、透明）
- 区块链：secp256k1（生态兼容）
- 高安全：P-384 或 P-521

---

## 参考资料

### 标准与规范

```
- NIST SP 800-56A：密钥协商建议
- NIST FIPS 186-4：数字签名标准（ECDSA）
- RFC 8410：Ed25519 和 Ed448 算法
- RFC 8446：TLS 1.3（强制 ECDHE）
- SEC 2：推荐椭圆曲线参数
```

### 工具与库

```
Python:
- cryptography: 现代密码学库
- PyNaCl: NaCl 的 Python 绑定（Ed25519）
- ecdsa: 纯 Python ECDSA 实现

OpenSSL:
- openssl genpkey -algorithm EC
- openssl ecparam -list_curves

SSH:
- ssh-keygen -t ed25519
```

### 学习资源

```
- 《Serious Cryptography》- Jean-Philippe Aumasson
- 《Guide to Elliptic Curve Cryptography》- Hankerson 等
- SafeCurves：https://safecurves.cr.yp.to/
- Daniel J. Bernstein 的 Ed25519 论文
```

### 在线工具

```
- Elliptic Curve Calculator: https://www.dcode.fr/elliptic-curves
- Curve25519 在线演示：https://ed25519.cr.yp.to/
```

---

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

> ECC 以短密钥提供高安全性，是现代密码学的首选。

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

---

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

*密码学系列 11/30 完成！*