SM2 确定性签名实战：RFC 6979 防御 k 值重用攻击的完整方案

步骤 1：计算 v 和 k 初始值
  v = 0x01 × hash_length     // 字节数组，全 0x01
  k = 0x00 × hash_length     // 字节数组，全 0x00

步骤 2：计算 K 值
  K = HMAC_K(v || 0x00 || private_key || hash(message))
  v = HMAC_K(v)
  
  如果 K >= order，回到步骤 2（重试）

步骤 3：计算最终 k 值
  K = HMAC_K(v || 0x01 || private_key || hash(message))
  v = HMAC_K(v)
  
  如果 K >= order，回到步骤 3（重试）

结果：k = K

import hashlib
import hmac
import struct

def generate_k_rfc6979(private_key: int, message_hash: bytes, curve_order: int) -> int:
    """
    RFC 6979 确定性 k 值生成器（针对 SM2/SECP256R1）
    
    Args:
        private_key: 私钥整数
        message_hash: 消息哈希（已截断到曲线位宽）
        curve_order: 曲线阶 n
    
    Returns:
        确定性 k 值（1 <= k < order）
    """
    hash_len = len(message_hash)  # SM3: 32 bytes, SHA-256: 32 bytes
    
    # 步骤 1：初始化 v 和 k
    v = b'\x01' * hash_len
    k = b'\x00' * hash_len
    private_key_bytes = _int_to_fixed_bytes(private_key, hash_len)
    curve_order_bytes = _int_to_fixed_bytes(curve_order, hash_len)
    
    # 步骤 2：第一次 K 计算
    k = hmac.new(k, v + b'\x00' + private_key_bytes + message_hash, 
                  hashlib.sha256).digest()
    v = hmac.new(v, k, hashlib.sha256).digest()
    
    # 步骤 3：第二次 K 计算（真正的 k 值）
    k = hmac.new(k, v + b'\x01' + private_key_bytes + message_hash, 
                  hashlib.sha256).digest()
    v = hmac.new(v, k, hashlib.sha256).digest()
    
    # 转换为整数并检查范围
    k_int = int.from_bytes(k, 'big')
    
    # 如果 k >= order，重试（极低概率）
    while k_int >= curve_order:
        k = hmac.new(k, v + b'\x00' + private_key_bytes + message_hash, 
                     hashlib.sha256).digest()
        v = hmac.new(v, k, hashlib.sha256).digest()
        k_int = int.from_bytes(k, 'big')
    
    return k_int

def _int_to_fixed_bytes(n: int, length: int) -> bytes:
    """将整数转换为固定长度字节（大端序，前导零填充）"""
    return n.to_bytes(length, 'big')

from gmssl import sm2, func, sm3
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend
import hashlib
import hmac

class RFC6979SM2Signer:
    """基于 RFC 6979 的 SM2 确定性签名实现"""
    
    # SM2 曲线参数（GM/T 0003.5-2012）
    CURVE_ORDER = 0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21B63EE400000000FFFFFFFC
    
    def __init__(self, private_key_hex: str):
        """
        Args:
            private_key_hex: 32 字节私钥的十六进制字符串
        """
        self.priv_key = int(private_key_hex, 16)
        self.pub_key = sm2.CryptSM2().public_key(private_key_hex)
    
    def _hash_message(self, message: bytes) -> bytes:
        """计算 SM3 哈希（含 ZA 预处理）"""
        # ZA 计算（简化版，完整实现需传入用户 ID 和曲线参数）
        # 实际项目中应从证书提取 ZA
        entl = len("user_id".encode('utf-8')) * 8
        za = sm3.sm3_za("user_id".encode('utf-8'), 
                       self.pub_key[:64],  # 省略 y 坐标
                       self.pub_key[64:])
        # 完整 ZA 应使用 sm2.CryptSM2()._sm3_z() 方法
        hash_val = sm3.sm3_hash(func.bytes_to_list(message))
        return bytes.fromhex(hash_val)
    
    def sign(self, message: bytes) -> bytes:
        """
        RFC 6979 确定性 SM2 签名
        
        Returns:
            DER 编码的签名 (r, s)
        """
        msg_hash = self._hash_message(message)
        
        # 生成确定性 k 值
        k = self._generate_k_rfc6979(msg_hash)
        
        # 计算 C1 = [k]G
        c1 = self._scalar_multiply(k)
        c1_hex = self._point_to_hex(c1)
        
        # 使用 gmssl 的标准签名（传入确定性 k）
        # 注意：gmssl.sign() 需要原始 hex 数据
        signature = sm2.CryptSM2().sign(
            message.hex(),
            format(k, '064x')  # k 作为 64 字符 hex
        )
        
        return signature
    
    def _generate_k_rfc6979(self, message_hash: bytes) -> int:
        """RFC 6979 确定性 k 值生成"""
        hash_len = len(message_hash)
        
        v = b'\x01' * hash_len
        k = b'\x00' * hash_len
        pk_bytes = self.priv_key.to_bytes(hash_len, 'big')
        order_bytes = self.CURVE_ORDER.to_bytes(hash_len, 'big')
        
        # 第一轮
        k = hmac.new(k, v + b'\x00' + pk_bytes + message_hash, 
                     hashlib.sha256).digest()
        v = hmac.new(v, k, hashlib.sha256).digest()
        
        # 第二轮
        k = hmac.new(k, v + b'\x01' + pk_bytes + message_hash, 
                     hashlib.sha256).digest()
        v = hmac.new(v, k, hashlib.sha256).digest()
        
        k_int = int.from_bytes(k, 'big')
        
        # 如果 k >= order，重试（概率极低）
        while k_int >= self.CURVE_ORDER:
            k = hmac.new(k, v + b'\x00' + pk_bytes + message_hash,
                        hashlib.sha256).digest()
            v = hmac.new(v, k, hashlib.sha256).digest()
            k_int = int.from_bytes(k, 'big')
        
        return k_int
    
    def _scalar_multiply(self, k: int) -> tuple:
        """计算 [k]G，返回 (x, y) 坐标"""
        # 使用 gmssl 的内部点乘方法
        # 注意：gmssl 的 _kg 方法需要内部调用
        from gmssl import ecc
        return ecc.kgc(k, ecc.Gx, ecc.Gy, ecc.p, ecc.n, ecc.a)
    
    def _point_to_hex(self, point: tuple) -> str:
        """点坐标转十六进制字符串"""
        x, y = point
        return f"{x:064x}{y:064x}"
    
    def verify(self, message: bytes, signature: bytes) -> bool:
        """验证签名"""
        return sm2.CryptSM2().verify_with_sm3(signature, message, self.pub_key)

if __name__ == "__main__":
    # 生成密钥对
    priv_key_hex = func.random_hex(32)
    signer = RFC6979SM2Signer(priv_key_hex)
    
    message = b"Test message for RFC 6979 deterministic signing"
    
    # 第一次签名
    sig1 = signer.sign(message)
    
    # 第二次签名（应完全相同）
    sig2 = signer.sign(message)
    
    print(f"Signature 1: {sig1.hex()[:32]}...")
    print(f"Signature 2: {sig2.hex()[:32]}...")
    print(f"Signatures match: {sig1 == sig2}")  # True
    
    # 验证
    assert signer.verify(message, sig1)
    assert signer.verify(message, sig2)
    
    # 不同消息应得到不同签名
    sig3 = signer.sign(b"Different message")
    print(f"Sig1 != Sig3: {sig1 != sig3}")  # True

import time

# 确定性签名 vs 随机签名性能
messages = [b"msg" + i.to_bytes(4, 'big') for i in range(1000)]

# 确定性签名（每次结果相同）
start = time.perf_counter()
for msg in messages:
    sig = signer.sign(msg)
det_time = time.perf_counter() - start

# 随机签名（gmssl 默认）
start = time.perf_counter()
for msg in messages:
    sig = crypt_sm2.sign_with_sm3(msg, priv_key_hex)
rand_time = time.perf_counter() - start

print(f"RFC 6979: {det_time:.3f}s")
print(f"Random:   {rand_time:.3f}s")
print(f"Ratio:    {rand_time/det_time:.2f}x")