国密实战（二）：SM2 签名验签前后端对接全指南

<dependencies>
    <!-- Hutool 加密模块 -->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-crypto</artifactId>
        <version>5.8.44</version>
    </dependency>
    <!-- BouncyCastle（Hutool 底层依赖） -->
    <dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcprov-jdk18on</artifactId>
        <version>1.84</version>
    </dependency>
</dependencies>

import cn.hutool.core.codec.Base64;
import cn.hutool.core.util.HexUtil;
import cn.hutool.crypto.SmUtil;
import cn.hutool.crypto.asymmetric.SM2;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import java.nio.charset.StandardCharsets;
import java.security.Security;

/**
 * SM2 签名验签工具类
 * 基于 Hutool 5.8.44 + BouncyCastle 1.84
 *
 * 默认行为：
 *   - userId: "1234567812345678"（GM/T 0009-2012 默认值）
 *   - 签名格式: r||s（128 hex 字符）
 *   - hash: false（不额外哈希，与 sm-crypto 的 hash: false 模式一致）
 */
public class Sm2SignUtil {

    static {
        // 注册 BouncyCastle Provider
        if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
            Security.addProvider(new BouncyCastleProvider());
        }
    }

    // 默认 userId（GM/T 0009-2012 规定的默认值）
    private static final String DEFAULT_USER_ID = "1234567812345678";

    /**
     * SM2 签名
     *
     * @param privateKeyHex 私钥 hex（64 字符）
     * @param message       待签名消息（明文字符串）
     * @param userId        用户标识（通常用默认值 "1234567812345678"）
     * @return 签名结果 hex 字符串（128 字符，r||s 拼接格式）
     */
    public static String sign(String privateKeyHex, String message, String userId) {
        // 创建 SM2 签名对象：SmUtil.sm2(私钥, 公钥)
        SM2 sm2 = SmUtil.sm2(privateKeyHex, null);
        // 设置 userId（影响 Z 值计算）
        sm2.setUserId(userId.getBytes(StandardCharsets.UTF_8));

        // 对消息进行签名（Hutool 默认返回 r||s 格式字节数组）
        byte[] msgBytes = message.getBytes(StandardCharsets.UTF_8);
        byte[] signBytes = sm2.sign(msgBytes);

        // 转为 hex 字符串（128 字符）
        return HexUtil.encodeHexStr(signBytes);
    }

    /**
     * SM2 签名（使用默认 userId）
     *
     * @param privateKeyHex 私钥 hex（64 字符）
     * @param message       待签名消息
     * @return 签名结果 hex（128 字符）
     */
    public static String sign(String privateKeyHex, String message) {
        return sign(privateKeyHex, message, DEFAULT_USER_ID);
    }

    /**
     * SM2 验签
     *
     * @param publicKeyHex 公钥 hex（130 字符，04 开头）
     * @param message      原始消息
     * @param signHex      签名 hex（128 字符）
     * @param userId       用户标识
     * @return 验签是否通过
     */
    public static boolean verify(String publicKeyHex, String message, String signHex, String userId) {
        SM2 sm2 = SmUtil.sm2(null, publicKeyHex);
        sm2.setUserId(userId.getBytes(StandardCharsets.UTF_8));

        byte[] msgBytes = message.getBytes(StandardCharsets.UTF_8);
        byte[] signBytes = HexUtil.decodeHex(signHex);

        return sm2.verify(msgBytes, signBytes);
    }

    /**
     * SM2 验签（使用默认 userId）
     *
     * @param publicKeyHex 公钥 hex（130 字符，04 开头）
     * @param message      原始消息
     * @param signHex      签名 hex（128 字符）
     * @return 验签是否通过
     */
    public static boolean verify(String publicKeyHex, String message, String signHex) {
        return verify(publicKeyHex, message, signHex, DEFAULT_USER_ID);
    }

    /**
     * 生成 SM2 密钥对
     *
     * @return String[] {privateKeyHex, publicKeyHex}
     */
    public static String[] generateKeyPair() {
        SM2 sm2 = SmUtil.sm2();
        return new String[] {
            sm2.getPrivateKeyBase64(),
            sm2.getPublicKeyBase64()
        };
    }
}

import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api/sm2")
public class Sm2SignController {

    // 后端持有的公钥（用于验签），从配置或 KeyStore 获取
    private static final String PUBLIC_KEY = "04xxxxxxxxxxxx..."; // 130 字符 hex

    /**
     * 验签接口
     * 前端传入消息和签名，后端验签
     *
     * 请求示例：
     * POST /api/sm2/verify
     * Content-Type: application/json
     * {
     *   "message": "Hello, SM2!",
     *   "signature": "aabbccdd...(128字符)"
     * }
     *
     * 响应示例：
     * { "code": 200, "valid": true, "message": "验签通过" }
     */
    @PostMapping("/verify")
    public Map<String, Object> verify(@RequestBody Map<String, String> request) {
        String message = request.get("message");
        String signature = request.get("signature");

        Map<String, Object> result = new HashMap<>();
        try {
            boolean valid = Sm2SignUtil.verify(PUBLIC_KEY, message, signature);
            result.put("code", 200);
            result.put("valid", valid);
            result.put("message", valid ? "验签通过" : "验签失败");
        } catch (Exception e) {
            result.put("code", 500);
            result.put("valid", false);
            result.put("message", "验签异常: " + e.getMessage());
        }
        return result;
    }
}

declare module 'sm-crypto' {
  interface Sm2 {
    /**
     * SM2 签名
     * @param msg 待签名消息
     * @param privateKey 私钥 hex（64 字符）
     * @param options 配置项
     */
    doSignature(msg: string, privateKey: string, options?: {
      pointPool?: any[];   // 预计算点池（提升性能）
      der?: boolean;       // 是否使用 DER 编码格式
      hash?: boolean;      // 是否对消息预哈希（SM3）
      userId?: string;     // 用户标识
      publicKey?: string;  // 公钥（某些场景需要）
    }): string;

    /**
     * SM2 验签
     * @param msg 原始消息
     * @param sigValue 签名 hex
     * @param publicKey 公钥 hex
     * @param options 配置项
     */
    doVerifySignature(msg: string, sigValue: string, publicKey: string, options?: {
      pointPool?: any[];
      der?: boolean;
      hash?: boolean;
      userId?: string;
    }): boolean;

    /** SM2 加密 */
    doEncrypt(msg: string | number[], publicKey: string, cipherMode?: number): string;

    /** SM2 解密 */
    doDecrypt(cipherText: string, privateKey: string, cipherMode?: number): string | false;

    /** 生成密钥对 */
    generateKeyPairHex(): {
      privateKey: string;  // 64 字符 hex
      publicKey: string;   // 130 字符 hex（04 开头）
    };
  }

  export const sm2: Sm2;

  /** SM3 哈希 */
  export function sm3(msg: string | number[]): string;

  /** SM4 对称加密 */
  export const sm4: {
    encrypt(msg: string | number[], key: string | number[], options?: any): string;
    decrypt(cipherText: string | number[], key: string | number[], options?: any): string | false;
  };
}

// src/utils/sm2.ts
import { sm2 } from 'sm-crypto';

// 默认 userId（GM/T 0009-2012 规定，与 Hutool 保持一致）
const DEFAULT_USER_ID = '1234567812345678';

export interface Sm2KeyPair {
  privateKey: string; // 64 字符 hex
  publicKey: string;  // 130 字符 hex，04 开头
}

/**
 * 生成 SM2 密钥对
 */
export function generateKeyPair(): Sm2KeyPair {
  const keypair = sm2.generateKeyPairHex();
  return {
    privateKey: keypair.privateKey,  // 64 字符 hex
    publicKey: keypair.publicKey,    // 130 字符 hex，04 开头
  };
}

/**
 * SM2 签名
 *
 * @param message      待签名消息
 * @param privateKey   私钥 hex（64 字符）
 * @param userId       用户标识（默认 "1234567812345678"）
 * @returns 签名结果 hex 字符串（128 字符，r||s 格式）
 */
export function sign(
  message: string,
  privateKey: string,
  userId: string = DEFAULT_USER_ID
): string {
  // hash: false 表示不对消息做额外哈希，与 Hutool 行为一致
  // sm-crypto 内部会计算 Z 值并用 SM3 哈希，不需要外部再哈希
  const signature = sm2.doSignature(message, privateKey, {
    hash: false,
    userId: userId,
  });
  return signature;
}

/**
 * SM2 验签
 *
 * @param message    原始消息
 * @param signature  签名 hex（128 字符）
 * @param publicKey  公钥 hex（130 字符，04 开头）
 * @param userId     用户标识
 * @returns 验签是否通过
 */
export function verify(
  message: string,
  signature: string,
  publicKey: string,
  userId: string = DEFAULT_USER_ID
): boolean {
  return sm2.doVerifySignature(message, signature, publicKey, {
    hash: false,
    userId: userId,
  });
}

/**
 * SM2 加密
 *
 * @param msg        明文
 * @param publicKey  公钥 hex（130 字符，04 开头）
 * @returns 密文 hex（C1C3C2 格式）
 */
export function encrypt(msg: string, publicKey: string): string {
  return sm2.doEncrypt(msg, publicKey, 1);  // 1 = C1C3C2
}

/**
 * SM2 解密
 *
 * @param cipherText 密文 hex
 * @param privateKey 私钥 hex（64 字符）
 * @returns 明文或 false（解密失败）
 */
export function decrypt(cipherText: string, privateKey: string): string | false {
  return sm2.doDecrypt(cipherText, privateKey, 1);  // 1 = C1C3C2
}

import React, { useState } from 'react';
import { sign, verify, generateKeyPair } from '../utils/sm2';

const Sm2SignDemo: React.FC = () => {
  const [message, setMessage] = useState('Hello, SM2!');
  const [signature, setSignature] = useState('');
  const [verifyResult, setVerifyResult] = useState<string>('');

  // 模拟前端持有的私钥（实际项目中应从安全存储获取）
  const PRIVATE_KEY = 'your_private_key_hex_64_chars';

  const handleSign = () => {
    const sig = sign(message, PRIVATE_KEY);
    setSignature(sig);
    console.log('签名结果:', sig);
  };

  const handleVerify = async () => {
    // 调用后端验签接口
    const response = await fetch('/api/sm2/verify', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ message, signature }),
    });
    const result = await response.json();
    setVerifyResult(result.message);
  };

  return (
    <div>
      <h2>SM2 签名验签演示</h2>
      <div>
        <label>消息：</label>
        <input value={message} onChange={e => setMessage(e.target.value)} />
      </div>
      <button onClick={handleSign}>前端签名</button>
      <div>
        <label>签名：</label>
        <textarea value={signature} readOnly rows={3} style={{ width: '100%' }} />
      </div>
      <button onClick={handleVerify}>后端验签</button>
      {verifyResult && <p>验签结果：{verifyResult}</p>}
    </div>
  );
};

export default Sm2SignDemo;

前端                                          后端
  │                                            │
  │  1. 用户输入消息 M                          │
  │                                            │
  │  2. 用私钥签名                              │
  │     sig = SM2.sign(M, privateKey, userId)  │
  │                                            │
  │  3. 发送请求 ──────────────────────────────→│
  │     POST /api/sm2/verify                   │
  │     { message: M, signature: sig }         │
  │                                            │
  │                    4. 用公钥验签             │
  │                       valid = SM2.verify(   │
  │                         M, sig, pubKey,     │
  │                         userId)             │
  │                                            │
  │  5. 返回结果 ←──────────────────────────────│
  │     { code: 200, valid: true }             │
  │                                            │

public class Sm2SignTest {

    public static void main(String[] args) {
        // 测试密钥对（实际项目中从证书或配置获取）
        String privateKey = "aabbccdd11223344aabbccdd11223344aabbccdd11223344aabbccdd11223344";
        String publicKey = "04"
            + "aabbccdd11223344aabbccdd11223344aabbccdd11223344aabbccdd11223344"
            + "aabbccdd11223344aabbccdd11223344aabbccdd11223344aabbccdd11223344";

        String message = "Hello, SM2!";
        String userId = "1234567812345678";

        // 1. 签名
        String signature = Sm2SignUtil.sign(privateKey, message, userId);
        System.out.println("签名结果: " + signature);
        System.out.println("签名长度: " + signature.length() + " 字符");  // 128

        // 2. 验签（使用正确的公钥和 userId）
        boolean valid = Sm2SignUtil.verify(publicKey, message, signature, userId);
        System.out.println("验签结果（正确参数）: " + valid);  // true

        // 3. 验签失败场景：错误的 userId
        boolean validWrongUserId = Sm2SignUtil.verify(publicKey, message, signature, "wrong_user_id");
        System.out.println("验签结果（错误userId）: " + validWrongUserId);  // false

        // 4. 验签失败场景：篡改消息
        boolean validTampered = Sm2SignUtil.verify(publicKey, "Tampered message", signature, userId);
        System.out.println("验签结果（篡改消息）: " + validTampered);  // false

        // 5. 验签失败场景：错误公钥
        String wrongPubKey = "04" + "00".repeat(64);
        boolean validWrongKey = Sm2SignUtil.verify(wrongPubKey, message, signature, userId);
        System.out.println("验签结果（错误公钥）: " + validWrongKey);  // false
    }
}

import { sign, verify, generateKeyPair } from './utils/sm2';

// 1. 生成密钥对
const keyPair = generateKeyPair();
console.log('私钥:', keyPair.privateKey, '长度:', keyPair.privateKey.length);   // 64
console.log('公钥:', keyPair.publicKey, '长度:', keyPair.publicKey.length);    // 130

// 2. 签名
const message = 'Hello, SM2!';
const signature = sign(message, keyPair.privateKey);
console.log('签名:', signature, '长度:', signature.length);  // 128

// 3. 本地验签
const valid = verify(message, signature, keyPair.publicKey);
console.log('本地验签:', valid);  // true

// 4. 篡改消息验签
const validTampered = verify('Tampered', signature, keyPair.publicKey);
console.log('篡改验签:', validTampered);  // false

// r||s → DER
public static String rsToDer(String rsHex) {
    byte[] rs = HexUtil.decodeHex(rsHex);
    byte[] r = new byte[32];
    byte[] s = new byte[32];
    System.arraycopy(rs, 0, r, 0, 32);
    System.arraycopy(rs, 32, s, 0, 32);

    ASN1EncodableVector v = new ASN1EncodableVector();
    v.add(new ASN1Integer(new BigInteger(1, r)));  // 注意：BigInteger(1, ...) 避免负数
    v.add(new ASN1Integer(new BigInteger(1, s)));
    return HexUtil.encodeHexStr(new DERSequence(v).getEncoded());
}

// 重放攻击防护示例
@PostMapping("/verify")
public Map<String, Object> verify(@RequestBody SignRequest request) {
    // 1. 检查时间戳（5 分钟内有效）
    long now = System.currentTimeMillis();
    if (Math.abs(now - request.getTimestamp()) > 5 * 60 * 1000) {
        return Map.of("code", 403, "message", "签名已过期");
    }
    // 2. 检查 nonce 是否已使用（Redis 缓存）
    if (nonceCache.exists(request.getNonce())) {
        return Map.of("code", 403, "message", "签名已使用");
    }
    nonceCache.set(request.getNonce(), "1", 5, TimeUnit.MINUTES);
    // 3. 验签
    boolean valid = Sm2SignUtil.verify(PUBLIC_KEY, request.getMessage(), request.getSignature());
    return Map.of("code", 200, "valid", valid);
}