SM9 标识密码实战：无证书加密与身份认证部署

┌─────────────────────────────────────────┐
│              KGC (密钥生成中心)           │
│                                         │
│  主密钥（Master Secret）                 │
│      │                                  │
│      ▼                                  │
│  为每个用户生成私钥                       │
│  d_ID = s · H₁(ID)                     │
└──────────────┬──────────────────────────┘
               │ 安全信道分发私钥
       ┌───────┴───────┐
       ▼               ▼
   Alice            Bob
  私钥 d_Alice     私钥 d_Bob

#!/usr/bin/env python3
"""
KGC 密钥生成中心初始化
基于 GM/T 0044-2016 标识密码算法标准
"""

import os
import hashlib
import json
from pathlib import Path

class SM9KGC:
    """SM9 密钥生成中心"""
    
    def __init__(self, kgc_dir: str = "/opt/sm9-kgc"):
        self.kgc_dir = Path(kgc_dir)
        self.kgc_dir.mkdir(parents=True, exist_ok=True)
        
        # 系统参数文件
        self.master_key_file = self.kgc_dir / "master.key"
        self.public_params_file = self.kgc_dir / "public_params.json"
        self.user_keys_dir = self.kgc_dir / "user_keys"
        self.user_keys_dir.mkdir(exist_ok=True)
    
    def initialize(self):
        """初始化 KGC：生成主密钥和系统参数"""
        if self.master_key_file.exists():
            print("⚠️  主密钥已存在，跳过初始化")
            return
        
        # 生成主密钥（256 位随机数）
        master_secret = os.urandom(32)
        
        # 安全存储主密钥
        self.master_key_file.write_bytes(master_secret)
        os.chmod(self.master_key_file, 0o400)
        
        # 生成系统公开参数
        # 注意：实际参数应符合 GM/T 0044-2016 标准
        public_params = {
            "algorithm": "SM9",
            "curve": "SM9-256",
            "hash": "SM3",
            # P_pub = master_secret · P₂（实际计算需要椭圆曲线库）
            "P_pub": "placeholder_for_actual_pub_key",
        }
        
        self.public_params_file.write_text(
            json.dumps(public_params, indent=2)
        )
        
        print("✅ KGC 初始化完成")
        print(f"   主密钥: {self.master_key_file}")
        print(f"   系统参数: {self.public_params_file}")
    
    def generate_user_key(self, identity: str) -> dict:
        """为用户生成私钥"""
        if not self.master_key_file.exists():
            raise RuntimeError("KGC 未初始化")
        
        master_secret = self.master_key_file.read_bytes()
        
        # 检查用户私钥是否已存在
        user_key_file = self.user_keys_dir / f"{identity.replace('@', '_at_')}.key"
        if user_key_file.exists():
            print(f"⚠️  用户 {identity} 的私钥已存在")
            return json.loads(user_key_file.read_text())
        
        # 计算用户私钥
        # d_ID = s · H₁(ID || hid) mod N
        # 这里使用简化的派生方式，实际应符合 GM/T 0044-2016
        hid = 0x02  # 签名私钥生成标识符
        identity_hash = hashlib.new('sm3', f"{identity}:{hid}".encode()).digest()
        
        # 私钥派生（简化版，实际需要使用椭圆曲线标量乘法）
        from gmssl import sm3, func
        h1 = sm3.sm3_hash(func.bytes_to_list(identity_hash))
        
        user_key = {
            "identity": identity,
            "private_key": h1.hex(),
            "created_at": str(os.times().system),
        }
        
        # 安全存储用户私钥
        user_key_file.write_text(json.dumps(user_key, indent=2))
        os.chmod(user_key_file, 0o400)
        
        print(f"✅ 已为用户 {identity} 生成私钥")
        return user_key
    
    def get_public_params(self) -> dict:
        """获取系统公开参数"""
        return json.loads(self.public_params_file.read_text())

# 使用示例
if __name__ == "__main__":
    kgc = SM9KGC("/opt/sm9-kgc")
    kgc.initialize()
    
    # 为用户生成私钥
    kgc.generate_user_key("alice@example.com")
    kgc.generate_user_key("bob@example.com")
    
    # 获取公开参数
    params = kgc.get_public_params()
    print(f"系统参数: {json.dumps(params, indent=2)}")

安全要求:
  主密钥保护:
    - 存储在 HSM（硬件安全模块）中
    - 使用 M-of-N 分割知识方案
    - 定期审计密钥使用记录
  
  私钥分发:
    - 使用安全信道（如 TLS + 客户端认证）分发用户私钥
    - 支持私钥的加密传输
    - 记录所有私钥分发日志
  
  高可用:
    - KGC 应部署为主从模式
    - 主密钥的备份应使用秘密共享（Shamir's Secret Sharing）
    - 定期进行灾难恢复演练

#!/usr/bin/env python3
"""
SM9 数字签名示例
"""

from gmssl import sm9, sm3, func

def sm9_sign_example():
    """SM9 签名和验证示例"""
    
    # 1. KGC 初始化
    kgc = sm9.KGC()
    kgc.setup()  # 生成主密钥和系统参数
    
    # 2. 为用户生成私钥
    signer_id = "alice@example.com"
    private_key = kgc.generate_private_key(signer_id)
    
    # 3. 签名
    message = "这是一条需要签名的消息".encode('utf-8')
    signature = sm9.sign(private_key, message)
    
    print(f"消息: {message.decode()}")
    print(f"签名: {signature.hex()}")
    
    # 4. 验证
    is_valid = sm9.verify(
        signer_id,  # 签名者标识
        message,
        signature,
        kgc.master_public_key  # KGC 公钥
    )
    
    print(f"验证结果: {'✅ 有效' if is_valid else '❌ 无效'}")

if __name__ == "__main__":
    sm9_sign_example()

#!/usr/bin/env python3
"""
SM9 基于身份的加密通信示例
"""

from gmssl import sm9

def sm9_encrypt_example():
    """SM9 加密和解密示例"""
    
    # 1. KGC 初始化
    kgc = sm9.KGC()
    kgc.setup()
    
    # 2. 为通信双方生成私钥
    alice_id = "alice@example.com"
    bob_id = "bob@example.com"
    
    alice_private_key = kgc.generate_private_key(alice_id)
    bob_private_key = kgc.generate_private_key(bob_id)
    
    # 3. Alice 用 Bob 的标识加密消息
    plaintext = "你好 Bob，这是加密消息".encode('utf-8')
    ciphertext = sm9.encrypt(
        bob_id,  # 接收方标识（即公钥）
        plaintext,
        kgc.master_public_key
    )
    
    print(f"明文: {plaintext.decode()}")
    print(f"密文: {ciphertext.hex()[:64]}...")
    
    # 4. Bob 用自己的私钥解密
    decrypted = sm9.decrypt(bob_private_key, ciphertext)
    
    print(f"解密: {decrypted.decode()}")
    assert decrypted == plaintext, "解密失败！"
    print("✅ 加解密验证通过")

if __name__ == "__main__":
    sm9_encrypt_example()

#!/usr/bin/env python3
"""
SM9 基于身份的密钥协商示例
"""

from gmssl import sm9
import os

def sm9_key_exchange_example():
    """SM9 密钥协商示例"""
    
    kgc = sm9.KGC()
    kgc.setup()
    
    alice_id = "alice@example.com"
    bob_id = "bob@example.com"
    
    alice_private_key = kgc.generate_private_key(alice_id)
    bob_private_key = kgc.generate_private_key(bob_id)
    
    # Alice 发起密钥协商
    alice_random = os.urandom(32)
    alice_token = sm9.key_exchange_init(
        alice_private_key, bob_id,
        alice_random, kgc.master_public_key
    )
    
    # Bob 响应
    bob_random = os.urandom(32)
    bob_token = sm9.key_exchange_response(
        bob_private_key, alice_id,
        bob_random, kgc.master_public_key,
        alice_token
    )
    
    # Alice 完成协商
    alice_shared_key = sm9.key_exchange_finish(
        alice_private_key, bob_token
    )
    
    # Bob 完成协商
    bob_shared_key = sm9.key_exchange_finish(
        bob_private_key, alice_token
    )
    
    # 双方应得到相同的共享密钥
    assert alice_shared_key == bob_shared_key
    print(f"✅ 密钥协商成功")
    print(f"   共享密钥: {alice_shared_key.hex()[:32]}...")

if __name__ == "__main__":
    sm9_key_exchange_example()