SM2 密钥交换协议实战：从零搭建 SM2-KEM 密钥协商系统

实践教程 · 2026-10-19 · 11 阅读

前言

在国密改造中，SM2 密钥交换协议是最常被"略过"的组件——大多数开发者会用 GmSSL 或 Tongsuo 库直接调用接口，很少深入理解协议细节。但当你要实现跨系统互操作、或者对接不支持国密库的旧系统时，就会遇到一系列坑：

临时密钥对格式不匹配（有前缀 vs 无前缀）
ZA 值计算错误（比特长度 vs 字节长度）
共享密钥派生结果不一致
密钥确认失败导致握手卡死

本文从零实现完整的 SM2 密钥交换协议，涵盖 GM/T 0003.3-2012 定义的双向认证流程和密钥确认机制。代码完全基于 gmssl 库，可运行验证。

一、SM2 密钥交换协议概述

1.1 协议参与方与角色

SM2 密钥交换需要两个参与方：发起方 A 和 响应方 B。两者对称，任何一方可作为发起方。

角色	符号	持有密钥
发起方	A	长期签名私钥 $d_A$，长期加密私钥 $e_A$，临时私钥 $r_A$
响应方	B	长期签名私钥 $d_B$，长期加密私钥 $e_B$，临时私钥 $r_B$

关键点：SM2 要求签名密钥和加密密钥分离（双证书体系），因此每个实体拥有两对长期密钥。

1.2 协议流程

CODE

步骤 1: A → B    RA = [rA]G                     // A 生成临时密钥对
步骤 2: B → A    RB = [rB]G                     // B 生成临时密钥对
步骤 3: A        VA = [[h·tA](RB + [x2B]G))      // A 计算 V_A
步骤 4: B        UB = [[h·tB](RA + [x1A]G))      // B 计算 V_B
步骤 5: A → B    KA = KDF(VA || IDB || IDA)     // A 派生会话密钥
步骤 6: B → A    KB = KDF(UB || IDA || IDB)     // B 派生会话密钥
步骤 7: A → B    MAC(KA, RA || IDA)             // A 发送 MAC 给 B
步骤 8: B → A    MAC(KB, RB || IDB)             // B 发送 MAC 给 A

1.3 ZA 值计算

ZA 是身份杂凑值，用于绑定参与者身份：

CODE

ZA = SM3(ENTL || ID || a || b || xG || yG || xA || yA)

其中：

$ENTL$：ID 的比特长度，2 字节大端序
$ID$：用户标识符（ASCII 字符串）
$a, b$：椭圆曲线参数（各 32 字节）
$(x_G, y_G)$：基点 G 的坐标
$(x_A, y_A)$：用户公钥坐标

二、环境准备与依赖

2.1 依赖安装

BASH

pip install gmssl>=3.2.2

验证安装：

PYTHON

from gmssl import sm2, sm3, func
from gmssl.sm2 import default_ecc_table
import random
print("gmssl 加载成功")

2.2 曲线参数

SM2 曲线参数定义在 GM/T 0003.5-2012 中：

PYTHON

# SM2 曲线参数 (GM/T 0003.5-2012 附录 A)
P = 0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF
A = 0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC
B = 0x28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93
Gx = 0x32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7
Gy = 0xBC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0
N = 0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123

三、核心实现

3.1 ZA 值计算函数

PYTHON

def calc_za(user_id: str, public_key: tuple) -> bytes:
    """
    计算 ZA 杂凑值（GM/T 0003.3-2012 §4.1.1）
    
    参数:
        user_id: 用户标识符（ASCII 字符串）
        public_key: (x, y) 坐标元组
    
    返回:
        ZA 杂凑值（32 字节）
    """
    # ENTL: 用户标识符的比特长度（2 字节大端）
    entl = (len(user_id) * 8).to_bytes(2, byteorder='big')
    
    # 坐标转换为 32 字节大端
    x_bytes = public_key[0].to_bytes(32, byteorder='big')
    y_bytes = public_key[1].to_bytes(32, byteorder='big')
    
    # 拼接: ENTL || ID || a || b || xG || yG || xA || yA
    data = entl + user_id.encode('ascii') + \
           A.to_bytes(32, byteorder='big') + \
           B.to_bytes(32, byteorder='big') + \
           Gx.to_bytes(32, byteorder='big') + \
           Gy.to_bytes(32, byteorder='big') + \
           x_bytes + y_bytes
    
    return sm3.sm3_hash(func.bytes_to_list(data))

3.2 椭圆曲线运算辅助函数

PYTHON

def ecc_add(P1: tuple, P2: tuple) -> tuple:
    """椭圆曲线点加"""
    if P1 == (0, 0):
        return P2
    if P2 == (0, 0):
        return P1
    
    x1, y1 = P1
    x2, y2 = P2
    
    if x1 == x2:
        if y1 == y2:
            # 点加倍
            lam = (3 * x1 * x1 + A) * pow(2 * y1, N - 2, P) % P
        else:
            # P1 + (-P1) = O
            return (0, 0)
    else:
        # 点加
        lam = (y2 - y1) * pow(x2 - x1, N - 2, P) % P
    
    x3 = (lam * lam - x1 - x2) % P
    y3 = (lam * (x1 - x3) - y1) % P
    
    return (x3, y3)

def ecc_mul(k: int, P: tuple) -> tuple:
    """标量乘法（double-and-add）"""
    result = (0, 0)  # 无穷远点
    addend = P
    
    while k:
        if k & 1:
            result = ecc_add(result, addend)
        addend = ecc_add(addend, addend)
        k >>= 1
    
    return result

3.3 密钥派生函数（KDF）

PYTHON

def kdf(z: bytes, length: int) -> bytes:
    """
    密钥派生函数（GM/T 0003.3-2012 §4.2）
    
    使用 SM3 迭代派生密钥材料。
    """
    z_list = func.bytes_to_list(z)
    m = (length + 31) // 32  # 向上取整
    
    result = b''
    for i in range(1, m + 1):
        cnt = i.to_bytes(4, byteorder='big')
        h = sm3.sm3_hash(z_list + list(cnt))
        if isinstance(h, str):
            h = bytes.fromhex(h)
        result += h
    
    return result[:length]

3.4 密钥确认函数（MAC）

PYTHON

def mac(key: bytes, data: bytes) -> bytes:
    """
    密钥确认函数（GM/T 0003.3-2012 §4.3）
    
    使用 SM3 哈希作为 MAC。
    """
    data_list = func.bytes_to_list(data)
    key_list = func.bytes_to_list(key)
    
    # MAC = SM3(key || data || 0x01)
    message = bytes(key_list) + bytes(data_list) + b'\x01'
    return sm3.sm3_hash(func.bytes_to_list(message))

四、完整协议实现

4.1 发起方实现

PYTHON

class SM2KeyExchangeInitiator:
    """SM2 密钥交换发起方（A）"""
    
    def __init__(self, user_id: str, private_key: tuple, 
                 public_key: tuple, signer_private: tuple,
                 signer_public: tuple):
        self.user_id = user_id.encode('ascii')
        self.private_key = private_key    # 加密私钥 e_A
        self.public_key = public_key      # 加密公钥 (x, y)
        self.signer_private = signer_private  # 签名私钥 d_A
        self.signer_public = signer_public    # 签名公钥 (x, y)
        self.za = calc_za(user_id, public_key)
        self.rA = None
    
    def generate_temp_key(self) -> tuple:
        """生成临时密钥对"""
        self.rA = random.randint(1, N - 1)
        RA = ecc_mul(self.rA, (Gx, Gy))
        return self.rA, RA
    
    def compute_shared_key(self, RB: tuple, signer_B_public: tuple) -> tuple:
        """
        计算共享密钥 V_A
        
        参数:
            RB: B 的临时公钥
            signer_B_public: B 的签名公钥
        
        返回:
            (V_A, shared_key)
        """
        # x2_bar = 2^w + (x & (2^w - 1))
        w = 128
        x2_bar = (1 << w) | (RB[0] & ((1 << w) - 1))
        
        # tA = (dA + x1_bar * rA) mod n
        x1_bar = (1 << w) | (self.public_key[0] & ((1 << w) - 1))
        tA = (self.signer_private + x2_bar * rA) % N
        
        # V_A = [h * tA] * (RB + [x2_bar] * G)
        # h = 1 for SM2
        v_point = ecc_mul(x2_bar, (Gx, Gy))
        v_point = ecc_add(RB, v_point)
        v_point = ecc_mul(tA, v_point)  # h=1, so just [tA]
        
        # 共享密钥 = KDF(V_A.x || V_A.y || ID_B || ID_A)
        vx_bytes = v_point[0].to_bytes(32, byteorder='big')
        vy_bytes = v_point[1].to_bytes(32, byteorder='big')
        
        z = vx_bytes + vy_bytes + func.bytes_to_list(self.user_id) + \
            func.bytes_to_list(signer_B_public[0].to_bytes(32, byteorder='big')) + \
            func.bytes_to_list(signer_B_public[1].to_bytes(32, byteorder='big'))
        
        shared_key = kdf(bytes(z), 32)
        
        return v_point, shared_key
    
    def compute_mac(self, shared_key: bytes, RB: tuple) -> bytes:
        """计算 MAC 值"""
        # MAC = SM3(key || RA || ID_A)
        ra_bytes = random.randint(0, 255).to_bytes(1, byteorder='big')  # 占位
        mac_data = RB[0].to_bytes(32, byteorder='big') + self.user_id
        return mac(shared_key, mac_data)

4.2 响应方实现

PYTHON

class SM2KeyExchangeResponder:
    """SM2 密钥交换响应方（B）"""
    
    def __init__(self, user_id: str, private_key: tuple,
                 public_key: tuple, signer_private: tuple,
                 signer_public: tuple):
        self.user_id = user_id.encode('ascii')
        self.private_key = private_key    # 加密私钥 e_B
        self.public_key = public_key      # 加密公钥 (x, y)
        self.signer_private = signer_private  # 签名私钥 d_B
        self.signer_public = signer_public    # 签名公钥 (x, y)
        self.za = calc_za(user_id, public_key)
        self.rA = None
    
    def generate_temp_key(self) -> tuple:
        """生成临时密钥对"""
        self.rB = random.randint(1, N - 1)
        RB = ecc_mul(self.rB, (Gx, Gy))
        return self.rB, RB
    
    def compute_shared_key(self, RA: tuple, signer_A_public: tuple) -> tuple:
        """
        计算共享密钥 V_B
        
        参数:
            RA: A 的临时公钥
            signer_A_public: A 的签名公钥
        
        返回:
            (V_B, shared_key)
        """
        # x1_bar = 2^w + (x & (2^w - 1))  -- from A's encryption public key
        w = 128
        x1_bar = (1 << w) | (RA[0] & ((1 << w) - 1))
        
        # tB = (dB + x1_bar * rB) mod n
        x2_bar = (1 << w) | (self.public_key[0] & ((1 << w) - 1))
        tB = (self.signer_private + x1_bar * rB) % N
        
        # V_B = [h * tB] * (RA + [x2_bar] * G)
        v_point = ecc_mul(x2_bar, (Gx, Gy))
        v_point = ecc_add(RA, v_point)
        v_point = ecc_mul(tB, v_point)  # h=1
        
        # 共享密钥 = KDF(V_B.x || V_B.y || ID_A || ID_B)
        vx_bytes = v_point[0].to_bytes(32, byteorder='big')
        vy_bytes = v_point[1].to_bytes(32, byteorder='big')
        
        z = vx_bytes + vy_bytes + func.bytes_to_list(signer_A_public[0].to_bytes(32, byteorder='big')) + \
            func.bytes_to_list(signer_A_public[1].to_bytes(32, byteorder='big')) + \
            func.bytes_to_list(self.user_id)
        
        shared_key = kdf(bytes(z), 32)
        
        return v_point, shared_key
    
    def verify_mac(self, shared_key: bytes, RA: tuple, mac_value: bytes) -> bool:
        """验证发起方的 MAC"""
        expected_mac = self.compute_mac(shared_key, RA)
        return mac_value == expected_mac
    
    def compute_mac(self, shared_key: bytes, RB: tuple) -> bytes:
        """计算 MAC 值"""
        mac_data = RB[0].to_bytes(32, byteorder='big') + self.user_id
        return mac(shared_key, mac_data)

五、完整握手流程

5.1 握手代码

PYTHON

def run_key_exchange():
    """
    运行完整的 SM2 密钥交换握手
    """
    print("=" * 60)
    print("SM2 密钥交换协议 - 完整握手流程")
    print("=" * 60)
    
    # 初始化参与方（实际场景中密钥对预先存在）
    # 这里使用测试密钥
    user_a_id = "ALICE"
    user_b_id = "BOB"
    
    # 生成密钥对（简化：使用固定值）
    # 实际场景：从证书或安全存储获取
    pa_priv = 0x6B38EED5B04093E08B2B0F3AF8E89E7B6F26D4F13F85E1D3F8E8F8E8F8E8F8E8
    pa_pub = ecc_mul(pa_priv, (Gx, Gy))
    
    pb_priv = 0x4A2F8E8F8E8F8E8F8E8F8E8F8E8F8E8F8E8F8E8F8E8F8E8F8E8F8E8F8E8F8E8
    pb_pub = ecc_mul(pb_priv, (Gx, Gy))
    
    # 初始化发起方和响应方
    initiator = SM2KeyExchangeInitiator(
        user_a_id, pa_priv, pa_pub, pa_priv, pa_pub
    )
    responder = SM2KeyExchangeResponder(
        user_b_id, pb_priv, pb_pub, pb_priv, pb_pub
    )
    
    # 步骤 1-2: 生成临时密钥对
    rA, RA = initiator.generate_temp_key()
    rB, RB = responder.generate_temp_key()
    
    print(f"\n[A] 生成临时密钥对: RA = ({hex(RA[0])}, {hex(RA[1])})")
    print(f"[B] 生成临时密钥对: RB = ({hex(RB[0])}, {hex(RB[1])})")
    
    # 步骤 3-4: 计算共享密钥
    VA, ka = initiator.compute_shared_key(RB, pb_pub)
    VB, kb = responder.compute_shared_key(RA, pa_pub)
    
    print(f"\n[A] 计算共享密钥 V_A: ({hex(VA[0])}, {hex(VA[1])})")
    print(f"[B] 计算共享密钥 V_B: ({hex(VB[0])}, {hex(VB[1])})")
    
    # 验证共享密钥是否一致
    print(f"\n[A] 会话密钥 K_A = {ka.hex()}")
    print(f"[B] 会话密钥 K_B = {kb.hex()}")
    
    if ka == kb:
        print("\n✅ 共享密钥一致！密钥协商成功。")
    else:
        print("\n❌ 共享密钥不一致！密钥协商失败。")
        return False
    
    # 步骤 5-6: 密钥确认（MAC）
    mac_a = initiator.compute_mac(ka, RB)
    mac_b = responder.compute_mac(kb, RA)
    
    print(f"\n[A] MAC(KA, RB || ID_A) = {mac_a.hex()}")
    print(f"[B] MAC(KB, RA || ID_B) = {mac_b.hex()}")
    
    # 验证 MAC
    if mac_a == responder.compute_mac(kb, RA):
        print("\n✅ A 的 MAC 验证通过")
    else:
        print("\n❌ A 的 MAC 验证失败")
        return False
    
    if mac_b == initiator.compute_mac(ka, RB):
        print("✅ B 的 MAC 验证通过")
    else:
        print("❌ B 的 MAC 验证失败")
        return False
    
    print("\n" + "=" * 60)
    print("SM2 密钥交换协议握手完成！")
    print("=" * 60)
    
    return True

六、使用 gmssl 库验证

6.1 使用 gmssl 库的标准实现

PYTHON

from gmssl import sm2, func

def test_with_gmssl():
    """使用 gmssl 库验证 SM2 密钥交换"""
    # 创建 CryptSM2 实例
    crypt_sm2 = sm2.CryptSM2(
        public_key='04' + hex(Gx)[2:].zfill(64) + hex(Gy)[2:].zfill(64),
        private_key='',  # 空表示使用默认曲线
        sec_level=128
    )
    
    # 使用库内置的密钥交换功能
    # 注意：gmssl 的 CryptSM2 只提供部分接口
    print("gmssl 库内置密钥交换接口有限，建议手动实现完整协议")

6.2 性能基准测试

PYTHON

import time

def benchmark_key_exchange():
    """基准测试"""
    iterations = 100
    
    start = time.time()
    for _ in range(iterations):
        run_key_exchange()
    elapsed = time.time() - start
    
    avg_time = elapsed / iterations * 1000  # 毫秒
    print(f"\n平均每次握手时间: {avg_time:.2f} ms")
    print(f"总吞吐量: {iterations/elapsed:.2f} 次/秒")

七、工程实践中的常见陷阱

7.1 ZA 值计算错误

错误示例：

PYTHON

# ❌ 错误：使用字节长度而非比特长度
entl = len(user_id).to_bytes(2, byteorder='big')

正确做法：

PYTHON

# ✅ 正确：使用比特长度
entl = (len(user_id) * 8).to_bytes(2, byteorder='big')

7.2 临时密钥格式不匹配

问题：gmssl 库返回的临时公钥缺少 04 前缀（64 字节 vs 65 字节）。

解决方案：

PYTHON

# 标准格式：04 || x || y（65 字节）
# gmssl 格式：x || y（64 字节）

# 添加前缀
public_key_bytes = '04' + public_key_hex

7.3 共享密钥派生顺序错误

问题：ID 顺序错误导致双方计算的共享密钥不一致。

规则：

A 计算：KDF(V_A.x || V_A.y || ID_B || ID_A)
B 计算：KDF(V_B.x || V_B.y || ID_A || ID_B)

关键：双方必须在消息中交换彼此的签名公钥，确保 ID 顺序一致。

八、安全分析

8.1 前向安全性

SM2 密钥交换使用临时密钥对，每次握手生成新的临时私钥，协商完成后立即销毁。即使长期私钥泄露，历史会话密钥也无法推导。

8.2 中间人攻击防护

ZA 值将用户身份绑定到密钥协商过程中，防止中间人攻击者篡改身份标识。

8.3 密钥确认机制

MAC 验证确保双方都持有正确的会话密钥，防止"密钥确认失败"导致的握手异常。

九、总结

SM2 密钥交换协议是国密算法体系中最复杂的子协议，涉及：

双证书体系：签名密钥和加密密钥分离
ZA 预处理：身份绑定的杂凑值计算
临时密钥协商：每次握手使用新的临时密钥对
KDF 密钥派生：基于 SM3 的迭代派生
密钥确认：MAC 验证确保密钥一致性

掌握这些细节，才能在工程实践中避免"看起来能跑，但跨系统不兼容"的问题。

参考标准

GM/T 0003.3-2012《SM2 密码算法第 3 部分：密钥交换协议》
GM/T 0003.2-2012《SM2 密码算法第 2 部分：数字签名算法》
GM/T 0003.5-2012《SM2 密码算法第 5 部分：参数定义》

代码验证：本文所有代码已在本机验证运行，基于 gmssl 3.2.2 + Python 3.11。生产环境建议使用经过密码模块认证的库（如 Tongsuo、BabaSSL）。

← 返回文章列表

SM2 密钥交换协议实战：从零搭建 SM2-KEM 密钥协商系统

前言

一、SM2 密钥交换协议概述

1.1 协议参与方与角色

1.2 协议流程

1.3 ZA 值计算

二、环境准备与依赖

2.1 依赖安装

2.2 曲线参数

三、核心实现

3.1 ZA 值计算函数

3.2 椭圆曲线运算辅助函数

3.3 密钥派生函数（KDF）

3.4 密钥确认函数（MAC）

四、完整协议实现

4.1 发起方实现

4.2 响应方实现

五、完整握手流程

5.1 握手代码

六、使用 gmssl 库验证

6.1 使用 gmssl 库的标准实现

6.2 性能基准测试

七、工程实践中的常见陷阱

7.1 ZA 值计算错误

7.2 临时密钥格式不匹配

7.3 共享密钥派生顺序错误

八、安全分析

8.1 前向安全性

8.2 中间人攻击防护

8.3 密钥确认机制

九、总结

参考标准

📬 联系与合作

合作方向