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

java 实现 国密sm2、sm3 + vue 加密_sm2加密java和vue

作者：AI编程探险家 | 2024-01-31 08:39:53

赞

踩

sm2加密java和vue

后端：公共类，生成sm2公私钥 ，sm2解密方法，并集成sm2加密、sm3加密

  1. public class SM2Utils {
  2.  
  3.     private static final Logger LOGGER = LoggerFactory.getLogger(SM2Utils.class);
  4.     private static final String publicKeyName = "PUBLICKEY";
  5.     private static final String privateKeyName = "PRIVATEKEY";
  6.     private static final String ENCODING = "UTF-8";
  7.     // 生成随机秘钥对
  8.     public static Map<String, String> generateKeyPair() {
  9.         SM2 sm2 = SM2.Instance();
  10.         AsymmetricCipherKeyPair key = null;
  11.         while (true) {
  12.             key = sm2.ecc_key_pair_generator.generateKeyPair();
  13.             if (((ECPrivateKeyParameters) key.getPrivate()).getD().toByteArray().length == 32) {
  14.                 break;
  15.             }
  16.         }
  17.         ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();
  18.         ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();
  19.         BigInteger privateKey = ecpriv.getD();
  20.         ECPoint publicKey = ecpub.getQ();
  21.         String pubk = Util.byteToHex(publicKey.getEncoded());
  22.         String prik = Util.byteToHex(privateKey.toByteArray());
  23.         System.out.println("公钥: " + pubk);
  24.         System.out.println("私钥: " + prik);
  25.  
  26.  
  27.  
  28.  
  29.         Map<String, String> result = new HashMap<>();
  30.  
  31.         result.put(publicKeyName, pubk);
  32.         result.put(privateKeyName, prik);
  33.  
  34.         return result;
  35.     }
  36.  
  37.     // 数据加密
  38.     public static String encrypt(byte[] publicKey, byte[] data) throws IOException {
  39.         if (publicKey == null || publicKey.length == 0) {
  40.             return null;
  41.         }
  42.  
  43.         if (data == null || data.length == 0) {
  44.             return null;
  45.         }
  46.  
  47.         byte[] source = new byte[data.length];
  48.         System.arraycopy(data, 0, source, 0, data.length);
  49.         Cipher cipher = new Cipher();
  50.         SM2 sm2 = SM2.Instance();
  51.         ECPoint userKey = sm2.ecc_curve.decodePoint(publicKey);
  52.         ECPoint c1 = cipher.Init_enc(sm2, userKey);
  53.         cipher.Encrypt(source);
  54.         byte[] c3 = new byte[32];
  55.         cipher.Dofinal(c3);
  56.         return new StringBuffer(Util.byteToHex(c1.getEncoded())).append(Util.byteToHex(c3)).append(Util.byteToHex(source)).toString();
  57.     }
  58.  
  59.     // 数据解密
  60.     public static byte[] decrypt(byte[] privateKey, byte[] encryptedData) throws IOException {
  61.         if (privateKey == null || privateKey.length == 0) {
  62.             return null;
  63.         }
  64.  
  65.         if (encryptedData == null || encryptedData.length == 0) {
  66.             return null;
  67.         }
  68.         // 加密字节数组转换为十六进制的字符串 长度变为encryptedData.length * 2
  69.         String data = Util.byteToHex(encryptedData);
  70.  
  71.         byte[] c1Bytes = Util.hexToByte(data.substring(0, 130));
  72.         int c2Len = encryptedData.length - 97;
  73.         byte[] c3 = Util.hexToByte(data.substring(130, 130 + 64));
  74.         byte[] c2 = Util.hexToByte(data.substring(194, 194 + 2 * c2Len));
  75.  
  76.         SM2 sm2 = SM2.Instance();
  77.         BigInteger userD = new BigInteger(1, privateKey);
  78.  
  79.         // 通过C1实体字节来生成ECPoint
  80.         ECPoint c1 = sm2.ecc_curve.decodePoint(c1Bytes);
  81.         Cipher cipher = new Cipher();
  82.         cipher.Init_dec(userD, c1);
  83.         cipher.Decrypt(c2);
  84.         cipher.Dofinal(c3);
  85.  
  86.         // 返回解密结果
  87.         return c2;
  88.     }
  89.  
  90.     /**
  91.      * sm3算法加密
  92.      * @explain
  93.      * @param paramStr 待加密字符串
  94.      * @param key 密钥
  95.      * @return 返回加密后，固定长度=32的16进制字符串
  96.      */
  97.     public static String sm3EncryptPlus(String paramStr,String key){
  98.         // 将返回的hash值转换成16进制字符串
  99.         String resultHexString = "";
  100.         try {
  101.             // 将字符串转换成byte数组
  102.             byte[] srcData = paramStr.getBytes(ENCODING);
  103.             // 调用hash()
  104.             byte[] resultHash = hmac(srcData,key.getBytes(ENCODING));
  105.             // 将返回的hash值转换成16进制字符串
  106.             resultHexString = ByteUtils.toHexString(resultHash);
  107.         } catch (UnsupportedEncodingException e) {
  108.             e.printStackTrace();
  109.         }
  110.         return resultHexString;
  111.     }
  112.  
  113.     /**
  114.      * 通过密钥进行加密
  115.      * @explain 指定密钥进行加密
  116.      * @param key 密钥
  117.      * @param srcData 被加密的byte数组
  118.      * @return
  119.      */
  120.     public static byte[] hmac(byte[] key, byte[] srcData) {
  121.         KeyParameter keyParameter = new KeyParameter(key);
  122.         SM3Digest digest = new SM3Digest();
  123.         HMac mac = new HMac(digest);
  124.         mac.init(keyParameter);
  125.         mac.update(srcData, 0, srcData.length);
  126.         byte[] result = new byte[mac.getMacSize()];
  127.         mac.doFinal(result, 0);
  128.         return result;
  129.     }
  130.  
  131.     /**
  132.      * sm3算法加密
  133.      * @explain
  134.      * @param paramStr 待加密字符串
  135.      * @return 返回加密后，固定长度=32的16进制字符串
  136.      */
  137.     public static String sm3Encrypt(String paramStr){
  138.         // 将返回的hash值转换成16进制字符串
  139.         String resultHexString = "";
  140.         try {
  141.             // 将字符串转换成byte数组
  142.             byte[] srcData = paramStr.getBytes(ENCODING);
  143.             // 调用hash()
  144.             byte[] resultHash = hash(srcData);
  145.             // 将返回的hash值转换成16进制字符串
  146.             resultHexString = ByteUtils.toHexString(resultHash);
  147.         } catch (UnsupportedEncodingException e) {
  148.             e.printStackTrace();
  149.         }
  150.         return resultHexString;
  151.     }
  152.     /**
  153.      * 返回长度=32的byte数组
  154.      * @explain 生成对应的hash值
  155.      * @param srcData
  156.      * @return
  157.      */
  158.     public static byte[] hash(byte[] srcData) {
  159.         SM3Digest digest = new SM3Digest();
  160.         digest.update(srcData, 0, srcData.length);
  161.         byte[] hash = new byte[digest.getDigestSize()];
  162.         digest.doFinal(hash, 0);
  163.         return hash;
  164.     }
  165. }

与之关联的工具类有：Util 、Cipher 、SM2

  1.  
  2. public class Cipher {
  3.     private int ct;
  4.     private ECPoint p2;
  5.     private SM3Digest sm3keybase;
  6.     private SM3Digest sm3c3;
  7.     private byte key[];
  8.     private byte keyOff;
  9.  
  10.     public Cipher()
  11.     {
  12.         this.ct = 1;
  13.         this.key = new byte[32];
  14.         this.keyOff = 0;
  15.     }
  16.  
  17.     private void Reset()
  18.     {
  19.         this.sm3keybase = new SM3Digest();
  20.         this.sm3c3 = new SM3Digest();
  21.  
  22.         byte p[] = Util.byteConvert32Bytes(p2.getX().toBigInteger());
  23.         this.sm3keybase.update(p, 0, p.length);
  24.         this.sm3c3.update(p, 0, p.length);
  25.  
  26.         p = Util.byteConvert32Bytes(p2.getY().toBigInteger());
  27.         this.sm3keybase.update(p, 0, p.length);
  28.         this.ct = 1;
  29.         NextKey();
  30.     }
  31.  
  32.     private void NextKey()
  33.     {
  34.         SM3Digest sm3keycur = new SM3Digest(this.sm3keybase);
  35.         sm3keycur.update((byte) (ct >> 24 & 0xff));
  36.         sm3keycur.update((byte) (ct >> 16 & 0xff));
  37.         sm3keycur.update((byte) (ct >> 8 & 0xff));
  38.         sm3keycur.update((byte) (ct & 0xff));
  39.         sm3keycur.doFinal(key, 0);
  40.         this.keyOff = 0;
  41.         this.ct++;
  42.     }
  43.  
  44.     public ECPoint Init_enc(SM2 sm2, ECPoint userKey)
  45.     {
  46.         AsymmetricCipherKeyPair key = sm2.ecc_key_pair_generator.generateKeyPair();
  47.         ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();
  48.         ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();
  49.         BigInteger k = ecpriv.getD();
  50.         ECPoint c1 = ecpub.getQ();
  51.         this.p2 = userKey.multiply(k);
  52.         Reset();
  53.         return c1;
  54.     }
  55.  
  56.     public void Encrypt(byte data[])
  57.     {
  58.         this.sm3c3.update(data, 0, data.length);
  59.         for (int i = 0; i < data.length; i++)
  60.         {
  61.             if (keyOff == key.length)
  62.             {
  63.                 NextKey();
  64.             }
  65.             data[i] ^= key[keyOff++];
  66.         }
  67.     }
  68.  
  69.     public void Init_dec(BigInteger userD, ECPoint c1)
  70.     {
  71.         this.p2 = c1.multiply(userD);
  72.         Reset();
  73.     }
  74.  
  75.     public void Decrypt(byte data[])
  76.     {
  77.         for (int i = 0; i < data.length; i++)
  78.         {
  79.             if (keyOff == key.length)
  80.             {
  81.                 NextKey();
  82.             }
  83.             data[i] ^= key[keyOff++];
  84.         }
  85.  
  86.         this.sm3c3.update(data, 0, data.length);
  87.     }
  88.  
  89.     public void Dofinal(byte c3[])
  90.     {
  91.         byte p[] = Util.byteConvert32Bytes(p2.getY().toBigInteger());
  92.         this.sm3c3.update(p, 0, p.length);
  93.         this.sm3c3.doFinal(c3, 0);
  94.         Reset();
  95.     }
  96.  
  97. }
  98.  
  99.  
  100.  
  101.  
  102.  
  103. public class SM2 {
  104.  
  105.     //正式参数
  106.     public static String[] ecc_param = {
  107.             "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF",
  108.             "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC",
  109.             "28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93",
  110.             "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123",
  111.             "32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7",
  112.             "BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0"
  113.     };
  114.  
  115.     public static SM2 Instance() {
  116.         return new SM2();
  117.     }
  118.  
  119.     /** 素数p */
  120.     public final BigInteger ecc_p;
  121.     /** 系数a */
  122.     public final BigInteger ecc_a;
  123.     /** 系数b */
  124.     public final BigInteger ecc_b;
  125.     /** 基点G, G=(xg,yg),其介记为n */
  126.     public final BigInteger ecc_n;
  127.     /** 坐标x */
  128.     public final BigInteger ecc_gx;
  129.     /** 坐标y */
  130.     public final BigInteger ecc_gy;
  131.     public final ECCurve ecc_curve;
  132.     public final ECPoint ecc_point_g;
  133.     public final ECDomainParameters ecc_bc_spec;
  134.     public final ECKeyPairGenerator ecc_key_pair_generator;
  135.     public final ECFieldElement ecc_gx_fieldelement;
  136.     public final ECFieldElement ecc_gy_fieldelement;
  137.  
  138.     public SM2() {
  139.         this.ecc_p = new BigInteger(ecc_param[0], 16);
  140.         this.ecc_a = new BigInteger(ecc_param[1], 16);
  141.         this.ecc_b = new BigInteger(ecc_param[2], 16);
  142.         this.ecc_n = new BigInteger(ecc_param[3], 16);
  143.         this.ecc_gx = new BigInteger(ecc_param[4], 16);
  144.         this.ecc_gy = new BigInteger(ecc_param[5], 16);
  145.  
  146.         this.ecc_gx_fieldelement = new ECFieldElement.Fp(this.ecc_p, this.ecc_gx);
  147.         this.ecc_gy_fieldelement = new ECFieldElement.Fp(this.ecc_p, this.ecc_gy);
  148.  
  149.         this.ecc_curve = new ECCurve.Fp(this.ecc_p, this.ecc_a, this.ecc_b);
  150.         this.ecc_point_g = new ECPoint.Fp(this.ecc_curve, this.ecc_gx_fieldelement, this.ecc_gy_fieldelement);
  151.  
  152.         this.ecc_bc_spec = new ECDomainParameters(this.ecc_curve, this.ecc_point_g, this.ecc_n);
  153.  
  154.         ECKeyGenerationParameters ecc_ecgenparam;
  155.         ecc_ecgenparam = new ECKeyGenerationParameters(this.ecc_bc_spec, new SecureRandom());
  156.  
  157.         this.ecc_key_pair_generator = new ECKeyPairGenerator();
  158.         this.ecc_key_pair_generator.init(ecc_ecgenparam);
  159.     }
  160.  
  161. }
  162.  
  163.  
  164.  
  165.  
  166. public class Util {
  167.     /**
  168.      * 整形转换成网络传输的字节流（字节数组）型数据
  169.      *
  170.      * @param num 一个整型数据
  171.      * @return 4个字节的自己数组
  172.      */
  173.     public static byte[] intToBytes(int num) {
  174.         byte[] bytes = new byte[4];
  175.         bytes[0] = (byte) (0xff & (num >> 0));
  176.         bytes[1] = (byte) (0xff & (num >> 8));
  177.         bytes[2] = (byte) (0xff & (num >> 16));
  178.         bytes[3] = (byte) (0xff & (num >> 24));
  179.         return bytes;
  180.     }
  181.  
  182.     /**
  183.      * 四个字节的字节数据转换成一个整形数据
  184.      *
  185.      * @param bytes 4个字节的字节数组
  186.      * @return 一个整型数据
  187.      */
  188.     public static int byteToInt(byte[] bytes) {
  189.         int num = 0;
  190.         int temp;
  191.         temp = (0x000000ff & (bytes[0])) << 0;
  192.         num = num | temp;
  193.         temp = (0x000000ff & (bytes[1])) << 8;
  194.         num = num | temp;
  195.         temp = (0x000000ff & (bytes[2])) << 16;
  196.         num = num | temp;
  197.         temp = (0x000000ff & (bytes[3])) << 24;
  198.         num = num | temp;
  199.         return num;
  200.     }
  201.  
  202.     /**
  203.      * 长整形转换成网络传输的字节流（字节数组）型数据
  204.      *
  205.      * @param num 一个长整型数据
  206.      * @return 4个字节的自己数组
  207.      */
  208.     public static byte[] longToBytes(long num) {
  209.         byte[] bytes = new byte[8];
  210.         for (int i = 0; i < 8; i++) {
  211.             bytes[i] = (byte) (0xff & (num >> (i * 8)));
  212.         }
  213.  
  214.         return bytes;
  215.     }
  216.  
  217.     /**
  218.      * 大数字转换字节流（字节数组）型数据
  219.      *
  220.      * @param n
  221.      * @return
  222.      */
  223.     public static byte[] byteConvert32Bytes(BigInteger n) {
  224.         byte tmpd[] = (byte[]) null;
  225.         if (n == null) {
  226.             return null;
  227.         }
  228.  
  229.         if (n.toByteArray().length == 33) {
  230.             tmpd = new byte[32];
  231.             System.arraycopy(n.toByteArray(), 1, tmpd, 0, 32);
  232.         } else if (n.toByteArray().length == 32) {
  233.             tmpd = n.toByteArray();
  234.         } else {
  235.             tmpd = new byte[32];
  236.             for (int i = 0; i < 32 - n.toByteArray().length; i++) {
  237.                 tmpd[i] = 0;
  238.             }
  239.             System.arraycopy(n.toByteArray(), 0, tmpd, 32 - n.toByteArray().length, n.toByteArray().length);
  240.         }
  241.         return tmpd;
  242.     }
  243.  
  244.     /**
  245.      * 换字节流（字节数组）型数据转大数字
  246.      *
  247.      * @param b
  248.      * @return
  249.      */
  250.     public static BigInteger byteConvertInteger(byte[] b) {
  251.         if (b[0] < 0) {
  252.             byte[] temp = new byte[b.length + 1];
  253.             temp[0] = 0;
  254.             System.arraycopy(b, 0, temp, 1, b.length);
  255.             return new BigInteger(temp);
  256.         }
  257.         return new BigInteger(b);
  258.     }
  259.  
  260.     /**
  261.      * 根据字节数组获得值(十六进制数字)
  262.      *
  263.      * @param bytes
  264.      * @return
  265.      */
  266.     public static String getHexString(byte[] bytes) {
  267.         return getHexString(bytes, true);
  268.     }
  269.  
  270.     /**
  271.      * 根据字节数组获得值(十六进制数字)
  272.      *
  273.      * @param bytes
  274.      * @param upperCase
  275.      * @return
  276.      */
  277.     public static String getHexString(byte[] bytes, boolean upperCase) {
  278.         String ret = "";
  279.         for (int i = 0; i < bytes.length; i++) {
  280.             ret += Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1);
  281.         }
  282.         return upperCase ? ret.toUpperCase() : ret;
  283.     }
  284.  
  285.     /**
  286.      * 打印十六进制字符串
  287.      *
  288.      * @param bytes
  289.      */
  290.     public static void printHexString(byte[] bytes) {
  291.         for (int i = 0; i < bytes.length; i++) {
  292.             String hex = Integer.toHexString(bytes[i] & 0xFF);
  293.             if (hex.length() == 1) {
  294.                 hex = '0' + hex;
  295.             }
  296.             System.out.print("0x" + hex.toUpperCase() + ",");
  297.         }
  298.         System.out.println("");
  299.     }
  300.  
  301.     /**
  302.      * Convert hex string to byte[]
  303.      *
  304.      * @param hexString the hex string
  305.      * @return byte[]
  306.      */
  307.     public static byte[] hexStringToBytes(String hexString) {
  308.         if (hexString == null || hexString.equals("")) {
  309.             return null;
  310.         }
  311.  
  312.         hexString = hexString.toUpperCase();
  313.         int length = hexString.length() / 2;
  314.         char[] hexChars = hexString.toCharArray();
  315.         byte[] d = new byte[length];
  316.         for (int i = 0; i < length; i++) {
  317.             int pos = i * 2;
  318.             d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
  319.         }
  320.         return d;
  321.     }
  322.  
  323.     /**
  324.      * Convert char to byte
  325.      *
  326.      * @param c char
  327.      * @return byte
  328.      */
  329.     public static byte charToByte(char c) {
  330.         return (byte) "0123456789ABCDEF".indexOf(c);
  331.     }
  332.  
  333.     /**
  334.      * 用于建立十六进制字符的输出的小写字符数组
  335.      */
  336.     private static final char[] DIGITS_LOWER = {'0', '1', '2', '3', '4', '5',
  337.             '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
  338.  
  339.     /**
  340.      * 用于建立十六进制字符的输出的大写字符数组
  341.      */
  342.     private static final char[] DIGITS_UPPER = {'0', '1', '2', '3', '4', '5',
  343.             '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  344.  
  345.     /**
  346.      * 将字节数组转换为十六进制字符数组
  347.      *
  348.      * @param data byte[]
  349.      * @return 十六进制char[]
  350.      */
  351.     public static char[] encodeHex(byte[] data) {
  352.         return encodeHex(data, true);
  353.     }
  354.  
  355.     /**
  356.      * 将字节数组转换为十六进制字符数组
  357.      *
  358.      * @param data        byte[]
  359.      * @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  360.      * @return 十六进制char[]
  361.      */
  362.     public static char[] encodeHex(byte[] data, boolean toLowerCase) {
  363.         return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
  364.     }
  365.  
  366.     /**
  367.      * 将字节数组转换为十六进制字符数组
  368.      *
  369.      * @param data     byte[]
  370.      * @param toDigits 用于控制输出的char[]
  371.      * @return 十六进制char[]
  372.      */
  373.     protected static char[] encodeHex(byte[] data, char[] toDigits) {
  374.         int l = data.length;
  375.         char[] out = new char[l << 1];
  376.         // two characters form the hex value.
  377.         for (int i = 0, j = 0; i < l; i++) {
  378.             out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
  379.             out[j++] = toDigits[0x0F & data[i]];
  380.         }
  381.         return out;
  382.     }
  383.  
  384.     /**
  385.      * 将字节数组转换为十六进制字符串
  386.      *
  387.      * @param data byte[]
  388.      * @return 十六进制String
  389.      */
  390.     public static String encodeHexString(byte[] data) {
  391.         return encodeHexString(data, true);
  392.     }
  393.  
  394.     /**
  395.      * 将字节数组转换为十六进制字符串
  396.      *
  397.      * @param data        byte[]
  398.      * @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  399.      * @return 十六进制String
  400.      */
  401.     public static String encodeHexString(byte[] data, boolean toLowerCase) {
  402.         return encodeHexString(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
  403.     }
  404.  
  405.     /**
  406.      * 将字节数组转换为十六进制字符串
  407.      *
  408.      * @param data     byte[]
  409.      * @param toDigits 用于控制输出的char[]
  410.      * @return 十六进制String
  411.      */
  412.     protected static String encodeHexString(byte[] data, char[] toDigits) {
  413.         return new String(encodeHex(data, toDigits));
  414.     }
  415.  
  416.     /**
  417.      * 将十六进制字符数组转换为字节数组
  418.      *
  419.      * @param data 十六进制char[]
  420.      * @return byte[]
  421.      * @throws RuntimeException 如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常
  422.      */
  423.     public static byte[] decodeHex(char[] data) {
  424.         int len = data.length;
  425.  
  426.         if ((len & 0x01) != 0) {
  427.             throw new RuntimeException("Odd number of characters.");
  428.         }
  429.  
  430.         byte[] out = new byte[len >> 1];
  431.  
  432.         // two characters form the hex value.
  433.         for (int i = 0, j = 0; j < len; i++) {
  434.             int f = toDigit(data[j], j) << 4;
  435.             j++;
  436.             f = f | toDigit(data[j], j);
  437.             j++;
  438.             out[i] = (byte) (f & 0xFF);
  439.         }
  440.  
  441.         return out;
  442.     }
  443.  
  444.     /**
  445.      * 将十六进制字符转换成一个整数
  446.      *
  447.      * @param ch    十六进制char
  448.      * @param index 十六进制字符在字符数组中的位置
  449.      * @return 一个整数
  450.      * @throws RuntimeException 当ch不是一个合法的十六进制字符时，抛出运行时异常
  451.      */
  452.     protected static int toDigit(char ch, int index) {
  453.         int digit = Character.digit(ch, 16);
  454.         if (digit == -1) {
  455.             throw new RuntimeException("Illegal hexadecimal character " + ch
  456.                     + " at index " + index);
  457.         }
  458.         return digit;
  459.     }
  460.  
  461.     /**
  462.      * 数字字符串转ASCII码字符串
  463.      *
  464.      * @param content 字符串
  465.      * @return ASCII字符串
  466.      */
  467.     public static String StringToAsciiString(String content) {
  468.         String result = "";
  469.         int max = content.length();
  470.         for (int i = 0; i < max; i++) {
  471.             char c = content.charAt(i);
  472.             String b = Integer.toHexString(c);
  473.             result = result + b;
  474.         }
  475.         return result;
  476.     }
  477.  
  478.     /**
  479.      * 十六进制转字符串
  480.      *
  481.      * @param hexString  十六进制字符串
  482.      * @param encodeType 编码类型4：Unicode，2：普通编码
  483.      * @return 字符串
  484.      */
  485.     public static String hexStringToString(String hexString, int encodeType) {
  486.         String result = "";
  487.         int max = hexString.length() / encodeType;
  488.         for (int i = 0; i < max; i++) {
  489.             char c = (char) hexStringToAlgorism(hexString
  490.                     .substring(i * encodeType, (i + 1) * encodeType));
  491.             result += c;
  492.         }
  493.         return result;
  494.     }
  495.  
  496.     /**
  497.      * 十六进制字符串装十进制
  498.      *
  499.      * @param hex 十六进制字符串
  500.      * @return 十进制数值
  501.      */
  502.     public static int hexStringToAlgorism(String hex) {
  503.         hex = hex.toUpperCase();
  504.         int max = hex.length();
  505.         int result = 0;
  506.         for (int i = max; i > 0; i--) {
  507.             char c = hex.charAt(i - 1);
  508.             int algorism = 0;
  509.             if (c >= '0' && c <= '9') {
  510.                 algorism = c - '0';
  511.             } else {
  512.                 algorism = c - 55;
  513.             }
  514.             result += Math.pow(16, max - i) * algorism;
  515.         }
  516.         return result;
  517.     }
  518.  
  519.     /**
  520.      * 十六转二进制
  521.      *
  522.      * @param hex 十六进制字符串
  523.      * @return 二进制字符串
  524.      */
  525.     public static String hexStringToBinary(String hex) {
  526.         hex = hex.toUpperCase();
  527.         String result = "";
  528.         int max = hex.length();
  529.         for (int i = 0; i < max; i++) {
  530.             char c = hex.charAt(i);
  531.             switch (c) {
  532.                 case '0':
  533.                     result += "0000";
  534.                     break;
  535.                 case '1':
  536.                     result += "0001";
  537.                     break;
  538.                 case '2':
  539.                     result += "0010";
  540.                     break;
  541.                 case '3':
  542.                     result += "0011";
  543.                     break;
  544.                 case '4':
  545.                     result += "0100";
  546.                     break;
  547.                 case '5':
  548.                     result += "0101";
  549.                     break;
  550.                 case '6':
  551.                     result += "0110";
  552.                     break;
  553.                 case '7':
  554.                     result += "0111";
  555.                     break;
  556.                 case '8':
  557.                     result += "1000";
  558.                     break;
  559.                 case '9':
  560.                     result += "1001";
  561.                     break;
  562.                 case 'A':
  563.                     result += "1010";
  564.                     break;
  565.                 case 'B':
  566.                     result += "1011";
  567.                     break;
  568.                 case 'C':
  569.                     result += "1100";
  570.                     break;
  571.                 case 'D':
  572.                     result += "1101";
  573.                     break;
  574.                 case 'E':
  575.                     result += "1110";
  576.                     break;
  577.                 case 'F':
  578.                     result += "1111";
  579.                     break;
  580.             }
  581.         }
  582.         return result;
  583.     }
  584.  
  585.     /**
  586.      * ASCII码字符串转数字字符串
  587.      *
  588.      * @param content ASCII字符串
  589.      * @return 字符串
  590.      */
  591.     public static String AsciiStringToString(String content) {
  592.         String result = "";
  593.         int length = content.length() / 2;
  594.         for (int i = 0; i < length; i++) {
  595.             String c = content.substring(i * 2, i * 2 + 2);
  596.             int a = hexStringToAlgorism(c);
  597.             char b = (char) a;
  598.             String d = String.valueOf(b);
  599.             result += d;
  600.         }
  601.         return result;
  602.     }
  603.  
  604.     /**
  605.      * 将十进制转换为指定长度的十六进制字符串
  606.      *
  607.      * @param algorism  int 十进制数字
  608.      * @param maxLength int 转换后的十六进制字符串长度
  609.      * @return String 转换后的十六进制字符串
  610.      */
  611.     public static String algorismToHexString(int algorism, int maxLength) {
  612.         String result = "";
  613.         result = Integer.toHexString(algorism);
  614.  
  615.         if (result.length() % 2 == 1) {
  616.             result = "0" + result;
  617.         }
  618.         return patchHexString(result.toUpperCase(), maxLength);
  619.     }
  620.  
  621.     /**
  622.      * 字节数组转为普通字符串（ASCII对应的字符）
  623.      *
  624.      * @param bytearray byte[]
  625.      * @return String
  626.      */
  627.     public static String byteToString(byte[] bytearray) {
  628.         String result = "";
  629.         char temp;
  630.  
  631.         int length = bytearray.length;
  632.         for (int i = 0; i < length; i++) {
  633.             temp = (char) bytearray[i];
  634.             result += temp;
  635.         }
  636.         return result;
  637.     }
  638.  
  639.     /**
  640.      * 二进制字符串转十进制
  641.      *
  642.      * @param binary 二进制字符串
  643.      * @return 十进制数值
  644.      */
  645.     public static int binaryToAlgorism(String binary) {
  646.         int max = binary.length();
  647.         int result = 0;
  648.         for (int i = max; i > 0; i--) {
  649.             char c = binary.charAt(i - 1);
  650.             int algorism = c - '0';
  651.             result += Math.pow(2, max - i) * algorism;
  652.         }
  653.         return result;
  654.     }
  655.  
  656.     /**
  657.      * 十进制转换为十六进制字符串
  658.      *
  659.      * @param algorism int 十进制的数字
  660.      * @return String 对应的十六进制字符串
  661.      */
  662.     public static String algorismToHEXString(int algorism) {
  663.         String result = "";
  664.         result = Integer.toHexString(algorism);
  665.  
  666.         if (result.length() % 2 == 1) {
  667.             result = "0" + result;
  668.  
  669.         }
  670.         result = result.toUpperCase();
  671.  
  672.         return result;
  673.     }
  674.  
  675.     /**
  676.      * HEX字符串前补0，主要用于长度位数不足。
  677.      *
  678.      * @param str       String 需要补充长度的十六进制字符串
  679.      * @param maxLength int 补充后十六进制字符串的长度
  680.      * @return 补充结果
  681.      */
  682.     static public String patchHexString(String str, int maxLength) {
  683.         String temp = "";
  684.         for (int i = 0; i < maxLength - str.length(); i++) {
  685.             temp = "0" + temp;
  686.         }
  687.         str = (temp + str).substring(0, maxLength);
  688.         return str;
  689.     }
  690.  
  691.     /**
  692.      * 将一个字符串转换为int
  693.      *
  694.      * @param s          String 要转换的字符串
  695.      * @param defaultInt int 如果出现异常,默认返回的数字
  696.      * @param radix      int 要转换的字符串是什么进制的,如16 8 10.
  697.      * @return int 转换后的数字
  698.      */
  699.     public static int parseToInt(String s, int defaultInt, int radix) {
  700.         int i = 0;
  701.         try {
  702.             i = Integer.parseInt(s, radix);
  703.         } catch (NumberFormatException ex) {
  704.             i = defaultInt;
  705.         }
  706.         return i;
  707.     }
  708.  
  709.     /**
  710.      * 将一个十进制形式的数字字符串转换为int
  711.      *
  712.      * @param s          String 要转换的字符串
  713.      * @param defaultInt int 如果出现异常,默认返回的数字
  714.      * @return int 转换后的数字
  715.      */
  716.     public static int parseToInt(String s, int defaultInt) {
  717.         int i = 0;
  718.         try {
  719.             i = Integer.parseInt(s);
  720.         } catch (NumberFormatException ex) {
  721.             i = defaultInt;
  722.         }
  723.         return i;
  724.     }
  725.  
  726.     /**
  727.      * 十六进制串转化为byte数组
  728.      *
  729.      * @return the array of byte
  730.      */
  731.     public static byte[] hexToByte(String hex)
  732.             throws IllegalArgumentException {
  733.         if (hex.length() % 2 != 0) {
  734.             throw new IllegalArgumentException();
  735.         }
  736.         if (hex.length() < 1) {
  737.             return null;
  738.         } else {
  739.             byte[] result = new byte[hex.length() / 2];
  740.             int j = 0;
  741.             for(int i = 0; i < hex.length(); i+=2) {
  742.                 result[j++] = (byte)Integer.parseInt(hex.substring(i,i+2), 16);
  743.             }
  744.             return result;
  745.         }
  746.     }
  747.  
  748.     /**
  749.      * 字节数组转换为十六进制字符串
  750.      *
  751.      * @param b byte[] 需要转换的字节数组
  752.      * @return String 十六进制字符串
  753.      */
  754.     public static String byteToHex(byte b[]) {
  755.         if (b == null) {
  756.             return "";
  757.         }
  758.         StringBuffer sb = new StringBuffer();
  759.         for(int i = 0; i < b.length; i++) {
  760.             String hex = Integer.toHexString(b[i] & 0xFF);
  761.             if(hex.length() < 2) {
  762.                 hex = "0" + hex;
  763.             }
  764.             sb.append(hex.toUpperCase());
  765.         }
  766.         return sb.toString();
  767.     }
  768.  
  769.     public static byte[] subByte(byte[] input, int startIndex, int length) {
  770.         byte[] bt = new byte[length];
  771.         for (int i = 0; i < length; i++) {
  772.             bt[i] = input[i + startIndex];
  773.         }
  774.         return bt;
  775.     }
  776. }

获取秘钥对，并对私钥保存，公钥返回给前端

  1. public ResponseData getSmPublicCode() {
  2.         Map<String, String> result = new HashMap<>();
  3.         String publicKry = "";
  4.         if(ObjectUtil.isNull(redisTemplate.opsForValue().get(SMPublicPrivate.SM_PUBLIC.getValue()))){
  5.             // 1. 获取公私钥对
  6.             Map<String, String> map =  SM2Utils.generateKeyPair();
  7.             redisTemplate.opsForValue().set(SMPublicPrivate.SM_PRIVATE.getValue(),map.get(privateKeyName));
  8.             redisTemplate.opsForValue().set(SMPublicPrivate.SM_PUBLIC.getValue(),map.get(publicKeyName));
  9.             publicKry = map.get(publicKeyName);
  10.         }else{
  11.             publicKry = (String) redisTemplate.opsForValue().get(SMPublicPrivate.SM_PUBLIC.getValue());
  12.         }
  13.         result.put("pubKey",publicKry);
  14.         return ResponseData.success(result);
  15.     }

前端：vue js端加密（使用sm-crypto）

通过引入sm-crypto.js，然后利用doEncrypt方法进行加密，参数为：明文密码、后端生成的公钥、加密方式

  1. encryption() {
  2.       const sm2 = require('sm-crypto').sm2
  3.       const cipherMode = 1 ;// 1 - C1C3C2，0 - C1C2C3，默认为1
  4.       alert(this.loginForm.password)
  5.       let encryptData = sm2.doEncrypt(this.loginForm.password, this.smPublicCode, cipherMode ) // 加密结果
  6.       return '04' + encryptData;
  7.     },

返回的密码密文需要拼接 “04”，避免后端因乱码解密失败

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

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

  

闽ICP备14008679号