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

文章数量 129

访问次数 422320

运行天数 1819

最近活跃 2025-10-05 10:13:46

进入后台管理系统

博客 - java使用SM2加解密工具类

java使用SM2加解密工具类 

  1. package wst.st.site.tools.sm2;
  3. import lombok.Data;
  5. @Data
  6. public class SM2KeyPair {
  7.     public SM2KeyPair(String publicKey, String privateKey) {
  8.         this.publicKey = publicKey;
  9.         this.privateKey = privateKey;
  10.     }
  12.     /** 公钥 */
  13.     private String publicKey;
  14.     /** 私钥 */
  15.     private String privateKey;
  16. }
  1. package wst.st.site.tools.sm2;
  3. import java.math.BigInteger;
  4. import java.security.SecureRandom;
  6. import org.bouncycastle.crypto.CipherParameters;
  7. import org.bouncycastle.crypto.Digest;
  8. import org.bouncycastle.crypto.InvalidCipherTextException;
  9. import org.bouncycastle.crypto.digests.SM3Digest;
  10. import org.bouncycastle.crypto.params.ECDomainParameters;
  11. import org.bouncycastle.crypto.params.ECKeyParameters;
  12. import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
  13. import org.bouncycastle.crypto.params.ECPublicKeyParameters;
  14. import org.bouncycastle.crypto.params.ParametersWithRandom;
  15. import org.bouncycastle.math.ec.ECConstants;
  16. import org.bouncycastle.math.ec.ECFieldElement;
  17. import org.bouncycastle.math.ec.ECPoint;
  18. import org.bouncycastle.util.Arrays;
  19. import org.bouncycastle.util.BigIntegers;
  21. public class SM2EngineExtend {
  23.     private final Digest digest;
  25.     /**是否为加密模式*/
  26.     private boolean forEncryption;
  27.     private ECKeyParameters ecKey;
  28.     private ECDomainParameters ecParams;
  29.     private int curveLength;
  30.     private SecureRandom random;
  31.     /**密文排序方式*/
  32.     private int cipherMode;
  34.     /**BC库默认排序方式-C1C2C3*/
  35.     public static int CIPHERMODE_BC = 0;
  36.     /**国密标准排序方式-C1C3C2*/
  37.     public static int CIPHERMODE_NORM = 1;
  39.     public SM2EngineExtend() {
  40.         this(new SM3Digest());
  41.     }
  43.     public SM2EngineExtend(Digest digest) {
  44.         this.digest = digest;
  45.     }
  47.     /**
  48.      * 设置密文排序方式
  49.      * @param cipherMode
  50.      */
  51.     public void setCipherMode(int cipherMode){
  52.         this.cipherMode = cipherMode;
  53.     }
  55.     /**
  56.      * 默认初始化方法，使用国密排序标准
  57.      * @param forEncryption - 是否以加密模式初始化
  58.      * @param param - 曲线参数
  59.      */
  60.     public void init(boolean forEncryption, CipherParameters param) {
  61.         init(forEncryption, CIPHERMODE_NORM, param);
  62.     }
  64.     /**
  65.      * 默认初始化方法，使用国密排序标准
  66.      * @param forEncryption 是否以加密模式初始化
  67.      * @param cipherMode 加密数据排列模式：1-标准排序；0-BC默认排序
  68.      * @param param 曲线参数
  69.      */
  70.     public void init(boolean forEncryption, int cipherMode, CipherParameters param) {
  71.         this.forEncryption = forEncryption;
  72.         this.cipherMode = cipherMode;
  73.         if (forEncryption) {
  74.             ParametersWithRandom rParam = (ParametersWithRandom) param;
  76.             ecKey = (ECKeyParameters) rParam.getParameters();
  77.             ecParams = ecKey.getParameters();
  79.             ECPoint s = ((ECPublicKeyParameters) ecKey).getQ().multiply(ecParams.getH());
  80.             if (s.isInfinity()) {
  81.                 throw new IllegalArgumentException("invalid key: [h]Q at infinity");
  82.             }
  84.             random = rParam.getRandom();
  85.         } else {
  86.             ecKey = (ECKeyParameters) param;
  87.             ecParams = ecKey.getParameters();
  88.         }
  90.         curveLength = (ecParams.getCurve().getFieldSize() + 7) / 8;
  91.     }
  93.     /**
  94.      * 加密或解密输入数据
  95.      * @param in
  96.      * @param inOff
  97.      * @param inLen
  98.      * @return
  99.      * @throws InvalidCipherTextException
  100.      */
  101.     public byte[] processBlock( byte[] in, int inOff, int inLen) throws InvalidCipherTextException {
  102.         if (forEncryption) {
  103.             // 加密
  104.             return encrypt(in, inOff, inLen);
  105.         } else {
  106.             return decrypt(in, inOff, inLen);
  107.         }
  108.     }
  110.     /**
  111.      * 加密实现，根据cipherMode输出指定排列的结果，默认按标准方式排列
  112.      * @param in
  113.      * @param inOff
  114.      * @param inLen
  115.      * @return
  116.      * @throws InvalidCipherTextException
  117.      */
  118.     private byte[] encrypt(byte[] in, int inOff, int inLen)
  119.             throws InvalidCipherTextException {
  120.         byte[] c2 = new byte[inLen];
  122.         System.arraycopy(in, inOff, c2, 0, c2.length);
  124.         byte[] c1;
  125.         ECPoint kPB;
  126.         do {
  127.             BigInteger k = nextK();
  129.             ECPoint c1P = ecParams.getG().multiply(k).normalize();
  131.             c1 = c1P.getEncoded(false);
  133.             kPB = ((ECPublicKeyParameters) ecKey).getQ().multiply(k).normalize();
  135.             kdf(digest, kPB, c2);
  136.         }
  137.         while (notEncrypted(c2, in, inOff));
  139.         byte[] c3 = new byte[digest.getDigestSize()];
  141.         addFieldElement(digest, kPB.getAffineXCoord());
  142.         digest.update(in, inOff, inLen);
  143.         addFieldElement(digest, kPB.getAffineYCoord());
  145.         digest.doFinal(c3, 0);
  146.         if (cipherMode == CIPHERMODE_NORM){
  147.             return Arrays.concatenate(c1, c3, c2);
  148.         }
  149.         return Arrays.concatenate(c1, c2, c3);
  150.     }
  152.     /**
  153.      * 解密实现，默认按标准排列方式解密，解密时解出c2部分原文并校验c3部分
  154.      * @param in
  155.      * @param inOff
  156.      * @param inLen
  157.      * @return
  158.      * @throws InvalidCipherTextException
  159.      */
  160.     private byte[] decrypt(byte[] in, int inOff, int inLen)
  161.             throws InvalidCipherTextException {
  162.         byte[] c1 = new byte[curveLength * 2 + 1];
  164.         System.arraycopy(in, inOff, c1, 0, c1.length);
  166.         ECPoint c1P = ecParams.getCurve().decodePoint(c1);
  168.         ECPoint s = c1P.multiply(ecParams.getH());
  169.         if (s.isInfinity()) {
  170.             throw new InvalidCipherTextException("[h]C1 at infinity");
  171.         }
  173.         c1P = c1P.multiply(((ECPrivateKeyParameters) ecKey).getD()).normalize();
  175.         byte[] c2 = new byte[inLen - c1.length - digest.getDigestSize()];
  176.         if (cipherMode == CIPHERMODE_BC) {
  177.             System.arraycopy(in, inOff + c1.length, c2, 0, c2.length);
  178.         }else{
  179.             // C1 C3 C2
  180.             System.arraycopy(in, inOff + c1.length + digest.getDigestSize(), c2, 0, c2.length);
  181.         }
  183.         kdf(digest, c1P, c2);
  185.         byte[] c3 = new byte[digest.getDigestSize()];
  187.         addFieldElement(digest, c1P.getAffineXCoord());
  188.         digest.update(c2, 0, c2.length);
  189.         addFieldElement(digest, c1P.getAffineYCoord());
  191.         digest.doFinal(c3, 0);
  193.         int check = 0;
  194.         // 检查密文输入值C3部分和由摘要生成的C3是否一致
  195.         if (cipherMode == CIPHERMODE_BC) {
  196.             for (int i = 0; i != c3.length; i++) {
  197.                 check |= c3[i] ^ in[c1.length + c2.length + i];
  198.             }
  199.         }else{
  200.             for (int i = 0; i != c3.length; i++) {
  201.                 check |= c3[i] ^ in[c1.length + i];
  202.             }
  203.         }
  205.         clearBlock(c1);
  206.         clearBlock(c3);
  208.         if (check != 0) {
  209.             clearBlock(c2);
  210.             throw new InvalidCipherTextException("invalid cipher text");
  211.         }
  213.         return c2;
  214.     }
  216.     private boolean notEncrypted(byte[] encData, byte[] in, int inOff) {
  217.         for (int i = 0; i != encData.length; i++) {
  218.             if (encData[i] != in[inOff]) {
  219.                 return false;
  220.             }
  221.         }
  223.         return true;
  224.     }
  226.     private void kdf(Digest digest, ECPoint c1, byte[] encData) {
  227.         int ct = 1;
  228.         int v = digest.getDigestSize();
  230.         byte[] buf = new byte[digest.getDigestSize()];
  231.         int off = 0;
  233.         for (int i = 1; i <= ((encData.length + v - 1) / v); i++) {
  234.             addFieldElement(digest, c1.getAffineXCoord());
  235.             addFieldElement(digest, c1.getAffineYCoord());
  236.             digest.update((byte) (ct >> 24));
  237.             digest.update((byte) (ct >> 16));
  238.             digest.update((byte) (ct >> 8));
  239.             digest.update((byte) ct);
  241.             digest.doFinal(buf, 0);
  243.             if (off + buf.length < encData.length) {
  244.                 xor(encData, buf, off, buf.length);
  245.             } else {
  246.                 xor(encData, buf, off, encData.length - off);
  247.             }
  249.             off += buf.length;
  250.             ct++;
  251.         }
  252.     }
  254.     private void xor(byte[] data, byte[] kdfOut, int dOff, int dRemaining) {
  255.         for (int i = 0; i != dRemaining; i++) {
  256.             data[dOff + i] ^= kdfOut[i];
  257.         }
  258.     }
  260.     private BigInteger nextK() {
  261.         int qBitLength = ecParams.getN().bitLength();
  263.         BigInteger k;
  264.         do {
  265.             k = new BigInteger(qBitLength, random);
  266.         }
  267.         while (k.equals(ECConstants.ZERO) || k.compareTo(ecParams.getN()) >= 0);
  269.         return k;
  270.     }
  272.     private void addFieldElement(Digest digest, ECFieldElement v) {
  273.         byte[] p = BigIntegers.asUnsignedByteArray(curveLength, v.toBigInteger());
  275.         digest.update(p, 0, p.length);
  276.     }
  278.     /**
  279.      * clear possible sensitive data
  280.      */
  281.     private void clearBlock(
  282.             byte[] block) {
  283.         for (int i = 0; i != block.length; i++) {
  284.             block[i] = 0;
  285.         }
  286.     }
  287. }
  1. package wst.st.site.tools.sm2;
  3. import java.math.BigInteger;
  4. import java.security.NoSuchAlgorithmException;
  5. import java.security.SecureRandom;
  7. import org.bouncycastle.asn1.gm.GMNamedCurves;
  8. import org.bouncycastle.asn1.x9.X9ECParameters;
  9. import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
  10. import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
  11. import org.bouncycastle.crypto.params.ECDomainParameters;
  12. import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
  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.math.ec.ECPoint;
  17. import org.bouncycastle.util.encoders.Hex;
  18. import org.slf4j.Logger;
  19. import org.slf4j.LoggerFactory;
  21. public class SM2Utils {
  23.     private static Logger logger = LoggerFactory.getLogger(SM2Utils.class);
  24.     /**
  25.      * SM2加密算法
  26.      * @param publicKey 公钥
  27.      * @param data 待加密的数据
  28.      * @return 密文，BC库产生的密文带由04标识符，与非BC库对接时需要去掉开头的04
  29.      */
  30.     public static String encrypt(String publicKey, String data){
  31.         // 按国密排序标准加密
  32.         return encrypt(publicKey, data, SM2EngineExtend.CIPHERMODE_NORM);
  33.     }
  35.     /**
  36.      * SM2加密算法
  37.      * @param publicKey 公钥
  38.      * @param data 待加密的数据
  39.      * @param cipherMode 密文排列方式0-C1C2C3；1-C1C3C2；
  40.      * @return 密文，BC库产生的密文带由04标识符，与非BC库对接时需要去掉开头的04
  41.      */
  42.     public static String encrypt(String publicKey, String data, int cipherMode){
  43.         // 获取一条SM2曲线参数
  44.         X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
  45.         // 构造ECC算法参数，曲线方程、椭圆曲线G点、大整数N
  46.         ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());
  47.         //提取公钥点
  48.         ECPoint pukPoint = sm2ECParameters.getCurve().decodePoint(Hex.decode(publicKey));
  49.         // 公钥前面的02或者03表示是压缩公钥，04表示未压缩公钥, 04的时候，可以去掉前面的04
  50.         ECPublicKeyParameters publicKeyParameters = new ECPublicKeyParameters(pukPoint, domainParameters);
  52.         SM2EngineExtend sm2Engine = new SM2EngineExtend();
  53.         // 设置sm2为加密模式
  54.         sm2Engine.init(true, cipherMode, new ParametersWithRandom(publicKeyParameters, new SecureRandom()));
  56.         byte[] arrayOfBytes = null;
  57.         try {
  58.             byte[] in = data.getBytes();
  59.             arrayOfBytes = sm2Engine.processBlock(in, 0, in.length);
  60.         } catch (Exception e) {
  61.             logger.error("SM2加密时出现异常:{}", e.getMessage(), e);
  62.         }
  63.         return Hex.toHexString(arrayOfBytes);
  64.     }
  66.     /**
  67.      * 获取sm2密钥对
  68.      * BC库使用的公钥=64个字节+1个字节（04标志位），BC库使用的私钥=32个字节
  69.      * SM2秘钥的组成部分有 私钥D 、公钥X 、 公钥Y , 他们都可以用长度为64的16进制的HEX串表示，
  70.      * <br/>SM2公钥并不是直接由X+Y表示 , 而是额外添加了一个头，当启用压缩时:公钥=有头+公钥X ，即省略了公钥Y的部分
  71.      * @param compressed 是否压缩公钥（加密解密都使用BC库才能使用压缩）
  72.      * @return
  73.      */
  74.     public static SM2KeyPair getSm2Keys(boolean compressed){
  75.         //获取一条SM2曲线参数
  76.         X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
  77.         //构造domain参数
  78.         ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());
  79.         //1.创建密钥生成器
  80.         ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
  81.         //2.初始化生成器,带上随机数
  82.         try {
  83.             keyPairGenerator.init(new ECKeyGenerationParameters(domainParameters, SecureRandom.getInstance("SHA1PRNG")));
  84.         } catch (NoSuchAlgorithmException e) {
  85.             logger.error("生成公私钥对时出现异常:", e);
  86.         }
  87.         //3.生成密钥对
  88.         AsymmetricCipherKeyPair asymmetricCipherKeyPair = keyPairGenerator.generateKeyPair();
  89.         ECPublicKeyParameters publicKeyParameters = (ECPublicKeyParameters)asymmetricCipherKeyPair.getPublic();
  90.         ECPoint ecPoint = publicKeyParameters.getQ();
  91.         // 把公钥放入map中,默认压缩公钥
  92.         // 公钥前面的02或者03表示是压缩公钥,04表示未压缩公钥,04的时候,可以去掉前面的04
  93.         String publicKey = Hex.toHexString(ecPoint.getEncoded(compressed));
  94.         ECPrivateKeyParameters privateKeyParameters = (ECPrivateKeyParameters) asymmetricCipherKeyPair.getPrivate();
  95.         BigInteger intPrivateKey = privateKeyParameters.getD();
  96.         // 把私钥放入map中
  97.         String privateKey = intPrivateKey.toString(16);
  98.         return new SM2KeyPair(publicKey, privateKey);
  99.     }
  101.     /**
  102.      * SM2解密算法
  103.      * @param privateKey    私钥
  104.      * @param cipherData    密文数据
  105.      * @return
  106.      */
  107.     public static String decrypt(String privateKey, String cipherData) {
  108.         // // 按国密排序标准解密
  109.         return decrypt(privateKey, cipherData, SM2EngineExtend.CIPHERMODE_NORM);
  110.     }
  112.     /**
  113.      * SM2解密算法
  114.      * @param privateKey    私钥
  115.      * @param cipherData    密文数据
  116.      * @param cipherMode 密文排列方式0-C1C2C3；1-C1C3C2；
  117.      * @return
  118.      */
  119.     public static String decrypt(String privateKey, String cipherData, int cipherMode) {
  120.         // 使用BC库加解密时密文以04开头，传入的密文前面没有04则补上
  121.         if (!cipherData.startsWith("04")){
  122.             cipherData = "04" + cipherData;
  123.         }
  124.         byte[] cipherDataByte = Hex.decode(cipherData);
  126.         //获取一条SM2曲线参数
  127.         X9ECParameters sm2ECParameters = GMNamedCurves.getByName("sm2p256v1");
  128.         //构造domain参数
  129.         ECDomainParameters domainParameters = new ECDomainParameters(sm2ECParameters.getCurve(), sm2ECParameters.getG(), sm2ECParameters.getN());
  131.         BigInteger privateKeyD = new BigInteger(privateKey, 16);
  132.         ECPrivateKeyParameters privateKeyParameters = new ECPrivateKeyParameters(privateKeyD, domainParameters);
  134.         SM2EngineExtend sm2Engine = new SM2EngineExtend();
  135.         // 设置sm2为解密模式
  136.         sm2Engine.init(false, cipherMode, privateKeyParameters);
  138.         String result = "";
  139.         try {
  140.             byte[] arrayOfBytes = sm2Engine.processBlock(cipherDataByte, 0, cipherDataByte.length);
  141.             return new String(arrayOfBytes);
  142.         } catch (Exception e) {
  143.             logger.error("SM2解密时出现异常:{}", e.getMessage(), e);
  144.         }
  145.         return result;
  146.     }
  148.     public static void main(String[] args) {
  149.         //获取公私钥
  150.         SM2KeyPair sm2Keys = SM2Utils.getSm2Keys(false);
  151.         System.out.println("公钥 ：" + sm2Keys.getPublicKey());
  152.         System.out.println("私钥 ：" + sm2Keys.getPrivateKey());
  154.         //需要加密的数据
  155.         String data = "9ol.0p;/?<>$^MJU&";
  156.         //公钥加密，获取密文
  157.         String encrypt = SM2Utils.encrypt(sm2Keys.getPublicKey(), data);
  158.         System.out.println("密文 ：" + encrypt);
  160.         //私钥解密
  161.         String decrypt = SM2Utils.decrypt(sm2Keys.getPrivateKey(), encrypt);
  162.         System.out.println("解密数据 : " + decrypt);
  164.         System.out.println("明文密文是否相同 ：" + data.equals(decrypt));
  165.     }
  166. }
给我留言

评论