国密算法#

import org.bouncycastle.crypto.signers.SM2Signer;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.jce.spec.ECParameterSpec;
import org.bouncycastle.util.encoders.Hex;

/**
 * SM2 签名实现
 */
public class Sm2Signature {
    
    /**
     * SM2 签名
     */
    public static byte[] sign(byte[] message, byte[] privateKey) throws Exception {
        
        // 1. 初始化签名器
        SM2Signer signer = new SM2Signer();
        
        // 2. 设置私钥
        ECPrivateKeyParameters privateKeyParams = new ECPrivateKeyParameters(
            new BigInteger(1, privateKey),  // 去掉前导 0
            Sm2Constants.EC_PARAMS
        );
        
        // 3. 初始化签名（传入用户 ID 和椭圆曲线参数）
        // 用户 ID 用于签名的一部分，增强安全性
        byte[] userId = "1234567812345678".getBytes();  // 默认 ID
        signer.init(true, new ParametersWithID(privateKeyParams, userId));
        
        // 4. 签名
        signer.update(message, 0, message.length);
        byte[] signature = signer.generateSignature();
        
        return signature;
    }
    
    /**
     * SM2 验签
     */
    public static boolean verify(byte[] message, byte[] signature, byte[] publicKey) {
        
        SM2Signer signer = new SM2Signer();
        
        // 1. 设置公钥
        ECPublicKeyParameters publicKeyParams = new ECPublicKeyParameters(
            Sm2Constants.EC_CURVE.decodePoint(publicKey),
            Sm2Constants.EC_PARAMS
        );
        
        // 2. 初始化验签
        byte[] userId = "1234567812345678".getBytes();
        signer.init(false, new ParametersWithID(publicKeyParams, userId));
        
        // 3. 验签
        signer.update(message, 0, message.length);
        return signer.verifySignature(signature);
    }
}

/**
 * SM2 密钥交换
 */
public class Sm2KeyExchange {
    
    /**
     * 密钥交换参与者
     */
    public static class Party {
        private final byte[] privateKey;  // 临时私钥
        private final ECPoint publicKey;   // 临时公钥
        private final ECPoint theirPublicKey;  // 对方公钥
        
        public Party(byte[] privateKey, ECPoint publicKey, ECPoint theirPublicKey) {
            this.privateKey = privateKey;
            this.publicKey = publicKey;
            this.theirPublicKey = theirPublicKey;
        }
        
        public byte[] getSharedSecret() {
            // SM2 密钥交换协议
            // 计算 S = (dB + dA * RA) * PB
            // 其中 dA 是己方私钥，dB 是对方私钥（隐藏在 PB 中）
            return calculateSharedSecret();
        }
    }
    
    /**
     * 执行密钥交换
     */
    public static byte[] performKeyExchange(
            byte[] initiatorPrivateKey,
            byte[] responderPrivateKey,
            byte[] userIdA,
            byte[] userIdB) {
        
        // 1. 初始化椭圆曲线
        SM2Curve curve = new SM2Curve(Sm2Constants.P, Sm2Constants.A, Sm2Constants.B);
        SM2Point G = new SM2Point(Sm2Constants.GX, Sm2Constants.GY);
        
        // 2. 生成临时密钥对
        BigInteger dA = new BigInteger(1, initiatorPrivateKey);
        ECPoint RA = curve.multiply(G, dA);
        
        BigInteger dB = new BigInteger(1, responderPrivateKey);
        ECPoint RB = curve.multiply(G, dB);
        
        // 3. 计算共享密钥
        // KDF 是密钥派生函数
        byte[] ZA = calculateZ(userIdA);
        byte[] ZB = calculateZ(userIdB);
        
        // 计算 S = Hash(dA * (RB + h * dB * RA))
        BigInteger h = Sm2Constants.N;  // 协子阶
        ECPoint temp = curve.add(RB, curve.multiply(curve.multiply(G, h.multiply(dB)), dA));
        ECPoint S = curve.multiply(temp, dA);
        
        // KDF(S.x || ZA || ZB, klen)
        byte[] sharedKey = KDF(new byte[][]{S.getX().toByteArray(), ZA, ZB}, 32);
        
        return sharedKey;
    }
}

import org.bouncycastle.crypto.digests.SM3Digest;

/**
 * SM3 哈希实现
 */
public class Sm3Hash {
    
    /**
     * 计算 SM3 哈希
     */
    public static byte[] hash(byte[] message) {
        
        SM3Digest digest = new SM3Digest();
        digest.update(message, 0, message.length);
        
        byte[] hash = new byte[digest.getDigestSize()];
        digest.doFinal(hash, 0);
        
        return hash;
    }
    
    /**
     * 计算 SM3 哈希（十六进制字符串）
     */
    public static String hashHex(byte[] message) {
        byte[] hash = hash(message);
        return Hex.toHexString(hash);
    }
    
    /**
     * 计算 SM3 带盐哈希（用于密码存储）
     */
    public static byte[] hashWithSalt(byte[] message, byte[] salt, int iterations) {
        
        SM3Digest digest = new SM3Digest();
        
        // 初始值 = SM3(salt || message)
        byte[] input = new byte[salt.length + message.length];
        System.arraycopy(salt, 0, input, 0, salt.length);
        System.arraycopy(message, 0, input, salt.length, message.length);
        
        digest.update(input, 0, input.length);
        byte[] result = new byte[digest.getDigestSize()];
        digest.doFinal(result, 0);
        
        // 迭代哈希
        for (int i = 1; i < iterations; i++) {
            digest.reset();
            digest.update(result, 0, result.length);
            digest.doFinal(result, 0);
        }
        
        return result;
    }
}

import org.bouncycastle.crypto.engines.SM4Engine;
import org.bouncycastle.crypto.modes.GMCipherMode;
import org.bouncycastle.crypto.params.KeyParameter;
import org.bouncycastle.crypto.params.ParametersWithIV;

/**
 * SM4 加密实现
 */
public class Sm4Encryption {
    
    private static final int KEY_SIZE = 128;
    private static final int IV_SIZE = 128;
    
    /**
     * SM4 ECB 模式加密
     */
    public static byte[] encryptECB(byte[] plaintext, byte[] key) {
        
        SM4Engine engine = new SM4Engine();
        engine.init(true, new KeyParameter(key));  // true = 加密模式
        
        // ECB 模式需要填充
        byte[] padded = pkcs7Pad(plaintext, 16);
        
        byte[] ciphertext = new byte[padded.length];
        int offset = 0;
        
        // 分组加密
        while (offset < padded.length) {
            engine.processBlock(padded, offset, ciphertext, offset);
            offset += 16;
        }
        
        return ciphertext;
    }
    
    /**
     * SM4 CBC 模式加密
     */
    public static byte[] encryptCBC(byte[] plaintext, byte[] key, byte[] iv) {
        
        SM4Engine engine = new SM4Engine();
        GMCipherMode mode = new GMCipherMode.CBCBlockCipher(new SM4Engine());
        mode.init(true, new ParametersWithIV(new KeyParameter(key), iv));
        
        byte[] padded = pkcs7Pad(plaintext, 16);
        byte[] ciphertext = new byte[padded.length];
        
        int offset = 0;
        while (offset < padded.length) {
            mode.processBlock(padded, offset, ciphertext, offset);
            offset += 16;
        }
        
        return ciphertext;
    }
    
    /**
     * SM4 GCM 模式加密（带认证）
     */
    public static EncryptedData encryptGCM(byte[] plaintext, byte[] key, byte[] iv) {
        
        SM4Engine engine = new SM4Engine();
        GCMBlockCipher gcm = new GCMBlockCipher(engine);
        
        // 参数：密钥、IV 长度（12 字节推荐）、认证标签长度（16 字节）
        GCMParameters params = new GCMParameters(iv, 12);
        gcm.init(true, params);
        
        byte[] ciphertext = new byte[gcm.getOutputSize(plaintext.length)];
        byte[] tag = new byte[16];
        
        int len = gcm.processBytes(plaintext, 0, plaintext.length, ciphertext, 0);
        len += gcm.doFinal(ciphertext, len);
        
        // 前 len 字节是密文，后 16 字节是 tag
        byte[] result = new byte[len - 16];
        System.arraycopy(ciphertext, 0, result, 0, len - 16);
        System.arraycopy(ciphertext, len - 16, tag, 0, 16);
        
        return new EncryptedData(result, tag);
    }
    
    /**
     * PKCS#7 填充
     */
    private static byte[] pkcs7Pad(byte[] data, int blockSize) {
        int padding = blockSize - (data.length % blockSize);
        byte[] padded = new byte[data.length + padding];
        System.arraycopy(data, 0, padded, 0, data.length);
        for (int i = data.length; i < padded.length; i++) {
            padded[i] = (byte) padding;
        }
        return padded;
    }
    
    public record EncryptedData(byte[] ciphertext, byte[] tag) {}
}

import org.bouncycastle.jsse.provider.GMJSSEProvider;
import javax.net.ssl.*;

/**
 * 国密 TLS 配置
 */
public class GmTlsConfig {
    
    /**
     * 注册国密 provider
     */
    public static void registerGmProvider() {
        Security.insertProviderAt(new GMJSSEProvider(), 1);
    }
    
    /**
     * 创建国密 SSLContext
     */
    public static SSLContext createGmSSLContext(
            String keyStorePath,
            char[] keyStorePassword,
            String trustStorePath,
            char[] trustStorePassword) throws Exception {
        
        // 1. 加载国密密钥库
        KeyStore keyStore = KeyStore.getInstance("GMKEYSTORE");
        keyStore.load(new FileInputStream(keyStorePath), keyStorePassword);
        
        KeyStore trustStore = KeyStore.getInstance("GMTRUSTSTORE");
        trustStore.load(new FileInputStream(trustStorePath), trustStorePassword);
        
        // 2. 创建 KeyManager
        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(keyStore, keyStorePassword);
        
        // 3. 创建 TrustManager
        TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
        tmf.init(trustStore);
        
        // 4. 创建 SSLContext（使用 GMTLS）
        SSLContext sslContext = SSLContext.getInstance("GMTLS");
        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
        
        return sslContext;
    }
}

import org.bouncycastle.asn1.gm.*;
import org.bouncycastle.crypto.signers.*;
import org.bouncycastle.jce.provider.*;
import java.security.*;

/**
 * 国密算法使用示例
 */
public class GmAlgorithmExamples {
    
    /**
     * 生成 SM2 密钥对
     */
    public static KeyPair generateSm2KeyPair() throws Exception {
        // 注册国密 Provider
        Security.addProvider(new BouncyCastleProvider());
        
        // 使用 KeyPairGenerator
        KeyPairGenerator generator = KeyPairGenerator.getInstance("SM2", "BC");
        generator.initialize(256, new SecureRandom());
        
        return generator.generateKeyPair();
    }
    
    /**
     * SM2 签名
     */
    public static byte[] signSm2(byte[] data, PrivateKey privateKey) throws Exception {
        Signature signature = Signature.getInstance("SM3WithSM2", "BC");
        signature.initSign(privateKey);
        signature.update(data);
        return signature.sign();
    }
    
    /**
     * SM2 验签
     */
    public static boolean verifySm2(byte[] data, byte[] signature, PublicKey publicKey) 
            throws Exception {
        Signature sig = Signature.getInstance("SM3WithSM2", "BC");
        sig.initVerify(publicKey);
        sig.update(data);
        return sig.verify(signature);
    }
    
    /**
     * SM3 哈希
     */
    public static byte[] hashSm3(byte[] data) throws Exception {
        MessageDigest digest = MessageDigest.getInstance("SM3", "BC");
        return digest.digest(data);
    }
    
    /**
     * SM4 加密
     */
    public static byte[] encryptSm4(byte[] data, byte[] key) throws Exception {
        Cipher cipher = Cipher.getInstance("SM4/ECB/PKCS5Padding", "BC");
        SecretKey secretKey = new SecretKeySpec(key, "SM4");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        return cipher.doFinal(data);
    }
    
    /**
     * SM4 解密
     */
    public static byte[] decryptSm4(byte[] data, byte[] key) throws Exception {
        Cipher cipher = Cipher.getInstance("SM4/ECB/PKCS5Padding", "BC");
        SecretKey secretKey = new SecretKeySpec(key, "SM4");
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        return cipher.doFinal(data);
    }
}

/**
 * 双证书生成
 */
public class DualCertificateGeneration {
    
    /**
     * 生成签名证书
     * 私钥由用户自己生成
     */
    public static CertificateRequest generateSigningCertificate(String userId) 
            throws Exception {
        
        // 1. 用户自己生成签名密钥对
        KeyPair signingKeyPair = KeyPairGenerator.getInstance("SM2", "BC")
            .generateKeyPair();
        
        // 2. 生成 CSR（用户持有私钥）
        PKCS10CertificationRequest csr = generateCSR(
            signingKeyPair.getPublic(),
            signingKeyPair.getPrivate(),
            userId,
            "signing"
        );
        
        // 3. 保存私钥（用户本地存储）
        savePrivateKey(signingKeyPair.getPrivate(), "signing-key.pem");
        
        return new CertificateRequest(csr, signingKeyPair.getPublic());
    }
    
    /**
     * 生成加密证书
     * 私钥由 CA 代为生成
     */
    public static EncryptedCertificateRequest generateEncryptionCertificate(
            String userId) throws Exception {
        
        // 1. CA 生成加密密钥对
        KeyPair encryptionKeyPair = KeyPairGenerator.getInstance("SM2", "BC")
            .generateKeyPair();
        
        // 2. CA 生成加密证书 CSR
        PKCS10CertificationRequest csr = generateCSR(
            encryptionKeyPair.getPublic(),
            encryptionKeyPair.getPrivate(),
            userId,
            "encryption"
        );
        
        // 3. 加密私钥并安全传输给用户
        byte[] encryptedPrivateKey = encryptPrivateKeyForUser(
            encryptionKeyPair.getPrivate(),
            userId
        );
        
        // 4. 返回加密证书请求和加密的私钥
        return new EncryptedCertificateRequest(
            csr, 
            encryptedPrivateKey,
            encryptionKeyPair.getPrivate()  // CA 保留用于密钥恢复
        );
    }
    
    /**
     * 用户接收加密证书
     */
    public static void receiveEncryptionCertificate(
            byte[] encryptedPrivateKey,
            byte[] encryptedCertificate,
            String userId) throws Exception {
        
        // 1. 解密私钥（使用用户口令和解密密钥）
        byte[] privateKey = decryptPrivateKey(encryptedPrivateKey, userId);
        
        // 2. 保存私钥
        savePrivateKey(privateKey, "encryption-key.pem");
        
        // 3. 保存证书
        saveCertificate(encryptedCertificate, "encryption-cert.pem");
    }
}