国密算法（SM2/SM3/SM4）

国密算法（SM2/SM3/SM4）详解：从性能对比到Java手机号安全处理实战

随着信息安全上升为国家战略，国密（国家商用密码）算法在金融、政务、物联网等关键领域得到了广泛应用。本文将带您深入了解国密的核心算法（SM2/SM3/SM4），对比它们的性能差异，并提供一份在Java中安全处理手机号的完整代码示例。

一、 国密核心算法简介

国密算法是一套由国家密码管理局发布的商用密码标准，主要包含以下三个核心算法：

1. SM2：非对称加密算法

   • 类型：非对称加密与签名算法。
   • 对标：国际上的 ECC（椭圆曲线密码算法），功能类似 RSA。
   • 用途：主要用于数字签名、身份认证和密钥协商。由于其计算复杂度高，不适合加密大量数据，通常用于加密对称密钥（如SM4的密钥）或对数据摘要进行签名。

2. SM3：哈希算法

   • 类型：密码杂凑算法（哈希函数）。
   • 对标：国际上的 SHA-256。
   • 用途：用于生成数据的唯一“数字指纹”，以保证数据完整性和身份验证。它是一个单向函数，意味着无法从哈希值反推出原文。这是存储密码、手机号等敏感信息的理想选择。

3. SM4：对称加密算法

   • 类型：对称加密算法（分组密码）。
   • 对标：国际上的 AES。
   • 用途：用于大量数据（如文件、通信报文）的加密和解密。收发双方使用相同的密钥进行加解密，速度快，效率高。

二、 性能深度对比

这三个算法的设计目标不同，因此性能差异巨大。简单来说，它们的计算速度排行如下：

SM3 (最快) > SM4 (很快) > SM2 (相对最慢)

• 为什么SM3最快？ 它的计算是纯粹的位运算，CPU执行效率极高，专为速度而生。
• 为什么SM4居中？ 它需要对数据分组并进行多轮复杂的迭代变换，比SM3慢，但远快于SM2，适合处理大数据。
• 为什么SM2最慢？ 它基于复杂的椭圆曲线数学难题，计算量巨大，但提供了非对称加密独有的安全性（如密钥交换和数字签名）。

三、 Java实战：手机号的安全处理

对于“加密”手机号，我们有两种主流且安全的方案，适用于不同业务场景。

方案一：使用SM3哈希存储（推荐用于验证场景）

当你的业务只需要验证用户输入的手机号是否正确，而不需要知道手机号原文时（例如用户注册、登录），这是最安全、最推荐的做法。

• 优点：不可逆。即使数据库泄露，攻击者也无法获得原始手机号。
• 实践：结合**加盐（Salt）**可以抵御彩虹表攻击，安全性更高。

方案二：使用SM4加密存储（用于需要原文的场景）

当你的业务必须使用手机号原文时（例如发送短信验证码、进行外呼），你需要使用可逆的对称加密。

• 优点：可以解密还原出原始手机号。
• 挑战：密钥的保护至关重要。密钥一旦泄露，所有数据都将暴露。

Java代码示例

首先，请确保你的项目中已添加 Bouncy Castle 依赖。

Maven pom.xml:

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk18on</artifactId>
    <version>1.78.1</version>
</dependency>

示例1：使用SM3哈希手机号（含加盐）

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Hex;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.Security;

/**
 * 国密 SM3 哈希工具类（推荐用于密码、手机号等敏感信息的存储）
 */
public class Sm3Demo {

    static {
        // 注册 Bouncy Castle 提供者
        if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
            Security.addProvider(new BouncyCastleProvider());
        }
    }

    /**
     * 生成一个安全的随机盐
     * @param aLength 盐的字节长度
     * @return 十六进制表示的盐字符串
     */
    public static String generateSalt(int length) {
        SecureRandom random = new SecureRandom();
        byte[] salt = new byte[length];
        random.nextBytes(salt);
        return Hex.toHexString(salt);
    }

    /**
     * 对输入字符串进行加盐 SM3 哈希
     *
     * @param input 待哈希的原文
     * @param salt  盐值（十六进制字符串）
     * @return 64位的十六进制哈希值
     */
    public static String hashWithSalt(String input, String salt) {
        if (input == null || salt == null) {
            return null;
        }

        // 盐值在前或在后，或混合都可以，但要保持一致
        String dataToHash = salt + input;

        try {
            MessageDigest digest = MessageDigest.getInstance("SM3", BouncyCastleProvider.PROVIDER_NAME);
            byte[] hashBytes = digest.digest(dataToHash.getBytes(StandardCharsets.UTF_8));
            return Hex.toHexString(hashBytes);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("SM3 algorithm not found", e);
        }
    }

    public static void main(String[] args) {
        String phoneNumber = "15888888888";

        // 1. 为该手机号生成一个唯一的盐
        // 在实际应用中，这个盐需要与哈希值一起存储在数据库的用户记录中
        String salt = generateSalt(16); // 生成16字节（32个十六进制字符）的盐

        System.out.println("原始手机号: " + phoneNumber);
        System.out.println("生成的盐 (Salt): " + salt);

        // 2. 计算加盐后的哈希值
        String hashedPhoneNumber = hashWithSalt(phoneNumber, salt);
        System.out.println("SM3 加盐哈希值: " + hashedPhoneNumber);
        System.out.println("哈希值长度: " + hashedPhoneNumber.length());

        // 3. 验证过程 (模拟用户登录)
        System.out.println("\n--- 用户验证 ---");
        String userInputPhone = "15888888888";
        // 从数据库中取出该用户存储的 salt 和 hashedPhoneNumber
        String storedSalt = salt;
        String storedHash = hashedPhoneNumber;

        // 使用相同的盐对用户输入进行哈希
        String verificationHash = hashWithSalt(userInputPhone, storedSalt);
        System.out.println("验证哈希: " + verificationHash);
        System.out.println("验证是否通过: " + storedHash.equals(verificationHash));

        // 错误输入
        String wrongInputPhone = "15800000000";
        String wrongVerificationHash = hashWithSalt(wrongInputPhone, storedSalt);
        System.out.println("错误输入验证是否通过: " + storedHash.equals(wrongVerificationHash));
    }
}

示例2：使用SM4加密/解密手机号

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Base64;

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

/**
 * 国密 SM4 对称加密工具类（用于需要还原原文的场景）
 */
public class Sm4Demo {

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

    private static final String ALGORITHM_NAME = "SM4";
    // SM4/CBC/PKCS5Padding 是一种常用的加密模式
    // CBC 模式需要一个初始化向量 (IV)
    private static final String PADDING_MODE = "SM4/CBC/PKCS5Padding";

    /**
     * 生成一个 SM4 密钥 (128位/16字节)
     * @return Base64 编码的密钥字符串
     */
    public static String generateKey() throws Exception {
        KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM_NAME, BouncyCastleProvider.PROVIDER_NAME);
        kg.init(128, new SecureRandom());
        return Base64.toBase64String(kg.generateKey().getEncoded());
    }

    /**
     * 生成一个初始化向量 (IV) (128位/16字节)
     * @return Base64 编码的 IV 字符串
     */
    public static String generateIv() {
        byte[] iv = new byte[16];
        new SecureRandom().nextBytes(iv);
        return Base64.toBase64String(iv);
    }
    
    /**
     * SM4 加密
     * @param plainText 明文
     * @param key Base64 编码的密钥
     * @param iv Base64 编码的 IV
     * @return Base64 编码的密文
     */
    public static String encrypt(String plainText, String key, String iv) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(Base64.decode(key), ALGORITHM_NAME);
        IvParameterSpec ivSpec = new IvParameterSpec(Base64.decode(iv));
        
        Cipher cipher = Cipher.getInstance(PADDING_MODE, BouncyCastleProvider.PROVIDER_NAME);
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
        
        byte[] encryptedBytes = cipher.doFinal(plainText.getBytes(StandardCharsets.UTF_8));
        return Base64.toBase64String(encryptedBytes);
    }

    /**
     * SM4 解密
     * @param cipherText Base64 编码的密文
     * @param key Base64 编码的密钥
     * @param iv Base64 编码的 IV
     * @return 明文
     */
    public static String decrypt(String cipherText, String key, String iv) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(Base64.decode(key), ALGORITHM_NAME);
        IvParameterSpec ivSpec = new IvParameterSpec(Base64.decode(iv));

        Cipher cipher = Cipher.getInstance(PADDING_MODE, BouncyCastleProvider.PROVIDER_NAME);
        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);

        byte[] decryptedBytes = cipher.doFinal(Base64.decode(cipherText));
        return new String(decryptedBytes, StandardCharsets.UTF_8);
    }

    public static void main(String[] args) throws Exception {
        String phoneNumber = "15888888888";
        
        // 在真实应用中，密钥和 IV 必须被安全地存储和管理，例如使用硬件加密机(HSM)或配置中心
        String sm4Key = generateKey();
        String sm4Iv = generateIv();

        System.out.println("原始手机号: " + phoneNumber);
        System.out.println("SM4 密钥 (Base64): " + sm4Key);
        System.out.println("SM4 IV (Base64): " + sm4Iv);

        // 加密
        String encryptedPhone = encrypt(phoneNumber, sm4Key, sm4Iv);
        System.out.println("SM4 加密后 (Base64): " + encryptedPhone);

        // 解密
        String decryptedPhone = decrypt(encryptedPhone, sm4Key, sm4Iv);
        System.out.println("SM4 解密后: " + decryptedPhone);

        System.out.println("解密是否成功: " + phoneNumber.equals(decryptedPhone));
    }
}

结论

• 选择合适的工具：没有“最好”的算法，只有“最合适”的场景。请根据你的业务需求选择正确的国密算法。
• SM3哈希优先：当处理用户密码、手机号等用于验证的敏感信息时，优先采用SM3加盐哈希，这是最安全的存储方式。
• 谨慎使用SM4：只有在业务流程中确实需要恢复原文时，才使用SM4加密。同时，必须投入资源确保密钥的安全，因为密钥就是一切。
• 协同工作：在复杂的系统中，SM2、SM3、SM4往往协同工作，共同构建起一个完整的、高强度的安全体系。