pom

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>org.example</groupId>
  8.     <artifactId>SM2test</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>org.bouncycastle</groupId>
  14.             <artifactId>bcprov-jdk15on</artifactId>
  15.             <version>1.56</version>
  16.         </dependency>
  17.     </dependencies>
  19. </project>

Cipher

  1. import java.math.BigInteger;
  2. import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
  3. import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
  4. import org.bouncycastle.crypto.params.ECPublicKeyParameters;
  5. import org.bouncycastle.math.ec.ECPoint;
  7. public class Cipher {
  8.     private int ct;
  9.     private ECPoint p2;
  10.     private SM3Digest sm3keybase;
  11.     private SM3Digest sm3c3;
  12.     private byte key[];
  13.     private byte keyOff;
  15.     public Cipher()
  16.     {
  17.         this.ct = 1;
  18.         this.key = new byte[32];
  19.         this.keyOff = 0;
  20.     }
  22.     private void Reset()
  23.     {
  24.         this.sm3keybase = new SM3Digest();
  25.         this.sm3c3 = new SM3Digest();
  27.         byte p[] = Util.byteConvert32Bytes(p2.getX().toBigInteger());
  28.         this.sm3keybase.update(p, 0, p.length);
  29.         this.sm3c3.update(p, 0, p.length);
  31.         p = Util.byteConvert32Bytes(p2.getY().toBigInteger());
  32.         this.sm3keybase.update(p, 0, p.length);
  33.         this.ct = 1;
  34.         NextKey();
  35.     }
  37.     private void NextKey()
  38.     {
  39.         SM3Digest sm3keycur = new SM3Digest(this.sm3keybase);
  40.         sm3keycur.update((byte) (ct >> 24 & 0xff));
  41.         sm3keycur.update((byte) (ct >> 16 & 0xff));
  42.         sm3keycur.update((byte) (ct >> 8 & 0xff));
  43.         sm3keycur.update((byte) (ct & 0xff));
  44.         sm3keycur.doFinal(key, 0);
  45.         this.keyOff = 0;
  46.         this.ct++;
  47.     }
  49.     public ECPoint Init_enc(SM2 sm2, ECPoint userKey)
  50.     {
  51.         AsymmetricCipherKeyPair key = sm2.ecc_key_pair_generator.generateKeyPair();
  52.         ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();
  53.         ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();
  54.         BigInteger k = ecpriv.getD();
  55.         ECPoint c1 = ecpub.getQ();
  56.         this.p2 = userKey.multiply(k);
  57.         Reset();
  58.         return c1;
  59.     }
  61.     public void Encrypt(byte data[])
  62.     {
  63.         this.sm3c3.update(data, 0, data.length);
  64.         for (int i = 0; i < data.length; i++)
  65.         {
  66.             if (keyOff == key.length)
  67.             {
  68.                 NextKey();
  69.             }
  70.             data[i] ^= key[keyOff++];
  71.         }
  72.     }
  74.     public void Init_dec(BigInteger userD, ECPoint c1)
  75.     {
  76.         this.p2 = c1.multiply(userD);
  77.         Reset();
  78.     }
  80.     public void Decrypt(byte data[])
  81.     {
  82.         for (int i = 0; i < data.length; i++)
  83.         {
  84.             if (keyOff == key.length)
  85.             {
  86.                 NextKey();
  87.             }
  88.             data[i] ^= key[keyOff++];
  89.         }
  91.         this.sm3c3.update(data, 0, data.length);
  92.     }
  94.     public void Dofinal(byte c3[])
  95.     {
  96.         byte p[] = Util.byteConvert32Bytes(p2.getY().toBigInteger());
  97.         this.sm3c3.update(p, 0, p.length);
  98.         this.sm3c3.doFinal(c3, 0);
  99.         Reset();
  100.     }
  101. }

SM2

  3. import java.math.BigInteger;
  4. import java.security.SecureRandom;
  6. import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
  7. import org.bouncycastle.crypto.params.ECDomainParameters;
  8. import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
  9. import org.bouncycastle.math.ec.ECCurve;
  10. import org.bouncycastle.math.ec.ECFieldElement;
  11. import org.bouncycastle.math.ec.ECPoint;
  12. import org.bouncycastle.math.ec.ECFieldElement.Fp;
  14. public class SM2 {
  16.     //正式参数
  17.     public static String[] ecc_param = {
  18.             "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF",
  19.             "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC",
  20.             "28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93",
  21.             "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123",
  22.             "32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7",
  23.             "BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0"
  24.     };
  26.     public static SM2 Instance() {
  27.         return new SM2();
  28.     }
  30.     public final BigInteger ecc_p;
  31.     public final BigInteger ecc_a;
  32.     public final BigInteger ecc_b;
  33.     public final BigInteger ecc_n;
  34.     public final BigInteger ecc_gx;
  35.     public final BigInteger ecc_gy;
  36.     public final ECCurve ecc_curve;
  37.     public final ECPoint ecc_point_g;
  38.     public final ECDomainParameters ecc_bc_spec;
  39.     public final ECKeyPairGenerator ecc_key_pair_generator;
  40.     public final ECFieldElement ecc_gx_fieldelement;
  41.     public final ECFieldElement ecc_gy_fieldelement;
  43.     public SM2() {
  44.         this.ecc_p = new BigInteger(ecc_param[0], 16);
  45.         this.ecc_a = new BigInteger(ecc_param[1], 16);
  46.         this.ecc_b = new BigInteger(ecc_param[2], 16);
  47.         this.ecc_n = new BigInteger(ecc_param[3], 16);
  48.         this.ecc_gx = new BigInteger(ecc_param[4], 16);
  49.         this.ecc_gy = new BigInteger(ecc_param[5], 16);
  51.         this.ecc_gx_fieldelement = new Fp(this.ecc_p, this.ecc_gx);
  52.         this.ecc_gy_fieldelement = new Fp(this.ecc_p, this.ecc_gy);
  54.         this.ecc_curve = new ECCurve.Fp(this.ecc_p, this.ecc_a, this.ecc_b);
  55.         this.ecc_point_g = new ECPoint.Fp(this.ecc_curve, this.ecc_gx_fieldelement, this.ecc_gy_fieldelement);
  57.         this.ecc_bc_spec = new ECDomainParameters(this.ecc_curve, this.ecc_point_g, this.ecc_n);
  59.         ECKeyGenerationParameters ecc_ecgenparam;
  60.         ecc_ecgenparam = new ECKeyGenerationParameters(this.ecc_bc_spec, new SecureRandom());
  62.         this.ecc_key_pair_generator = new ECKeyPairGenerator();
  63.         this.ecc_key_pair_generator.init(ecc_ecgenparam);
  64.     }
  65. }

SM2KeyPair


  2. public class SM2KeyPair {
  4.     /** 公钥 */
  5.     private  String publicKey;
  7.     /** 私钥 */
  8.     private String privateKey;
  10.     SM2KeyPair(String publicKey, String privateKey) {
  11.         this.publicKey = publicKey;
  12.         this.privateKey = privateKey;
  13.     }
  15.     public String getPublicKey() {
  16.         return publicKey;
  17.     }
  19.     public String getPrivateKey() {
  20.         return privateKey;
  21.     }
  23. }

SM2Utils

  1. import java.io.IOException;
  2. import java.math.BigInteger;
  3. import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
  4. import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
  5. import org.bouncycastle.crypto.params.ECPublicKeyParameters;
  6. import org.bouncycastle.math.ec.ECPoint;
  8. public class SM2Utils {
  9.     //生成随机秘钥对
  10.     public static SM2KeyPair generateKeyPair() {
  11.         SM2 sm2 = SM2.Instance();
  12.         AsymmetricCipherKeyPair key = sm2.ecc_key_pair_generator.generateKeyPair();
  13.         ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();
  14.         ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();
  15.         BigInteger privateKey = ecpriv.getD();
  16.         ECPoint publicKey = ecpub.getQ();
  17.         System.out.println("公钥: " + Util.byteToHex(publicKey.getEncoded()));
  18.         System.out.println("私钥: " + Util.byteToHex(privateKey.toByteArray()));
  19.         return new SM2KeyPair(Util.byteToHex(publicKey.getEncoded(false)), Util.byteToHex(privateKey.toByteArray()));
  20.     }
  22.     //数据加密
  23.     public static String encrypt(byte[] publicKey, byte[] data) throws IOException {
  24.         if (publicKey == null || publicKey.length == 0) {
  25.             return null;
  26.         }
  28.         if (data == null || data.length == 0) {
  29.             return null;
  30.         }
  32.         byte[] source = new byte[data.length];
  33.         System.arraycopy(data, 0, source, 0, data.length);
  35.         Cipher cipher = new Cipher();
  36.         SM2 sm2 = SM2.Instance();
  37.         ECPoint userKey = sm2.ecc_curve.decodePoint(publicKey);
  39.         ECPoint c1 = cipher.Init_enc(sm2, userKey);
  40.         cipher.Encrypt(source);
  41.         byte[] c3 = new byte[32];
  42.         cipher.Dofinal(c3);
  44. //      System.out.println("C1 " + Util.byteToHex(c1.getEncoded()));
  45. //      System.out.println("C2 " + Util.byteToHex(source));
  46. //      System.out.println("C3 " + Util.byteToHex(c3));
  47.         //C1 C2 C3拼装成加密字串
  48.         return Util.byteToHex(c1.getEncoded(false)) + Util.byteToHex(source) + Util.byteToHex(c3);
  50.     }
  52.     //数据解密
  53.     public static byte[] decrypt(byte[] privateKey, byte[] encryptedData) throws IOException {
  54.         if (privateKey == null || privateKey.length == 0) {
  55.             return null;
  56.         }
  58.         if (encryptedData == null || encryptedData.length == 0) {
  59.             return null;
  60.         }
  61.         //加密字节数组转换为十六进制的字符串 长度变为encryptedData.length * 2
  62.         String data = Util.byteToHex(encryptedData);
  63.         /***分解加密字串
  64.          * （C1 = C1标志位2位 + C1实体部分128位 = 130）
  65.          * （C3 = C3实体部分64位  = 64）
  66.          * （C2 = encryptedData.length * 2 - C1长度  - C2长度）
  67.          */
  68.         byte[] c1Bytes = Util.hexToByte(data.substring(0, 130));
  69.         int c2Len = encryptedData.length - 97;
  70.         byte[] c2 = Util.hexToByte(data.substring(130, 130 + 2 * c2Len));
  71.         byte[] c3 = Util.hexToByte(data.substring(130 + 2 * c2Len, 194 + 2 * c2Len));
  73.         SM2 sm2 = SM2.Instance();
  74.         BigInteger userD = new BigInteger(1, privateKey);
  76.         //通过C1实体字节来生成ECPoint
  77.         ECPoint c1 = sm2.ecc_curve.decodePoint(c1Bytes);
  78.         Cipher cipher = new Cipher();
  79.         cipher.Init_dec(userD, c1);
  80.         cipher.Decrypt(c2);
  81.         cipher.Dofinal(c3);
  83.         //返回解密结果
  84.         return c2;
  85.     }
  87.     public static void main(String[] args) throws Exception {
  88.         //生成密钥对
  89.         generateKeyPair();
  90.         String plainText = "lxw测试！@#￥%……&*（）";
  91.         //下面的秘钥可以使用generateKeyPair()生成的秘钥内容
  92.         // 国密规范正式私钥
  93.         String prik = "7BF3DC32F3CCA2176CD8EA9267EE06E02E51378E7EA52CCEB42346BE70186804";
  94.         // 国密规范正式公钥
  95.         String pubk = "0497077E61FA0168D4EB00F475CAA21629D8BE5377311EAB2BB59D98B00970D0B9571935D8D4DB4DB8C24923FEBC3951088805EBF7989F16694CE57A903D24317B";
  96.         System.out.println("-------加密: ");
  97.         String cipherText = SM2Utils.encrypt(Util.hexStringToBytes(pubk), plainText.getBytes());
  98.         System.out.println(cipherText);
  99.         System.out.println("-------加密后字符串长度:" + cipherText.length());
  100.         System.out.println("-------解密: ");
  101.         byte[] decrypt = SM2Utils.decrypt(Util.hexStringToBytes(prik), Util.hexStringToBytes(cipherText));
  102.         System.out.println(new String(decrypt));
  103.     }
  105. }

SM3

  1. public class SM3 {
  2.     public static final byte[] iv = { 0x73, (byte) 0x80, 0x16, 0x6f, 0x49,
  3.             0x14, (byte) 0xb2, (byte) 0xb9, 0x17, 0x24, 0x42, (byte) 0xd7,
  4.             (byte) 0xda, (byte) 0x8a, 0x06, 0x00, (byte) 0xa9, 0x6f, 0x30,
  5.             (byte) 0xbc, (byte) 0x16, 0x31, 0x38, (byte) 0xaa, (byte) 0xe3,
  6.             (byte) 0x8d, (byte) 0xee, 0x4d, (byte) 0xb0, (byte) 0xfb, 0x0e,
  7.             0x4e };
  9.     public static int[] Tj = new int[64];
  11.     static
  12.     {
  13.         for (int i = 0; i < 16; i++)
  14.         {
  15.             Tj[i] = 0x79cc4519;
  16.         }
  18.         for (int i = 16; i < 64; i++)
  19.         {
  20.             Tj[i] = 0x7a879d8a;
  21.         }
  22.     }
  24.     public static byte[] CF(byte[] V, byte[] B)
  25.     {
  26.         int[] v, b;
  27.         v = convert(V);
  28.         b = convert(B);
  29.         return convert(CF(v, b));
  30.     }
  32.     private static int[] convert(byte[] arr)
  33.     {
  34.         int[] out = new int[arr.length / 4];
  35.         byte[] tmp = new byte[4];
  36.         for (int i = 0; i < arr.length; i += 4)
  37.         {
  38.             System.arraycopy(arr, i, tmp, 0, 4);
  39.             out[i / 4] = bigEndianByteToInt(tmp);
  40.         }
  41.         return out;
  42.     }
  44.     private static byte[] convert(int[] arr)
  45.     {
  46.         byte[] out = new byte[arr.length * 4];
  47.         byte[] tmp = null;
  48.         for (int i = 0; i < arr.length; i++)
  49.         {
  50.             tmp = bigEndianIntToByte(arr[i]);
  51.             System.arraycopy(tmp, 0, out, i * 4, 4);
  52.         }
  53.         return out;
  54.     }
  56.     public static int[] CF(int[] V, int[] B)
  57.     {
  58.         int a, b, c, d, e, f, g, h;
  59.         int ss1, ss2, tt1, tt2;
  60.         a = V[0];
  61.         b = V[1];
  62.         c = V[2];
  63.         d = V[3];
  64.         e = V[4];
  65.         f = V[5];
  66.         g = V[6];
  67.         h = V[7];
  69.         int[][] arr = expand(B);
  70.         int[] w = arr[0];
  71.         int[] w1 = arr[1];
  73.         for (int j = 0; j < 64; j++)
  74.         {
  75.             ss1 = (bitCycleLeft(a, 12) + e + bitCycleLeft(Tj[j], j));
  76.             ss1 = bitCycleLeft(ss1, 7);
  77.             ss2 = ss1 ^ bitCycleLeft(a, 12);
  78.             tt1 = FFj(a, b, c, j) + d + ss2 + w1[j];
  79.             tt2 = GGj(e, f, g, j) + h + ss1 + w[j];
  80.             d = c;
  81.             c = bitCycleLeft(b, 9);
  82.             b = a;
  83.             a = tt1;
  84.             h = g;
  85.             g = bitCycleLeft(f, 19);
  86.             f = e;
  87.             e = P0(tt2);
  89. 		            /*System.out.print(j+" ");
  90. 		            System.out.print(Integer.toHexString(a)+" ");
  91. 		            System.out.print(Integer.toHexString(b)+" ");
  92. 		            System.out.print(Integer.toHexString(c)+" ");
  93. 		            System.out.print(Integer.toHexString(d)+" ");
  94. 		            System.out.print(Integer.toHexString(e)+" ");
  95. 		            System.out.print(Integer.toHexString(f)+" ");
  96. 		            System.out.print(Integer.toHexString(g)+" ");
  97. 		            System.out.print(Integer.toHexString(h)+" ");
  98. 		            System.out.println("");*/
  99.         }
  100. //		      System.out.println("");
  102.         int[] out = new int[8];
  103.         out[0] = a ^ V[0];
  104.         out[1] = b ^ V[1];
  105.         out[2] = c ^ V[2];
  106.         out[3] = d ^ V[3];
  107.         out[4] = e ^ V[4];
  108.         out[5] = f ^ V[5];
  109.         out[6] = g ^ V[6];
  110.         out[7] = h ^ V[7];
  112.         return out;
  113.     }
  115.     private static int[][] expand(int[] B)
  116.     {
  117.         int W[] = new int[68];
  118.         int W1[] = new int[64];
  119.         for (int i = 0; i < B.length; i++)
  120.         {
  121.             W[i] = B[i];
  122.         }
  124.         for (int i = 16; i < 68; i++)
  125.         {
  126.             W[i] = P1(W[i - 16] ^ W[i - 9] ^ bitCycleLeft(W[i - 3], 15))
  127.                     ^ bitCycleLeft(W[i - 13], 7) ^ W[i - 6];
  128.         }
  130.         for (int i = 0; i < 64; i++)
  131.         {
  132.             W1[i] = W[i] ^ W[i + 4];
  133.         }
  135.         int arr[][] = new int[][] { W, W1 };
  136.         return arr;
  137.     }
  139.     private static byte[] bigEndianIntToByte(int num)
  140.     {
  141.         return back(Util.intToBytes(num));
  142.     }
  144.     private static int bigEndianByteToInt(byte[] bytes)
  145.     {
  146.         return Util.byteToInt(back(bytes));
  147.     }
  149.     private static int FFj(int X, int Y, int Z, int j)
  150.     {
  151.         if (j >= 0 && j <= 15)
  152.         {
  153.             return FF1j(X, Y, Z);
  154.         }
  155.         else
  156.         {
  157.             return FF2j(X, Y, Z);
  158.         }
  159.     }
  161.     private static int GGj(int X, int Y, int Z, int j)
  162.     {
  163.         if (j >= 0 && j <= 15)
  164.         {
  165.             return GG1j(X, Y, Z);
  166.         }
  167.         else
  168.         {
  169.             return GG2j(X, Y, Z);
  170.         }
  171.     }
  173.     // 逻辑位运算函数
  174.     private static int FF1j(int X, int Y, int Z)
  175.     {
  176.         int tmp = X ^ Y ^ Z;
  177.         return tmp;
  178.     }
  180.     private static int FF2j(int X, int Y, int Z)
  181.     {
  182.         int tmp = ((X & Y) | (X & Z) | (Y & Z));
  183.         return tmp;
  184.     }
  186.     private static int GG1j(int X, int Y, int Z)
  187.     {
  188.         int tmp = X ^ Y ^ Z;
  189.         return tmp;
  190.     }
  192.     private static int GG2j(int X, int Y, int Z)
  193.     {
  194.         int tmp = (X & Y) | (~X & Z);
  195.         return tmp;
  196.     }
  198.     private static int P0(int X)
  199.     {
  200.         int y = rotateLeft(X, 9);
  201.         y = bitCycleLeft(X, 9);
  202.         int z = rotateLeft(X, 17);
  203.         z = bitCycleLeft(X, 17);
  204.         int t = X ^ y ^ z;
  205.         return t;
  206.     }
  208.     private static int P1(int X)
  209.     {
  210.         int t = X ^ bitCycleLeft(X, 15) ^ bitCycleLeft(X, 23);
  211.         return t;
  212.     }
  214.     /**
  215.      * 对最后一个分组字节数据padding
  216.      *
  217.      * @param in
  218.      * @param bLen
  219.      *            分组个数
  220.      * @return
  221.      */
  222.     public static byte[] padding(byte[] in, int bLen)
  223.     {
  224.         int k = 448 - (8 * in.length + 1) % 512;
  225.         if (k < 0)
  226.         {
  227.             k = 960 - (8 * in.length + 1) % 512;
  228.         }
  229.         k += 1;
  230.         byte[] padd = new byte[k / 8];
  231.         padd[0] = (byte) 0x80;
  232.         long n = in.length * 8 + bLen * 512;
  233.         byte[] out = new byte[in.length + k / 8 + 64 / 8];
  234.         int pos = 0;
  235.         System.arraycopy(in, 0, out, 0, in.length);
  236.         pos += in.length;
  237.         System.arraycopy(padd, 0, out, pos, padd.length);
  238.         pos += padd.length;
  239.         byte[] tmp = back(Util.longToBytes(n));
  240.         System.arraycopy(tmp, 0, out, pos, tmp.length);
  241.         return out;
  242.     }
  244.     /**
  245.      * 字节数组逆序
  246.      *
  247.      * @param in
  248.      * @return
  249.      */
  250.     private static byte[] back(byte[] in)
  251.     {
  252.         byte[] out = new byte[in.length];
  253.         for (int i = 0; i < out.length; i++)
  254.         {
  255.             out[i] = in[out.length - i - 1];
  256.         }
  258.         return out;
  259.     }
  261.     public static int rotateLeft(int x, int n)
  262.     {
  263.         return (x << n) | (x >> (32 - n));
  264.     }
  266.     private static int bitCycleLeft(int n, int bitLen)
  267.     {
  268.         bitLen %= 32;
  269.         byte[] tmp = bigEndianIntToByte(n);
  270.         int byteLen = bitLen / 8;
  271.         int len = bitLen % 8;
  272.         if (byteLen > 0)
  273.         {
  274.             tmp = byteCycleLeft(tmp, byteLen);
  275.         }
  277.         if (len > 0)
  278.         {
  279.             tmp = bitSmall8CycleLeft(tmp, len);
  280.         }
  282.         return bigEndianByteToInt(tmp);
  283.     }
  285.     private static byte[] bitSmall8CycleLeft(byte[] in, int len)
  286.     {
  287.         byte[] tmp = new byte[in.length];
  288.         int t1, t2, t3;
  289.         for (int i = 0; i < tmp.length; i++)
  290.         {
  291.             t1 = (byte) ((in[i] & 0x000000ff) << len);
  292.             t2 = (byte) ((in[(i + 1) % tmp.length] & 0x000000ff) >> (8 - len));
  293.             t3 = (byte) (t1 | t2);
  294.             tmp[i] = (byte) t3;
  295.         }
  297.         return tmp;
  298.     }
  300.     private static byte[] byteCycleLeft(byte[] in, int byteLen)
  301.     {
  302.         byte[] tmp = new byte[in.length];
  303.         System.arraycopy(in, byteLen, tmp, 0, in.length - byteLen);
  304.         System.arraycopy(in, 0, tmp, in.length - byteLen, byteLen);
  305.         return tmp;
  306.     }
  307. }

SM3Digest

  1. import org.bouncycastle.util.encoders.Hex;
  3. public class SM3Digest {
  4.     /** SM3值的长度 */
  5.     private static final int BYTE_LENGTH = 32;
  7.     /** SM3分组长度 */
  8.     private static final int BLOCK_LENGTH = 64;
  10.     /** 缓冲区长度 */
  11.     private static final int BUFFER_LENGTH = BLOCK_LENGTH * 1;
  13.     /** 缓冲区 */
  14.     private byte[] xBuf = new byte[BUFFER_LENGTH];
  16.     /** 缓冲区偏移量 */
  17.     private int xBufOff;
  19.     /** 初始向量 */
  20.     private byte[] V = SM3.iv.clone();
  22.     private int cntBlock = 0;
  24.     public SM3Digest() {
  25.     }
  27.     public SM3Digest(SM3Digest t)
  28.     {
  29.         System.arraycopy(t.xBuf, 0, this.xBuf, 0, t.xBuf.length);
  30.         this.xBufOff = t.xBufOff;
  31.         System.arraycopy(t.V, 0, this.V, 0, t.V.length);
  32.     }
  34.     /**
  35.      * SM3结果输出
  36.      *
  37.      * @param out 保存SM3结构的缓冲区
  38.      * @param outOff 缓冲区偏移量
  39.      * @return
  40.      */
  41.     public int doFinal(byte[] out, int outOff)
  42.     {
  43.         byte[] tmp = doFinal();
  44.         System.arraycopy(tmp, 0, out, 0, tmp.length);
  45.         return BYTE_LENGTH;
  46.     }
  48.     public void reset()
  49.     {
  50.         xBufOff = 0;
  51.         cntBlock = 0;
  52.         V = SM3.iv.clone();
  53.     }
  55.     /**
  56.      * 明文输入
  57.      *
  58.      * @param in
  59.      *            明文输入缓冲区
  60.      * @param inOff
  61.      *            缓冲区偏移量
  62.      * @param len
  63.      *            明文长度
  64.      */
  65.     public void update(byte[] in, int inOff, int len)
  66.     {
  67.         int partLen = BUFFER_LENGTH - xBufOff;
  68.         int inputLen = len;
  69.         int dPos = inOff;
  70.         if (partLen < inputLen)
  71.         {
  72.             System.arraycopy(in, dPos, xBuf, xBufOff, partLen);
  73.             inputLen -= partLen;
  74.             dPos += partLen;
  75.             doUpdate();
  76.             while (inputLen > BUFFER_LENGTH)
  77.             {
  78.                 System.arraycopy(in, dPos, xBuf, 0, BUFFER_LENGTH);
  79.                 inputLen -= BUFFER_LENGTH;
  80.                 dPos += BUFFER_LENGTH;
  81.                 doUpdate();
  82.             }
  83.         }
  85.         System.arraycopy(in, dPos, xBuf, xBufOff, inputLen);
  86.         xBufOff += inputLen;
  87.     }
  89.     private void doUpdate()
  90.     {
  91.         byte[] B = new byte[BLOCK_LENGTH];
  92.         for (int i = 0; i < BUFFER_LENGTH; i += BLOCK_LENGTH)
  93.         {
  94.             System.arraycopy(xBuf, i, B, 0, B.length);
  95.             doHash(B);
  96.         }
  97.         xBufOff = 0;
  98.     }
  100.     private void doHash(byte[] B)
  101.     {
  102.         byte[] tmp = SM3.CF(V, B);
  103.         System.arraycopy(tmp, 0, V, 0, V.length);
  104.         cntBlock++;
  105.     }
  107.     private byte[] doFinal()
  108.     {
  109.         byte[] B = new byte[BLOCK_LENGTH];
  110.         byte[] buffer = new byte[xBufOff];
  111.         System.arraycopy(xBuf, 0, buffer, 0, buffer.length);
  112.         byte[] tmp = SM3.padding(buffer, cntBlock);
  113.         for (int i = 0; i < tmp.length; i += BLOCK_LENGTH)
  114.         {
  115.             System.arraycopy(tmp, i, B, 0, B.length);
  116.             doHash(B);
  117.         }
  118.         return V;
  119.     }
  121.     public void update(byte in)
  122.     {
  123.         byte[] buffer = new byte[] { in };
  124.         update(buffer, 0, 1);
  125.     }
  127.     public int getDigestSize()
  128.     {
  129.         return BYTE_LENGTH;
  130.     }
  132.     public static void main(String[] args)
  133.     {
  134.         byte[] md = new byte[32];
  135.         byte[] msg1 = "lxw 测试".getBytes();
  136.         SM3Digest sm3 = new SM3Digest();
  137.         sm3.update(msg1, 0, msg1.length);
  138.         sm3.doFinal(md, 0);
  139.         String s = new String(Hex.encode(md));
  140.         System.out.println(s.toUpperCase());
  141.     }
  142. }

Util

  1. import java.math.BigInteger;
  3. public class Util {
  4.     /**
  5.      * 整形转换成网络传输的字节流（字节数组）型数据
  6.      *
  7.      * @param num 一个整型数据
  8.      * @return 4个字节的自己数组
  9.      */
  10.     public static byte[] intToBytes(int num)
  11.     {
  12.         byte[] bytes = new byte[4];
  13.         bytes[0] = (byte) (0xff & (num >> 0));
  14.         bytes[1] = (byte) (0xff & (num >> 8));
  15.         bytes[2] = (byte) (0xff & (num >> 16));
  16.         bytes[3] = (byte) (0xff & (num >> 24));
  17.         return bytes;
  18.     }
  20.     /**
  21.      * 四个字节的字节数据转换成一个整形数据
  22.      *
  23.      * @param bytes 4个字节的字节数组
  24.      * @return 一个整型数据
  25.      */
  26.     public static int byteToInt(byte[] bytes)
  27.     {
  28.         int num = 0;
  29.         int temp;
  30.         temp = (0x000000ff & (bytes[0])) << 0;
  31.         num = num | temp;
  32.         temp = (0x000000ff & (bytes[1])) << 8;
  33.         num = num | temp;
  34.         temp = (0x000000ff & (bytes[2])) << 16;
  35.         num = num | temp;
  36.         temp = (0x000000ff & (bytes[3])) << 24;
  37.         num = num | temp;
  38.         return num;
  39.     }
  41.     /**
  42.      * 长整形转换成网络传输的字节流（字节数组）型数据
  43.      *
  44.      * @param num 一个长整型数据
  45.      * @return 4个字节的自己数组
  46.      */
  47.     public static byte[] longToBytes(long num)
  48.     {
  49.         byte[] bytes = new byte[8];
  50.         for (int i = 0; i < 8; i++)
  51.         {
  52.             bytes[i] = (byte) (0xff & (num >> (i * 8)));
  53.         }
  55.         return bytes;
  56.     }
  58.     /**
  59.      * 大数字转换字节流（字节数组）型数据
  60.      *
  61.      * @param n
  62.      * @return
  63.      */
  64.     public static byte[] byteConvert32Bytes(BigInteger n)
  65.     {
  66.         byte tmpd[] = (byte[])null;
  67.         if(n == null)
  68.         {
  69.             return null;
  70.         }
  72.         if(n.toByteArray().length == 33)
  73.         {
  74.             tmpd = new byte[32];
  75.             System.arraycopy(n.toByteArray(), 1, tmpd, 0, 32);
  76.         }
  77.         else if(n.toByteArray().length == 32)
  78.         {
  79.             tmpd = n.toByteArray();
  80.         }
  81.         else
  82.         {
  83.             tmpd = new byte[32];
  84.             for(int i = 0; i < 32 - n.toByteArray().length; i++)
  85.             {
  86.                 tmpd[i] = 0;
  87.             }
  88.             System.arraycopy(n.toByteArray(), 0, tmpd, 32 - n.toByteArray().length, n.toByteArray().length);
  89.         }
  90.         return tmpd;
  91.     }
  93.     /**
  94.      * 换字节流（字节数组）型数据转大数字
  95.      *
  96.      * @param b
  97.      * @return
  98.      */
  99.     public static BigInteger byteConvertInteger(byte[] b)
  100.     {
  101.         if (b[0] < 0)
  102.         {
  103.             byte[] temp = new byte[b.length + 1];
  104.             temp[0] = 0;
  105.             System.arraycopy(b, 0, temp, 1, b.length);
  106.             return new BigInteger(temp);
  107.         }
  108.         return new BigInteger(b);
  109.     }
  111.     /**
  112.      * 根据字节数组获得值(十六进制数字)
  113.      *
  114.      * @param bytes
  115.      * @return
  116.      */
  117.     public static String getHexString(byte[] bytes)
  118.     {
  119.         return getHexString(bytes, true);
  120.     }
  122.     /**
  123.      * 根据字节数组获得值(十六进制数字)
  124.      *
  125.      * @param bytes
  126.      * @param upperCase
  127.      * @return
  128.      */
  129.     public static String getHexString(byte[] bytes, boolean upperCase)
  130.     {
  131.         String ret = "";
  132.         for (int i = 0; i < bytes.length; i++)
  133.         {
  134.             ret += Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1);
  135.         }
  136.         return upperCase ? ret.toUpperCase() : ret;
  137.     }
  139.     /**
  140.      * 打印十六进制字符串
  141.      *
  142.      * @param bytes
  143.      */
  144.     public static void printHexString(byte[] bytes)
  145.     {
  146.         for (int i = 0; i < bytes.length; i++)
  147.         {
  148.             String hex = Integer.toHexString(bytes[i] & 0xFF);
  149.             if (hex.length() == 1)
  150.             {
  151.                 hex = '0' + hex;
  152.             }
  153.             System.out.print("0x" + hex.toUpperCase() + ",");
  154.         }
  155.         System.out.println("");
  156.     }
  158.     /**
  159.      * Convert hex string to byte[]
  160.      *
  161.      * @param hexString
  162.      *            the hex string
  163.      * @return byte[]
  164.      */
  165.     public static byte[] hexStringToBytes(String hexString)
  166.     {
  167.         if (hexString == null || hexString.equals(""))
  168.         {
  169.             return null;
  170.         }
  172.         hexString = hexString.toUpperCase();
  173.         int length = hexString.length() / 2;
  174.         char[] hexChars = hexString.toCharArray();
  175.         byte[] d = new byte[length];
  176.         for (int i = 0; i < length; i++)
  177.         {
  178.             int pos = i * 2;
  179.             d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
  180.         }
  181.         return d;
  182.     }
  184.     /**
  185.      * Convert char to byte
  186.      *
  187.      * @param c
  188.      *            char
  189.      * @return byte
  190.      */
  191.     public static byte charToByte(char c)
  192.     {
  193.         return (byte) "0123456789ABCDEF".indexOf(c);
  194.     }
  196.     /**
  197.      * 用于建立十六进制字符的输出的小写字符数组
  198.      */
  199.     private static final char[] DIGITS_LOWER = {'0', '1', '2', '3', '4', '5',
  200.             '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
  202.     /**
  203.      * 用于建立十六进制字符的输出的大写字符数组
  204.      */
  205.     private static final char[] DIGITS_UPPER = {'0', '1', '2', '3', '4', '5',
  206.             '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  208.     /**
  209.      * 将字节数组转换为十六进制字符数组
  210.      *
  211.      * @param data byte[]
  212.      * @return 十六进制char[]
  213.      */
  214.     public static char[] encodeHex(byte[] data) {
  215.         return encodeHex(data, true);
  216.     }
  218.     /**
  219.      * 将字节数组转换为十六进制字符数组
  220.      *
  221.      * @param data        byte[]
  222.      * @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  223.      * @return 十六进制char[]
  224.      */
  225.     public static char[] encodeHex(byte[] data, boolean toLowerCase) {
  226.         return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
  227.     }
  229.     /**
  230.      * 将字节数组转换为十六进制字符数组
  231.      *
  232.      * @param data     byte[]
  233.      * @param toDigits 用于控制输出的char[]
  234.      * @return 十六进制char[]
  235.      */
  236.     protected static char[] encodeHex(byte[] data, char[] toDigits) {
  237.         int l = data.length;
  238.         char[] out = new char[l << 1];
  239.         // two characters form the hex value.
  240.         for (int i = 0, j = 0; i < l; i++) {
  241.             out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
  242.             out[j++] = toDigits[0x0F & data[i]];
  243.         }
  244.         return out;
  245.     }
  247.     /**
  248.      * 将字节数组转换为十六进制字符串
  249.      *
  250.      * @param data byte[]
  251.      * @return 十六进制String
  252.      */
  253.     public static String encodeHexString(byte[] data) {
  254.         return encodeHexString(data, true);
  255.     }
  257.     /**
  258.      * 将字节数组转换为十六进制字符串
  259.      *
  260.      * @param data        byte[]
  261.      * @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  262.      * @return 十六进制String
  263.      */
  264.     public static String encodeHexString(byte[] data, boolean toLowerCase) {
  265.         return encodeHexString(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
  266.     }
  268.     /**
  269.      * 将字节数组转换为十六进制字符串
  270.      *
  271.      * @param data     byte[]
  272.      * @param toDigits 用于控制输出的char[]
  273.      * @return 十六进制String
  274.      */
  275.     protected static String encodeHexString(byte[] data, char[] toDigits) {
  276.         return new String(encodeHex(data, toDigits));
  277.     }
  279.     /**
  280.      * 将十六进制字符数组转换为字节数组
  281.      *
  282.      * @param data 十六进制char[]
  283.      * @return byte[]
  284.      * @throws RuntimeException 如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常
  285.      */
  286.     public static byte[] decodeHex(char[] data) {
  287.         int len = data.length;
  289.         if ((len & 0x01) != 0) {
  290.             throw new RuntimeException("Odd number of characters.");
  291.         }
  293.         byte[] out = new byte[len >> 1];
  295.         // two characters form the hex value.
  296.         for (int i = 0, j = 0; j < len; i++) {
  297.             int f = toDigit(data[j], j) << 4;
  298.             j++;
  299.             f = f | toDigit(data[j], j);
  300.             j++;
  301.             out[i] = (byte) (f & 0xFF);
  302.         }
  304.         return out;
  305.     }
  307.     /**
  308.      * 将十六进制字符转换成一个整数
  309.      *
  310.      * @param ch    十六进制char
  311.      * @param index 十六进制字符在字符数组中的位置
  312.      * @return 一个整数
  313.      * @throws RuntimeException 当ch不是一个合法的十六进制字符时，抛出运行时异常
  314.      */
  315.     protected static int toDigit(char ch, int index) {
  316.         int digit = Character.digit(ch, 16);
  317.         if (digit == -1) {
  318.             throw new RuntimeException("Illegal hexadecimal character " + ch
  319.                     + " at index " + index);
  320.         }
  321.         return digit;
  322.     }
  324.     /**
  325.      * 数字字符串转ASCII码字符串
  326.      *
  327.      * @param content
  328.      *            字符串
  329.      * @return ASCII字符串
  330.      */
  331.     public static String StringToAsciiString(String content) {
  332.         String result = "";
  333.         int max = content.length();
  334.         for (int i = 0; i < max; i++) {
  335.             char c = content.charAt(i);
  336.             String b = Integer.toHexString(c);
  337.             result = result + b;
  338.         }
  339.         return result;
  340.     }
  342.     /**
  343.      * 十六进制转字符串
  344.      *
  345.      * @param hexString
  346.      *            十六进制字符串
  347.      * @param encodeType
  348.      *            编码类型4：Unicode，2：普通编码
  349.      * @return 字符串
  350.      */
  351.     public static String hexStringToString(String hexString, int encodeType) {
  352.         String result = "";
  353.         int max = hexString.length() / encodeType;
  354.         for (int i = 0; i < max; i++) {
  355.             char c = (char) hexStringToAlgorism(hexString
  356.                     .substring(i * encodeType, (i + 1) * encodeType));
  357.             result += c;
  358.         }
  359.         return result;
  360.     }
  362.     /**
  363.      * 十六进制字符串装十进制
  364.      *
  365.      * @param hex
  366.      *            十六进制字符串
  367.      * @return 十进制数值
  368.      */
  369.     public static int hexStringToAlgorism(String hex) {
  370.         hex = hex.toUpperCase();
  371.         int max = hex.length();
  372.         int result = 0;
  373.         for (int i = max; i > 0; i--) {
  374.             char c = hex.charAt(i - 1);
  375.             int algorism = 0;
  376.             if (c >= '0' && c <= '9') {
  377.                 algorism = c - '0';
  378.             } else {
  379.                 algorism = c - 55;
  380.             }
  381.             result += Math.pow(16, max - i) * algorism;
  382.         }
  383.         return result;
  384.     }
  386.     /**
  387.      * 十六转二进制
  388.      *
  389.      * @param hex
  390.      *            十六进制字符串
  391.      * @return 二进制字符串
  392.      */
  393.     public static String hexStringToBinary(String hex) {
  394.         hex = hex.toUpperCase();
  395.         String result = "";
  396.         int max = hex.length();
  397.         for (int i = 0; i < max; i++) {
  398.             char c = hex.charAt(i);
  399.             switch (c) {
  400.                 case '0':
  401.                     result += "0000";
  402.                     break;
  403.                 case '1':
  404.                     result += "0001";
  405.                     break;
  406.                 case '2':
  407.                     result += "0010";
  408.                     break;
  409.                 case '3':
  410.                     result += "0011";
  411.                     break;
  412.                 case '4':
  413.                     result += "0100";
  414.                     break;
  415.                 case '5':
  416.                     result += "0101";
  417.                     break;
  418.                 case '6':
  419.                     result += "0110";
  420.                     break;
  421.                 case '7':
  422.                     result += "0111";
  423.                     break;
  424.                 case '8':
  425.                     result += "1000";
  426.                     break;
  427.                 case '9':
  428.                     result += "1001";
  429.                     break;
  430.                 case 'A':
  431.                     result += "1010";
  432.                     break;
  433.                 case 'B':
  434.                     result += "1011";
  435.                     break;
  436.                 case 'C':
  437.                     result += "1100";
  438.                     break;
  439.                 case 'D':
  440.                     result += "1101";
  441.                     break;
  442.                 case 'E':
  443.                     result += "1110";
  444.                     break;
  445.                 case 'F':
  446.                     result += "1111";
  447.                     break;
  448.             }
  449.         }
  450.         return result;
  451.     }
  453.     /**
  454.      * ASCII码字符串转数字字符串
  455.      *
  456.      * @param content
  457.      *            ASCII字符串
  458.      * @return 字符串
  459.      */
  460.     public static String AsciiStringToString(String content) {
  461.         String result = "";
  462.         int length = content.length() / 2;
  463.         for (int i = 0; i < length; i++) {
  464.             String c = content.substring(i * 2, i * 2 + 2);
  465.             int a = hexStringToAlgorism(c);
  466.             char b = (char) a;
  467.             String d = String.valueOf(b);
  468.             result += d;
  469.         }
  470.         return result;
  471.     }
  473.     /**
  474.      * 将十进制转换为指定长度的十六进制字符串
  475.      *
  476.      * @param algorism
  477.      *            int 十进制数字
  478.      * @param maxLength
  479.      *            int 转换后的十六进制字符串长度
  480.      * @return String 转换后的十六进制字符串
  481.      */
  482.     public static String algorismToHexString(int algorism, int maxLength) {
  483.         String result = "";
  484.         result = Integer.toHexString(algorism);
  486.         if (result.length() % 2 == 1) {
  487.             result = "0" + result;
  488.         }
  489.         return patchHexString(result.toUpperCase(), maxLength);
  490.     }
  492.     /**
  493.      * 字节数组转为普通字符串（ASCII对应的字符）
  494.      *
  495.      * @param bytearray
  496.      *            byte[]
  497.      * @return String
  498.      */
  499.     public static String byteToString(byte[] bytearray) {
  500.         String result = "";
  501.         char temp;
  503.         int length = bytearray.length;
  504.         for (int i = 0; i < length; i++) {
  505.             temp = (char) bytearray[i];
  506.             result += temp;
  507.         }
  508.         return result;
  509.     }
  511.     /**
  512.      * 二进制字符串转十进制
  513.      *
  514.      * @param binary
  515.      *            二进制字符串
  516.      * @return 十进制数值
  517.      */
  518.     public static int binaryToAlgorism(String binary) {
  519.         int max = binary.length();
  520.         int result = 0;
  521.         for (int i = max; i > 0; i--) {
  522.             char c = binary.charAt(i - 1);
  523.             int algorism = c - '0';
  524.             result += Math.pow(2, max - i) * algorism;
  525.         }
  526.         return result;
  527.     }
  529.     /**
  530.      * 十进制转换为十六进制字符串
  531.      *
  532.      * @param algorism
  533.      *            int 十进制的数字
  534.      * @return String 对应的十六进制字符串
  535.      */
  536.     public static String algorismToHEXString(int algorism) {
  537.         String result = "";
  538.         result = Integer.toHexString(algorism);
  540.         if (result.length() % 2 == 1) {
  541.             result = "0" + result;
  543.         }
  544.         result = result.toUpperCase();
  546.         return result;
  547.     }
  549.     /**
  550.      * HEX字符串前补0，主要用于长度位数不足。
  551.      *
  552.      * @param str
  553.      *            String 需要补充长度的十六进制字符串
  554.      * @param maxLength
  555.      *            int 补充后十六进制字符串的长度
  556.      * @return 补充结果
  557.      */
  558.     static public String patchHexString(String str, int maxLength) {
  559.         String temp = "";
  560.         for (int i = 0; i < maxLength - str.length(); i++) {
  561.             temp = "0" + temp;
  562.         }
  563.         str = (temp + str).substring(0, maxLength);
  564.         return str;
  565.     }
  567.     /**
  568.      * 将一个字符串转换为int
  569.      *
  570.      * @param s
  571.      *            String 要转换的字符串
  572.      * @param defaultInt
  573.      *            int 如果出现异常,默认返回的数字
  574.      * @param radix
  575.      *            int 要转换的字符串是什么进制的,如16 8 10.
  576.      * @return int 转换后的数字
  577.      */
  578.     public static int parseToInt(String s, int defaultInt, int radix) {
  579.         int i = 0;
  580.         try {
  581.             i = Integer.parseInt(s, radix);
  582.         } catch (NumberFormatException ex) {
  583.             i = defaultInt;
  584.         }
  585.         return i;
  586.     }
  588.     /**
  589.      * 将一个十进制形式的数字字符串转换为int
  590.      *
  591.      * @param s
  592.      *            String 要转换的字符串
  593.      * @param defaultInt
  594.      *            int 如果出现异常,默认返回的数字
  595.      * @return int 转换后的数字
  596.      */
  597.     public static int parseToInt(String s, int defaultInt) {
  598.         int i = 0;
  599.         try {
  600.             i = Integer.parseInt(s);
  601.         } catch (NumberFormatException ex) {
  602.             i = defaultInt;
  603.         }
  604.         return i;
  605.     }
  607.     /**
  608.      * 十六进制串转化为byte数组
  609.      *
  610.      * @return the array of byte
  611.      */
  612.     public static byte[] hexToByte(String hex)
  613.             throws IllegalArgumentException {
  614.         if (hex.length() % 2 != 0) {
  615.             throw new IllegalArgumentException();
  616.         }
  617.         char[] arr = hex.toCharArray();
  618.         byte[] b = new byte[hex.length() / 2];
  619.         for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
  620.             String swap = "" + arr[i++] + arr[i];
  621.             int byteint = Integer.parseInt(swap, 16) & 0xFF;
  622.             b[j] = new Integer(byteint).byteValue();
  623.         }
  624.         return b;
  625.     }
  627.     /**
  628.      * 字节数组转换为十六进制字符串
  629.      *
  630.      * @param b
  631.      *            byte[] 需要转换的字节数组
  632.      * @return String 十六进制字符串
  633.      */
  634.     public static String byteToHex(byte b[]) {
  635.         if (b == null) {
  636.             throw new IllegalArgumentException(
  637.                     "Argument b ( byte array ) is null! ");
  638.         }
  639.         String hs = "";
  640.         String stmp = "";
  641.         for (int n = 0; n < b.length; n++) {
  642.             stmp = Integer.toHexString(b[n] & 0xff);
  643.             if (stmp.length() == 1) {
  644.                 hs = hs + "0" + stmp;
  645.             } else {
  646.                 hs = hs + stmp;
  647.             }
  648.         }
  649.         return hs.toUpperCase();
  650.     }
  652.     public static byte[] subByte(byte[] input, int startIndex, int length) {
  653.         byte[] bt = new byte[length];
  654.         for (int i = 0; i < length; i++) {
  655.             bt[i] = input[i + startIndex];
  656.         }
  657.         return bt;
  658.     }
  659. }

附件下载

Java SM2的更多相关文章

  1. Spark案例分析

    一.需求:计算网页访问量前三名 import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf, SparkContext} /* ...

  2. java 解析国密SM2算法证书

    首先说明用Java自带的解析x509证书类,是不能解析sm2算法的证书,执行会抛出异常. 用开源库bouncycastle能够解析.详细代码 private byte[] getCSPK(byte[] ...

  3. SM2的非对称加解密java工具类

    maven依赖 <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov- ...

  4. Java BC包做sm2加密方法 ，签名验签方法

    package com.sdyy.common.bc_sm2; import org.bouncycastle.jcajce.provider.asymmetric.x509.CertificateF ...

  5. JAVA 【SM2】加密解密

    JAVA [SM2]加密解密 前言:最近项目中必须用到SM2的加密解密 引入的Maven依赖 <dependency> <groupId>cn.hutool</group ...

  6. java解析密钥格式

    import java.io.StringReader; import org.bouncycastle.asn1.ASN1Sequence; import org.bouncycastle.asn1 ...

  7. 制作SM2证书

    前段时间将系统的RSA算法全部升级为SM2国密算法,密码机和UKey硬件设备大都同时支持RSA和SM2算法,只是应用系统的加解密签名验证需要修改,这个更改底层调用的加密动态库来,原来RSA用的对称加密 ...

  8. Java设计模式之《外观模式》及应用场景

    原创作品,可以转载,但是请标注出处地址http://www.cnblogs.com/V1haoge/p/6484128.html 1.外观模式简介 外观模式,一般用在子系统与访问之间,用于对访问屏蔽复 ...

  9. bouncycastle 国密SM2 API的使用

    摘要:本文不对SM2做过多的介绍,主要介绍java bouncycastle库关于SM2的相关API的使用及注意事项 1. SM2 签名: 注意: 1)签名格式ASN1(描述了一种对数据进行表示.编码 ...

  10. java调用dll/so文件

    大家都知道用C++编写的程序如果用于windows使用则编译为xxx.dll文件,如果是Linux使用则编译为libxxx.so文件.下面将java调用dll/so文件的方法粘出来方便下次使用.此处使 ...

随机推荐

  1. Codeforces Round #824 (Div. 2) A-E

    比赛链接 A 题解 知识点:贪心,数学. 注意到三段工作时间一共 \(n-3\) 天,且天数实际上可以随意分配到任意一段,每段至少有一天,现在目的就是最大化段差最小值. 不妨设 \(l_1<l_ ...

  2. 数据抽取平台pydatax介绍

       缘起一:         公司现有数据仓库,是通过kettle从mysql抽取到目标库,运行多年,主要有以下问题, 1,效率低:kettle抽取行数少 2,容错性差:一个表抽取出错就导致后续计算 ...

  3. layui切换select选项事件

    说明 我们经常遇到表单上面选择不同的下拉选项需要触发函数去完成一些业务逻辑,比如我这个地方根据所选商品查询它底下明细的数量,并展示. 效果演示 代码 <!--选择商品--> <div ...

  4. python调用namp.py进行扫描,调用go编译的so文件

    #!/usr/bin/env python # -*- coding: utf-8 -*- import json import os import platform from ctypes impo ...

  5. 如何保证消息顺序执行(Rabbitmq/kafka)

    转载: https://www.cnblogs.com/-wenli/p/13047059.html https://www.jianshu.com/p/02fdcb9e8784

  6. 利用wiile双层循环打印各种星星---day06

    # 十行十列小星星 j = 0 #定义行数 while j<10: #当行数小于10的时候 i=0 #定义列 while i <10: #当列小于10的时候 print('*',end=' ...

  7. OFDM系统各种QAM调制阶数在多径信道下的误码性能仿真（暂存版本）

    本文考虑OFDM系统在多径信道下的误码性能 代码 clc;close all;clear %% Seting parameters EbN0_list = 20:2:40; Q_order_list ...

  8. Spring使用注解方式进行事务管理

    目录 使用步骤: 步骤一.在spring配置文件中引入tx:命名空间 步骤二.具有@Transactional 注解的bean自动配置为声明式事务支持 步骤三.在接口或类的声明处 ,写一个@Trans ...

  9. 【Azure App Service for Windows】 PHP应用出现500 : The page cannot be displayed because an internal server error has occurred. 错误

    问题描述 PHP应用突然遇见了500 The page cannot be displayed because an internal server error has occurred.错误,但是如 ...

  10. 【Azure 存储服务】关于中国区Azure Storage Account 存储账号服务误删除后的恢复问题

    问题描述 在Azure上,如果需要恢复之前删除的存储账户(Storage Account), 有什么办法呢? 问题解答 Azure 现在推出了自主恢复已删除的存储账号的功能,具体步骤如下: 第一步: ...