远方蔚蓝
一刹那情真，相逢不如不见

文章数量 130

访问次数 611590

运行天数 2128

最近活跃 2026-08-05 15:50:46

进入后台管理系统

博客 - java使用SM2加解密及前端加密后端解密

java使用SM2加解密及前端加密后端解密

加密工具类1

1、实现前端加密，后端解密，前端需要引入js文件

  1. <script src="/business/libs/crypto-js.js"></script>
  3. // js调用方式
  4. var encryptData = sm2Encrypt('明文', '公钥', 0);

2、后端SM2生成公私钥及解密

  1. package wst.st.site.tools;
  3. import java.math.BigInteger;
  4. import java.nio.charset.StandardCharsets;
  5. import java.security.SecureRandom;
  7. import org.apache.commons.codec.binary.Base64;
  8. import org.bouncycastle.asn1.gm.GMNamedCurves;
  9. import org.bouncycastle.asn1.x9.X9ECParameters;
  10. import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
  11. import org.bouncycastle.crypto.engines.SM2Engine;
  12. import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
  13. import org.bouncycastle.crypto.params.ECDomainParameters;
  14. import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
  15. import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
  16. import org.bouncycastle.crypto.params.ECPublicKeyParameters;
  17. import org.bouncycastle.crypto.params.ParametersWithRandom;
  18. import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
  19. import org.bouncycastle.jce.provider.BouncyCastleProvider;
  20. import org.bouncycastle.jce.spec.ECParameterSpec;
  21. import org.bouncycastle.jce.spec.ECPrivateKeySpec;
  22. import org.bouncycastle.math.ec.ECPoint;
  23. import org.bouncycastle.util.encoders.Hex;
  25. import wst.st.site.constant.SiteWebConstant;
  27. /**
  28.  * SM2工具类
  29.  * 
  30.  * @author wst 2023年8月21日 上午10:32:33
  31.  *
  32.  */
  33. public class SM2Util {
  35.     public static void main(String[] args) throws Exception {
  37.     }
  39.     /**
  40.      * 生成密钥
  41.      * 
  42.      * @author wst 2023年8月21日 上午10:37:37
  43.      */
  44.     public static void getPKs() {
  45.         try {
  46.             X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
  47.             ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(),
  48.                     sm2ECParameters.getG(), sm2ECParameters.getN());
  49.             ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
  50.             keyPairGenerator
  51.                     .init(new ECKeyGenerationParameters(domainParameters, SecureRandom.getInstance("SHA1PRNG")));
  52.             AsymmetricCipherKeyPair asymmetricCipherKeyPair = keyPairGenerator.generateKeyPair();
  54.             // 私钥，16进制格式，自己保存
  55.             BigInteger privatekey = ((ECPrivateKeyParameters) asymmetricCipherKeyPair.getPrivate()).getD();
  56.             String privateKeyHex = privatekey.toString(16);
  57.             System.out.println("private Key :" + privateKeyHex);
  59.             // 公钥，16进制格式，发给前端
  60.             ECPoint ecPoint = ((ECPublicKeyParameters) asymmetricCipherKeyPair.getPublic()).getQ();
  61.             String publicKeyHex = Hex.toHexString(ecPoint.getEncoded(false));
  62.             System.out.println("public Key :" + publicKeyHex);
  63.         } catch (Exception e) {
  64.             e.printStackTrace();
  65.         }
  66.     }
  68.     /**
  69.      * 解密，前端登录信息解码及解码
  70.      * 
  71.      * @author wst 2024年9月12日 下午1:41:47
  72.      * @param cipherData
  73.      * @return
  74.      */
  75.     public static String decrypt(String cipherData) {
  76.         // 得到明文
  77.         String data = null;
  78.         try {
  79.             byte[] cipherDataByte = Hex.decode(cipherData);
  81.             // sm2私钥
  82.             BigInteger privateKeyD = new BigInteger(SiteWebConstant.Common.Config.Sm2_Private_Key, 16);
  83.             X9ECParameters sm2ECParameters1 = GMNamedCurves.getByName("sm2p256v1");
  84.             ECDomainParameters domainParameters1 = new ECDomainParameters(sm2ECParameters1.getCurve(),
  85.                     sm2ECParameters1.getG(), sm2ECParameters1.getN());
  86.             ECPrivateKeyParameters privateKeyParameters = new ECPrivateKeyParameters(privateKeyD, domainParameters1);
  88.             // 用私钥解密
  89.             SM2Engine sm2Engine = new SM2Engine();
  90.             sm2Engine.init(false, privateKeyParameters);
  92.             // 前端传入的密文解密后的processBlock得到Base64格式，记得解码
  93.             // 如果只用下面给出的加密方法加密则不需要这个解码流程
  94.             byte[] arrayOfBytes = Base64.decodeBase64(sm2Engine.processBlock(cipherDataByte, 0, cipherDataByte.length));
  96.             data = new String(arrayOfBytes);
  97.         } catch (Exception e) {
  98.             e.printStackTrace();
  99.         }
  100.         return data;
  101.     }
  103.     /**
  104.      * 解密
  105.      * @author wst 2024年9月12日 下午2:44:39
  106.      * @param cipherData
  107.      * @return
  108.      */
  109.     public static String sm2decrypt(String cipherData) {
  110.         String result = null;
  111.         try {
  112.             // 加密算法
  113.             String algorithm = "EC";
  114.             // 私钥Hex，还原私钥
  115.             BigInteger privateKeyD = new BigInteger(SiteWebConstant.Common.Config.Sm2_Private_Key, 16);
  116.             // 使用标准名称创建EC参数生成的参数规范
  117.             X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
  118.             // 获取私钥的基本域参数
  119.             ECParameterSpec ecParameterSpec = new ECParameterSpec(sm2ECParameters.getCurve(), sm2ECParameters.getG(),
  120.                     sm2ECParameters.getN());
  121.             ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(privateKeyD, ecParameterSpec);
  122.             // 获取私钥对象
  123.             BCECPrivateKey bcecPrivateKey = new BCECPrivateKey(algorithm, ecPrivateKeySpec,
  124.                     BouncyCastleProvider.CONFIGURATION);
  126.             byte[] cipherDataByte = Hex.decode(cipherData);
  127.             ECDomainParameters ecDomainParameters = new ECDomainParameters(ecParameterSpec.getCurve(),
  128.                     ecParameterSpec.getG(), ecParameterSpec.getN());
  129.             // 通过私钥值和私钥基本参数创建私钥参数对象
  130.             ECPrivateKeyParameters ecPrivateKeyParameters = new ECPrivateKeyParameters(bcecPrivateKey.getD(),
  131.                     ecDomainParameters);
  132.             // 通过解密模式创建解密引擎并初始化
  133.             SM2Engine sm2Engine = new SM2Engine();
  134.             sm2Engine.init(false, ecPrivateKeyParameters);
  135.             try {
  136.                 byte[] arrayOfBytes = sm2Engine.processBlock(cipherDataByte, 0, cipherDataByte.length);
  137.                 return new String(arrayOfBytes, StandardCharsets.UTF_8);
  138.             } catch (Exception e) {
  139.             }
  140.         } catch (Exception e) {
  141.         }
  142.         return result;
  143.     }
  145.     /**
  146.      * 加密
  147.      * @author wst 2024年9月12日 下午2:42:21
  148.      * @param data
  149.      * @return
  150.      */
  151.     public static String encrypt(String data){
  152.         // 获取一条SM2曲线参数
  153.         X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
  154.         // 构造ECC算法参数，曲线方程、椭圆曲线G点、大整数N
  155.         ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());
  156.         //提取公钥点
  157.         ECPoint pukPoint = sm2ECParameters.getCurve().decodePoint(Hex.decode(SiteWebConstant.Common.Config.Sm2_Public_Key));
  158.         // 公钥前面的02或者03表示是压缩公钥，04表示未压缩公钥, 04的时候，可以去掉前面的04
  159.         ECPublicKeyParameters publicKeyParameters = new ECPublicKeyParameters(pukPoint, domainParameters);
  161.         SM2Engine sm2Engine = new SM2Engine();
  162.         sm2Engine.init(true, new ParametersWithRandom(publicKeyParameters, new SecureRandom()));
  163.         byte[] arrayOfBytes = null;
  164.         try {
  165.             byte[] in = data.getBytes();
  166.             arrayOfBytes = sm2Engine.processBlock(in, 0, in.length);
  167.         } catch (Exception e) {
  168.             e.printStackTrace();
  169.         }
  170.         return Hex.toHexString(arrayOfBytes);
  171.     }
  172. }

加密工具类2

  1. import java.math.BigInteger;
  2. import java.security.KeyPair;
  3. import java.security.KeyPairGenerator;
  4. import java.security.PrivateKey;
  5. import java.security.PublicKey;
  6. import java.security.SecureRandom;
  7. import java.security.spec.ECGenParameterSpec;
  8. import org.apache.commons.net.util.Base64;
  9. import org.bouncycastle.asn1.gm.GMNamedCurves;
  10. import org.bouncycastle.asn1.x9.X9ECParameters;
  11. import org.bouncycastle.crypto.engines.SM2Engine;
  12. import org.bouncycastle.crypto.params.ECDomainParameters;
  13. import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
  14. import org.bouncycastle.crypto.params.ECPublicKeyParameters;
  15. import org.bouncycastle.crypto.params.ParametersWithRandom;
  16. import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
  17. import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
  18. import org.bouncycastle.jce.provider.BouncyCastleProvider;
  19. import org.bouncycastle.jce.spec.ECParameterSpec;
  20. import org.bouncycastle.jce.spec.ECPrivateKeySpec;
  21. import org.bouncycastle.jce.spec.ECPublicKeySpec;
  22. import org.bouncycastle.math.ec.ECPoint;
  23. import org.bouncycastle.util.encoders.Hex;
  25. /**
  26.  * 
  27.  * @author wst 2026年8月5日 下午3:44:15
  28.  *
  29.  */
  30. public class SM2Utils {
  32.     /*
  33.          // 前端调用sm2加密函数
  34.          // 需要导入 crypto-js.js, sm2.js
  35.         function sm2EncryptPwd(data) {
  36.                 <!--sm2公钥-->
  37.                 var publicKey = '你生成的公钥';
  38.                 return sm2Encrypt(data, publicKey, 1);
  39.         }
  40.      */
  41.     public static final String PUBLIC_KEY = "0469b67671fca561ca5383adf320f42700a686034d6bc3ecafca4e27b0560870549288ccb36b6ca7326d9d0497f49a6ac4ee04fd302f0f29f6e942cc7edb6a8152";
  42.     private static final String PRIVATE_KEY = "5f2382a0722be0df1983593d20fb32307f3524e58d4f58bddf8f6dd77cfe565d";
  43.     private static final SM2Engine.Mode MODE =  SM2Engine.Mode.C1C3C2;
  45.     //椭圆曲线ECParameters ASN.1 结构
  46.     private static X9ECParameters x9ECParameters = GMNamedCurves.getByName("sm2p256v1");
  47.     //椭圆曲线公钥或私钥的基本域参数。
  48.     private static ECParameterSpec ecDomainParameters = new ECParameterSpec(x9ECParameters.getCurve(), x9ECParameters.getG(), x9ECParameters.getN());
  50.     /**
  51.      * 生成秘钥对
  52.      * @author wst(shi-tao.wen) 2026年7月16日 16:51:10
  53.      * @return
  54.      */
  55.     public static KeyPair createECKeyPair() {
  56.         //使用标准名称创建EC参数生成的参数规范
  57.         final ECGenParameterSpec sm2Spec = new ECGenParameterSpec("sm2p256v1");
  59.         // 获取一个椭圆曲线类型的密钥对生成器
  60.         final KeyPairGenerator kpg;
  61.         try {
  62.             kpg = KeyPairGenerator.getInstance("EC", new BouncyCastleProvider());
  63.             // 使用SM2算法域参数集初始化密钥生成器（默认使用以最高优先级安装的提供者的 SecureRandom 的实现作为随机源）
  64.             // kpg.initialize(sm2Spec);
  66.             // 使用SM2的算法域参数集和指定的随机源初始化密钥生成器
  67.             kpg.initialize(sm2Spec, new SecureRandom());
  69.             // 通过密钥生成器生成密钥对
  70.             return kpg.generateKeyPair();
  71.         } catch (Exception e) {
  72.             e.printStackTrace();
  73.             return null;
  74.         }
  75.     }
  77.     /**
  78.      * 解密，并且获取解密后的字符串
  79.      * @author wst(shi-tao.wen) 2026年7月16日 16:50:56
  80.      * @param cipherData
  81.      * @return
  82.      */
  83.     public static String sm2decrypt(String cipherData) {
  84.         byte[] cipherDataByte = Hex.decode(cipherData);
  85.         BigInteger privateKeyD = new BigInteger(PRIVATE_KEY, 16);
  86.         X9ECParameters sm2ECParameters1 = GMNamedCurves.getByName("sm2p256v1");
  87.         ECDomainParameters domainParameters1 = new ECDomainParameters(sm2ECParameters1.getCurve(), sm2ECParameters1.getG(), sm2ECParameters1.getN());
  88.         ECPrivateKeyParameters privateKeyParameters = new ECPrivateKeyParameters(privateKeyD, domainParameters1);
  90.         //用私钥解密,SM2Engine.Mode.C1C3C2得加，不然就会报错invalid cipher text
  91.         SM2Engine sm2Engine = new SM2Engine(MODE);
  92.         sm2Engine.init(false, privateKeyParameters);
  94.         //processBlock得到Base64格式，记得解码
  95.         byte[] arrayOfBytes = null;
  96.         try {
  97.             arrayOfBytes = Base64.decodeBase64(sm2Engine.processBlock(cipherDataByte, 0, cipherDataByte.length));
  98.         } catch (Exception e) {
  99.             e.printStackTrace();
  100.             return null;
  101.         }
  103.         //得到明文：SM2 Encryption Test
  104.         return new String(arrayOfBytes);
  105.     }
  107.     /**
  108.      * 加密
  109.      * @author wst 2024年9月12日 下午2:42:21
  110.      * @param data
  111.      * @return
  112.      */
  113.     public static String sm2encrypt(String data){
  114.         // 获取一条SM2曲线参数
  115.         X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
  116.         // 构造ECC算法参数，曲线方程、椭圆曲线G点、大整数N
  117.         ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());
  118.         //提取公钥点
  119.         ECPoint pukPoint = sm2ECParameters.getCurve().decodePoint(Hex.decode(PUBLIC_KEY));
  120.         // 公钥前面的02或者03表示是压缩公钥，04表示未压缩公钥, 04的时候，可以去掉前面的04
  121.         ECPublicKeyParameters publicKeyParameters = new ECPublicKeyParameters(pukPoint, domainParameters);
  122.         SM2Engine sm2Engine = new SM2Engine(MODE);
  123.         sm2Engine.init(true, new ParametersWithRandom(publicKeyParameters, new SecureRandom()));
  124.         byte[] arrayOfBytes = null;
  125.         try {
  126.             byte[] in = Base64.encodeBase64(data.getBytes());
  127.             arrayOfBytes = sm2Engine.processBlock(in, 0, in.length);
  128.         } catch (Exception e) {
  129.             e.printStackTrace();
  130.         }
  131.         return Hex.toHexString(arrayOfBytes);
  132.     }
  134.     /**
  135.      * 公钥加密
  136.      * @author wst(shi-tao.wen) 2026年7月16日 16:51:30
  137.      * @param publicKeyHex 公钥
  138.      * @param data 明文
  139.      * @return
  140.      */
  141.     public static String encrypt(String publicKeyHex, String data) {
  142.         return encrypt(getECPublicKeyByPublicKeyHex(publicKeyHex), data, 1);
  143.     }
  145.     /**
  146.      * 公钥加密
  147.      * @author wst(shi-tao.wen) 2026年7月16日 16:51:46
  148.      * @param data 明文
  149.      * @return
  150.      */
  151.     public static String encrypt(String data) {
  152.         return encrypt(getECPublicKeyByPublicKeyHex(PUBLIC_KEY), data, 1);
  153.     }
  155.     /**
  156.      * 公钥加密
  157.      * @author wst(shi-tao.wen) 2026年7月16日 16:52:03
  158.      * @param publicKey 公钥
  159.      * @param data 明文
  160.      * @param modeType 加密模式
  161.      * @return
  162.      */
  163.     public static String encrypt(BCECPublicKey publicKey, String data, int modeType) {
  164.         //加密模式
  165.         SM2Engine.Mode mode = SM2Engine.Mode.C1C3C2;
  166.         if (modeType != 1) {
  167.             mode = SM2Engine.Mode.C1C2C3;
  168.         }
  169.         //通过公钥对象获取公钥的基本域参数。
  170.         ECParameterSpec ecParameterSpec = publicKey.getParameters();
  171.         ECDomainParameters ecDomainParameters = new ECDomainParameters(ecParameterSpec.getCurve(),
  172.                 ecParameterSpec.getG(), ecParameterSpec.getN());
  173.         //通过公钥值和公钥基本参数创建公钥参数对象
  174.         ECPublicKeyParameters ecPublicKeyParameters = new ECPublicKeyParameters(publicKey.getQ(), ecDomainParameters);
  175.         //根据加密模式实例化SM2公钥加密引擎
  176.         SM2Engine sm2Engine = new SM2Engine(mode);
  177.         //初始化加密引擎
  178.         sm2Engine.init(true, new ParametersWithRandom(ecPublicKeyParameters, new SecureRandom()));
  179.         byte[] arrayOfBytes = null;
  180.         try {
  181.             //将明文字符串转换为指定编码的字节串
  182.             byte[] in = data.getBytes("utf-8");
  183.             //通过加密引擎对字节数串行加密
  184.             arrayOfBytes = sm2Engine.processBlock(in, 0, in.length);
  185.         } catch (Exception e) {
  186.             System.out.println("SM2加密时出现异常:" + e.getMessage());
  187.             e.printStackTrace();
  188.         }
  189.         //将加密后的字节串转换为十六进制字符串
  190.         return Hex.toHexString(arrayOfBytes);
  191.     }
  192.     /**
  193.      * 私钥解密
  194.      * @author wst(shi-tao.wen) 2026年7月16日 16:52:23
  195.      * @param privateKeyHex 私钥
  196.      * @param cipherData 密文
  197.      * @return
  198.      */
  199.     public static String decrypt(String privateKeyHex, String cipherData) {
  200.         return decrypt(getBCECPrivateKeyByPrivateKeyHex(privateKeyHex), cipherData, 1);
  201.     }
  202.     /**
  203.      * 私钥解密
  204.      * @author wst(shi-tao.wen) 2026年7月16日 16:52:52
  205.      * @param cipherData 密文
  206.      * @return
  207.      */
  208.     public static String decrypt(String cipherData) {
  209.         return decrypt(getBCECPrivateKeyByPrivateKeyHex(PRIVATE_KEY), cipherData, 1);
  210.     }
  211.     /**
  212.      * 私钥解密
  213.      * @author wst(shi-tao.wen) 2026年7月16日 16:53:15
  214.      * @param privateKey 私钥
  215.      * @param cipherData 密文
  216.      * @param modeType 解密模式
  217.      * @return
  218.      */
  219.     public static String decrypt(BCECPrivateKey privateKey, String cipherData, int modeType) {
  220.         //解密模式
  221.         SM2Engine.Mode mode = SM2Engine.Mode.C1C3C2;
  222.         if (modeType != 1) {
  223.             mode = SM2Engine.Mode.C1C2C3;
  224.         }
  225.         //将十六进制字符串密文转换为字节数组（需要与加密一致，加密是：加密后的字节数组转换为了十六进制字符串）
  226.         byte[] cipherDataByte = Hex.decode(cipherData);
  227.         //通过私钥对象获取私钥的基本域参数。
  228.         ECParameterSpec ecParameterSpec = privateKey.getParameters();
  229.         ECDomainParameters ecDomainParameters = new ECDomainParameters(ecParameterSpec.getCurve(),
  230.                 ecParameterSpec.getG(), ecParameterSpec.getN());
  231.         //通过私钥值和私钥钥基本参数创建私钥参数对象
  232.         ECPrivateKeyParameters ecPrivateKeyParameters = new ECPrivateKeyParameters(privateKey.getD(),
  233.                 ecDomainParameters);
  234.         //通过解密模式创建解密引擎并初始化
  235.         SM2Engine sm2Engine = new SM2Engine(mode);
  236.         sm2Engine.init(false, ecPrivateKeyParameters);
  237.         String result = null;
  238.         try {
  239.             //通过解密引擎对密文字节串进行解密
  240.             byte[] arrayOfBytes = sm2Engine.processBlock(cipherDataByte, 0, cipherDataByte.length);
  241.             //将解密后的字节串转换为utf8字符编码的字符串（需要与明文加密时字符串转换成字节串所指定的字符编码保持一致）
  242.             result = new String(arrayOfBytes, "utf-8");
  243.         } catch (Exception e) {
  244.             System.out.println("SM2解密时出现异常" + e.getMessage());
  245.         }
  246.         return result;
  247.     }
  249.     /**
  250.      * 公钥字符串转换为 BCECPublicKey 公钥对象
  251.      * @author wst(shi-tao.wen) 2026年7月16日 16:53:53
  252.      * @param pubKeyHex 64字节十六进制公钥字符串(如果公钥字符串为65字节首个字节为0x04：表示该公钥为非压缩格式，操作时需要删除)
  253.      * @return SM2公钥对象
  254.      */
  255.     public static BCECPublicKey getECPublicKeyByPublicKeyHex(String pubKeyHex) {
  256.         //截取64字节有效的SM2公钥（如果公钥首个字节为0x04）
  257.         if (pubKeyHex.length() > 128) {
  258.             pubKeyHex = pubKeyHex.substring(pubKeyHex.length() - 128);
  259.         }
  260.         //将公钥拆分为x,y分量（各32字节）
  261.         String stringX = pubKeyHex.substring(0, 64);
  262.         String stringY = pubKeyHex.substring(stringX.length());
  263.         //将公钥x、y分量转换为BigInteger类型
  264.         BigInteger x = new BigInteger(stringX, 16);
  265.         BigInteger y = new BigInteger(stringY, 16);
  266.         //通过公钥x、y分量创建椭圆曲线公钥规范
  267.         ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(x9ECParameters.getCurve().createPoint(x, y), ecDomainParameters);
  268.         //通过椭圆曲线公钥规范，创建出椭圆曲线公钥对象（可用于SM2加密及验签）
  269.         return new BCECPublicKey("EC", ecPublicKeySpec, BouncyCastleProvider.CONFIGURATION);
  270.     }
  272.     /**
  273.      * 私钥字符串转换为 BCECPrivateKey 私钥对象
  274.      * @author wst(shi-tao.wen) 2026年7月16日 16:54:17
  275.      * @param privateKeyHex 32字节十六进制私钥字符串
  276.      * @return SM2私钥对象
  277.      */
  278.     public static BCECPrivateKey getBCECPrivateKeyByPrivateKeyHex(String privateKeyHex) {
  279.         //将十六进制私钥字符串转换为BigInteger对象
  280.         BigInteger d = new BigInteger(privateKeyHex, 16);
  281.         //通过私钥和私钥域参数集创建椭圆曲线私钥规范
  282.         ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(d, ecDomainParameters);
  283.         //通过椭圆曲线私钥规范，创建出椭圆曲线私钥对象（可用于SM2解密和签名）
  284.         return new BCECPrivateKey("EC", ecPrivateKeySpec, BouncyCastleProvider.CONFIGURATION);
  285.     }
  287.     public static void main(String[] args) {
  288.         String publicKeyHex = null;
  289.         String privateKeyHex = null;
  290.         KeyPair keyPair = createECKeyPair();
  291.         PublicKey publicKey = keyPair.getPublic();
  292.         if (publicKey instanceof BCECPublicKey) {
  293.             //获取65字节非压缩缩的十六进制公钥串(0x04)
  294.             publicKeyHex = Hex.toHexString(((BCECPublicKey) publicKey).getQ().getEncoded(false));
  295.             System.out.println("---->SM2公钥：" + publicKeyHex);
  296.         }
  297.         PrivateKey privateKey = keyPair.getPrivate();
  298.         if (privateKey instanceof BCECPrivateKey) {
  299.             //获取32字节十六进制私钥串
  300.             privateKeyHex = ((BCECPrivateKey) privateKey).getD().toString(16);
  301.             System.out.println("---->SM2私钥：" + privateKeyHex);
  302.         }
  304.         /**
  305.          * 公钥加密
  306.          */
  307.         String data = "=========待加密数据=========";
  308.         //将十六进制公钥串转换为 BCECPublicKey 公钥对象
  309.         String encryptData = encrypt(publicKeyHex, data);
  310.         System.out.println("---->加密结果：" + encryptData);
  311.         /**
  312.          * 私钥解密
  313.          */
  314.         //将十六进制私钥串转换为 BCECPrivateKey 私钥对象
  315.         data = decrypt(privateKeyHex, encryptData);
  316.         System.out.println("---->解密结果：" + data);
  318.         String mdata = "04d1a73aa9b169ceaaaefb242f444510958cf5d53f464588f05008cb2f9d3ccc9a9611518e90a425697003eff19bf00937a575851c09b1525aec472645442987135f48a0bf8b91300062b37dc274bc33555a06260c1def986bfb7f082b73921ca2572fe384f944bf3be0d76dcbaa25c40c879e7612d044511d";
  319.         System.out.println(sm2decrypt(mdata));
  320.         System.out.println(sm2decrypt(sm2encrypt("20260717_@_admin")));
  321.     }
  322. }
给我留言

评论