前后端分离项目（springboot+vue+mybatis）-sm对jwt进行加密-2

1.国密算法(sm)

1.国密实验室

国密实验室
点击进入
网址：https://www.gmssl.cn/gmssl/index.jsp
支持国密项目：
点击进入
网址：http://gmssl.org/
参考网址：
https://blog.csdn.net/wang_jing_jing/article/details/121493025
https://zhuanlan.zhihu.com/p/377362017
https://blog.csdn.net/samsho2/article/details/80772228
https://blog.csdn.net/qq_38658567/article/details/107840554

2.什么是国密算法

国密算法，即国家密码局认定的国产密码算法，主要用于保护国家关键信息基础设施和商业领域的加密通信和数据安全。根据 2019年10月26日第十三届全国人民代表大会常务委员会第十四次会议通过的《中华人民共和国密码法》，国家对密码实行分类管理，密码分为核心密码、普通密码和商用密码
核心密码、普通密码用于保护国家秘密信息，核心密码保护信息的最高密级为绝密级，普通密码保护信息的最高密级为机密级。
核心密码、普通密码属于国家秘密。
商用密码用于保护不属于国家秘密的信息。公民、法人和其他组织可以依法使用商用密码保护网络与信息安全。

3.国密算法概述

为了保障商用密码的安全性，国家密码局制定了一系列密码标准。
其中SM1、SM4、SM7、祖冲之密码（ZUC）是对称算法。
SM2、SM9是非对称算法。
SM3是哈希算法。
其中SM1、SM7算法不公开，调用该算法时，需要通过加密芯片的接口进行调用。

1.SM1对称密码

SM1 算法是分组密码算法，分组长度为128位，密钥长度都为 128 比特，算法安全保密强度及相关软硬件实现性能与 AES 相当，算法不公开，仅以IP核的形式存在于芯片中。
采用该算法已经研制了系列芯片、智能IC卡、智能密码钥匙、加密卡、加密机等安全产品，广泛应用于电子政务、电子商务及国民经济的各个应用领域（包括国家政务通、警务通等重要领域）。

2.SM2椭圆曲线公钥密码算法

非对称加密算法的实现基于ECC算法。SM2椭圆曲线公钥密码算法是我国自主设计的公钥密码算法、包括SM2-1椭圆曲线数字签名算法、SM2-2椭圆曲线密钥交换协议和SM2-3椭圆曲线公钥加密算法,分别用于实现数字签名密钥协商和数据加密等功能。SM2算法与RSA算法不同的是,SM2算法是基于椭圆曲线上的点群离散对数难题,相对于RSA算法、256位的SM2密码强度比2048位的RSA 密码强度要高。SM2以其高安全性和运算快速的特点在数据安全领域应用越来越广泛。
SM2算法是一种 ECC椭圆曲线密码机制,但在签名、密钥交换方面不同于ECDSA、ECDH 等国际标准,而是采取了更为安全的机制。另外,SM2推荐了一条256位的曲线作为标准曲线。
SM2标准包括总则、数字签名算法、密钥交换协议、公钥加密算法四个部分,并在每个部分的附录详细说明了实现的相关细节及示例。
SM2算法主要考虑素域Fp和二元扩域F2m上的椭圆曲线,分别介绍le1这l两类域的寇义,运算,以及域上的桶圆曲线的点的定义,运算和耄倍点运算。并目切且介绍了编程语言中的数据转换,包括整数和宇节串、字节串和比特串,城元素和宇节串、域元素和整数,点和字节津之间的数据转换规则。
详细说明了有限域上椭圆曲线的参数牛成以N验征,椭圆曲线的参数包精有限域的选取、椭圆曲线方程参数、椭圆曲线群基点的选取等,并给出了选取的标准以便验证。最后给椭圆曲线上密钥对的生成以及公钥的验证,其中用户的密钥对为(s，sP)，为用户的私钥,sP为用户的公钥由于离散对数问题从sP难以得到s,并针对素域和二元扩域给出了密钥对生成细节和验证方式。总则中的知识也适用于SM9算法。
在总则的基础上给出了数字签名算法(包括数字签名生成算法和验证算法)密钥交换协议以及公钥加密算法(包括加密算法和解密算法),并在每个部分给出了算法描述、算法流程和相关示例。
数字签名算法、密钥交换协议以及公钥加密算法都使用了国家密码管理局批准的SM3密码杂凑算法和随机数发生器。数字签名算法、密钥交换协议以及公钥加密算法根据总则来选取有限域和椭圆曲线，并生成密钥对。

3.SM3杂凑算法

SM3密码杂凑（哈希、散列）算法给出了杂凑函数算法的计算方法和计算步骤，并给出了运算示例。此算法适用于商用密码应用中的数字签名和验证，消息认证码的生成与验证以及随机数的生成，可满足多种密码应用的安全需求。在SM2，SM9标准中使用。
此算法对输入长度小于2的64次方的比特消息，经过填充和迭代压缩，生成长度为256比特的杂凑值，其中使用了异或，模，模加，移位，与，或，非运算，由填充，迭代过程，消息扩展和压缩函数所构成。具体算法及运算示例见SM3标准。

4.SM4对称算法

此算法是一个分组算法，用于无线局域网产品。该算法的分组长度为128比特，密钥长度为128比特。加密算法与密钥扩展算法都采用32轮非线性迭代结构。解密算法与加密算法的结构相同，只是轮密钥的使用顺序相反，解密轮密钥是加密轮密钥的逆序。
此算法采用非线性迭代结构，每次迭代由一个轮函数给出，其中轮函数由一个非线性变换和线性变换复合而成，非线性变换由S盒所给出。其中rki为轮密钥，合成置换T组成轮函数。轮密钥的产生与上图流程类似，由加密密钥作为输入生成，轮函数中的线性变换不同，还有些参数的区别。SM4算法的具体描述和示例见SM4标准。

5.SM7对称密码

SM7算法，是一种分组密码算法，分组长度为128比特，密钥长度为128比特。SM7适用于非接触式IC卡，应用包括身份识别类应用(门禁卡、工作证、参赛证)，票务类应用(大型赛事门票、展会门票)，支付与通卡类应用（积分消费卡、校园一卡通、企业一卡通等）。

6.SM9标识密码算法

为了降低公开密钥系统中密钥和证书管理的复杂性，以色列科学家、RSA算法发明人之一Adi Shamir在1984年提出了标识密码（Identity-Based Cryptography）的理念。标识密码将用户的标识（如邮件地址、手机号码、QQ号码等）作为公钥，省略了交换数字证书和公钥过程，使得安全系统变得易于部署和管理，非常适合端对端离线安全通讯、云端数据加密、基于属性加密、基于策略加密的各种场合。2008年标识密码算法正式获得国家密码管理局颁发的商密算法型号：SM9(商密九号算法)，为我国标识密码技术的应用奠定了坚实的基础。
SM9算法不需要申请数字证书，适用于互联网应用的各种新兴应用的安全保障。如基于云技术的密码服务、电子邮件安全、智能终端保护、物联网安全、云存储安全等等。这些安全应用可采用手机号码或邮件地址作为公钥，实现数据加密、身份认证、通话加密、通道加密等安全应用，并具有使用方便，易于部署的特点，从而开启了普及密码算法的大门。

7.ZUC祖冲之算法

祖冲之序列密码算法是中国自主研究的流密码算法,是运用于移动通信4G网络中的国际标准密码算法,该算法包括祖冲之算法(ZUC)、加密算法(128-EEA3)和完整性算法(128-EIA3)三个部分。目前已有对ZUC算法的优化实现，有专门针对128-EEA3和128-EIA3的硬件实现与优化
密码算法作为国家战略资源，比历史上任何时候都显得更为关键。在大数据和云计算的时代，关键信息往往通过数据挖掘技术在海量数据中获得，所以每一个人的信息保护都非常重要。

3.详解sm2算法

国密 SM2 为非对称加密，也称为公钥密码；国密算法的本质是椭圆曲线加密。关于对称加密和非对称加密的内容请查阅笔者写的《深入理解对称加密和非对称加密》一文。SM2 椭圆曲线公钥密码 ( ECC ) 算法是我国公钥密码算法标准。SM2 算法的主要内容包括 ３ 部分: 数字签名算法; 密钥交换协议和公钥加密算法。

1.SM2 的形成过程

在所有的公钥密码中，使用得比较广泛的有ECC 和 RSA； 而在相同安全强度下 ECC 比 RSA 的私钥位长及系统参数小得多， 这意味着应用 ECC 所需的存储空间要小得多， 传输所的带宽要求更低， 硬件实现 ECC 所需逻辑电路的逻辑门数要较 RSA 少得多， 功耗更低。 这使得 ECC 比 RSA 更适合实现到资源严重受限制的设备中 ， 如低功耗要求的移动通信设备 、无线 通信设备和智能卡等。
ECC 的优势使其成为了最具发展潜力和应用前景的公钥密码算法 ， 至 2000 年国际上已有多个国家和行业组织将 ECC 采纳为公钥密码算法标准。在此背景下，我国从 2001 年开始组织研究自主知识产权的 ECC， 通过运用国际密码学界公认的公钥密码算法设计及安全性分析理论和方法 ， 在吸收国内外已有 ECC 研究成果的基础上 ， 于2004 研制完成了 SM2 算法． SM2 算法于 2010 年 12 月首次公开发布 ， 2012 年3 月成为中国 商用密码标准 （ 标准号为 GM/T0003—2012）， 2016 年 8 月成为中国 国家密码标准 (标准号为 ＧB/Ｔ 32918-2016)。

2.椭圆曲线

在有限域 K 上，形如以下方程：

的方程被称为 Weierstrass 方程，其中 O=[0,1,0] 是唯一 的 Z 坐标为零的点，称为无穷远点。令 x=X/Z, y=Y/Z, 可将方 程记为:

且仍有无穷远点 O。 对于方程中的系数，定义

其中:

当 Δ ≠ 0 时，椭圆曲线是非奇异的 [1]，即对所有满足 F(X,Y,Z)=0 的射影点 P=(X ∶ Y ∶ Z), F 在 P 点的 3 个偏导数

必不全为 0。
当 K 的特征不为 2 或 3 时，Weierstrass 方程又有以下形式：

其中:E:y2=x3+Ax2+B 就是国家密码局建议使用的椭圆曲线，本文也是以此曲线为基础进行算法实现。

3.椭圆曲线基本运算

在椭圆曲线上，可以通过以下方式定义加法运算：取椭圆曲线上两点 P、Q，过 P、Q 作直线交椭圆曲线于R’…，过 R’做 y 轴的平行线交椭圆曲线于 R。若 P、Q 重合，则过 P 作曲线的切线交椭圆曲线于 R’…, 过 R’…做 y 轴的平行线交椭圆曲线于 R。规定 R=P+Q。如图一所示。对无穷远点 O 与椭圆曲线上一点 P，O+P=P+O=P。对 于 上 述 简 化 的 Weierstrass 方 程

令

若 R=P+Q，则 :

椭圆曲线密码体制即建立在上述加法运算和曲线构成的Abel 群上的密码体制。椭圆曲线密码体制主要涉及的运算是椭圆曲线上的点乘计算：Q=kP。Q、P 为椭圆曲线上的点，k为整数。

4. 椭圆曲线大数运算的数学基础

1.模运算与素数域

同余是数论中的等价关系，对于正整数 m 如果有 a=b+km（a，b，k 均是整数）那么记b=a mod（m），则称 a 与 b 关于 m 同余。当 m=p（p为素数）时，我们定义素数域 FP 可由{0，1，2，3…p-1}中 P 个元素构成，关于 P的模运算称为素数域上模运算。

2.有限域上的模运算的设计与实现

有限域上的模运算是 SM2 椭圆曲线公钥密码算法的基础，主要包括模加和模减运算、模乘运算、模幂和模逆运算。模逆运算是模运算中最复杂运算量最大的运算，模逆运算可以通过费马小定理（n 是素数的时候，和 n 互素的某个整数 a 有公式 an-1=1modn 成立）得到，即当 p 为素数时，有ap-1=1mod p，则可得到模逆运算 a-1=ap-2mod p，这样就可以利用模幂运算来表示模逆运算。

3.有限域上标量乘运算的设计与实现

标量乘的数学形式，P=（xp，yp）为椭圆曲线E（FP）上的点，k为正整数，P的k倍点为Q。Q=［k］P=P+P+…+P（k个p）。标量乘运算是所有运算中最耗时的运算操作，主要由点加和倍点产生，点加和倍点运算在不同坐标系下的运算规则不同。采用仿射与雅可比混合坐标系下的运算规则：

，其中，a，b为椭圆曲线上的整数，并且△=

三维坐标P（x1，y1，z1），Q（x2，y2，1）的无穷远点为（1，1，0）。倍点运算P+P=（ x3，y3，z3）声明为Padd1（x1，y1，z1，x3，y3，z3），把2P的值存入（x3，y3，z3），点加运算P+Q=（x3，y3，z3）声明为Padd2（x1，y1，z1，x2，y2，x3，y3，z3），把P+Q的值存入（x3，y3，z3）。最后还要把结果（x3，y3，z3）从雅可比加重摄影坐标系下转换到仿射坐标系下，需要对参数进行转换：x3=x3/z12，y3=y3/z13，即可得到所需的二维坐标点（x3，y3）。
有了点加和倍点运算就可以进行标量乘运算，标量乘从右往左的算法为：输入：点P∈E（Fp）整数k=（k 31k30－k 0）（ki 为 8 位整型数）
输出：Q=［k］P 初始化Q=O为无穷远点 循环i：0~31 b=k（i b为8位整型数） 循环j：0~7 若（b&1）=1，则Q=Q+P b=b>>1 P=P+P 返回Q

5.SM2公钥加密算法

素数域椭圆曲线的参数：素数域的模P，椭圆曲线E（FP）的 系数：a，b；E（FP）上的基点G（Gx，Gy）≠0，基点G的解为n余 因子h=1，用户A持有的用户B的公钥PB，用户B持有的私钥dB。

1.SM2加密算法

（1）用随机数发生器生成随机数

（2）计算椭圆曲线上的点

（3）计算椭圆曲线点

若S为无穷远点则报错并退出，h 为余因子，这里取为 1。
（4）计算椭圆曲线上的点

（5）计算

若t全为0则返回1。
（6）计算

（7）计算

（8）计算密文

2.SM2解密算法

（1）从密文中取出 C1，验证C1是否满足椭圆曲线方程，若不满足则报错并退出。
（2）计算

若S为无穷远点则报错并退出。
（3）计算

（4）计算

（5）从 C 中取出 C2 计算

（6）计算

若 u 与 C3 不相等，则报错 并退出。
（7）输出明文 m。

6.图解

1.椭圆曲线

2.公私钥

私钥：BN_大整数
公钥：EC-Point椭圆曲线上的点
整体结构

3.数字签名算法

(1)签名（User A）
签名者用户A的密钥对包括其私钥dA和公钥PA=[dA]G= (xA,yA)
签名者用户A具有长度为entlenA比特的可辨别标识IDA，
ENTLA是由整数entlenA转换而成的两个字节
ZA=H256(ENTLA || IDA || a || b || xG || yG|| xA || yA)。
待签名的消息为M，
数字签名(r,s)

说明：第5步若r=0或r+k=n则返回第3步；第6步若s=0则返回第3步。
(2)验签（User B）
签名者用户A的密钥对包括其私钥dA和公钥PA=[dA]G= (xA,yA)
签名者用户A具有长度为entlenA比特的可辨别标识IDA，
ENTLA是由整数entlenA转换而成的两个字节
ZA=H256(ENTLA || IDA || a || b || xG || yG|| xA || yA)。
消息为M，数字签名(r,s)

4.密钥交换协议

5.密钥封装和加解密

(1)加密（User A）

说明：第3步计算S=[h]PB略，因h=1。
(2)解密（User B）

说明：第2步计算S=[h]C1略，因h=1。

7.SM2 小结

SM2 算法是我国在吸收国际先进成果基础上研发出来的具有自主知识产权的 ECC 算法， 它在安全性和实现效率方面相当于或略优于国 际上同类的 ECC 算法， 能取代 RSA 以满足各种应用对公钥密码算法安全性和实现效率的更高要求， 具有广阔的推广和应用前景。

2.jwt技术

1.JWT介绍

JWT(json web token)是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准。
JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源。比如用户登录。在传统的用户登录认证中，因为http是无状态的，所以都是采用session方式。用户登录成功，服务端会保存一个session，服务端会返回给客户端一个sessionId，客户端会把sessionId保存在cookie中，每次请求都会携带这个sessionId。
cookie+session这种模式通常是保存在内存中，而且服务从单服务到多服务会面临的session共享问题。虽然目前存在使用Redis进行Session共享的机制，但是随着用户量和访问量的增加，Redis中保存的数据会越来越多，开销就会越来越大，多服务间的耦合性也会越来越大，Redis中的数据也很难进行管理，例如当Redis集群服务器出现Down机的情况下，整个业务系统随之将变为不可用的状态。而JWT不是这样的，只需要服务端生成token，客户端保存这个token，每次请求携带这个token，服务端认证解析就可。

2.JWT的结构解析

第一部分我们称它为头部（header),第二部分我们称其为载荷（payload)，第三部分是签证（signature)

JWT格式

eyJ0eXAiOiJKV1QiLCJhbGciOiJTTTNXaXRoU00yIn0.eyJpc3MiOiJtYWNoYW8iLCJuYW1lIjoibWFjaGFvIiwiYWdlIjoiMjMiLCLkuJPkuJoiOiLorqHnrpfmnLrnp5HlrabkuI7mioDmnK8ifQ.MEYCIQCPVB1wzknv1U1uGlQP83jbDATfct-A8K1LIXzknQUuPAIhAP0aT8VZiJip5M5X-CnN2rj-UlBs-fpG-TyUcgnPVLk-

1.头部

header
jwt的头部承载两部分信息：
1.声明类型，这里是jwt
2.声明加密的算法 通常直接使用 HMAC SHA256

{
"typ": "JWT",
"alg": "HS256"
}

然后将头部进行base64加密（该加密是可以对称解密的),构成了第一部分：

eyJ0eXAiOiJKV1QiLCJhbGciOiJTTTNXaXRoU00yIn0

2.载荷

playload
载荷就是存放有效信息的地方。这个名字像是特指飞机上承载的货品，这些有效信息包含三个部分：标准中注册的声明、公共的声明、私有的声明。
标准中注册的声明 (建议但不强制使用) ：
iss: jwt签发者
sub: jwt所面向的用户
aud: 接收jwt的一方
exp: jwt的过期时间，这个过期时间必须要大于签发时间
nbf: 定义在什么时间之前，该jwt都是不可用的.
iat: jwt的签发时间
jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。
公共的声明 ：
公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息，因为该部分在客户端可解密。
私有的声明 ：
私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。

定义一个payload：

{
"name":"machao",
"age":"23",
"专业":"计算机科学与技术"
}

然后将其进行base64加密，得到Jwt的第二部分：

eyJpc3MiOiJtYWNoYW8iLCJuYW1lIjoibWFjaGFvIiwiYWdlIjoiMjMiLCLkuJPkuJoiOiLorqHnrpfmnLrnp5HlrabkuI7mioDmnK8ifQ

3.签证

signature
jwt的第三部分是一个签证信息，这个签证信息由三部分组成：header (base64后的)、payload (base64后的)、secret。
这个部分需要base64加密后的header和base64加密后的payload使用。连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，

然后就构成了jwt的第三部分：

MEYCIQCPVB1wzknv1U1uGlQP83jbDATfct-A8K1LIXzknQUuPAIhAP0aT8VZiJip5M5X-CnN2rj-UlBs-fpG-TyUcgnPVLk-

密钥secret是保存在服务端的，服务端会根据这个密钥进行生成token和验证，所以需要保护好。

3.网站解析jwt

官网（点击进入）
网址：https://config.net.cn/tools/Jwt.html
图片展示

4.jwt认证流程

在身份验证中，当用户成功登录系统时，授权服务器将会把 JSON Web Token 返回给客户端，用户需要将此凭证信息存储在本地(cookie或浏览器缓存)。当用户发起新的请求时，需要在请求头中附带此凭证信息，当服务器接收到用户请求时，会先检查请求头中有无凭证，是否过期，是否有效。如果凭证有效，将放行请求；若凭证非法或者过期，服务器将回跳到认证中心，重新对用户身份进行验证，直至用户身份验证成功。以访问 API 资源为例，下图显示了获取并使用 JWT 的基本流程：

3.用sm对jwt进行加密

在多个系统之间，由于调用链长，使用了jwt token的方式鉴权，然后获取相应的资源，这里用到核心的一点就是jwt的防篡改特性。
以往使用的签名算法大都是HS256（HMAC with SHA-256）、RS256（RSASSA-PKCS1-v1_5 with SHA-256），这次来试试SM3WithSM2签名算法给jwt签名

1.jwt通常使用的加密方式

1、可逆加密算法
加密后，密文可以解密得到原文
一般用于签名和认证。私钥服务器保存, 用来加密, 公钥客户拿着用于对于令牌或 者签名的解密或者校验使用.
常见的非对称加密算法有： RSA、DSA（数字签名用）、ECC（移动设备用）、RS256 (采用 SHA‐256 的 RSA 签名)
2、不可逆加密算法
加密后，不能反向解密得到原文
一般用于敏感信息，密码，卡号等不可解密的信息
常见的不可逆加密算法有：MD5、SHA、HMAC 4.3.Base64编码
3、对称加密
4、非对称加密
base64是网络上最常见的用于传输8bit字节代码的编码方式之一。Base64编码可用于在 HTTP环境下传递较长的标识信息。采用Base64编码解码具有不可读性，即所编码的数据 不会被人用肉眼所直接看到。
注意：Base64只是一种编码方式，不算加密方法。

2.思路

jwt技术支持RSA等加密技术，但是不支持国密加密，我们按照源码可以封装一个支持国密的jwt，首先需要生成证书，.cer和.pri两个证书，根据证书生成公钥和私钥，然后写入封装好的jwt中，就可以成功的让jwt支持国密

3.为什么加密后解析工具还能解析

JWT（JSON Web Token）由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。
头部（Header）部分指定了JWT的类型（typ）以及所使用的签名算法（alg）。它是一个由Base64编码的JSON字符串，包含了这些信息。在这段代码中，签名算法被指定为HS256，即采用HMAC SHA-256算法进行签名。
载荷（Payload）部分存放了实际的数据，也就是我们通常所说的“声明”。这些声明是一些关于实体（通常是用户）及其相关信息的声明，比如用户ID、角色、过期时间等等。
签名（Signature）部分是对前两部分的签名，用于验证消息的完整性和真实性。签名是使用指定的签名算法和密钥对头部和载荷进行加密得到的字符串。
所以，整个JWT由这三部分按照一定的规则组成的，经过Base64编码后形成了一个字符串。这个字符串可以被传递、存储，并且在需要验证身份、权限等方面起到关键作用。
我们加密的是签名部分，头部和载荷还是使用的是Base64，所以使用解析工具的话还是会解析出来信息

4.代码

1.资源下载与环境配置

1.国密资源下载

国密实验室提供示例点击下载
国密实验室提供jar包点击下载

2.pom.xml环境配置

<dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15on</artifactId>
            <version>1.67</version>
        </dependency>
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcpkix-jdk15on</artifactId>
            <version>1.67</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>29.0-jre</version>
        </dependency>

2.sm测试包（官网提供）

首先将国密实验室jar包添加为库

1.sm2

package algorithm;

import java.security.*;
import javax.crypto.Cipher;

/**
 * @author gmssl.cn
 * 密钥对生成/签名验签/加密解密
 */
public class test_sm2
{
	public test_sm2()
	{}

	public static void main(String[] args) throws Exception
	{
		Security.insertProviderAt((Provider)Class.forName("cn.gmssl.jce.provider.GMJCE").newInstance(), 1);
		
		KeyPairGenerator generator = KeyPairGenerator.getInstance("SM2");
		generator.initialize(256);
		KeyPair keyPair = generator.generateKeyPair();
		
		PublicKey pubKey = keyPair.getPublic();
		PrivateKey priKey = keyPair.getPrivate();
		System.out.println(pubKey);
		System.out.println(priKey);
		
		// 签名
		String msg = "你好";
		byte[] signature = null;
		{
			Signature sig = Signature.getInstance("SM3withSM2");
			sig.initSign(priKey);
			sig.update(msg.getBytes());
			signature = sig.sign();
			System.out.println("signature.len="+signature.length);
			utils.dump(System.out, signature, 0, signature.length);
		}
		
		// 验签
		{
			Signature sig = Signature.getInstance("SM3withSM2");
			sig.initVerify(pubKey);
			sig.update(msg.getBytes());
			boolean ok = sig.verify(signature);
			System.out.println("signature ok="+ok);
		}

		// 加密
		byte [] cipherBuf = null;
		{
			Cipher cipher = Cipher.getInstance("SM2", "GMJCE");
			cipher.init(Cipher.ENCRYPT_MODE, pubKey);
			cipherBuf = cipher.doFinal(msg.getBytes());
			System.out.println("cipherBuf.len="+cipherBuf.length);
			utils.dump(System.out, cipherBuf, 0, cipherBuf.length);
		}

		// 解密
		byte[] plainBuf = null;
		{
			Cipher cipher = Cipher.getInstance("SM2", "GMJCE");
			cipher.init(Cipher.DECRYPT_MODE, priKey);
			plainBuf = cipher.doFinal(cipherBuf);
			System.out.println("plain ="+new String(plainBuf));
		}
	}
}

2.sm3

package algorithm;

import java.security.*;

/**
 * @author gmssl.cn
 */
public class test_sm3
{
	public test_sm3()
	{}

	public static void main(String[] args) throws Exception
	{
		Security.insertProviderAt((Provider)Class.forName("cn.gmssl.jce.provider.GMJCE").newInstance(), 1);

		MessageDigest digest = MessageDigest.getInstance("SM3");
		digest.update("1234567890".getBytes());
		byte[] buf = digest.digest();
		utils.dump(System.out, buf, 0, buf.length);
	}
}

3.sm4

package algorithm;

import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * @author gmssl.cn
 * 单组数据加密解密
 */
public class test_sm4
{
	public test_sm4()
	{}

	public static void main(String[] args) throws Exception
	{
		Security.insertProviderAt((Provider)Class.forName("cn.gmssl.jce.provider.GMJCE").newInstance(), 1);

		byte[] key = "1234567890111111".getBytes();
    	byte[] iv = "1234567890abcdef".getBytes();
    	byte[] plain = "11".getBytes();
    	
    	SecretKeySpec sm4key = new SecretKeySpec(key, "SM4");
    	IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
		
    	// 加密
    	Cipher sm4 = Cipher.getInstance("SM4/CBC/Pkcs7Padding");
		sm4.init(Cipher.ENCRYPT_MODE, sm4key, ivParameterSpec);
		byte[] cipher1 = sm4.doFinal(plain);
		if(cipher1 != null)utils.dump(System.out, cipher1, 0, cipher1.length);
		
		// 解密
		sm4.init(Cipher.DECRYPT_MODE, sm4key, ivParameterSpec);
		byte[] plain1 = sm4.doFinal(cipher1);
		System.out.println("Plain:");
		if(plain1 != null) utils.dump(System.out, plain1, 0, plain1.length);
	}
}

3.jwt认证（HS256）

1.生成jwt

 String jwt = JWT.create()
                .withAudience("machao")
                .withExpiresAt(DateUtil.offsetHour(new Date(), 5)) // 设置过期时间为1小时
                .sign(Algorithm.HMAC256("password"));

2.解析jwt

String map1 = JWT.decode(token).getAudience().get(0);

3.jwt异常处理

try {
            String map1 = JWT.decode(token).getAudience().get(0);
            System.out.println(map1);
        }catch (TokenExpiredException e){//超时
            System.out.println("jwt超时");
            System.out.println(e.getMessage());
        }catch (JWTDecodeException e){//第一段或第二段错误
            System.out.println("jwt编码错误");
        }catch (SignatureVerificationException e){
            System.out.println("验签失败");//第三段错误
        }

4.总

package com.mc.jwtsm;


import cn.hutool.core.date.DateUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.mc.utils.JwtSm.JwtHelper;
import org.junit.Test;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

//@SpringBootTest
public class JwtUtils{
    //生成jwt
    @Test
    public void set(){
        String jwt = JWT.create()
                .withAudience("machao")
                .withExpiresAt(DateUtil.offsetHour(new Date(), 5)) // 设置过期时间为1小时
                .sign(Algorithm.HMAC256("password"));
        System.out.println(jwt);
    }
    //解析jwt
    @Test
    public void get(){
        String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJtYWNoYW8iLCJleHAiOjE3MDQ5MTk2MzN9.LTGDI_nb6Mo83t7F7reahHHtciVSTdIkaYGkenRCVzM";

        try {
            String map1 = JWT.decode(token).getAudience().get(0);
            System.out.println(map1);
        }catch (TokenExpiredException e){//超时
            System.out.println("jwt超时");
            System.out.println(e.getMessage());
        }catch (JWTDecodeException e){//第一段或第二段错误
            System.out.println("jwt编码错误");
        }catch (SignatureVerificationException e){
            System.out.println("验签失败");//第三段错误
        }

    }

}

4.sm2对jwt进行加密

1.查看源码

github封装点击下载

1.证书生成

package com.mc.cert.test;

import java.io.IOException;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyPair;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import java.security.cert.X509Certificate;

import org.bouncycastle.asn1.x500.X500Name;
import org.bouncycastle.asn1.x500.X500NameBuilder;
import org.bouncycastle.asn1.x500.style.BCStyle;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.junit.Assert;
import org.junit.Test;
import com.mc.utils.BCECUtil;
import com.mc.utils.SM2Util;
import com.mc.utils.cert.CertSNAllocator;
import com.mc.utils.cert.CommonUtil;
import com.mc.utils.cert.RandomSNAllocator;
import com.mc.utils.cert.SM2PublicKey;
import com.mc.utils.cert.SM2X509CertMaker;
import com.mc.utils.cert.exception.InvalidX500NameException;
import com.mc.test.util.FileUtil;

public class SM2X509CertMakerTest {

    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    @Test
    public void testMakeCertificate() {
        try {
            KeyPair subKP = SM2Util.generateKeyPair();
            X500Name subDN = buildSubjectDN();
            SM2PublicKey sm2SubPub = new SM2PublicKey(subKP.getPublic().getAlgorithm(),
                (BCECPublicKey) subKP.getPublic());
            byte[] csr = CommonUtil.createCSR(subDN, sm2SubPub, subKP.getPrivate(),
                SM2X509CertMaker.SIGN_ALGO_SM3WITHSM2).getEncoded();
            savePriKey("target/test.sm2.pri", (BCECPrivateKey) subKP.getPrivate(),
                (BCECPublicKey) subKP.getPublic());
            SM2X509CertMaker certMaker = buildCertMaker();
            X509Certificate cert = certMaker.makeSSLEndEntityCert(csr);
            FileUtil.writeFile("target/test.sm2.cer", cert.getEncoded());
        } catch (Exception ex) {
            ex.printStackTrace();
            Assert.fail();
        }
    }

    public static void savePriKey(String filePath, BCECPrivateKey priKey, BCECPublicKey pubKey) throws IOException {
        ECPrivateKeyParameters priKeyParam = BCECUtil.convertPrivateKeyToParameters(priKey);
        ECPublicKeyParameters pubKeyParam = BCECUtil.convertPublicKeyToParameters(pubKey);
        byte[] derPriKey = BCECUtil.convertECPrivateKeyToSEC1(priKeyParam, pubKeyParam);
        FileUtil.writeFile(filePath, derPriKey);
    }

    public static X500Name buildSubjectDN() {
        X500NameBuilder builder = new X500NameBuilder(BCStyle.INSTANCE);
        builder.addRDN(BCStyle.C, "CN");
        builder.addRDN(BCStyle.O, "com.mc");
        builder.addRDN(BCStyle.OU, "com.mc");
        builder.addRDN(BCStyle.CN, "example.org");
        builder.addRDN(BCStyle.EmailAddress, "abc@example.org");
        return builder.build();
    }









    public static X500Name buildRootCADN() {
        X500NameBuilder builder = new X500NameBuilder(BCStyle.INSTANCE);
        builder.addRDN(BCStyle.C, "CN");
        builder.addRDN(BCStyle.O, "com.mc");
        builder.addRDN(BCStyle.OU, "com.mc");
        builder.addRDN(BCStyle.CN, "MC Root CA");
        return builder.build();
    }

    public static SM2X509CertMaker buildCertMaker() throws InvalidAlgorithmParameterException,
        NoSuchAlgorithmException, NoSuchProviderException, InvalidX500NameException {
        X500Name issuerName = buildRootCADN();
        KeyPair issKP = SM2Util.generateKeyPair();
        long certExpire = 20L * 365 * 24 * 60 * 60 * 1000; // 20年
        CertSNAllocator snAllocator = new RandomSNAllocator(); // 实际应用中可能需要使用数据库来保证证书序列号的唯一性。
        return new SM2X509CertMaker(issKP, certExpire, issuerName, snAllocator);
    }
}

2.读取证书生成公私钥

Security.addProvider(new BouncyCastleProvider());
        X509Certificate cert;
        try {
            InputStream streamCer = Thread.currentThread().getContextClassLoader().getResourceAsStream("jwt.sm2.cer");
            InputStream streamPri = Thread.currentThread().getContextClassLoader().getResourceAsStream("jwt.sm2.pri");
            int streamPriLen = Objects.requireNonNull(streamPri).available();
            cert = SM2CertUtil.getX509Certificate(streamCer);

            byte[] priKeyData = new byte[streamPriLen];
            streamPri.read(priKeyData);
            // 从证书中获取公钥，从私钥文件中获取私钥
            publicKey = SM2CertUtil.getBCECPublicKey(cert);
            privateKey = BCECUtil.convertSEC1ToBCECPrivateKey(priKeyData);

        } catch (Exception e) {
            log.error("JWT工具初始化异常", e);
        }

2.封装jwt加密包

封装，使得jwt支持国密

package com.mc.utils.JwtSm;

import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.SignatureGenerationException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.mc.utils.SM2Util;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.crypto.CryptoException;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;

/**
 * 扩充auth0.java-jwt的签名算法
 * SM2是国家密码管理局于2010年12月17日发布的椭圆曲线公钥密码算法
 * 是一种非对称加密算法，证书保存在 /resources/jwt.sm2.cer
 * SM3是中华人民共和国政府采用的一种密码散列函数标准，由国家密码管理局于2010年12月17日发布
 *
 * QA: 为什么使用该系列算法 ===> 支持国产！
 * 基于ECC的SM2证书普遍采用256位密钥长度，加密强度等同于3072位RSA证书，远高于业界普遍采用的2048位RSA证书
 * 测基准试：com.ai.base.tool.JwtTest、com.ai.base.tool.JwtTestSm3WithSm2
 * 对各种算法进行简单的性能测试，SM3WithSM2速度大大快于ECDSA256

 * @see com.auth0.jwt.algorithms.Algorithm
 * 这里使用SM3WithSM2的方式签名、验签，对标SHA256withRSA(RS256)
 * signature = SM2(SM3(base64encode(header) + '.' + base64encode(payload)), 'SECRET_KEY')
 * <p>
 * 签名：用SM3对jwt生成摘要， 再用SM2的私钥对其进行加密(如上面的公式)，完成后即生成jwt的signature
 * 验签：拿到jwt，用base64解码，再用SM2算法+SM2公钥对signature进行解密，就得到了信息的摘要，然后把信息用相同的算法（SM3）生成摘要与jwt解密后的signature进行对比，一致则验签通过，这样就达到了防篡改的效果
 *
 * @author Created by zkk on 2020/9/23
 **/
@Slf4j
public class SMAlgorithm extends Algorithm {

    private final BCECPublicKey publicKey;
    private final BCECPrivateKey privateKey;

    private static final byte JWT_PART_SEPARATOR = (byte) 46;

    protected SMAlgorithm(BCECPublicKey publicKey, BCECPrivateKey privateKey) {
        super("SM3WithSM2", "SM3WithSM2");
        this.publicKey = publicKey;
        this.privateKey = privateKey;
        if (publicKey == null || privateKey == null) {
            throw new IllegalArgumentException("The Key Provider cannot be null.");
        }
    }

    @Override
    public void verify(DecodedJWT jwt) throws SignatureVerificationException {
        byte[] signatureBytes = Base64.decodeBase64(jwt.getSignature());
        byte[] data = combineSignByte(jwt.getHeader().getBytes(), jwt.getPayload().getBytes());
        try {
            if(!SM2Util.verify(publicKey, data, signatureBytes)) {
                throw new SignatureVerificationException(this);
            }
        } catch (Exception e) {
            throw new SignatureVerificationException(this);
        }
    }

    @Override
    @Deprecated
    public byte[] sign(byte[] contentBytes) throws SignatureGenerationException {
        // 不支持该方法
        throw new RuntimeException("该方法已过时");
    }

    @Override
    public byte[] sign(byte[] headerBytes, byte[] payloadBytes) throws SignatureGenerationException {
        byte[] hash = combineSignByte(headerBytes, payloadBytes);
        byte[] signatureByte;
        try {
            signatureByte = SM2Util.sign(privateKey, hash);
        } catch (CryptoException e) {
            throw new SignatureGenerationException(this, e);
        }

        return signatureByte;
    }

    /**
     * 拼接签名部分 header + . + payload
     *
     * @param headerBytes  header
     * @param payloadBytes payload
     * @return bytes
     */
    private byte[] combineSignByte(byte[] headerBytes, byte[] payloadBytes) {
        // header + payload
        byte[] hash = new byte[headerBytes.length + payloadBytes.length + 1];
        System.arraycopy(headerBytes, 0, hash, 0, headerBytes.length);
        hash[headerBytes.length] = JWT_PART_SEPARATOR;
        System.arraycopy(payloadBytes, 0, hash, headerBytes.length + 1, payloadBytes.length);
        return hash;
    }

    /**
     * builder
     */
    public static class SMAlogrithmBuilder {
        private BCECPublicKey publicKey;
        private BCECPrivateKey privateKey;

        SMAlogrithmBuilder() {
        }

        public SMAlgorithm.SMAlogrithmBuilder publicKey(final BCECPublicKey publicKey) {
            this.publicKey = publicKey;
            return this;
        }

        public SMAlgorithm.SMAlogrithmBuilder privateKey(final BCECPrivateKey privateKey) {
            this.privateKey = privateKey;
            return this;
        }

        public SMAlgorithm build() {
            return new SMAlgorithm(this.publicKey, this.privateKey);
        }
    }

    public static SMAlgorithm.SMAlogrithmBuilder builder() {
        return new SMAlgorithm.SMAlogrithmBuilder();
    }
}

对jwt封装

package com.mc.utils.JwtSm;

import cn.hutool.core.date.DateUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.auth0.jwt.interfaces.JWTVerifier;
import com.google.common.collect.Maps;
import com.mc.utils.BCECUtil;
import com.mc.utils.cert.SM2CertUtil;
import lombok.extern.slf4j.Slf4j;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import java.io.InputStream;
import java.security.Security;
import java.security.cert.X509Certificate;
import java.util.Date;
import java.util.Map;
import java.util.Objects;

/**
 * 生成jwt的工具类，基于auth0.java-jwt封装
 * 签名算法使用SM3WithSM2
 * payload统一使用Map<String, String>类型
 * @author Created by zkk on 2020/9/22
 **/
@Slf4j
public class JwtHelper {

    static {
        Security.addProvider(new BouncyCastleProvider());
        X509Certificate cert;
        try {
            InputStream streamCer = Thread.currentThread().getContextClassLoader().getResourceAsStream("jwt.sm2.cer");
            InputStream streamPri = Thread.currentThread().getContextClassLoader().getResourceAsStream("jwt.sm2.pri");
            int streamPriLen = Objects.requireNonNull(streamPri).available();
            cert = SM2CertUtil.getX509Certificate(streamCer);

            byte[] priKeyData = new byte[streamPriLen];
            streamPri.read(priKeyData);
            // 从证书中获取公钥，从私钥文件中获取私钥
            publicKey = SM2CertUtil.getBCECPublicKey(cert);
            privateKey = BCECUtil.convertSEC1ToBCECPrivateKey(priKeyData);

        } catch (Exception e) {
            log.error("JWT工具初始化异常", e);
        }

    }

    /**
     * 设置发行人
     */
    private static final String ISSUER = "machao";

    /**
     * SM2需要的公钥和私钥
     */
    private static BCECPublicKey publicKey;
    private static BCECPrivateKey privateKey;

    /**
     * 初始化SM3WithSM2算法
     */
    private static final SMAlgorithm ALGORITHM = SMAlgorithm.builder().publicKey(publicKey).privateKey(privateKey).build();

    /**
     * 生成jwt
     * @param claims 携带的payload
     * @return jwt token
     */
    public static String genToken(Map<String, String> claims){
        System.out.println(publicKey);
        System.out.println(privateKey);
        try {
            JWTCreator.Builder builder = JWT.create()
                    .withIssuer(ISSUER)
                    .withExpiresAt(DateUtil.offsetHour(new Date(), 2));//两小时后到期
            claims.forEach(builder::withClaim);
            return builder.sign(ALGORITHM);
        } catch (IllegalArgumentException e) {
            log.error("jwt生成失败", e);
        }
        return null;
    }

    /**
     * 验签方法
     * @param token jwt token
     * @return jwt payload
     */
    public static Map<String, String> verifyToken(String token) {
        JWTVerifier verifier = JWT.require(ALGORITHM).withIssuer(ISSUER).build();
        DecodedJWT jwt =  verifier.verify(token);
        Map<String, Claim> map = jwt.getClaims();
        Map<String, String> resultMap = Maps.newHashMap();
        map.forEach((k,v) -> resultMap.put(k, v.asString()));
        return resultMap;
    }
}

3.生成jwt

	public void signToken() {
        HashMap<String, String> map = new HashMap<>();
        map.put("name","machao");
        map.put("age","23");
        map.put("专业","计算机科学与技术");
        String token = JwtHelper.genToken(map);
        System.out.println(token);
    }

4.解析jwt

public void time(){
        String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJTTTNXaXRoU00yIn0.eyJpc3MiOiJtYWNoYW8iLCJuYW1lIjoibWFjaGFvIiwiZXhwIjoxNzA0ODI0OTc2LCJhZ2UiOiIyMyIsIuS4k-S4miI6Iuiuoeeul-acuuenkeWtpuS4juaKgOacryJ9.MEQCIDfCkJaWKcQq0chqKGyCuHrjjM-RfRQUUv0xXmPztM9eAiAwQwR_o7Eay6W5FztHqFRlnX05vQy21zjTZg-3Zhwqlg";

        try {
            Map<String, String> map1 = JwtHelper.verifyToken(token);
            System.out.println(map1);
        }catch (TokenExpiredException e){//超时
            System.out.println("jwt超时");
            System.out.println(e.getMessage());
        }catch (JWTDecodeException e){//第一段或第二段错误
            System.out.println("jwt编码错误");
        }catch (SignatureVerificationException e){
            System.out.println("验签失败");//第三段错误
        }
    }

5.sm封装

package com.mc.utils.JwtSm;

import com.mc.utils.SM2Util;
import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.crypto.CryptoException;
import org.bouncycastle.crypto.InvalidCipherTextException;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.bouncycastle.jce.interfaces.ECPrivateKey;

import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class MySm2 {
    public static BCECPublicKey bcPubKey;
    public static BCECPrivateKey bcecPriKey;

    /**
     * 获取公钥和私钥
     */
    public static void getkey() throws InvalidAlgorithmParameterException, NoSuchAlgorithmException, NoSuchProviderException {
        KeyPair keyPair= SM2Util.generateKeyPair();
        bcPubKey = (BCECPublicKey) keyPair.getPublic();
        bcecPriKey=(BCECPrivateKey) keyPair.getPrivate();
    }
    public static BCECPublicKey getBcPubKey(){
        return bcPubKey;
    }
    public static BCECPrivateKey getBcecPriKey(){
        return bcecPriKey;
    }

    /**
     * BCECPublicKey转String
     */
    public static String pub2str(BCECPublicKey publicKey){
        return Base64.encodeBase64String(publicKey.getEncoded());
    }

    /**
     * BCECPrivateKey转String
     */
    public static String pri2str(BCECPrivateKey privateKey){
        return Base64.encodeBase64String(privateKey.getEncoded());
    }

    /**
     * String转BCECPublicKey
     */
    public static BCECPublicKey str2pub(String publicKey) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {
        byte[] publicKeyBytes = java.util.Base64.getDecoder().decode(publicKey);

        // 创建X509EncodedKeySpec对象，用于构造公钥的规范
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
        // 使用EC算法和Bouncy Castle提供的KeyFactory来生成公钥对象
        KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
        BCECPublicKey PubKey = (BCECPublicKey) keyFactory.generatePublic(keySpec);
        return PubKey;
    }

    /**
     * String转BCECPrivateKey
     */
    public static BCECPrivateKey str2pri(String privateKey) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {
        byte[] privateKeyBytes = java.util.Base64.getDecoder().decode(privateKey);
        // 创建PKCS8EncodedKeySpec对象，用于构造私钥的规范
        PKCS8EncodedKeySpec keySpecs = new PKCS8EncodedKeySpec(privateKeyBytes);
        // 使用EC算法和Bouncy Castle提供的KeyFactory来生成私钥对象
        KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
        BCECPrivateKey PriKey = (BCECPrivateKey) keyFactory.generatePrivate(keySpecs);
        return PriKey;
    }

    /**
     * 加密
     */
    public static String encryption(String publickey,String data) throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchProviderException, InvalidCipherTextException {
        byte[] dataBytes= data.getBytes();
        BCECPublicKey publicKey=str2pub(publickey);
        byte[] cipherbyte=SM2Util.encrypt(publicKey, dataBytes);
        String ciphertext= java.util.Base64.getEncoder().encodeToString(cipherbyte);
        return ciphertext;
    }

    /**
     * 解密
     */
    public static String decrypt(String privatekey,String data) throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchProviderException, InvalidCipherTextException {
        byte[] dataBytes= java.util.Base64.getDecoder().decode(data);
        BCECPrivateKey priKey=str2pri(privatekey);
        byte[] plaintbyte=SM2Util.decrypt(priKey, dataBytes);
        String plainttext= new String(plaintbyte);
        return plainttext;
    }
    /**
     * 签名
     */
    public static String signaure(String privatekey,String data) throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchProviderException, CryptoException {
        BCECPrivateKey priKey=str2pri(privatekey);
        byte[] dataBytes= data.getBytes();
        byte[] k=SM2Util.sign(priKey,dataBytes);
        String sign= java.util.Base64.getEncoder().encodeToString(k);
        return sign;
    }
    /**
     * 验签
     */
    public static boolean visa(String publickey,String sign,String data) throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchProviderException {
        byte[] dataBytes= data.getBytes();
        byte[] signBytes= java.util.Base64.getDecoder().decode(sign);
        BCECPublicKey publicKey=str2pub(publickey);
        boolean result=SM2Util.verify(publicKey,dataBytes,signBytes);
        return result;
    }
}

package com.mc.jwtsm;

import com.mc.utils.JwtSm.MySm2;
import org.bouncycastle.crypto.CryptoException;
import org.bouncycastle.crypto.InvalidCipherTextException;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.junit.Test;

import java.security.InvalidAlgorithmParameterException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.spec.InvalidKeySpecException;

public class mysm2test {
    @Test
    public void Test() throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchProviderException, CryptoException {
        //生成公钥和私钥
        try {
            MySm2.getkey();
        } catch (InvalidAlgorithmParameterException e) {
            throw new RuntimeException(e);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        } catch (NoSuchProviderException e) {
            throw new RuntimeException(e);
        }
        BCECPublicKey publicKey = MySm2.getBcPubKey();
        BCECPrivateKey privateKey = MySm2.getBcecPriKey();
        String pubkey=MySm2.pub2str(publicKey);
        String prikey=MySm2.pri2str(privateKey);
        System.out.println("---------------------公钥和私钥---------------------------------------");
        System.out.println(pubkey);
        System.out.println(MySm2.str2pub(pubkey));
        System.out.println(prikey);
        System.out.println(MySm2.str2pri(prikey));
        System.out.println("----------------------加密解密----------------------------------------");
        String data="你好 2023 hello";
        String mi=MySm2.encryption(pubkey,data);
        System.out.println("密文:"+mi);
        String ming=MySm2.decrypt(prikey,mi);
        System.out.println("明文:"+ming);
        System.out.println("----------------------签名验签----------------------------------------");
        String qian=MySm2.signaure(prikey,data);
        System.out.println("签名:"+qian);
        boolean result=MySm2.visa(pubkey,qian,data);
        System.out.println("结果:"+result);
    }
}