国密算法全链路性能基准测试：SM2/SM3/SM4 vs RSA/SHA-256/AES 实测对比与选型指南

"""
基准测试核心代码
"""

import time
import statistics
from gmssl import sm2, sm3, sm4, func
from cryptography.hazmat.primitives.asymmetric import rsa, ec, padding
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives.asymmetric import utils
import os


class Benchmark:
    """通用基准测试框架"""

    def __init__(self, warmup=50, iterations=1000):
        self.warmup = warmup
        self.iterations = iterations

    def run(self, name, func, *args, **kwargs):
        """运行基准测试并返回结果"""
        # 预热
        for _ in range(self.warmup):
            func(*args, **kwargs)

        # 正式测试
        times = []
        for _ in range(self.iterations):
            start = time.perf_counter_ns()
            func(*args, **kwargs)
            elapsed = time.perf_counter_ns() - start
            times.append(elapsed / 1000)  # 转换为 μs

        return {
            "name": name,
            "ops_per_sec": self.iterations / (sum(times) / 1_000_000),
            "p50_us": statistics.median(times),
            "p99_us": sorted(times)[int(len(times) * 0.99)],
            "min_us": min(times),
            "max_us": max(times),
        }


def format_result(result):
    """格式化输出测试结果"""
    print(f"  {result['name']}")
    print(f"    吞吐量: {result['ops_per_sec']:.0f} ops/s")
    print(f"    延迟 P50: {result['p50_us']:.1f} μs")
    print(f"    延迟 P99: {result['p99_us']:.1f} μs")

def benchmark_hash():
    """哈希算法性能对比"""
    bench = Benchmark(warmup=100, iterations=5000)
    data_1kb = os.urandom(1024)
    data_64kb = os.urandom(65536)

    results = []

    # SM3 (gmssl)
    results.append(bench.run(
        "SM3 (1KB)",
        lambda: sm3.sm3_hash(func.bytes_to_list(data_1kb))
    ))
    results.append(bench.run(
        "SM3 (64KB)",
        lambda: sm3.sm3_hash(func.bytes_to_list(data_64kb))
    ))

    # SHA-256 (hashlib)
    import hashlib
    results.append(bench.run(
        "SHA-256 (1KB)",
        lambda: hashlib.sha256(data_1kb).digest()
    ))
    results.append(bench.run(
        "SHA-256 (64KB)",
        lambda: hashlib.sha256(data_64kb).digest()
    ))

    return results

def benchmark_symmetric():
    """对称加密性能对比"""
    bench = Benchmark(warmup=100, iterations=5000)
    key_128 = os.urandom(16)
    key_256 = os.urandom(32)
    data_1kb = os.urandom(1024)
    data_64kb = os.urandom(65536)
    iv = os.urandom(16)

    results = []

    # SM4-CBC (gmssl)
    sm4_enc = sm4.CryptSM4(sm4.SM4_ENCRYPT, key_128)
    results.append(bench.run(
        "SM4-CBC (1KB)",
        lambda: sm4_enc.crypt_cbc(iv, data_1kb)
    ))

    # AES-128-CBC (cryptography)
    cipher = Cipher(algorithms.AES(key_128), modes.CBC(iv))
    enc = cipher.encryptor()
    results.append(bench.run(
        "AES-128-CBC (1KB)",
        lambda: enc.update(data_1kb) + enc.finalize()
    ))

    # AES-256-CBC
    cipher256 = Cipher(algorithms.AES(key_256), modes.CBC(iv))
    enc256 = cipher256.encryptor()
    results.append(bench.run(
        "AES-256-CBC (1KB)",
        lambda: enc256.update(data_1kb) + enc256.finalize()
    ))

    # AES-128-GCM
    gcm_cipher = Cipher(algorithms.AES(key_128), modes.GCM(iv[:12]))
    gcm_enc = gcm_cipher.encryptor()
    results.append(bench.run(
        "AES-128-GCM (1KB)",
        lambda: gcm_enc.update(data_1kb) + gcm_enc.finalize()
    ))

    return results

def benchmark_asymmetric():
    """非对称加密性能对比"""
    bench = Benchmark(warmup=20, iterations=500)
    data = os.urandom(256)  # 典型签名数据

    results = []

    # --- 签名方案 ---

    # SM2 签名 (gmssl)
    sm2_priv = sm2.CryptSM2(None)
    sm2_key = sm2_priv.generate_private_key()
    sm2_pub = sm2_key.public_key
    results.append(bench.run(
        "SM2 Sign (256B)",
        lambda: sm2_key.sign(data)
    ))
    sig_sm2 = sm2_key.sign(data)
    results.append(bench.run(
        "SM2 Verify (256B)",
        lambda: sm2_pub.verify(sig_sm2, data)
    ))

    # RSA-2048 签名
    rsa_key = rsa.generate_private_key(
        public_exponent=65537, key_size=2048
    )
    results.append(bench.run(
        "RSA-2048 Sign (256B)",
        lambda: rsa_key.sign(data, padding.PKCS1v15(), hashes.SHA256())
    ))
    sig_rsa = rsa_key.sign(data, padding.PKCS1v15(), hashes.SHA256())
    results.append(bench.run(
        "RSA-2048 Verify (256B)",
        lambda: rsa_key.public_key().verify(
            sig_rsa, data, padding.PKCS1v15(), hashes.SHA256()
        )
    ))

    # ECDSA P-256 签名
    ec_key = ec.generate_private_key(ec.SECP256R1())
    results.append(bench.run(
        "ECDSA P-256 Sign (256B)",
        lambda: ec_key.sign(data, ec.ECDSA(hashes.SHA256()))
    ))
    sig_ec = ec_key.sign(data, ec.ECDSA(hashes.SHA256()))
    results.append(bench.run(
        "ECDSA P-256 Verify (256B)",
        lambda: ec_key.public_key().verify(
            sig_ec, data, ec.ECDSA(hashes.SHA256())
        )
    ))

    return results

def sm2_sig_to_raw(sig_der: bytes) -> bytes:
    """将 DER 编码的 SM2 签名转换为 64 字节裸 R||S"""
    # 简化实现，实际需要完整 DER 解析
    from gmssl.func import der_decode
    r, s = der_decode(sig_der)
    return r.to_bytes(32, 'big') + s.to_bytes(32, 'big')


def sm2_sig_from_raw(sig_raw: bytes) -> bytes:
    """将 64 字节裸 R||S 转换为 DER 编码"""
    from gmssl.func import der_encode
    r = int.from_bytes(sig_raw[:32], 'big')
    s = int.from_bytes(sig_raw[32:], 'big')
    return der_encode(r, s)