国密实战（三）：SM2+SM4 数字信封完整实现（对接国企实战）

发送方                              接收方
  │                                  │
  │ 1. 生成随机 SM4 密钥 K            │
  │ 2. SM4(K) 加密业务数据 → 密文 C    │
  │ 3. SM2(接收方公钥) 加密 K → 加密密钥 E│
  │ 4. DER 编码 (E + C)               │
  │ 5. 发送 ─────────────────────────→│
  │                    6. ASN.1 解码   │
  │                    7. SM2(接收方私钥) 解密 E → K │
  │                    8. SM4(K) 解密 C → 明文 │
  │                                  │

步骤1: 生成 SM4 密钥
  K = SecureRandom(16 字节)   // 每次加密重新生成

步骤2: SM4 加密业务数据
  C = SM4_ECB_Encrypt(plaintext, K)
  注：ECB 模式简单，适合单块数据；大文件建议 CBC 模式

步骤3: SM2 加密 SM4 密钥
  E = SM2_Encrypt(K, receiverPublicKey)
  密文格式: C1C3C2（65 + 32 + 16 = 113 字节）

步骤4: ASN.1 DER 编码
  将 E 和 C 封装为 DER 结构

<dependencies>
    <!-- BouncyCastle 核心加密库（推荐 jdk18on） -->
    <dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcprov-jdk18on</artifactId>
        <version>1.84</version>
    </dependency>
    <dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcpkix-jdk18on</artifactId>
        <version>1.84</version>
    </dependency>
</dependencies>

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;
import java.security.Security;

/**
 * SM4 对称加密工具类
 *
 * 支持 ECB/CBC 模式，默认 PKCS5Padding 填充。
 * SM4 密钥固定 128 位（16 字节），分组长度 128 位。
 */
public class Sm4Util {

    static {
        if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
            Security.addProvider(new BouncyCastleProvider());
        }
    }

    /** SM4 算法名称 */
    private static final String ALGORITHM = "SM4";

    /** ECB 模式变换（适合单块小数据） */
    private static final String ECB_TRANSFORMATION = "SM4/ECB/PKCS5Padding";

    /** CBC 模式变换（适合大数据，需要 IV） */
    private static final String CBC_TRANSFORMATION = "SM4/CBC/PKCS5Padding";

    /**
     * SM4 ECB 加密
     *
     * @param plaintext 明文字节数组
     * @param key       SM4 密钥（必须 16 字节）
     * @return 密文字节数组
     * @throws Exception 加密异常
     */
    public static byte[] encryptEcb(byte[] plaintext, byte[] key) throws Exception {
        validateKey(key);
        SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM);
        Cipher cipher = Cipher.getInstance(ECB_TRANSFORMATION, "BC");
        cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        return cipher.doFinal(plaintext);
    }

    /**
     * SM4 ECB 解密
     *
     * @param ciphertext 密文字节数组
     * @param key        SM4 密钥（必须 16 字节）
     * @return 明文字节数组
     * @throws Exception 解密异常
     */
    public static byte[] decryptEcb(byte[] ciphertext, byte[] key) throws Exception {
        validateKey(key);
        SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM);
        Cipher cipher = Cipher.getInstance(ECB_TRANSFORMATION, "BC");
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        return cipher.doFinal(ciphertext);
    }

    /**
     * SM4 CBC 加密（需要 IV）
     *
     * @param plaintext 明文
     * @param key       SM4 密钥（16 字节）
     * @param iv        初始化向量（16 字节）
     * @return 密文
     */
    public static byte[] encryptCbc(byte[] plaintext, byte[] key, byte[] iv) throws Exception {
        validateKey(key);
        if (iv == null || iv.length != 16) {
            throw new IllegalArgumentException("IV 必须为 16 字节");
        }
        SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM);
        javax.crypto.spec.IvParameterSpec ivSpec = new javax.crypto.spec.IvParameterSpec(iv);
        Cipher cipher = Cipher.getInstance(CBC_TRANSFORMATION, "BC");
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
        return cipher.doFinal(plaintext);
    }

    /**
     * SM4 CBC 解密
     */
    public static byte[] decryptCbc(byte[] ciphertext, byte[] key, byte[] iv) throws Exception {
        validateKey(key);
        SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM);
        javax.crypto.spec.IvParameterSpec ivSpec = new javax.crypto.spec.IvParameterSpec(iv);
        Cipher cipher = Cipher.getInstance(CBC_TRANSFORMATION, "BC");
        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
        return cipher.doFinal(ciphertext);
    }

    /**
     * 生成随机 SM4 密钥（16 字节）
     *
     * @return 16 字节随机密钥
     */
    public static byte[] generateKey() {
        byte[] key = new byte[16];
        new SecureRandom().nextBytes(key);
        return key;
    }

    /**
     * 生成随机 IV（16 字节，CBC 模式使用）
     */
    public static byte[] generateIv() {
        byte[] iv = new byte[16];
        new SecureRandom().nextBytes(iv);
        return iv;
    }

    /**
     * 校验密钥长度
     */
    private static void validateKey(byte[] key) {
        if (key == null || key.length != 16) {
            throw new IllegalArgumentException(
                "SM4 密钥必须为 16 字节，当前: " + (key == null ? "null" : key.length + " 字节"));
        }
    }
}

import org.bouncycastle.crypto.InvalidCipherTextException;
import org.bouncycastle.crypto.engines.SM2Engine;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.crypto.params.ECDomainParameters;
import org.bouncycastle.crypto.params.ParametersWithRandom;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;

import java.security.SecureRandom;

/**
 * SM2 加密解密工具类
 *
 * 使用 BouncyCastle SM2Engine，固定 C1C3C2 模式（新国密标准推荐）。
 * SM2 加密数据长度受限，通常只用于加密 SM4 密钥等小数据。
 */
public class Sm2CryptoUtil {

    /**
     * SM2 加密（C1C3C2 模式）
     *
     * @param data      待加密数据（通常为 16 字节 SM4 密钥）
     * @param publicKey SM2 公钥（BCECPublicKey）
     * @return SM2 密文字节数组（C1C3C2 格式）
     * @throws InvalidCipherTextException 加密异常
     */
    public static byte[] encrypt(byte[] data, BCECPublicKey publicKey) throws InvalidCipherTextException {
        // 从 JCE 公钥对象提取 BC 加密引擎所需的参数
        ECPublicKeyParameters pubKeyParams = new ECPublicKeyParameters(
            publicKey.getQ(),
            new ECDomainParameters(
                publicKey.getParameters().getCurve(),
                publicKey.getParameters().getG(),
                publicKey.getParameters().getN(),
                publicKey.getParameters().getH()
            )
        );

        // 使用 C1C3C2 模式（新国密标准推荐，ISO/IEC 18033-2 兼容）
        SM2Engine engine = new SM2Engine(SM2Engine.Mode.C1C3C2);
        // 必须使用 ParametersWithRandom 包装，确保每次加密使用新的随机数
        engine.init(true, new ParametersWithRandom(pubKeyParams, new SecureRandom()));

        return engine.processBlock(data, 0, data.length);
    }

    /**
     * SM2 解密（C1C3C2 模式）
     *
     * @param cipherData SM2 密文（C1C3C2 格式，通常 113 字节）
     * @param privateKey SM2 私钥（BCECPrivateKey）
     * @return 解密后的数据（通常为 16 字节 SM4 密钥）
     * @throws InvalidCipherTextException 解密异常
     */
    public static byte[] decrypt(byte[] cipherData, BCECPrivateKey privateKey) throws InvalidCipherTextException {
        ECPrivateKeyParameters privKeyParams = new ECPrivateKeyParameters(
            privateKey.getD(),
            new ECDomainParameters(
                privateKey.getParameters().getCurve(),
                privateKey.getParameters().getG(),
                privateKey.getParameters().getN(),
                privateKey.getParameters().getH()
            )
        );

        SM2Engine engine = new SM2Engine(SM2Engine.Mode.C1C3C2);
        engine.init(false, privKeyParams);

        return engine.processBlock(cipherData, 0, cipherData.length);
    }
}

import org.bouncycastle.asn1.*;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.bouncycastle.jce.ECNamedCurveTable;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.jce.spec.ECParameterSpec;
import org.bouncycastle.jce.spec.ECPrivateKeySpec;
import org.bouncycastle.jce.spec.ECPublicKeySpec;
import org.bouncycastle.math.ec.ECPoint;

import java.io.IOException;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.Security;

/**
 * SM2+SM4 数字信封
 *
 * 加密流程：
 *   1. 生成随机 SM4 密钥（16 字节）
 *   2. SM4 加密业务数据
 *   3. SM2 加密 SM4 密钥（使用接收方公钥）
 *   4. ASN.1 DER 编码（加密密钥 + 加密数据）
 *
 * 解密流程：
 *   1. ASN.1 DER 解码（提取加密密钥和加密数据）
 *   2. SM2 解密得到 SM4 密钥（使用接收方私钥）
 *   3. SM4 解密业务数据
 *
 * DER 编码结构：
 *   SEQUENCE {
 *       encryptedKey   OCTET STRING,  -- SM2 加密的 SM4 密钥（113 字节）
 *       encryptedData  OCTET STRING   -- SM4 加密的业务数据
 *   }
 */
public class DigitalEnvelope {

    static {
        if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
            Security.addProvider(new BouncyCastleProvider());
        }
    }

    // ============ 加密 ============

    /**
     * 创建数字信封（加密）
     *
     * @param plaintext          明文数据
     * @param receiverPubKeyHex  接收方 SM2 公钥 hex（130 字符，04 开头）
     * @return DER 编码的数字信封字节数组
     * @throws Exception 加密或编码异常
     */
    public static byte[] seal(byte[] plaintext, String receiverPubKeyHex) throws Exception {
        // 1. 生成随机 SM4 密钥（每次加密必须重新生成）
        byte[] sm4Key = Sm4Util.generateKey();

        // 2. SM4 加密业务数据
        byte[] encryptedData = Sm4Util.encryptEcb(plaintext, sm4Key);

        // 3. SM2 加密 SM4 密钥（使用接收方公钥）
        BCECPublicKey receiverPubKey = buildPublicKey(receiverPubKeyHex);
        byte[] encryptedKey = Sm2CryptoUtil.encrypt(sm4Key, receiverPubKey);

        // 4. ASN.1 DER 编码
        return derEncode(encryptedKey, encryptedData);
    }

    /**
     * 创建数字信封（加密）- 字符串版本
     *
     * @param plaintext          明文字符串（UTF-8 编码）
     * @param receiverPubKeyHex  接收方公钥 hex
     * @return DER 编码的 hex 字符串（适合网络传输）
     */
    public static String sealToHex(String plaintext, String receiverPubKeyHex) throws Exception {
        byte[] derBytes = seal(plaintext.getBytes(StandardCharsets.UTF_8), receiverPubKeyHex);
        return bytesToHex(derBytes);
    }

    // ============ 解密 ============

    /**
     * 打开数字信封（解密）
     *
     * @param derEnvelope        DER 编码的数字信封
     * @param receiverPrivKeyHex 接收方 SM2 私钥 hex（64 字符）
     * @return 解密后的明文数据
     * @throws Exception 解码或解密异常
     */
    public static byte[] open(byte[] derEnvelope, String receiverPrivKeyHex) throws Exception {
        // 1. ASN.1 DER 解码
        Asn1Data asn1Data = derDecode(derEnvelope);

        // 2. SM2 解密得到 SM4 密钥
        BCECPrivateKey receiverPrivKey = buildPrivateKey(receiverPrivKeyHex);
        byte[] sm4Key = Sm2CryptoUtil.decrypt(asn1Data.encryptedKey, receiverPrivKey);

        // 3. SM4 解密业务数据
        return Sm4Util.decryptEcb(asn1Data.encryptedData, sm4Key);
    }

    /**
     * 打开数字信封（解密）- 字符串版本
     *
     * @param derHex             DER 编码的 hex 字符串
     * @param receiverPrivKeyHex 接收方私钥 hex
     * @return 解密后的明文字符串
     */
    public static String openFromHex(String derHex, String receiverPrivKeyHex) throws Exception {
        byte[] derBytes = hexToBytes(derHex);
        byte[] plaintext = open(derBytes, receiverPrivKeyHex);
        return new String(plaintext, StandardCharsets.UTF_8);
    }

    // ============ ASN.1 DER 编码/解码 ============

    /**
     * DER 编码：将加密密钥和加密数据封装为 ASN.1 SEQUENCE
     *
     * 结构：
     * SEQUENCE {
     *     encryptedKey   OCTET STRING,  -- SM2 加密的 SM4 密钥
     *     encryptedData  OCTET STRING   -- SM4 加密的业务数据
     * }
     */
    private static byte[] derEncode(byte[] encryptedKey, byte[] encryptedData) throws IOException {
        ASN1EncodableVector vector = new ASN1EncodableVector();
        vector.add(new DEROctetString(encryptedKey));
        vector.add(new DEROctetString(encryptedData));
        DERSequence sequence = new DERSequence(vector);
        return sequence.getEncoded();
    }

    /**
     * DER 解码：从 ASN.1 结构中提取加密密钥和加密数据
     */
    private static Asn1Data derDecode(byte[] derBytes) throws IOException {
        ASN1InputStream ais = new ASN1InputStream(derBytes);
        try {
            // 读取外层 SEQUENCE
            ASN1Sequence sequence = (ASN1Sequence) ais.readObject();

            // 提取加密密钥（第一个元素）
            DEROctetString encKeyOctets = (DEROctetString) sequence.getObjectAt(0);
            byte[] encryptedKey = encKeyOctets.getOctets();

            // 提取加密数据（第二个元素）
            DEROctetString encDataOctets = (DEROctetString) sequence.getObjectAt(1);
            byte[] encryptedData = encDataOctets.getOctets();

            return new Asn1Data(encryptedKey, encryptedData);
        } finally {
            ais.close();
        }
    }

    // ============ 密钥构建辅助方法 ============

    /**
     * 从 hex 构建 SM2 公钥
     *
     * @param hexKey 130 字符 hex 公钥（04 开头，可省略 04）
     * @return BCECPublicKey 对象
     */
    private static BCECPublicKey buildPublicKey(String hexKey) throws Exception {
        String fullHex = hexKey;
        if (!fullHex.startsWith("04")) {
            fullHex = "04" + fullHex;
        }
        ECParameterSpec ecSpec = ECNamedCurveTable.getParameterSpec("sm2p256v1");
        ECPoint point = ecSpec.getCurve().decodePoint(hexToBytes(fullHex));
        ECPublicKeySpec pubSpec = new ECPublicKeySpec(point, ecSpec);
        KeyFactory kf = KeyFactory.getInstance("EC", "BC");
        return (BCECPublicKey) kf.generatePublic(pubSpec);
    }

    /**
     * 从 hex 构建 SM2 私钥
     *
     * @param hexKey 64 字符 hex 私钥
     * @return BCECPrivateKey 对象
     */
    private static BCECPrivateKey buildPrivateKey(String hexKey) throws Exception {
        String padded = String.format("%064s", hexKey).replace(' ', '0');
        BigInteger d = new BigInteger(padded, 16);
        ECParameterSpec ecSpec = ECNamedCurveTable.getParameterSpec("sm2p256v1");
        ECPrivateKeySpec privSpec = new ECPrivateKeySpec(d, ecSpec);
        KeyFactory kf = KeyFactory.getInstance("EC", "BC");
        return (BCECPrivateKey) kf.generatePrivate(privSpec);
    }

    // ============ 工具方法 ============

    /** 字节数组转 hex 字符串 */
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder(bytes.length * 2);
        for (byte b : bytes) {
            sb.append(String.format("%02x", b & 0xFF));
        }
        return sb.toString();
    }

    /** hex 字符串转字节数组 */
    private static byte[] hexToBytes(String hex) {
        int len = hex.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4)
                + Character.digit(hex.charAt(i + 1), 16));
        }
        return data;
    }

    /**
     * ASN.1 解码结果内部类
     */
    private static class Asn1Data {
        final byte[] encryptedKey;
        final byte[] encryptedData;

        Asn1Data(byte[] encryptedKey, byte[] encryptedData) {
            this.encryptedKey = encryptedKey;
            this.encryptedData = encryptedData;
        }
    }
}

import java.nio.charset.StandardCharsets;

/**
 * SM2+SM4 数字信封完整测试
 */
public class DigitalEnvelopeTest {

    public static void main(String[] args) throws Exception {
        // ============ 准备密钥对 ============
        // 实际项目中从证书/PFX 中提取，参考本系列第一篇文章
        String receiverPrivKey = "aabbccdd11223344aabbccdd11223344aabbccdd11223344aabbccdd11223344";
        String receiverPubKey = "04"
            + "aabbccdd11223344aabbccdd11223344aabbccdd11223344aabbccdd11223344"
            + "aabbccdd11223344aabbccdd11223344aabbccdd11223344aabbccdd11223344";

        // 业务数据
        String plaintext = "{\"orderId\":\"20240101001\",\"amount\":9999.00,\"merchant\":\"国企测试商户\"}";
        System.out.println("原始明文: " + plaintext);
        System.out.println("明文长度: " + plaintext.getBytes(StandardCharsets.UTF_8).length + " 字节");

        // ============ 加密（发送方） ============
        System.out.println("\n===== 加密 =====");

        // 方式1：字节数组版本
        byte[] derEnvelope = DigitalEnvelope.seal(
            plaintext.getBytes(StandardCharsets.UTF_8),
            receiverPubKey
        );
        System.out.println("DER 编码长度: " + derEnvelope.length + " 字节");

        // 方式2：hex 字符串版本（适合网络传输）
        String derHex = DigitalEnvelope.sealToHex(plaintext, receiverPubKey);
        System.out.println("DER hex 长度: " + derHex.length() + " 字符");
        System.out.println("DER hex 前 100 字符: " + derHex.substring(0, Math.min(100, derHex.length())) + "...");

        // ============ 解密（接收方） ============
        System.out.println("\n===== 解密 =====");

        // 方式1：字节数组版本
        byte[] decrypted = DigitalEnvelope.open(derEnvelope, receiverPrivKey);
        String decryptedText = new String(decrypted, StandardCharsets.UTF_8);
        System.out.println("解密结果: " + decryptedText);

        // 方式2：hex 字符串版本
        String decryptedFromHex = DigitalEnvelope.openFromHex(derHex, receiverPrivKey);
        System.out.println("解密结果(hex): " + decryptedFromHex);

        // 验证
        boolean match = plaintext.equals(decryptedText);
        System.out.println("\n解密验证: " + (match ? "✅ 成功" : "❌ 失败"));

        // ============ 大数据测试 ============
        System.out.println("\n===== 大数据测试 =====");
        StringBuilder largeData = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            largeData.append("测试数据行").append(i).append("\n");
        }
        String largePlaintext = largeData.toString();
        int largeSize = largePlaintext.getBytes(StandardCharsets.UTF_8).length;
        System.out.println("大数据长度: " + largeSize + " 字节 (" + String.format("%.2f", largeSize / 1024.0) + " KB)");

        byte[] largeEnvelope = DigitalEnvelope.seal(
            largePlaintext.getBytes(StandardCharsets.UTF_8),
            receiverPubKey
        );
        byte[] largeDecrypted = DigitalEnvelope.open(largeEnvelope, receiverPrivKey);
        boolean largeMatch = largePlaintext.equals(new String(largeDecrypted, StandardCharsets.UTF_8));
        System.out.println("大数据解密验证: " + (largeMatch ? "✅ 成功" : "❌ 失败"));
    }
}

请求格式：
POST /api/data/exchange
Content-Type: application/json

{
  "appId": "YOUR_APP_ID",
  "timestamp": 1704067200000,
  "data": "<DER编码的hex字符串>",
  "sign": "<SM2签名的hex字符串>"
}

响应格式：
{
  "code": "0000",
  "message": "success",
  "data": "<DER编码的hex字符串>"
}

/**
 * 构造加密请求
 */
public Map<String, String> buildEncryptedRequest(String bizData, String partnerPubKey) throws Exception {
    // 1. 用数字信封加密业务数据
    String encryptedData = DigitalEnvelope.sealToHex(bizData, partnerPubKey);

    // 2. 构造待签名内容（按字典序拼接参数）
    long timestamp = System.currentTimeMillis();
    String appId = "YOUR_APP_ID";
    String signContent = "appId=" + appId + "&data=" + encryptedData + "&timestamp=" + timestamp;

    // 3. SM2 签名
    String sign = Sm2SignUtil.sign(ownPrivateKey, signContent);

    // 4. 组装请求
    Map<String, String> request = new HashMap<>();
    request.put("appId", appId);
    request.put("timestamp", String.valueOf(timestamp));
    request.put("data", encryptedData);
    request.put("sign", sign);
    return request;
}

/**
 * 解密并验证请求
 */
public String processEncryptedRequest(Map<String, String> request, String partnerPubKey) throws Exception {
    // 1. 验签
    String appId = request.get("appId");
    String data = request.get("data");
    String timestamp = request.get("timestamp");
    String sign = request.get("sign");

    String signContent = "appId=" + appId + "&data=" + data + "&timestamp=" + timestamp;
    boolean valid = Sm2SignUtil.verify(partnerPubKey, signContent, sign);
    if (!valid) {
        throw new SecurityException("签名验证失败");
    }

    // 2. 检查时间戳（5 分钟内有效）
    long reqTime = Long.parseLong(timestamp);
    if (Math.abs(System.currentTimeMillis() - reqTime) > 5 * 60 * 1000) {
        throw new SecurityException("请求已过期");
    }

    // 3. 解密数字信封
    return DigitalEnvelope.openFromHex(data, ownPrivateKey);
}