4. ECC椭圆曲线密码学

椭圆曲线密码学（Elliptic Curve Cryptography, ECC）是当前公钥密码体系中最具效率优势的分支之一。相比RSA，ECC在提供相同安全强度的前提下，密钥长度更短、计算开销更低。本节从数学定义出发，逐步构建ECC的密钥对生成、加密解密（ECIES）流程，并与RSA进行多维度性能对比。

4.1 椭圆曲线定义与群结构

ECC使用的椭圆曲线并非椭圆函数曲线，而是满足以下Weierstrass标准形式的方程（在有限域 \( \mathbb{F}_p \) 上）：

y² = x³ + ax + b  (mod p)
其中 4a³ + 27b² ≠ 0 (mod p) 保证曲线无奇异点

曲线上所有点（包含一个特殊的无穷远点 \( \mathcal{O} \)）构成一个阿贝尔群。群运算规则如下：

• 单位元：无穷远点 \( \mathcal{O} \)
• 逆元：点 \( P = (x, y) \) 的逆为 \( -P = (x, -y) \)
• 加法规则：过 \( P \) 和 \( Q \) 的直线与曲线交于第三点 \( R' \)，则 \( P + Q = -R' \)
• 标量乘法：\( kP = P + P + \dots + P \)（k次），是ECC的核心困难问题——椭圆曲线离散对数问题（ECDLP）的基础

4.2 ECC密钥对生成

ECC密钥对生成过程简洁高效，主要依赖椭圆曲线域参数的选择。标准曲线（如secp256k1、P-256）已预定义参数，开发者只需生成随机私钥并计算公钥。

# Python 示例：使用 cryptography 库生成 ECC 密钥对
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization

# 使用 NIST P-256 曲线（secp256r1）
private_key = ec.generate_private_key(ec.SECP256R1())
public_key = private_key.public_key()

# 导出私钥（PEM 格式，加密保护）
private_pem = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.BestAvailableEncryption(b"strong_password")
)

# 导出公钥（PEM 格式）
public_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)

print("私钥长度:", len(private_pem), "字节")
print("公钥长度:", len(public_pem), "字节")
# 输出示例：私钥约 302 字节，公钥约 91 字节（PEM 编码后）

4.3 ECC加密与解密（ECIES）

椭圆曲线集成加密方案（Elliptic Curve Integrated Encryption Scheme, ECIES）是ECC的标准混合加密框架。它结合了公钥密钥交换与对称加密，兼具安全性与效率。

ECIES加密流程

1. 临时密钥对：发送方生成临时私钥 \( r \) 和临时公钥 \( R = rG \)
2. 共享秘密：计算 \( S = rQ_{recipient} \)（使用接收方公钥）
3. 密钥派生：通过KDF（如HKDF）从 \( S \) 派生对称密钥 \( k_{enc} \) 和 \( k_{mac} \)
4. 对称加密：使用 \( k_{enc} \) 加密明文 \( M \) 得到密文 \( C \)
5. 认证标签：使用 \( k_{mac} \) 计算 \( C \) 的MAC标签 \( T \)
6. 输出：\( (R, C, T) \) 发送给接收方

ECIES解密流程

1. 共享秘密：接收方使用私钥 \( d \) 计算 \( S = dR \)
2. 密钥派生：使用相同KDF从 \( S \) 派生 \( k_{enc} \) 和 \( k_{mac} \)
3. 验证MAC：重新计算 \( T' \)，与接收到的 \( T \) 比较；不匹配则拒绝
4. 对称解密：使用 \( k_{enc} \) 解密密文 \( C \) 得到明文 \( M \)

# Python 示例：ECIES 加密与解密（使用 cryptography 库）
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
import os

# 接收方生成密钥对
bob_private = ec.generate_private_key(ec.SECP256R1())
bob_public = bob_private.public_key()

# 发送方加密
def ecies_encrypt(public_key, plaintext: bytes):
    # 临时密钥
    ephemeral_private = ec.generate_private_key(ec.SECP256R1())
    ephemeral_public = ephemeral_private.public_key()
    # 共享秘密
    shared_secret = ephemeral_private.exchange(ec.ECDH(), public_key)
    # KDF 派生密钥
    derived_key = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=None,
        info=b'ecies-encryption'
    ).derive(shared_secret)
    # 对称加密（AES-GCM）
    nonce = os.urandom(12)
    cipher = Cipher(algorithms.AES(derived_key), modes.GCM(nonce))
    encryptor = cipher.encryptor()
    ciphertext = encryptor.update(plaintext) + encryptor.finalize()
    return ephemeral_public, nonce, ciphertext, encryptor.tag

# 接收方解密
def ecies_decrypt(private_key, ephemeral_public, nonce, ciphertext, tag):
    shared_secret = private_key.exchange(ec.ECDH(), ephemeral_public)
    derived_key = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=None,
        info=b'ecies-encryption'
    ).derive(shared_secret)
    cipher = Cipher(algorithms.AES(derived_key), modes.GCM(nonce, tag))
    decryptor = cipher.decryptor()
    return decryptor.update(ciphertext) + decryptor.finalize()

# 测试
msg = b"ECC ECIES 加密通信测试"
epub, nonce, ct, tag = ecies_encrypt(bob_public, msg)
decrypted = ecies_decrypt(bob_private, epub, nonce, ct, tag)
print("解密结果:", decrypted.decode())

4.4 ECC与RSA性能对比

ECC与RSA在安全强度、密钥长度、计算效率、带宽占用等方面存在显著差异。以下表格基于NIST推荐的等效安全等级进行对比。

性能基准测试（Python 示例）

# 简单性能对比：ECC vs RSA 签名
import time
from cryptography.hazmat.primitives.asymmetric import ec, rsa, padding
from cryptography.hazmat.primitives import hashes

# ECC 密钥
ecc_private = ec.generate_private_key(ec.SECP256R1())
# RSA 密钥（3072位）
rsa_private = rsa.generate_private_key(public_exponent=65537, key_size=3072)

msg = b"性能测试消息" * 100

# ECC 签名
start = time.perf_counter()
for _ in range(1000):
    sig = ecc_private.sign(msg, ec.ECDSA(hashes.SHA256()))
ecc_sign_time = (time.perf_counter() - start) / 1000

# RSA 签名
start = time.perf_counter()
for _ in range(1000):
    sig = rsa_private.sign(msg, padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=32), hashes.SHA256())
rsa_sign_time = (time.perf_counter() - start) / 1000

print(f"ECC 签名平均耗时: {ecc_sign_time*1000:.2f} ms")
print(f"RSA 签名平均耗时: {rsa_sign_time*1000:.2f} ms")
print(f"ECC 比 RSA 快约 {rsa_sign_time/ecc_sign_time:.1f} 倍")