1. Toy模板网首页
  2. > Toy博客

Java实现SM2前后端加解密

7月前 作者：LemonSmile_ 分类：Toy博客 阅读(29) 违法举报

这篇具有很好参考价值的文章主要介绍了Java实现SM2前后端加解密。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

Sm2加解密原理，非对称加密，公钥加密，私钥解密。公私钥对成对生成，加密端解密端各自保存。用公钥加密必须要用对应的私钥才能解密，保证安全性。

这里我们实现的功能是前端加密，后端解密，这样前端暴露了公钥，后端持有配对的私钥，保证安全性。

1.jsp引入sm2

<script type="text/javascript" src="${pageContext.request.contextPath}/jslib/jquery-easyui-1.5.2/jquery.easyui.min.js" charset="utf-8"></script>
<script type="text/javascript" src="${pageContext.request.contextPath}/jslib/sm2/crypto-js.js" charset="utf-8"></script>
<script type="text/javascript" src="${pageContext.request.contextPath}/jslib/sm2/sm2.js" charset="utf-8"></script>

2.js加密

改写sm2.js，输入公钥

sm2.js下载路径

https://download.csdn.net/download/liuyuxuan2388/88612724

function sm2EncryptPwd(data) {

var publicKey = '04XXXXXXXXXXXXXXXXXXXXXXXXXXXCB42F6044B1BA8640B42AE038252F3490F02029E37B91D6E0796DE0B3D67166CDD971E556EF1D6B54ED350031817DED6B0C40';

return sm2Encrypt(data, publicKey, 1);

}

公钥用后端的生成公私钥对方法生成，请勿使用文章提到的公私钥对。

例如login.js使用了加密，即

login.js，调用加密函数

var encryptedPwd = sm2EncryptPwd(pwd);

3.后端Java解密

引用依赖库 bcprov-jdk15on-1.68.jar

<dependency>

  <groupId>org.bouncycastle</groupId>

  <artifactId>bcprov-jdk15on</artifactId>

  <version>1.68</version>

</dependency>

login.java

私钥附上对应的值

pwd = new String(SM2Utils.decrypt(pwd, sm2PrivKey));

Sm2Utils.java文章来源地址https://www.toymoban.com/news/detail-678827.html

package com.sgsg.basic.encrypt.util;


import org.bouncycastle.asn1.gm.GMNamedCurves;
import org.bouncycastle.asn1.x9.X9ECParameters;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.engines.SM2Engine;
import org.bouncycastle.crypto.params.ECDomainParameters;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.crypto.params.ParametersWithRandom;
import org.bouncycastle.crypto.signers.SM2Signer;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.jce.spec.ECParameterSpec;
import org.bouncycastle.jce.spec.ECPrivateKeySpec;
import org.bouncycastle.math.ec.ECPoint;
import org.bouncycastle.util.encoders.Hex;

import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.spec.ECGenParameterSpec;
import java.util.Base64;

	/**
	 * SM2工具类
	 * @author van
	 */
	public class SM2Utils {

	    /**
	     * 生成 SM2 公私钥对
	     *
	     * @return
	     * @throws NoSuchAlgorithmException
	     * @throws InvalidAlgorithmParameterException
	     */
	    public static KeyPair geneSM2KeyPair() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException {
	        final ECGenParameterSpec sm2Spec = new ECGenParameterSpec("sm2p256v1");
	        // 获取一个椭圆曲线类型的密钥对生成器
	        final KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", new BouncyCastleProvider());
	        // 产生随机数
	        SecureRandom secureRandom = new SecureRandom();
	        // 使用SM2参数初始化生成器
	        kpg.initialize(sm2Spec, secureRandom);
	        // 获取密钥对
	        KeyPair keyPair = kpg.generateKeyPair();
	        return keyPair;
	    }

	    /**
	     * 生产hex秘钥对
	     */
	    public static void geneSM2HexKeyPair(){
	        try {
	            KeyPair keyPair = geneSM2KeyPair();
	            PrivateKey privateKey = keyPair.getPrivate();
	            PublicKey publicKey = keyPair.getPublic();
	            System.out.println("========  EC X Y keyPair    ========");
	            System.out.println(privateKey);
	            System.out.println(publicKey);
	            System.out.println("========  hex keyPair       ========");
	            System.out.println("hex priKey: " + getPriKeyHexString(privateKey));
	            System.out.println("hex pubKey: " + getPubKeyHexString(publicKey));
	            System.out.println("========  base64 keyPair    ========");
	            System.out.println("base64 priKey: " + new String(Base64.getEncoder().encode(privateKey.getEncoded())));
	            System.out.println("base64 pubKey: " + new String(Base64.getEncoder().encode(publicKey.getEncoded())));
	            System.out.println("========  generate finished ========");
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	    }
	    /**
	     * 获取私钥（16进制字符串，头部不带00长度共64）
	     *
	     * @param privateKey 私钥PrivateKey型
	     * @return
	     */
	    public static String getPriKeyHexString(PrivateKey privateKey) {
	        // OK
//	        BCECPrivateKey s=(BCECPrivateKey)privateKey;
//	        String priKeyHexString = Hex.toHexString(s.getD().toByteArray());
//	        if(null!= priKeyHexString && priKeyHexString.length()==66 && "00".equals(priKeyHexString.substring(0,2))){
//	            return priKeyHexString.substring(2);
//	        }
	        // OK
	        BCECPrivateKey key = (BCECPrivateKey) privateKey;
	        BigInteger intPrivateKey = key.getD();
	        String priKeyHexString = intPrivateKey.toString(16);
	        return priKeyHexString;
	    }
	    /**
	     * 获取私钥 base64字符串
	     *
	     * @param privateKey 私钥PrivateKey型
	     * @return
	     */
	    public static String getPriKeyBase64String(PrivateKey privateKey) {
	        return new String(Base64.getEncoder().encode(privateKey.getEncoded()));
	    }

	    /**
	     * 获取公钥（16进制字符串，头部带04长度共130）
	     *
	     * @param publicKey 公钥PublicKey型
	     * @return
	     */
	    public static String getPubKeyHexString(PublicKey publicKey) {
	        BCECPublicKey key = (BCECPublicKey) publicKey;
	        return Hex.toHexString(key.getQ().getEncoded(false));
	    }
	    /**
	     * 获取公钥 base64字符串
	     *
	     * @param publicKey 公钥PublicKey型
	     * @return
	     */
	    public static String getPubKeyBase64String(PublicKey publicKey) {
	        return new String(Base64.getEncoder().encode(publicKey.getEncoded()));
	    }

	    /**
	     * SM2加密算法
	     *
	     * @param publicKey 公钥
	     * @param data      明文数据
	     * @return
	     */
	    public static String encrypt(String data, PublicKey publicKey) {
	        return encrypt(data.getBytes(StandardCharsets.UTF_8), publicKey);
	    }

	    /**
	     * @param data
	     * @param publicKey
	     * @return
	     * @author 
	     * @version 1.0
	     * 2023年4月12日下午4:41:24
	     */
	    public static String encrypt(byte[] data, PublicKey publicKey) {
	        BCECPublicKey key = (BCECPublicKey) publicKey;
	        return encrypt(data, Hex.toHexString(key.getQ().getEncoded(false)));
	    }

	    /**
	     * @param data
	     * @param pubKeyHexString
	     * @return
	     * @author 
	     * @version 1.0
	     * 2023年4月12日下午4:46:37
	     */
	    public static String encrypt(String data, String pubKeyHexString) {
	        return encrypt(data.getBytes(StandardCharsets.UTF_8), pubKeyHexString);
	    }

	    /**
	     * SM2加密算法
	     *
	     * @param pubKeyHexString 公钥（16进制字符串）
	     * @param data            明文数据
	     * @return hex字符串
	     */
	    public static String encrypt(byte[] data, String pubKeyHexString) {
	        // 获取一条SM2曲线参数
	        X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
	        // 构造ECC算法参数，曲线方程、椭圆曲线G点、大整数N
	        ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());
	        //提取公钥点
	        ECPoint pukPoint = sm2ECParameters.getCurve().decodePoint(Hex.decode(pubKeyHexString));
	        // 公钥前面的02或者03表示是压缩公钥，04表示未压缩公钥, 04的时候，可以去掉前面的04
	        ECPublicKeyParameters publicKeyParameters = new ECPublicKeyParameters(pukPoint, domainParameters);

	        SM2Engine sm2Engine = new SM2Engine(SM2Engine.Mode.C1C3C2);
	        // 设置sm2为加密模式
	        sm2Engine.init(true, new ParametersWithRandom(publicKeyParameters, new SecureRandom()));

	        byte[] arrayOfBytes = null;
	        try {
	            arrayOfBytes = sm2Engine.processBlock(data, 0, data.length);
	        } catch (Exception e) {
	            System.out.println("SM2加密时出现异常:" + e.getMessage());
	        }
	        return Hex.toHexString(arrayOfBytes);

	    }

	    /**
	     * SM2解密算法
	     * @param cipherData    hex格式密文
	     * @param privateKey    密钥PrivateKey型
	     * @return              明文
	     */
	    public static String decrypt(String cipherData, PrivateKey privateKey) {
	        return decrypt(Hex.decode(cipherData), privateKey);
	    }

	    /**
	     * @param cipherData
	     * @param privateKey
	     * @return
	     * @author 
	     * @version 1.0
	     * 2023年4月12日下午4:46:50
	     */
	    public static String decrypt(byte[] cipherData, PrivateKey privateKey) {
	        BCECPrivateKey key = (BCECPrivateKey) privateKey;
	        return decrypt(cipherData, Hex.toHexString(key.getD().toByteArray()));
	    }

	    /**
	     * @param cipherData
	     * @param priKeyHexString
	     * @return
	     * @author 
	     * @version 1.0
	     * 2023年4月12日下午4:46:53
	     */
	    public static String decrypt(String cipherData, String priKeyHexString) {
	        // 使用BC库加解密时密文以04开头，传入的密文前面没有04则补上
	        if (!cipherData.startsWith("04")) {
	            cipherData = "04" + cipherData;
	        }
	        return decrypt(Hex.decode(cipherData), priKeyHexString);
	    }

	    /**
	     * SM2解密算法
	     *
	     * @param cipherData      密文数据
	     * @param priKeyHexString 私钥（16进制字符串）
	     * @return
	     */
	    public static String decrypt(byte[] cipherData, String priKeyHexString) {
	        //获取一条SM2曲线参数
	        X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
	        //构造domain参数
	        ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());

	        BigInteger privateKeyD = new BigInteger(priKeyHexString, 16);
	        ECPrivateKeyParameters privateKeyParameters = new ECPrivateKeyParameters(privateKeyD, domainParameters);

	        SM2Engine sm2Engine = new SM2Engine(SM2Engine.Mode.C1C3C2);
	        // 设置sm2为解密模式
	        sm2Engine.init(false, privateKeyParameters);

	        String result = "";
	        try {
	            byte[] arrayOfBytes = sm2Engine.processBlock(cipherData, 0, cipherData.length);
	            return new String(arrayOfBytes);
	        } catch (Exception e) {
	            System.out.println("SM2解密时出现异常:" + e.getMessage());
	        }
	        return result;
	    }

	    /**
	     * @param data
	     * @param priKeyHexString hex私钥，长度64
	     * @return hex格式签名值
	     * @throws Exception
	     */
	    public static String sign(String data, String priKeyHexString) throws Exception {
	        return sign(data.getBytes(StandardCharsets.UTF_8), priKeyHexString);
	    }

	    /**
	     * 签名
	     * @param data              原始数据，字节数组
	     * @param priKeyHexString   hex私钥，64长度
	     * @return                  Hex字符串
	     * @throws Exception
	     */
	    public static String sign(byte[] data, String priKeyHexString) throws Exception {
	        String signValue = null;
	        SM2Signer signer = new SM2Signer();
	        X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
	        //构造domain参数
	        ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());
	        CipherParameters param = new ParametersWithRandom(new ECPrivateKeyParameters(new BigInteger(priKeyHexString, 16), domainParameters));
	        signer.init(true, param);
	        signer.update(data, 0, data.length);
	        signValue = Hex.toHexString(signer.generateSignature());
	        return signValue;
	    }

	    /**
	     * 验签
	     * @param data                  数据
	     * @param signValue             签名值(hex型)
	     * @param pKHexString    hex130长度公钥
	     * @return 
	     */
	    public static boolean verify(String data, String signValue, String publicKeyHexString) throws Exception {
	        return verify(data.getBytes(StandardCharsets.UTF_8), Hex.decode(signValue), publicKeyHexString);
	    }

	    /**
	     * 验签
	     * @param data                  原始数据字节数组
	     * @param sign                  字节数组()
	     * @param pKHexString    hex130长度公钥
	     * @return                      true or false
	     * @throws Exception
	     */
	    public static boolean verify(byte[] data, byte[] sign, String pKHexString) throws Exception {
	        SM2Signer signer = new SM2Signer();
	        X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
	        //构造domain参数
	        ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());
	        if (pKHexString.length() == 128) {
	            pKHexString = "04" + pKHexString;
	        }
	        ECPoint ecPoint = sm2ECParameters.getCurve().decodePoint(Hex.decode(pKHexString));
	        CipherParameters param = new ECPublicKeyParameters(ecPoint, domainParameters);
	        signer.init(false, param);
	        signer.update(data, 0, data.length);
	        return signer.verifySignature(sign);
	    }

	    /**
	     * 私钥生成公钥
	     * @param priKeyHexString 私钥Hex格式，必须64位
	     * @return 公钥Hex格式，04开头，130位
	     * @throws Exception 例如：
	     */
	    public static String getPubKeyByPriKey(String priKeyHexString) throws Exception {
	        if (priKeyHexString == null || priKeyHexString.length() != 64) {
	            System.err.println("priKey 必须是Hex 64位格式，例如：11d0a44d47449d48d614f753ded6b06af76033b9c3a2af2b8b2239374ccbce3a");
	            return "";
	        }
	        String pubKeyHexString = null;
	        X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
	        //构造domain参数
	        BigInteger privateKeyD = new BigInteger(priKeyHexString, 16);

	        ECParameterSpec ecParameterSpec = new ECParameterSpec(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());
	        ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(privateKeyD, ecParameterSpec);
	        PrivateKey privateKey = null;
	        privateKey = KeyFactory.getInstance("EC", new BouncyCastleProvider()).generatePrivate(ecPrivateKeySpec);

	        // 临时解决办法
	        String pointString = privateKey.toString();
//	        System.out.println(pointString);
	        String pointString_X = pointString.substring(pointString.indexOf("X: ") + "X: ".length(), pointString.indexOf("Y: ")).trim();
	        String pointString_Y = pointString.substring(pointString.indexOf("Y: ") + "Y: ".length()).trim();
//	        System.out.println(pointString_X);
//	        System.out.println(pointString_Y);

	        pubKeyHexString = "04" + pointString_X + pointString_Y;
	        return pubKeyHexString;

	    }

	}

到了这里，关于Java实现SM2前后端加解密的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 国密算法SM2/3/4简单比较，以及基于Java的SM4（ECB模式，CBC模式）对称加解密实现

    常用的国密算法包含SM2，SM3，SM4。以下针对每个算法使用场景进行说明以比较其差异 SM2：非对称加密算法，可以替代RSA 数字签名，SM2为非对称加密，加解密使用一对私钥和公钥，只有签名发行者拥有私钥，可用于加密，其他需要验证解密或验签者使用公钥进行。如果使用公

    2024年04月13日
    浏览(30)

  • 国密算法（SM2）java语言的实现：利用bcprov库来实现SM2算法，非对称算法

    随着密码技术和计算机技术的发展，目前常用的1024位RSA算法面临严重的安全威胁，我们国家密码管理部门经过研究，决定采用SM2椭圆曲线算法替换RSA算法。 SM2是非对称加密算法； SM2是基于椭圆曲线密码的公钥密码算法标准； SM2是国密算法，用于替换RSA/DH/ECDSA/ECDH等国际算法

    2024年02月03日
    浏览(32)
  • 国密SM2算法（JS加密，C#、Java解密）

    国密SM2算法（JS加密，C#、Java解密）

    常见的渗透测试会将网站登录时密码使用明文传输视为风险。推荐使用国密算法或者RSA算法对密码进行加密传输。 RSA加密（JS加密，C#、Java解密）请参考《RSA对称加密（JS加密，C#、Java解密）》​​​​​​ 本文描述国密SM2算法的实现。 一、工作原理 前端js使用公钥进行加密

    2024年02月02日
    浏览(43)

  • 前端VUE后端JAVA，SM2加解密，一篇解决你的问题

    1、后端加密后密文前两位为“04”,前端解密不了，所以在前端解密时要把“04”去掉， 2、前端加密后，密文没有“04”，所以前端加密完要在密文前面加上“04”

    2024年04月23日
    浏览(30)
  • 适用于前后端公用的SM2国密加密传输, JAVA + VUE

    适用于前后端公用的SM2国密加密传输, JAVA + VUE

    由于等保和多个系统间的数据传输加密, 写了一个共有的前端与后端, 后端与后端,的通用算法SM2简单加密,  不需要验签, 几行代码搞定.  引包, 测试好几遍, 这个包适合jdk1.8使用 引包, 没有意外就应该直接能用下面代码了     publicKey：04aa909915f87880507e3de515220cc8f82b1c5693f56a0475b3

    2024年02月16日
    浏览(34)

  • SM2加密实现之JAVA方式

    如有问题，请私信。

    2024年02月10日
    浏览(34)

  • javascript实现SM2加密解密

    前提JavaWeb环境 前端代码 实现步骤 java

    2024年02月14日
    浏览(56)

  • Java SM2加密相关实现与简单原理

            首先我们应该了解SM2加密的主要用途：数字签名、密钥交换和公钥加密等应用。以下为SM2加密的简单原理： 密钥生成：首先，生成一对公钥和私钥。公钥用于加密和验证签名，私钥用于解密和生成签名。 加密过程： 随机选择一个临时的非零整数k，计算椭圆曲线点

    2024年01月23日
    浏览(34)
  • 国密算法SM2，SM3，SM4-java实现原理

    国密算法SM2，SM3，SM4-java实现原理

    SM2是国家密码管理局于2010年12月17日发布的椭圆曲线公钥密码算法，基于ECC。其签名速度与秘钥生成速度都快于RSA，非对称加密，该算法已公开 SM3是中华人民共和国政府采用的一种密码散列函数标准，由国家密码管理局于2010年12月17日发布。SM3主要用数字签名及验证、消息认

    2024年02月13日
    浏览(26)
  • 基于GMSSL实现的sm2加解密在vscode实现（C++）（自用）

    基于GMSSL实现的sm2加解密在vscode实现（C++）（自用）

    原文地址：https://blog.csdn.net/hacker_lpy/article/details/124211114 原文改进方案地址：https://blog.csdn.net/canlynetsky/article/details/131212028 本人最近刚刚开始学习Linux下的C++开发，不太习惯命令行编译程序，听说vscode挺好用，于是开始尝试使用vscode来编写程序，以下记录自己在跑通原文案例时

    2024年01月17日
    浏览(26)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包