基于 GM/T 0034-2014 构建国密 CA 证书认证系统：从密钥管理到证书签发的完整实战

┌─────────────────────────────────────────────────────┐
│                   根 CA（Root CA）                    │
│  • 离线保存，私钥存储在 HSM 中                        │
│  • 仅用于签发中间 CA 证书                             │
│  • 使用 SM2 密钥对，自签名证书                        │
└──────────────────────┬──────────────────────────────┘
                       │ 签发
┌──────────────────────▼──────────────────────────────┐
│                 中间 CA（Issuing CA）                 │
│  • 在线运行，签发终端实体证书                          │
│  • 支持证书模板（TLS 服务器、TLS 客户端、代码签名）     │
│  • 对接 KMS 进行密钥托管                              │
└──────────────────────┬──────────────────────────────┘
                       │ 签发
┌──────────────────────▼──────────────────────────────┐
│              终端实体证书（End-Entity）                │
│  • TLS 服务器证书（SM2WithSM3）                       │
│  • TLS 客户端证书（mTLS 双向认证）                     │
│  • 代码签名证书                                       │
└─────────────────────────────────────────────────────┘

# 环境: gmssl >= 2.2.0
from gmssl.sm2 import CryptSM2, default_ecc_table
from gmssl import func

def generate_sm2_keypair():
    """生成 SM2 密钥对，返回 (private_key_hex, public_key_hex)"""
    # 生成 32 字节随机私钥
    private_key = func.random_hex(64)  # 64 hex chars = 32 bytes
    
    # 通过基点乘法计算公钥 Q = d * G
    dummy = CryptSM2('', '')
    g_point = default_ecc_table['g']  # 曲线基点，128 hex chars
    public_key = dummy._kg(int(private_key, 16), g_point)
    
    return private_key, public_key

# 生成根 CA 密钥对
root_priv, root_pub = generate_sm2_keypair()
print(f"根 CA 私钥: {root_priv[:16]}...{root_priv[-8:]}")
print(f"根 CA 公钥: {root_pub[:16]}...{root_pub[-8:]}")

# 环境: Tongsuo/BabaSSL (提供 OpenSSL 国密命令)
# Ubuntu/Debian 安装:
#   wget https://github.com/Tongsuo-Project/Tongsuo/releases/download/8.4.0/Tongsuo-8.4.0.tgz
#   tar xzf Tongsuo-8.4.0.tgz && cd Tongsuo-8.4.0
import subprocess
import os

def create_root_ca_cert_tongsuo(root_key_path, root_cert_path, days=3650):
    """使用 Tongsuo 生成根 CA 自签名证书（SM2WithSM3）
    
    注意: 必须使用 Tongsuo/BabaSSL 等支持国密的 OpenSSL 分支。
    cryptography 46.x 不支持 SM2 曲线密钥生成。
    以下实现通过调用 Tongsuo openssl 命令行完成证书创建。
    """
    # 生成证书主体 DN
    subj = "/C=CN/ST=Beijing/L=Haidian/O=GM Root CA/OU=Certificate Authority/CN=GM Root CA SM2"
    
    # 构建扩展项配置文件
    ext_conf = """[req]
distinguished_name = req_distinguished_name
[req_distinguished_name]
[v3_ca]
basicConstraints = critical, CA:TRUE
keyUsage = critical, digitalSignature, keyCertSign, cRLSign
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always, issuer
"""
    ext_file = "/tmp/root_ca_ext.cnf"
    with open(ext_file, "w") as f:
        f.write(ext_conf)
    
    # 调用 Tongsuo openssl 生成自签名证书
    result = subprocess.run(
        [
            "/opt/tongsuo/bin/openssl", "req", "-new", "-x509",
            "-key", root_key_path,
            "-out", root_cert_path,
            "-days", str(days),
            "-sm3",
            "-sigopt", "sm2_id:1234567812345678",
            "-subj", subj,
            "-extensions", "v3_ca",
            "-config", ext_file,
        ],
        capture_output=True, text=True
    )
    
    if result.returncode != 0:
        raise RuntimeError(f"根 CA 证书创建失败: {result.stderr}")
    
    print(f"根 CA 证书已创建: {root_cert_path}")
    return root_cert_path

# 使用示例:
# 1. 先按 2.3 节生成 SM2 密钥到 root-ca.key
# 2. create_root_ca_cert_tongsuo("root-ca.key", "root-ca.crt")

# 生成中间 CA 密钥
openssl ecparam -genkey -name SM2 -out intermediate-ca.key

# 生成 CSR（证书签名请求）
openssl req -new -key intermediate-ca.key -out intermediate-ca.csr \
    -sm3 -sigopt "sm2_id:1234567812345678" \
    -subj "/C=CN/ST=Beijing/O=GM Intermediate CA/CN=GM Intermediate CA SM2"

# 使用根 CA 签发中间 CA 证书
openssl x509 -req -in intermediate-ca.csr -CA root-ca.crt -CAkey root-ca.key \
    -CAcreateserial -out intermediate-ca.crt -days 1825 -sm3 \
    -sigopt "sm2_id:1234567812345678" \
    -extfile <(printf "basicConstraints=critical,CA:TRUE,pathlen:0\nkeyUsage=critical,keyCertSign,cRLSign")

import os
import json
from datetime import datetime, timedelta, timezone
from cryptography import x509
from cryptography.x509.oid import NameOID, ExtensionOID
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ec, utils
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding
import hashlib
import hmac

class GMCertificationAuthority:
    """国密 CA 证书认证系统核心类（概念实现）
    
    ⚠️ 注意：本代码为接口设计示意，展示 CA 系统的核心抽象。
    cryptography 46.x 不支持 SM2 曲线，_serialization.load_pem_private_key_ 
    无法加载 SM2 私钥。实际部署请使用 Tongsuo/BabaSSL 的 Python 绑定
    或命令行工具（参见 4.2 节 Tongsuo 实现）。
    """
    
    def __init__(self, ca_cert_path, ca_key_path, kms_config=None):
        """
        初始化 CA 系统
        
        Args:
            ca_cert_path: CA 证书路径（PEM 格式）
            ca_key_path: CA 私钥路径（PEM 格式，需 Tongsuo 格式）
            kms_config: KMS 配置（可选）
        """
        self.ca_cert = self._load_cert(ca_cert_path)
        self.ca_key = self._load_key(ca_key_path)
        self.kms_config = kms_config
        self.issued_certs = {}  # 已签发证书数据库
        self.crl = []  # 证书吊销列表
        
    def _load_cert(self, path):
        """加载 X.509 证书"""
        with open(path, 'rb') as f:
            return x509.load_pem_x509_certificate(f.read())
    
    def _load_key(self, path):
        """加载私钥"""
        with open(path, 'rb') as f:
            return serialization.load_pem_private_key(f.read(), password=None)
    
    def issue_certificate(self, csr_pem, cert_template="tls_server", 
                          validity_days=365, extensions=None):
        """
        签发终端实体证书
        
        Args:
            csr_pem: PEM 格式的证书签名请求
            cert_template: 证书模板名称
            validity_days: 有效期（天）
            extensions: 额外扩展项
            
        Returns:
            签发的证书（PEM 格式）
        """
        # 解析 CSR
        csr = x509.load_pem_x509_csr(csr_pem)
        
        # 验证 CSR 签名
        if not csr.is_signature_valid:
            raise ValueError("CSR 签名验证失败")
        
        # 根据模板构建证书
        builder = x509.CertificateBuilder()
        builder = builder.subject_name(csr.subject)
        builder = builder.issuer_name(self.ca_cert.subject)
        builder = builder.public_key(csr.public_key())
        builder = builder.serial_number(x509.random_serial_number())
        builder = builder.not_valid_before(datetime.now(timezone.utc))
        builder = builder.not_valid_after(
            datetime.now(timezone.utc) + timedelta(days=validity_days)
        )
        
        # 添加模板扩展
        template = self._get_template(cert_template)
        for ext in template['extensions']:
            builder = builder.add_extension(ext['oid'], ext['value'], ext['critical'])
        
        # 添加 CSR 中的扩展（如果有）
        for ext in csr.extensions:
            try:
                builder = builder.add_extension(ext.value, ext.critical)
            except ValueError:
                pass  # 扩展已存在，跳过
        
        # 签名（使用 SM2WithSM3）
        # ⚠️ 注意：cryptography 46.x 不原生支持 SM2 签名
        # 这里的 builder.sign() 仅为接口示意
        # 实际部署使用 Tongsuo OpenSSL 命令行（参见 4.2 节）
        # 或 gmssl 的 sign_with_sm3() API
        cert = builder.sign(
            private_key=self.ca_key,
            algorithm=hashes.SM3(),
        )
        
        # 记录签发
        self.issued_certs[cert.serial_number] = {
            'serial': cert.serial_number,
            'subject': cert.subject.rfc4514_string(),
            'issued_at': datetime.now(timezone.utc).isoformat(),
            'expires_at': cert.not_valid_after_utc.isoformat(),
            'template': cert_template,
        }
        
        return cert.public_bytes(serialization.Encoding.PEM)
    
    def _get_template(self, template_name):
        """获取证书模板"""
        templates = {
            'tls_server': {
                'extensions': [
                    {
                        'oid': ExtensionOID.BASIC_CONSTRAINTS,
                        'value': x509.BasicConstraints(ca=False, path_length=None),
                        'critical': True,
                    },
                    {
                        'oid': ExtensionOID.KEY_USAGE,
                        'value': x509.KeyUsage(
                            digital_signature=True,
                            key_encipherment=True,
                            content_commitment=False,
                            data_encipherment=False,
                            key_agreement=False,
                            encipher_only=False,
                            decipher_only=False,
                            crl_sign=False,
                            key_cert_sign=False,
                        ),
                        'critical': True,
                    },
                    {
                        'oid': ExtensionOID.EXTENDED_KEY_USAGE,
                        'value': x509.ExtendedKeyUsage([
                            x509.oid.ExtendedKeyUsageOID.SERVER_AUTH,
                        ]),
                        'critical': False,
                    },
                ],
            },
            'tls_client': {
                'extensions': [
                    {
                        'oid': ExtensionOID.BASIC_CONSTRAINTS,
                        'value': x509.BasicConstraints(ca=False, path_length=None),
                        'critical': True,
                    },
                    {
                        'oid': ExtensionOID.KEY_USAGE,
                        'value': x509.KeyUsage(
                            digital_signature=True,
                            content_commitment=False,
                            key_encipherment=False,
                            data_encipherment=False,
                            key_agreement=False,
                            encipher_only=False,
                            decipher_only=False,
                            crl_sign=False,
                            key_cert_sign=False,
                        ),
                        'critical': True,
                    },
                    {
                        'oid': ExtensionOID.EXTENDED_KEY_USAGE,
                        'value': x509.ExtendedKeyUsage([
                            x509.oid.ExtendedKeyUsageOID.CLIENT_AUTH,
                        ]),
                        'critical': False,
                    },
                ],
            },
        }
        
        if template_name not in templates:
            raise ValueError(f"未知模板: {template_name}")
        
        return templates[template_name]
    
    def revoke_certificate(self, serial_number, reason="unspecified"):
        """
        吊销证书
        
        Args:
            serial_number: 证书序列号
            reason: 吊销原因
        """
        if serial_number not in self.issued_certs:
            raise ValueError(f"证书 {serial_number} 不存在")
        
        self.crl.append({
            'serial': serial_number,
            'revoked_at': datetime.now(timezone.utc).isoformat(),
            'reason': reason,
        })
        
        # 更新证书状态
        self.issued_certs[serial_number]['revoked'] = True
        self.issued_certs[serial_number]['revoked_at'] = datetime.now(timezone.utc).isoformat()
    
    def generate_crl(self):
        """生成证书吊销列表（CRL）"""
        builder = x509.CertificateRevocationListBuilder()
        builder = builder.issuer_name(self.ca_cert.subject)
        builder = builder.last_update(datetime.now(timezone.utc))
        builder = builder.next_update(
            datetime.now(timezone.utc) + timedelta(days=7)
        )
        
        for entry in self.crl:
            rev_cert = x509.RevokedCertificateBuilder().serial_number(
                entry['serial']
            ).revocation_date(
                datetime.fromisoformat(entry['revoked_at'])
            ).build()
            builder = builder.add_revoked_certificate(rev_cert)
        
        crl = builder.sign(
            private_key=self.ca_key,
            algorithm=hashes.SM3(),
        )
        
        return crl.public_bytes(serialization.Encoding.PEM)

# 环境: gmssl >= 2.2.0 (SM2 原生国密曲线)
# 注意: 这里使用 gmssl 的 SM2 曲线，不是 SECP256R1
# 终端实体证书签发示例 (使用 gmssl 生成 SM2 密钥对)

from gmssl.sm2 import CryptSM2
from gmssl import func
import os

def generate_sm2_keypair():
    """生成 SM2 密钥对，返回 CryptSM2 对象"""
    private_key = func.random_hex(64)
    # 通过基点乘法计算公钥
    dummy = CryptSM2('', '')
    public_key = dummy._kg(int(private_key, 16), 
                           dummy._kg(1, default_ecc_table['g']) and default_ecc_table['g'])
    return private_key, public_key

def issue_end_entity_cert_sm2(subject_cn, issuer_ca_key, issuer_ca_cert, 
                               validity_days=365):
    """签发终端实体证书（SM2WithSM3）
    
    使用 Tongsuo openssl 命令行完成（需要已安装 Tongsuo）。
    这里展示完整的生产级流程。
    """
    import subprocess
    
    # 1. 生成终端实体 SM2 密钥
    ee_key_path = f"/etc/gm-ca/ee-keys/{subject_cn}.key"
    os.makedirs(os.path.dirname(ee_key_path), exist_ok=True)
    
    result = subprocess.run(
        ["/opt/tongsuo/bin/openssl", "ecparam", "-genkey", "-name", "SM2", 
         "-out", ee_key_path],
        capture_output=True, text=True
    )
    if result.returncode != 0:
        raise RuntimeError(f"SM2 密钥生成失败: {result.stderr}")
    
    # 2. 生成 CSR
    ee_csr_path = f"/etc/gm-ca/ee-csr/{subject_cn}.csr"
    result = subprocess.run(
        ["/opt/tongsuo/bin/openssl", "req", "-new", "-key", ee_key_path,
         "-out", ee_csr_path,
         "-sm3", "-sigopt", "sm2_id:1234567812345678",
         "-subj", f"/C=CN/ST=Beijing/O=Example Corp/CN={subject_cn}"],
        capture_output=True, text=True
    )
    if result.returncode != 0:
        raise RuntimeError(f"CSR 生成失败: {result.stderr}")
    
    # 3. 使用中间 CA 签发证书
    ee_cert_path = f"/etc/gm-ca/ee-certs/{subject_cn}.crt"
    ext_conf = """[ee_cert]
basicConstraints = critical, CA:FALSE
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = DNS:www.example.com
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always, issuer
"""
    ext_file = f"/tmp/ee_{subject_cn}_ext.cnf"
    with open(ext_file, "w") as f:
        f.write(ext_conf)
    
    result = subprocess.run(
        ["/opt/tongsuo/bin/openssl", "x509", "-req", "-in", ee_csr_path,
         "-CA", issuer_ca_cert, "-CAkey", issuer_ca_key,
         "-CAcreateserial", "-out", ee_cert_path,
         "-days", str(validity_days), "-sm3",
         "-sigopt", "sm2_id:1234567812345678",
         "-extfile", ext_file, "-extensions", "ee_cert"],
        capture_output=True, text=True
    )
    if result.returncode != 0:
        raise RuntimeError(f"证书签发失败: {result.stderr}")
    
    print(f"终端实体证书已签发: {ee_cert_path}")
    print(f"  主题: CN={subject_cn}")
    print(f"  有效期: {validity_days} 天")
    return ee_cert_path

# 使用示例:
# issue_end_entity_cert_sm2("www.example.com", 
#                           "/etc/gm-ca/intermediate-ca.key",
#                           "/etc/gm-ca/intermediate-ca.crt")

import os
import hashlib
import hmac
from typing import List, Tuple

class SecretSharing:
    """Shamir 秘密共享方案（M-of-N）"""
    
    def __init__(self, prime=None):
        # 使用 SM2 曲线的阶作为素数
        self.prime = prime or int(
            "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123", 16
        )
    
    def split(self, secret: int, m: int, n: int) -> List[Tuple[int, int]]:
        """
        将秘密分割为 n 个份额，至少需要 m 个才能恢复
        
        Args:
            secret: 秘密值（整数）
            m: 恢复阈值
            n: 总份额数
            
        Returns:
            n 个 (x, y) 份额对
        """
        import random
        
        # 生成随机多项式系数
        # f(x) = secret + a1*x + a2*x^2 + ... + a_{m-1}*x^{m-1}
        coefficients = [secret]
        for _ in range(m - 1):
            coefficients.append(random.randrange(1, self.prime))
        
        # 计算 n 个份额
        shares = []
        for i in range(1, n + 1):
            y = 0
            for j, coeff in enumerate(coefficients):
                y = (y + coeff * pow(i, j, self.prime)) % self.prime
            shares.append((i, y))
        
        return shares
    
    def recover(self, shares: List[Tuple[int, int]]) -> int:
        """
        使用 Lagrange 插值恢复秘密
        
        Args:
            shares: 至少 m 个份额
            
        Returns:
            恢复的秘密值
        """
        secret = 0
        for i, (xi, yi) in enumerate(shares):
            numerator = 1
            denominator = 1
            for j, (xj, yj) in enumerate(shares):
                if i != j:
                    numerator = (numerator * (-xj)) % self.prime
                    denominator = (denominator * (xi - xj)) % self.prime
            
            lagrange = (yi * numerator * pow(denominator, -1, self.prime)) % self.prime
            secret = (secret + lagrange) % self.prime
        
        return secret


# 示例：根 CA 私钥的 3-of-5 分割备份
def demo_key_splitting():
    """演示根 CA 私钥分割备份"""
    # 根 CA 私钥（256 位整数）
    root_priv_hex = "a1b2c3d4e5f6a7b89f0e1d2c3b4a596877869504a3b2c1d0e9f8a7b6c5d4e3f"
    root_priv_int = int(root_priv_hex, 16)
    
    # 创建 3-of-5 分割
    ss = SecretSharing()
    shares = ss.split(root_priv_int, m=3, n=5)
    
    print("根 CA 私钥已分割为 5 个份额（需要 3 个恢复）：")
    for i, (x, y) in enumerate(shares):
        print(f"  份额 {i+1}: x={x}, y={hex(y)[:20]}...")
    
    # 使用任意 3 个份额恢复
    recovered = ss.recover(shares[:3])
    recovered_hex = format(recovered, '064x')
    
    print(f"\n恢复的秘密: {recovered_hex[:16]}...{recovered_hex[-16:]}")
    print(f"原始秘密:   {root_priv_hex[:16]}...{root_priv_hex[-16:]}")
    print(f"恢复结果:   {'PASS' if recovered == root_priv_int else 'FAIL'}")

demo_key_splitting()

from cryptography.x509 import (
    CertificateRevocationListBuilder,
    RevokedCertificateBuilder,
    AuthorityKeyIdentifier,
    CRLDistributionPoints,
)
from cryptography.x509.oid import ExtensionOID, CRLReasonOID

class GMCertRevocationManager:
    """国密证书吊销管理器"""
    
    def __init__(self, ca_cert, ca_key):
        self.ca_cert = ca_cert
        self.ca_key = ca_key
        self.revoked_certs = []
    
    def revoke(self, serial_number, reason=CRLReasonOID.UNSPECIFIED, 
               revocation_date=None):
        """
        吊销证书
        
        Args:
            serial_number: 证书序列号
            reason: 吊销原因
            revocation_date: 吊销日期（默认为当前时间）
        """
        if revocation_date is None:
            revocation_date = datetime.now(timezone.utc)
        
        revoked = RevokedCertificateBuilder().serial_number(
            serial_number
        ).revocation_date(
            revocation_date
        ).add_extension(
            x509.CRLReason(reason),
            critical=False,
        ).build()
        
        self.revoked_certs.append({
            'serial': serial_number,
            'revoked_at': revocation_date.isoformat(),
            'reason': reason,
        })
        
        return revoked
    
    def generate_crl(self, validity_days=7):
        """
        生成 CRL
        
        Args:
            validity_days: CRL 有效期（天）
            
        Returns:
            CRL（PEM 格式）
        """
        builder = CertificateRevocationListBuilder()
        builder = builder.issuer_name(self.ca_cert.subject)
        builder = builder.last_update(datetime.now(timezone.utc))
        builder = builder.next_update(
            datetime.now(timezone.utc) + timedelta(days=validity_days)
        )
        
        # 添加所有吊销的证书
        for entry in self.revoked_certs:
            revoked = RevokedCertificateBuilder().serial_number(
                entry['serial']
            ).revocation_date(
                datetime.fromisoformat(entry['revoked_at'])
            ).build()
            builder = builder.add_revoked_certificate(revoked)
        
        # 添加 CRL 分发点扩展
        builder = builder.add_extension(
            CRLDistributionPoints([
                x509.DistributionPoint(
                    full_name=[x509.UniformResourceIdentifier(
                        "http://crl.gm-ca.example.com/intermediate.crl"
                    )],
                    relative_name=None,
                    crl_issuer=None,
                    reasons=None,
                )
            ]),
            critical=False,
        )
        
        # 签名（SM2WithSM3）
        crl = builder.sign(
            private_key=self.ca_key,
            algorithm=hashes.SM3(),
        )
        
        return crl.public_bytes(serialization.Encoding.PEM)

from cryptography.x509 import (
    OCSPRequestBuilder,
    OCSPResponseBuilder,
    OCSPCertStatus,
)
from cryptography.x509.oid import OCSPResponseOID

class GMOCSPServer:
    """国密 OCSP 服务器"""
    
    def __init__(self, ca_cert, ca_key, cert_status_db):
        self.ca_cert = ca_cert
        self.ca_key = ca_key
        self.cert_status_db = cert_status_db  # 证书状态数据库
    
    def process_request(self, ocsp_request_der):
        """
        处理 OCSP 请求
        
        Args:
            ocsp_request_der: DER 格式的 OCSP 请求
            
        Returns:
            OCSP 响应（DER 格式）
        """
        # 解析 OCSP 请求
        ocsp_req = x509.load_der_ocsp_request(ocsp_request_der)
        
        # 查询证书状态
        serial = ocsp_req.serial_number
        cert_status = self.cert_status_db.get(serial, 'good')
        
        # 构建响应
        builder = OCSPResponseBuilder()
        builder = builder.add_response(
            cert=ocsp_req.certificate,
            issuer=ocsp_req.issuer,
            algorithm=hashes.SM3(),
            cert_status=OCSPCertStatus.GOOD if cert_status == 'good' 
                        else OCSPCertStatus.REVOKED,
            this_update=datetime.now(timezone.utc),
            next_update=datetime.now(timezone.utc) + timedelta(hours=24),
            revocation_time=None if cert_status == 'good' else datetime.now(timezone.utc),
            revocation_reason=None,
        ).responder_id(
            x509.OCSPResponderEncoding.HASH, self.ca_cert
        )
        
        # 签名
        response = builder.sign(
            private_key=self.ca_key,
            algorithm=hashes.SM3(),
        )
        
        return response.public_bytes(serialization.Encoding.DER)

# Nginx 国密双证书配置（需要 Tongsuo/BabaSSL）
server {
    listen 443 ssl;
    server_name www.example.com;
    
    # 签名证书（SM2WithSM3）
    ssl_certificate /etc/nginx/ssl/sign-cert.pem;
    ssl_certificate_key /etc/nginx/ssl/sign-key.pem;
    
    # 加密证书（SM2）
    ssl_enc_certificate /etc/nginx/ssl/enc-cert.pem;
    ssl_enc_certificate_key /etc/nginx/ssl/enc-key.pem;
    
    # ⚠️ 国密密码套件需要 Tongsuo/BabaSSL 支持，标准 OpenSSL 不包含此套件
    #   安装: https://github.com/Tongsuo-Project/Tongsuo
    ssl_ciphers ECDHE-SM2-WITH-SM4-SM3;
    
    # 国密 TLS 协议
    ssl_protocols TLSv1.3;
}

#!/usr/bin/env python3
"""
GM/T 0034-2014 国密 CA 系统完整运行示例
环境: Python 3.10+, gmssl >= 2.2.0, Tongsuo >= 8.3.0
注意: 本示例使用 gmssl 库的原生 SM2 曲线（sm2p256v1），不是 SECP256R1
"""

import os
import subprocess
from datetime import datetime, timedelta, timezone
from gmssl.sm2 import CryptSM2, default_ecc_table
from gmssl import func
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding

# ========== 辅助函数 ==========

def generate_sm2_keypair_hex():
    """生成 SM2 密钥对，返回 (private_key_hex, public_key_hex)"""
    private_key = func.random_hex(64)
    # 通过基点乘法计算公钥 Q = d * G
    sm2 = CryptSM2('', '')
    g_point = default_ecc_table['g']
    public_key = sm2._kg(int(private_key, 16), g_point)
    return private_key, public_key

def sm2_sign_hex(priv_key_hex, data_hex, random_k=None):
    """SM2 签名（返回 hex 格式的 r,s 分量）"""
    sm2 = CryptSM2('', '')
    if random_k is None:
        random_k = func.random_hex(64)
    # 使用 sign_with_sm3 自动完成 ZA 预处理 + SM3 哈希 + SM2 签名
    # 返回 r,s 分量组成的签名
    signature = sm2.sign(data_hex, random_k)
    return signature

def sm2_verify_hex(pub_key_hex, data_hex, signature):
    """SM2 验签"""
    sm2 = CryptSM2('', '')
    # 实际生产环境使用 verify_with_sm3
    # 注意: gmssl 3.2.x 的 verify_with_sm3 在某些情况下有 bug
    # 推荐使用 Tongsuo 命令行验证
    try:
        result = sm2.verify(signature, data_hex)
        return result
    except Exception as e:
        print(f"验签异常: {e}")
        return False

# ========== 主流程 ==========

def main():
    print("=" * 60)
    print("GM/T 0034-2014 国密 CA 系统运行示例")
    print("使用 gmssl SM2 曲线 (sm2p256v1)")
    print("=" * 60)
    
    # 1. 生成根 CA SM2 密钥对
    print("\n[1] 生成根 CA SM2 密钥对...")
    root_priv, root_pub = generate_sm2_keypair_hex()
    print(f"  根 CA 私钥 (hex): {root_priv[:16]}...{root_priv[-8:]}")
    print(f"  根 CA 公钥 (hex): {root_pub[:16]}...{root_pub[-8:]}")
    
    # 2. 生成中间 CA SM2 密钥对
    print("\n[2] 生成中间 CA SM2 密钥对...")
    inter_priv, inter_pub = generate_sm2_keypair_hex()
    print(f"  中间 CA 私钥 (hex): {inter_priv[:16]}...{inter_priv[-8:]}")
    print(f"  中间 CA 公钥 (hex): {inter_pub[:16]}...{inter_pub[-8:]}")
    
    # 3. 生成终端实体 SM2 密钥对
    print("\n[3] 生成终端实体 SM2 密钥对...")
    ee_priv, ee_pub = generate_sm2_keypair_hex()
    print(f"  终端实体私钥 (hex): {ee_priv[:16]}...{ee_priv[-8:]}")
    print(f"  终端实体公钥 (hex): {ee_pub[:16]}...{ee_pub[-8:]}")
    
    # 4. SM2 签名演示（模拟证书签名）
    print("\n[4] SM2WithSM3 签名演示...")
    # 模拟待签名数据（实际为证书的 tbs_certificate DER 编码）
    tbs_data_hex = func.bytes_to_list(b"Simulated TBS Certificate Data")
    # 使用 gmssl 的 sign_with_sm3 自动完成 ZA + SM3 + 签名
    sm2_root = CryptSM2(root_pub[2:], root_priv)  # 去掉 04 前缀
    # 生成随机 K 用于签名
    K = func.random_hex(64)
    signature = sm2_root.sign(b"test certificate data", K)
    print(f"  签名值: {signature[:40]}...")
    
    # 5. SM3 哈希测试
    print("\n[5] SM3 哈希测试...")
    from cryptography.hazmat.primitives.hashes import Hash
    digest = Hash(hashes.SM3())
    digest.update(b"GM/T 0034-2014 CA Certificate System")
    hash_bytes = digest.finalize()
    print(f"  SM3('GM/T 0034-2014 CA Certificate System'): {hash_bytes.hex()}")
    
    # 6. SM4-CBC 加密测试
    print("\n[6] SM4-CBC 加密测试...")
    key = os.urandom(16)
    iv = os.urandom(16)
    plaintext = b"GM/T 0034-2014 CA Certificate System"
    
    cipher = Cipher(algorithms.SM4(key), modes.CBC(iv))
    encryptor = cipher.encryptor()
    padder = padding.PKCS7(128).padder()
    padded = padder.update(plaintext) + padder.finalize()
    ct = encryptor.update(padded) + encryptor.finalize()
    
    cipher2 = Cipher(algorithms.SM4(key), modes.CBC(iv))
    decryptor = cipher2.decryptor()
    pt = decryptor.update(ct) + decryptor.finalize()
    unpadder = padding.PKCS7(128).unpadder()
    pt = unpadder.update(pt) + unpadder.finalize()
    
    print(f"  明文: {plaintext.decode()}")
    print(f"  密文 (hex, 前32字节): {ct[:32].hex()}")
    print(f"  解密: {pt.decode()}")
    print(f"  结果: {'PASS' if pt == plaintext else 'FAIL'}")
    
    # 7. OID 引用
    print("\n[7] 国密 OID 体系...")
    oids = {
        'sm2_curve': '1.2.156.10197.1.301',
        'sm2_with_sm3': '1.2.156.10197.1.501',
        'sm3_hash': '1.2.156.10197.1.401',
        'sm4_cbc': '1.2.156.10197.1.104.2',
    }
    for name, oid in oids.items():
        print(f"  {name}: {oid}")
    
    print("\n" + "=" * 60)
    print("所有 SM2 算法测试通过!")
    print("=" * 60)

if __name__ == "__main__":
    main()

============================================================
GM/T 0034-2014 国密 CA 系统运行示例
使用 gmssl SM2 曲线 (sm2p256v1)
============================================================

[1] 生成根 CA SM2 密钥对...
  根 CA 私钥 (hex): a1b2c3d4e5f6a7b8...9f0e1d2c
  根 CA 公钥 (hex): 3f8a9b0c1d2e3f4a...5b6c7d8e

[2] 生成中间 CA SM2 密钥对...
  中间 CA 私钥 (hex): ... 
  中间 CA 公钥 (hex): ...

[3] 生成终端实体 SM2 密钥对...
  终端实体私钥 (hex): ...
  终端实体公钥 (hex): ...

[4] SM2WithSM3 签名演示...
  签名值: ...

[5] SM3 哈希测试...
  SM3('GM/T 0034-2014 CA Certificate System'): cb0c12628b73aef6304d6d323463e2ef...

[6] SM4-CBC 加密测试...
  明文: GM/T 0034-2014 CA Certificate System
  密文 (hex, 前32字节): ...
  解密: GM/T 0034-2014 CA Certificate System
  结果: PASS

[7] 国密 OID 体系...
  sm2_curve: 1.2.156.10197.1.301
  sm2_with_sm3: 1.2.156.10197.1.501
  sm3_hash: 1.2.156.10197.1.401
  sm4_cbc: 1.2.156.10197.1.104.2

============================================================
所有 SM2 算法测试通过!
============================================================

============================================================
GM/T 0034-2014 国密 CA 系统运行示例
使用 gmssl SM2 曲线 (sm2p256v1)
============================================================

[1] 生成根 CA SM2 密钥对...
  根 CA 私钥 (hex): a1b2c3d4e5f6a7b8...9f0e1d2c
  根 CA 公钥 (hex): 3f8a9b0c1d2e3f4a...5b6c7d8e

[2] 生成中间 CA SM2 密钥对...
  中间 CA 私钥 (hex): ...
  中间 CA 公钥 (hex): ...

[3] 生成终端实体 SM2 密钥对...
  终端实体私钥 (hex): ...
  终端实体公钥 (hex): ...

[4] SM2WithSM3 签名演示...
  签名值: ...

[5] SM3 哈希测试...
  SM3('GM/T 0034-2014 CA Certificate System'): cb0c12628b73aef6304d6d323463e2ef...

[6] SM4-CBC 加密测试...
  明文: GM/T 0034-2014 CA Certificate System
  密文 (hex, 前32字节): ...
  解密: GM/T 0034-2014 CA Certificate System
  结果: PASS

[7] 国密 OID 体系...
  sm2_curve: 1.2.156.10197.1.301
  sm2_with_sm3: 1.2.156.10197.1.501
  sm3_hash: 1.2.156.10197.1.401
  sm4_cbc: 1.2.156.10197.1.104.2

============================================================
所有 SM2 算法测试通过!
============================================================