devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

国密SM2算法进行数据的加密、签名和验签、解密_sm2加解密

作者：不正经 | 2024-06-04 15:27:34

赞

踩

sm2加解密

一、算法介绍

SM2算法是中国密码学研究所（中国国家加密管理局）发布的一种非对称加密算法，适用于数字签名、密钥交换和公钥加密等场景。该算法基于椭圆曲线密码学，使用椭圆曲线上的点进行运算。

SM2算法的安全性主要基于椭圆曲线离散对数问题的难解性。它采用的是一个特定的椭圆曲线参数集，该参数集已经在国际上得到了广泛的认可。SM2算法的安全性与RSA算法和Diffie-Hellman算法相当。

SM2算法的主要特点如下：

  1. 安全性高：SM2算法基于椭圆曲线离散对数问题，具有较高的安全性。
  2. 算法效率高：SM2算法的计算量相对较小，适合在资源受限的环境中使用。
  3. 适用性广泛：SM2算法可用于数字签名、密钥交换和公钥加密等多种密码应用场景。
  4. 算法标准化：SM2算法已被国际电信联盟（ITU-T）和国际标准化组织（ISO）认可为国际标准。

总的来说，SM2算法是一种安全性高、效率高且广泛应用的非对称加密算法，被广泛应用于各种密码场景中。

二、引入pom依赖

  1. <dependency>
  2.     <groupId>org.bouncycastle</groupId>
  3.     <artifactId>bcprov-jdk15on</artifactId>
  4.     <version>1.70</version>
  5. </dependency>
  6. <!--注意检查是否已经引入lombok依赖，已经引入则不需要此依赖-->
  7. <dependency>
  8.     <groupId>org.projectlombok</groupId>
  9.     <artifactId>lombok</artifactId>
  10.     <scope>provided</scope>
  11. </dependency>

主要是引入了工具包和lombok依赖

 三、密钥对工具类

  1. package com.hl.sm2demo.util;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.bouncycastle.jce.provider.BouncyCastleProvider;
  5.  
  6. import java.security.*;
  7. import java.security.spec.ECGenParameterSpec;
  8. import java.security.spec.PKCS8EncodedKeySpec;
  9. import java.security.spec.X509EncodedKeySpec;
  10. import java.util.Base64;
  11. import java.util.Map;
  12.  
  13. /**
  14.  * @ Description 国密公私钥对工具类
  15.  */
  16. @Slf4j
  17. public class KeyUtils {
  18.     public static final String PUBLIC_KEY = "publicKey";
  19.  
  20.     public static final String PRIVATE_KEY = "privateKey";
  21.  
  22.     /**
  23.      * 生成国密公私钥对
  24.      */
  25.     public static Map<String, String> generateSmKey() throws Exception {
  26.         KeyPairGenerator keyPairGenerator = null;
  27.         SecureRandom secureRandom = new SecureRandom();
  28.         ECGenParameterSpec sm2Spec = new ECGenParameterSpec("sm2p256v1");
  29.         keyPairGenerator = KeyPairGenerator.getInstance("EC", new BouncyCastleProvider());
  30.         keyPairGenerator.initialize(sm2Spec);
  31.         keyPairGenerator.initialize(sm2Spec, secureRandom);
  32.         KeyPair keyPair = keyPairGenerator.generateKeyPair();
  33.         PrivateKey privateKey = keyPair.getPrivate();
  34.         PublicKey publicKey = keyPair.getPublic();
  35.         String publicKeyStr = new String(Base64.getEncoder().encode(publicKey.getEncoded()));
  36.         String privateKeyStr = new String(Base64.getEncoder().encode(privateKey.getEncoded()));
  37.         return Map.of(PUBLIC_KEY, publicKeyStr, PRIVATE_KEY, privateKeyStr);
  38.     }
  39.  
  40.     /**
  41.      * 将Base64转码的公钥串，转化为公钥对象
  42.      */
  43.     public static PublicKey createPublicKey(String publicKey) {
  44.         PublicKey publickey = null;
  45.         try {
  46.             X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));
  47.             KeyFactory keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider());
  48.             publickey = keyFactory.generatePublic(publicKeySpec);
  49.         } catch (Exception e) {
  50.             log.error("将Base64转码的公钥串，转化为公钥对象异常：{}", e.getMessage(), e);
  51.         }
  52.         return publickey;
  53.     }
  54.  
  55.     /**
  56.      * 将Base64转码的私钥串，转化为私钥对象
  57.      */
  58.     public static PrivateKey createPrivateKey(String privateKey) {
  59.         PrivateKey publickey = null;
  60.         try {
  61.             PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));
  62.             KeyFactory keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider());
  63.             publickey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
  64.         } catch (Exception e) {
  65.             log.error("将Base64转码的私钥串，转化为私钥对象异常：{}", e.getMessage(), e);
  66.         }
  67.         return publickey;
  68.     }
  69.  
  70. }

1.生成国密公私钥对：
方法generateSmKey()使用KeyPairGenerator生成一个基于椭圆曲线"sm2p256v1"的KeyPair，这是SM2算法所使用的曲线。
公钥和私钥分别编码为Base64字符串，然后以键值对的形式存储在Map中，键分别为PUBLIC_KEY和PRIVATE_KEY。

2.公钥对象的转换：
方法createPublicKey(String publicKey)接收一个Base64编码的公钥字符串，通过X509EncodedKeySpec解析成公钥对象。这里使用了KeyFactory实例化EC类型的公钥。

3.私钥对象的转换：
方法createPrivateKey(String privateKey)类似地，接收一个Base64编码的私钥字符串，通过PKCS8EncodedKeySpec解析成私钥对象。同样使用KeyFactory实例化EC类型的私钥。

四、 SM2工具类

  1. package com.hl.sm2demo.util;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.bouncycastle.asn1.gm.GMObjectIdentifiers;
  5. import org.bouncycastle.crypto.InvalidCipherTextException;
  6. import org.bouncycastle.crypto.engines.SM2Engine;
  7. import org.bouncycastle.crypto.params.ECDomainParameters;
  8. import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
  9. import org.bouncycastle.crypto.params.ECPublicKeyParameters;
  10. import org.bouncycastle.crypto.params.ParametersWithRandom;
  11. import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
  12. import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
  13. import org.bouncycastle.jce.provider.BouncyCastleProvider;
  14. import org.bouncycastle.jce.spec.ECParameterSpec;
  15.  
  16. import java.security.*;
  17.  
  18. /**
  19.  * @ Description SM2实现工具类
  20.  */
  21. @Slf4j
  22. public class Sm2Util {
  23. /*    这行代码是在Java中用于向安全系统添加Bouncy Castle安全提供器的。
  24.     Bouncy Castle是一个流行的开源加密库，它提供了许多密码学算法和安全协议的实现。
  26.     通过调用Security.addProvider并传入BouncyCastleProvider对象，你可以注册Bouncy Castle提供的安全服务和算法到Java的安全框架中。
  27.     这样一来，你就可以在你的应用程序中使用Bouncy Castle所提供的加密算法、密钥生成和管理等功能。*/
  28.     static {
  29.         Security.addProvider(new BouncyCastleProvider());
  30.     }
  31.  
  32.     /**
  33.      * 根据publicKey对原始数据data，使用SM2加密
  34.      */
  35.     public static byte[] encrypt(byte[] data, PublicKey publicKey) {
  36.         ECPublicKeyParameters localECPublicKeyParameters = getEcPublicKeyParameters(publicKey);
  37.         SM2Engine localSM2Engine = new SM2Engine();
  38.         localSM2Engine.init(true, new ParametersWithRandom(localECPublicKeyParameters, new SecureRandom()));
  39.         byte[] arrayOfByte2;
  40.         try {
  41.             arrayOfByte2 = localSM2Engine.processBlock(data, 0, data.length);
  42.             return arrayOfByte2;
  43.         } catch (InvalidCipherTextException e) {
  44.             log.error("SM2加密失败:{}", e.getMessage(), e);
  45.             return null;
  46.         }
  47.     }
  48.  
  49.     private static ECPublicKeyParameters getEcPublicKeyParameters(PublicKey publicKey) {
  50.         ECPublicKeyParameters localECPublicKeyParameters = null;
  51.         if (publicKey instanceof BCECPublicKey localECPublicKey) {
  52.             ECParameterSpec localECParameterSpec = localECPublicKey.getParameters();
  53.             ECDomainParameters localECDomainParameters = new ECDomainParameters(localECParameterSpec.getCurve(),
  54.                     localECParameterSpec.getG(), localECParameterSpec.getN());
  55.             localECPublicKeyParameters = new ECPublicKeyParameters(localECPublicKey.getQ(), localECDomainParameters);
  56.         }
  57.         return localECPublicKeyParameters;
  58.     }
  59.  
  60.     /**
  61.      * 根据privateKey对加密数据encode data，使用SM2解密
  62.      */
  63.     public static byte[] decrypt(byte[] encodeData, PrivateKey privateKey) {
  64.         SM2Engine localSM2Engine = new SM2Engine();
  65.         BCECPrivateKey sm2PriK = (BCECPrivateKey) privateKey;
  66.         ECParameterSpec localECParameterSpec = sm2PriK.getParameters();
  67.         ECDomainParameters localECDomainParameters = new ECDomainParameters(localECParameterSpec.getCurve(),
  68.                 localECParameterSpec.getG(), localECParameterSpec.getN());
  69.         ECPrivateKeyParameters localECPrivateKeyParameters = new ECPrivateKeyParameters(sm2PriK.getD(),
  70.                 localECDomainParameters);
  71.         localSM2Engine.init(false, localECPrivateKeyParameters);
  72.         try {
  73.             return localSM2Engine.processBlock(encodeData, 0, encodeData.length);
  74.         } catch (InvalidCipherTextException e) {
  75.             log.error("SM2解密失败:{}", e.getMessage(), e);
  76.             return null;
  77.         }
  78.     }
  79.  
  80.     /**
  81.      * 私钥签名
  82.      */
  83.     public static byte[] signByPrivateKey(byte[] data, PrivateKey privateKey) throws Exception {
  84.         Signature sig = Signature.getInstance(GMObjectIdentifiers.sm2sign_with_sm3.toString(), BouncyCastleProvider.PROVIDER_NAME);
  85.         sig.initSign(privateKey);
  86.         sig.update(data);
  87.         return sig.sign();
  88.     }
  89.  
  90.     /**
  91.      * 公钥验签
  92.      */
  93.     public static boolean verifyByPublicKey(byte[] data, PublicKey publicKey, byte[] signature) throws Exception {
  94.         Signature sig = Signature.getInstance(GMObjectIdentifiers.sm2sign_with_sm3.toString(), BouncyCastleProvider.PROVIDER_NAME);
  95.         sig.initVerify(publicKey);
  96.         sig.update(data);
  97.         return sig.verify(signature);
  98.     }
  99.  
  100. }

1.加密：
encrypt方法使用SM2算法对原始数据进行加密。它首先获取ECPublicKeyParameters对象，然后初始化SM2Engine并进行加密处理。如果加密过程中出现InvalidCipherTextException，则记录错误日志并返回null。

2.解密：
decrypt方法根据私钥解密加密数据。同样，初始化SM2Engine，进行解密处理。如果解密过程中出现InvalidCipherTextException，则记录错误日志并返回null。

3.签名：
signByPrivateKey方法使用私钥对数据进行签名。首先，创建一个Signature实例，指定SM2签名算法，初始化签名器，更新数据，然后生成签名。

4.验证：
verifyByPublicKey方法使用公钥验证签名。创建Signature实例，指定SM2签名算法，初始化验证器，更新数据，然后执行验证。返回验证结果，即布尔值表示签名是否有效

五、案例测试Junit 

  1. package com.hl.sm2demo;
  2.  
  3. import com.hl.sm2demo.util.KeyUtils;
  4. import com.hl.sm2demo.util.Sm2Util;
  5. import org.junit.jupiter.api.Test;
  6. import org.springframework.boot.test.context.SpringBootTest;
  7.  
  8. import java.security.PrivateKey;
  9. import java.security.PublicKey;
  10. import java.util.Base64;
  11. import java.util.Map;
  12.  
  13. @SpringBootTest
  14. class Sm2DemoApplicationTests {
  15.  
  16.     PublicKey publicKey = null;
  17.     PrivateKey privateKey = null;
  18.  
  19.  
  20.     @Test
  21.     public void test() throws Exception {
  22.         //生成公私钥对
  23.         Map<String,String> keys = KeyUtils.generateSmKey();
  24.  
  25.         String testStr = "hello JAVA";
  26.         System.out.println("原始字符串：" + testStr);
  27.         System.out.println("公钥：" + keys.get(KeyUtils.PUBLIC_KEY));
  28.         publicKey = KeyUtils.createPublicKey(keys.get(KeyUtils.PUBLIC_KEY));
  29.  
  30.         System.out.println("私钥：" + keys.get(KeyUtils.PRIVATE_KEY));
  31.         privateKey = KeyUtils.createPrivateKey(keys.get(KeyUtils.PRIVATE_KEY));
  32.  
  33.         System.out.println();
  34.  
  35.         //公钥加密
  36.         byte[] encrypt = Sm2Util.encrypt(testStr.getBytes(), publicKey);
  37.         //加密转base64
  38.         String encryptBase64Str = Base64.getEncoder().encodeToString(encrypt);
  39.         System.out.println("加密数据：" + encryptBase64Str);
  40.         //私钥签名,方便对方收到数据后用公钥验签
  41.         byte[] sign = Sm2Util.signByPrivateKey(testStr.getBytes(), privateKey);
  42.         System.out.println("数据签名：" + Base64.getEncoder().encodeToString(sign));
  43.  
  44.         //公钥验签，验证通过后再进行数据解密
  45.         boolean b = Sm2Util.verifyByPublicKey(testStr.getBytes(), publicKey, sign);
  46.         System.out.println("数据验签：" + b);
  47.         //私钥解密
  48.         byte[] decode = Base64.getDecoder().decode(encryptBase64Str);
  49.         byte[] decrypt = Sm2Util.decrypt(decode, privateKey);
  50.         assert decrypt != null;
  51.         System.out.println("解密数据：" + new String(decrypt));
  52.     }
  53. }

测试代码主要逻辑：

密钥准备：首先生成一个公私钥对字符串，再使用工具分别转换为公私钥的java对象；

加密过程：把数据使用公钥加密，把密文转换成base64编码格式，再用私钥签名；

解密过程：拿到加密数据后用公钥验签，以确保密文数据没有被第三方拦截篡改，验证通过后，base64解码，最后使用私钥进行解密，还原数据

测试结果如下图：

六、总结

SM2是一款优秀的国产加密算法，目前已经应用到多种领域内，保障了国家信息安全 ，我们日常开发中也可以尽量多使用SM系列的加密算法，如SM3、SM4等，支持国产从点点滴滴做起！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/672401
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号