Java实现国密算法SM2,SM3,SM4,并且实现ECB和CBC模式

10

代码中实现了电码本ECB模式和密文分组连接CBC模式，SM3.java和SM4.java为算法实现类，utils的都是根据实现类写的工具，可以根据需要调用杂凑算法SM3的杂凑功能获得杂凑值。

图片[1]-Java实现国密算法SM2,SM3,SM4,并且实现ECB和CBC模式-第五维

图片[2]-Java实现国密算法SM2,SM3,SM4,并且实现ECB和CBC模式-第五维

SM4.java中

sm4_crypt_ecb(SM4_Context ctx, byte[] input)      ECB模式加解密方法，根据密钥判断加解密功能

sm4_crypt_cbc(SM4_Context ctx, byte[] iv, byte[] input)      CBC模式加解密方法，根据密钥判断加解密功能

加密解密通过如下方法：

sm4_setkey_enc(SM4_Context ctx, byte[] key)  设置加密密钥调用上述方法，实现加密

sm4_setkey_dec(SM4_Context ctx, byte[] key)  设置解密密钥调用上述方法，实现解密

需要导入的包为bcprov-jdk16  我用的版本是bcprov-jdk16-1.46

maven中配置依赖：

  1. <dependency>
  2. <groupId>org.bouncycastle</groupId>
  3. <artifactId></artifactId>
  4. <version>1.46</version>
  5. </dependency>

 

package中class目录如下：

图片[3]-Java实现国密算法SM2,SM3,SM4,并且实现ECB和CBC模式-第五维

chiper.java

  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.java

  1. import java.math.BigInteger;
  2. import java.security.SecureRandom;
  4. import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
  5. import org.bouncycastle.crypto.params.ECDomainParameters;
  6. import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
  7. import org.bouncycastle.math.ec.ECCurve;
  8. import org.bouncycastle.math.ec.ECFieldElement;
  9. import org.bouncycastle.math.ec.ECPoint;
  10. import org.bouncycastle.math.ec.ECFieldElement.Fp;
  12. public class SM2 {
  13. //测试参数
  14. // public static final String[] ecc_param = {
  15. // “8542D69E4C044F18E8B92435BF6FF7DE457283915C45517D722EDB8B08F1DFC3”,
  16. // “787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498”,
  17. // “63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A”,
  18. // “8542D69E4C044F18E8B92435BF6FF7DD297720630485628D5AE74EE7C32E79B7”,
  19. // “421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D”,
  20. // “0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2”
  21. // };
  23. //正式参数
  24. public static String[] ecc_param = {
  25. “FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF”,
  26. “FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC”,
  27. “28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93”,
  28. “FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123”,
  29. “32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7”,
  30. “BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0”
  31. };
  33. public static SM2 Instance()
  34. {
  35. return new SM2();
  36. }
  38. public final BigInteger ecc_p;
  39. public final BigInteger ecc_a;
  40. public final BigInteger ecc_b;
  41. public final BigInteger ecc_n;
  42. public final BigInteger ecc_gx;
  43. public final BigInteger ecc_gy;
  44. public final ECCurve ecc_curve;
  45. public final ECPoint ecc_point_g;
  46. public final ECDomainParameters ecc_bc_spec;
  47. public final ECKeyPairGenerator ecc_key_pair_generator;
  48. public final ECFieldElement ecc_gx_fieldelement;
  49. public final ECFieldElement ecc_gy_fieldelement;
  51. public SM2()
  52. {
  53. this.ecc_p = new BigInteger(ecc_param[0], 16);
  54. this.ecc_a = new BigInteger(ecc_param[1], 16);
  55. this.ecc_b = new BigInteger(ecc_param[2], 16);
  56. this.ecc_n = new BigInteger(ecc_param[3], 16);
  57. this.ecc_gx = new BigInteger(ecc_param[4], 16);
  58. this.ecc_gy = new BigInteger(ecc_param[5], 16);
  60. this.ecc_gx_fieldelement = new Fp(this.ecc_p, this.ecc_gx);
  61. this.ecc_gy_fieldelement = new Fp(this.ecc_p, this.ecc_gy);
  63. this.ecc_curve = new ECCurve.Fp(this.ecc_p, this.ecc_a, this.ecc_b);
  64. this.ecc_point_g = new ECPoint.Fp(this.ecc_curve, this.ecc_gx_fieldelement, this.ecc_gy_fieldelement);
  66. this.ecc_bc_spec = new ECDomainParameters(this.ecc_curve, this.ecc_point_g, this.ecc_n);
  68. ECKeyGenerationParameters ecc_ecgenparam;
  69. ecc_ecgenparam = new ECKeyGenerationParameters(this.ecc_bc_spec, new SecureRandom());
  71. this.ecc_key_pair_generator = new ECKeyPairGenerator();
  72. this.ecc_key_pair_generator.init(ecc_ecgenparam);
  73. }
  74. }

SM2Utils.java

  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 void 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();
  18. System.out.println(“公钥: “ + Util.byteToHex(publicKey.getEncoded()));
  19. System.out.println(“私钥: “ + Util.byteToHex(privateKey.toByteArray()));
  20. }
  22. //数据加密
  23. public static String encrypt(byte[] publicKey, byte[] data) throws IOException
  24. {
  25. if (publicKey == null || publicKey.length == 0)
  26. {
  27. return null;
  28. }
  30. if (data == null || data.length == 0)
  31. {
  32. return null;
  33. }
  35. byte[] source = new byte[data.length];
  36. System.arraycopy(data, 0, source, 0, data.length);
  38. Cipher cipher = new Cipher();
  39. SM2 sm2 = SM2.Instance();
  40. ECPoint userKey = sm2.ecc_curve.decodePoint(publicKey);
  42. ECPoint c1 = cipher.Init_enc(sm2, userKey);
  43. cipher.Encrypt(source);
  44. byte[] c3 = new byte[32];
  45. cipher.Dofinal(c3);
  47. // System.out.println(“C1 ” + Util.byteToHex(c1.getEncoded()));
  48. // System.out.println(“C2 ” + Util.byteToHex(source));
  49. // System.out.println(“C3 ” + Util.byteToHex(c3));
  50. //C1 C2 C3拼装成加密字串
  51. return Util.byteToHex(c1.getEncoded()) + Util.byteToHex(source) + Util.byteToHex(c3);
  53. }
  55. //数据解密
  56. public static byte[] decrypt(byte[] privateKey, byte[] encryptedData) throws IOException
  57. {
  58. if (privateKey == null || privateKey.length == 0)
  59. {
  60. return null;
  61. }
  63. if (encryptedData == null || encryptedData.length == 0)
  64. {
  65. return null;
  66. }
  67. //加密字节数组转换为十六进制的字符串 长度变为encryptedData.length * 2
  68. String data = Util.byteToHex(encryptedData);
  69. /***分解加密字串
  70. * （C1 = C1标志位2位 + C1实体部分128位 = 130）
  71. * （C3 = C3实体部分64位 = 64）
  72. * （C2 = encryptedData.length * 2 – C1长度 – C2长度）
  73. */
  74. byte[] c1Bytes = Util.hexToByte(data.substring(0,130));
  75. int c2Len = encryptedData.length – 97;
  76. byte[] c2 = Util.hexToByte(data.substring(130,130 + 2 * c2Len));
  77. byte[] c3 = Util.hexToByte(data.substring(130 + 2 * c2Len,194 + 2 * c2Len));
  79. SM2 sm2 = SM2.Instance();
  80. BigInteger userD = new BigInteger(1, privateKey);
  82. //通过C1实体字节来生成ECPoint
  83. ECPoint c1 = sm2.ecc_curve.decodePoint(c1Bytes);
  84. Cipher cipher = new Cipher();
  85. cipher.Init_dec(userD, c1);
  86. cipher.Decrypt(c2);
  87. cipher.Dofinal(c3);
  89. //返回解密结果
  90. return c2;
  91. }
  93. public static void main(String[] args) throws Exception
  94. {
  95. //生成密钥对
  96. generateKeyPair();
  98. String plainText = “ererfeiisgod”;
  99. byte[] sourceData = plainText.getBytes();
  101. //下面的秘钥可以使用generateKeyPair()生成的秘钥内容
  102. // 国密规范正式私钥
  103. String prik = “3690655E33D5EA3D9A4AE1A1ADD766FDEA045CDEAA43A9206FB8C430CEFE0D94”;
  104. // 国密规范正式公钥
  105. String pubk = “04F6E0C3345AE42B51E06BF50B98834988D54EBC7460FE135A48171BC0629EAE205EEDE253A530608178A98F1E19BB737302813BA39ED3FA3C51639D7A20C7391A”;
  107. System.out.println(“加密: “);
  108. String cipherText = SM2Utils.encrypt(Util.hexToByte(pubk), sourceData);
  109. System.out.println(cipherText);
  110. System.out.println(“解密: “);
  111. plainText = new String(SM2Utils.decrypt(Util.hexToByte(prik), Util.hexToByte(cipherText)));
  112. System.out.println(plainText);
  114. }
  115. }

SM3.java

  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.java

  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 = “ererfeiisgod”.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. }

SM4_Context.java

  1. public class SM4_Context {
  2. public int mode;
  4. public long[] sk;
  6. public boolean isPadding;
  8. public SM4_Context()
  9. {
  10. this.mode = 1;
  11. this.isPadding = true;
  12. this.sk = new long[32];
  13. }
  14. }

SM4.java

  1. import java.io.ByteArrayInputStream;
  2. import java.io.ByteArrayOutputStream;
  4. public class SM4 {
  5. public static final int SM4_ENCRYPT = 1;
  7. public static final int SM4_DECRYPT = 0;
  9. private long GET_ULONG_BE(byte[] b, int i)
  10. {
  11. long n = (long)(b[i] & 0xff) << 24 | (long)((b[i + 1] & 0xff) << 16) | (long)((b[i + 2] & 0xff) << 8) | (long)(b[i + 3] & 0xff) & 0xffffffffL;
  12. return n;
  13. }
  15. private void PUT_ULONG_BE(long n, byte[] b, int i)
  16. {
  17. b[i] = (byte)(int)(0xFF & n >> 24);
  18. b[i + 1] = (byte)(int)(0xFF & n >> 16);
  19. b[i + 2] = (byte)(int)(0xFF & n >> 8);
  20. b[i + 3] = (byte)(int)(0xFF & n);
  21. }
  23. private long SHL(long x, int n)
  24. {
  25. return (x & 0xFFFFFFFF) << n;
  26. }
  28. private long ROTL(long x, int n)
  29. {
  30. return SHL(x, n) | x >> (32 – n);
  31. }
  33. private void SWAP(long[] sk, int i)
  34. {
  35. long t = sk[i];
  36. sk[i] = sk[(31 – i)];
  37. sk[(31 – i)] = t;
  38. }
  40. public static final byte[] SboxTable = { (byte) 0xd6, (byte) 0x90, (byte) 0xe9, (byte) 0xfe,
  41. (byte) 0xcc, (byte) 0xe1, 0x3d, (byte) 0xb7, 0x16, (byte) 0xb6,
  42. 0x14, (byte) 0xc2, 0x28, (byte) 0xfb, 0x2c, 0x05, 0x2b, 0x67,
  43. (byte) 0x9a, 0x76, 0x2a, (byte) 0xbe, 0x04, (byte) 0xc3,
  44. (byte) 0xaa, 0x44, 0x13, 0x26, 0x49, (byte) 0x86, 0x06,
  45. (byte) 0x99, (byte) 0x9c, 0x42, 0x50, (byte) 0xf4, (byte) 0x91,
  46. (byte) 0xef, (byte) 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43,
  47. (byte) 0xed, (byte) 0xcf, (byte) 0xac, 0x62, (byte) 0xe4,
  48. (byte) 0xb3, 0x1c, (byte) 0xa9, (byte) 0xc9, 0x08, (byte) 0xe8,
  49. (byte) 0x95, (byte) 0x80, (byte) 0xdf, (byte) 0x94, (byte) 0xfa,
  50. 0x75, (byte) 0x8f, 0x3f, (byte) 0xa6, 0x47, 0x07, (byte) 0xa7,
  51. (byte) 0xfc, (byte) 0xf3, 0x73, 0x17, (byte) 0xba, (byte) 0x83,
  52. 0x59, 0x3c, 0x19, (byte) 0xe6, (byte) 0x85, 0x4f, (byte) 0xa8,
  53. 0x68, 0x6b, (byte) 0x81, (byte) 0xb2, 0x71, 0x64, (byte) 0xda,
  54. (byte) 0x8b, (byte) 0xf8, (byte) 0xeb, 0x0f, 0x4b, 0x70, 0x56,
  55. (byte) 0x9d, 0x35, 0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, (byte) 0xd1,
  56. (byte) 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, (byte) 0x87,
  57. (byte) 0xd4, 0x00, 0x46, 0x57, (byte) 0x9f, (byte) 0xd3, 0x27,
  58. 0x52, 0x4c, 0x36, 0x02, (byte) 0xe7, (byte) 0xa0, (byte) 0xc4,
  59. (byte) 0xc8, (byte) 0x9e, (byte) 0xea, (byte) 0xbf, (byte) 0x8a,
  60. (byte) 0xd2, 0x40, (byte) 0xc7, 0x38, (byte) 0xb5, (byte) 0xa3,
  61. (byte) 0xf7, (byte) 0xf2, (byte) 0xce, (byte) 0xf9, 0x61, 0x15,
  62. (byte) 0xa1, (byte) 0xe0, (byte) 0xae, 0x5d, (byte) 0xa4,
  63. (byte) 0x9b, 0x34, 0x1a, 0x55, (byte) 0xad, (byte) 0x93, 0x32,
  64. 0x30, (byte) 0xf5, (byte) 0x8c, (byte) 0xb1, (byte) 0xe3, 0x1d,
  65. (byte) 0xf6, (byte) 0xe2, 0x2e, (byte) 0x82, 0x66, (byte) 0xca,
  66. 0x60, (byte) 0xc0, 0x29, 0x23, (byte) 0xab, 0x0d, 0x53, 0x4e, 0x6f,
  67. (byte) 0xd5, (byte) 0xdb, 0x37, 0x45, (byte) 0xde, (byte) 0xfd,
  68. (byte) 0x8e, 0x2f, 0x03, (byte) 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b,
  69. 0x51, (byte) 0x8d, 0x1b, (byte) 0xaf, (byte) 0x92, (byte) 0xbb,
  70. (byte) 0xdd, (byte) 0xbc, 0x7f, 0x11, (byte) 0xd9, 0x5c, 0x41,
  71. 0x1f, 0x10, 0x5a, (byte) 0xd8, 0x0a, (byte) 0xc1, 0x31,
  72. (byte) 0x88, (byte) 0xa5, (byte) 0xcd, 0x7b, (byte) 0xbd, 0x2d,
  73. 0x74, (byte) 0xd0, 0x12, (byte) 0xb8, (byte) 0xe5, (byte) 0xb4,
  74. (byte) 0xb0, (byte) 0x89, 0x69, (byte) 0x97, 0x4a, 0x0c,
  75. (byte) 0x96, 0x77, 0x7e, 0x65, (byte) 0xb9, (byte) 0xf1, 0x09,
  76. (byte) 0xc5, 0x6e, (byte) 0xc6, (byte) 0x84, 0x18, (byte) 0xf0,
  77. 0x7d, (byte) 0xec, 0x3a, (byte) 0xdc, 0x4d, 0x20, 0x79,
  78. (byte) 0xee, 0x5f, 0x3e, (byte) 0xd7, (byte) 0xcb, 0x39, 0x48 };
  80. public static final int[] FK = { 0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc };
  82. public static final int[] CK = { 0x00070e15,0x1c232a31,0x383f464d,0x545b6269,
  83. 0x70777e85,0x8c939aa1,0xa8afb6bd,0xc4cbd2d9,
  84. 0xe0e7eef5,0xfc030a11,0x181f262d,0x343b4249,
  85. 0x50575e65,0x6c737a81,0x888f969d,0xa4abb2b9,
  86. 0xc0c7ced5,0xdce3eaf1,0xf8ff060d,0x141b2229,
  87. 0x30373e45,0x4c535a61,0x686f767d,0x848b9299,
  88. 0xa0a7aeb5,0xbcc3cad1,0xd8dfe6ed,0xf4fb0209,
  89. 0x10171e25,0x2c333a41,0x484f565d,0x646b7279 };
  91. private byte sm4Sbox(byte inch)
  92. {
  93. int i = inch & 0xFF;
  94. byte retVal = SboxTable[i];
  95. return retVal;
  96. }
  98. private long sm4Lt(long ka)
  99. {
  100. long bb = 0L;
  101. long c = 0L;
  102. byte[] a = new byte[4];
  103. byte[] b = new byte[4];
  104. PUT_ULONG_BE(ka, a, 0);
  105. b[0] = sm4Sbox(a[0]);
  106. b[1] = sm4Sbox(a[1]);
  107. b[2] = sm4Sbox(a[2]);
  108. b[3] = sm4Sbox(a[3]);
  109. bb = GET_ULONG_BE(b, 0);
  110. c = bb ^ ROTL(bb, 2) ^ ROTL(bb, 10) ^ ROTL(bb, 18) ^ ROTL(bb, 24);
  111. return c;
  112. }
  114. private long sm4F(long x0, long x1, long x2, long x3, long rk)
  115. {
  116. return x0 ^ sm4Lt(x1 ^ x2 ^ x3 ^ rk);
  117. }
  119. private long sm4CalciRK(long ka)
  120. {
  121. long bb = 0L;
  122. long rk = 0L;
  123. byte[] a = new byte[4];
  124. byte[] b = new byte[4];
  125. PUT_ULONG_BE(ka, a, 0);
  126. b[0] = sm4Sbox(a[0]);
  127. b[1] = sm4Sbox(a[1]);
  128. b[2] = sm4Sbox(a[2]);
  129. b[3] = sm4Sbox(a[3]);
  130. bb = GET_ULONG_BE(b, 0);
  131. rk = bb ^ ROTL(bb, 13) ^ ROTL(bb, 23);
  132. return rk;
  133. }
  135. private void sm4_setkey(long[] SK, byte[] key)
  136. {
  137. long[] MK = new long[4];
  138. long[] k = new long[36];
  139. int i = 0;
  140. MK[0] = GET_ULONG_BE(key, 0);
  141. MK[1] = GET_ULONG_BE(key, 4);
  142. MK[2] = GET_ULONG_BE(key, 8);
  143. MK[3] = GET_ULONG_BE(key, 12);
  144. k[0] = MK[0] ^ (long) FK[0];
  145. k[1] = MK[1] ^ (long) FK[1];
  146. k[2] = MK[2] ^ (long) FK[2];
  147. k[3] = MK[3] ^ (long) FK[3];
  148. for (; i < 32; i++)
  149. {
  150. k[(i + 4)] = (k[i] ^ sm4CalciRK(k[(i + 1)] ^ k[(i + 2)] ^ k[(i + 3)] ^ (long) CK[i]));
  151. SK[i] = k[(i + 4)];
  152. }
  153. }
  155. private void sm4_one_round(long[] sk, byte[] input, byte[] output)
  156. {
  157. int i = 0;
  158. long[] ulbuf = new long[36];
  159. ulbuf[0] = GET_ULONG_BE(input, 0);
  160. ulbuf[1] = GET_ULONG_BE(input, 4);
  161. ulbuf[2] = GET_ULONG_BE(input, 8);
  162. ulbuf[3] = GET_ULONG_BE(input, 12);
  163. while (i < 32)
  164. {
  165. ulbuf[(i + 4)] = sm4F(ulbuf[i], ulbuf[(i + 1)], ulbuf[(i + 2)], ulbuf[(i + 3)], sk[i]);
  166. i++;
  167. }
  168. PUT_ULONG_BE(ulbuf[35], output, 0);
  169. PUT_ULONG_BE(ulbuf[34], output, 4);
  170. PUT_ULONG_BE(ulbuf[33], output, 8);
  171. PUT_ULONG_BE(ulbuf[32], output, 12);
  172. }
  174. private byte[] padding(byte[] input, int mode)
  175. {
  176. if (input == null)
  177. {
  178. return null;
  179. }
  181. byte[] ret = (byte[]) null;
  182. if (mode == SM4_ENCRYPT)
  183. {
  184. int p = 16 – input.length % 16;
  185. ret = new byte[input.length + p];
  186. System.arraycopy(input, 0, ret, 0, input.length);
  187. for (int i = 0; i < p; i++)
  188. {
  189. ret[input.length + i] = (byte) p;
  190. }
  191. }
  192. else
  193. {
  194. int p = input[input.length – 1];
  195. ret = new byte[input.length – p];
  196. System.arraycopy(input, 0, ret, 0, input.length – p);
  197. }
  198. return ret;
  199. }
  201. public void sm4_setkey_enc(SM4_Context ctx, byte[] key) throws Exception
  202. {
  203. if (ctx == null)
  204. {
  205. throw new Exception(“ctx is null!”);
  206. }
  208. if (key == null || key.length != 16)
  209. {
  210. throw new Exception(“key error!”);
  211. }
  213. ctx.mode = SM4_ENCRYPT;
  214. sm4_setkey(ctx.sk, key);
  215. }
  217. public void sm4_setkey_dec(SM4_Context ctx, byte[] key) throws Exception
  218. {
  219. if (ctx == null)
  220. {
  221. throw new Exception(“ctx is null!”);
  222. }
  224. if (key == null || key.length != 16)
  225. {
  226. throw new Exception(“key error!”);
  227. }
  229. int i = 0;
  230. ctx.mode = SM4_DECRYPT;
  231. sm4_setkey(ctx.sk, key);
  232. for (i = 0; i < 16; i++)
  233. {
  234. SWAP(ctx.sk, i);
  235. }
  236. }
  238. public byte[] sm4_crypt_ecb(SM4_Context ctx, byte[] input) throws Exception
  239. {
  240. if (input == null)
  241. {
  242. throw new Exception(“input is null!”);
  243. }
  245. if ((ctx.isPadding) && (ctx.mode == SM4_ENCRYPT))
  246. {
  247. input = padding(input, SM4_ENCRYPT);
  248. }
  250. int length = input.length;
  251. ByteArrayInputStream bins = new ByteArrayInputStream(input);
  252. ByteArrayOutputStream bous = new ByteArrayOutputStream();
  253. for(; length > 0; length -= 16)
  254. {
  255. byte[] in = new byte[16];
  256. byte[] out = new byte[16];
  257. bins.read(in);
  258. sm4_one_round(ctx.sk, in, out);
  259. bous.write(out);
  260. }
  262. byte[] output = bous.toByteArray();
  263. if (ctx.isPadding && ctx.mode == SM4_DECRYPT)
  264. {
  265. output = padding(output, SM4_DECRYPT);
  266. }
  267. bins.close();
  268. bous.close();
  269. return output;
  270. }
  272. public byte[] sm4_crypt_cbc(SM4_Context ctx, byte[] iv, byte[] input) throws Exception
  273. {
  274. if (iv == null || iv.length != 16)
  275. {
  276. throw new Exception(“iv error!”);
  277. }
  279. if (input == null)
  280. {
  281. throw new Exception(“input is null!”);
  282. }
  284. if (ctx.isPadding && ctx.mode == SM4_ENCRYPT)
  285. {
  286. input = padding(input, SM4_ENCRYPT);
  287. }
  289. int i = 0;
  290. int length = input.length;
  291. ByteArrayInputStream bins = new ByteArrayInputStream(input);
  292. ByteArrayOutputStream bous = new ByteArrayOutputStream();
  293. if (ctx.mode == SM4_ENCRYPT)
  294. {
  295. for(; length > 0; length -= 16)
  296. {
  297. byte[] in = new byte[16];
  298. byte[] out = new byte[16];
  299. byte[] out1 = new byte[16];
  301. bins.read(in);
  302. for (i = 0; i < 16; i++)
  303. {
  304. out[i] = ((byte) (in[i] ^ iv[i]));
  305. }
  306. sm4_one_round(ctx.sk, out, out1);
  307. System.arraycopy(out1, 0, iv, 0, 16);
  308. bous.write(out1);
  309. }
  310. }
  311. else
  312. {
  313. byte[] temp = new byte[16];
  314. for(; length > 0; length -= 16)
  315. {
  316. byte[] in = new byte[16];
  317. byte[] out = new byte[16];
  318. byte[] out1 = new byte[16];
  320. bins.read(in);
  321. System.arraycopy(in, 0, temp, 0, 16);
  322. sm4_one_round(ctx.sk, in, out);
  323. for (i = 0; i < 16; i++)
  324. {
  325. out1[i] = ((byte) (out[i] ^ iv[i]));
  326. }
  327. System.arraycopy(temp, 0, iv, 0, 16);
  328. bous.write(out1);
  329. }
  330. }
  332. byte[] output = bous.toByteArray();
  333. if (ctx.isPadding && ctx.mode == SM4_DECRYPT)
  334. {
  335. output = padding(output, SM4_DECRYPT);
  336. }
  337. bins.close();
  338. bous.close();
  339. return output;
  340. }
  341. }

SM4Utils.java

  1. import java.io.IOException;
  2. import java.util.regex.Matcher;
  3. import java.util.regex.Pattern;
  5. import sun.misc.BASE64Decoder;
  6. import sun.misc.BASE64Encoder;
  8. public class SM4Utils {
  9. // private String secretKey = “”;
  10. // private String iv = “”;
  11. // private boolean hexString = false;
  13. public String secretKey = “”;
  14. private String iv = “”;
  15. public boolean hexString = false;
  17. public SM4Utils()
  18. {
  19. }
  20. //
  21. // public byte encryptData_ECB1(byte[] inputStream){
  22. // try
  23. // {
  24. // SM4_Context ctx = new SM4_Context();
  25. // ctx.isPadding = true;
  26. // ctx.mode = SM4.SM4_ENCRYPT;
  27. //
  28. // byte[] keyBytes;
  29. // if (hexString)
  30. // {
  31. // keyBytes = Util.hexStringToBytes(secretKey);
  32. // }
  33. // else
  34. // {
  35. // keyBytes = secretKey.getBytes();
  36. // }
  37. //
  38. // SM4 sm4 = new SM4();
  39. // sm4.sm4_setkey_enc(ctx, keyBytes);
  40. // String cipherText = new BASE64Encoder().encode(inputStream);
  41. // if (cipherText != null && cipherText.trim().length() > 0)
  42. // {
  43. // Pattern p = Pattern.compile(“\\s*|\t|\r|\n”);
  44. // Matcher m = p.matcher(cipherText);
  45. // cipherText = m.replaceAll(“”);
  46. // }
  47. // return cipherText;
  48. // }
  49. // catch (Exception e)
  50. // {
  51. // e.printStackTrace();
  52. // return (Byte) null;
  53. // }
  54. // }
  56. public String encryptData_ECB(String plainText)
  57. {
  58. try
  59. {
  60. SM4_Context ctx = new SM4_Context();
  61. ctx.isPadding = true;
  62. ctx.mode = SM4.SM4_ENCRYPT;
  64. byte[] keyBytes;
  65. if (hexString)
  66. {
  67. keyBytes = Util.hexStringToBytes(secretKey);
  68. }
  69. else
  70. {
  71. keyBytes = secretKey.getBytes();
  72. }
  74. SM4 sm4 = new SM4();
  75. sm4.sm4_setkey_enc(ctx, keyBytes);
  76. byte[] encrypted = sm4.sm4_crypt_ecb(ctx, plainText.getBytes(“GBK”));
  77. String cipherText = new BASE64Encoder().encode(encrypted);
  78. if (cipherText != null && cipherText.trim().length() > 0)
  79. {
  80. Pattern p = Pattern.compile(“\\s*|\t|\r|\n”);
  81. Matcher m = p.matcher(cipherText);
  82. cipherText = m.replaceAll(“”);
  83. }
  84. return cipherText;
  85. }
  86. catch (Exception e)
  87. {
  88. e.printStackTrace();
  89. return null;
  90. }
  91. }
  93. public String decryptData_ECB(String cipherText)
  94. {
  95. try
  96. {
  97. SM4_Context ctx = new SM4_Context();
  98. ctx.isPadding = true;
  99. ctx.mode = SM4.SM4_DECRYPT;
  101. byte[] keyBytes;
  102. if (hexString)
  103. {
  104. keyBytes = Util.hexStringToBytes(secretKey);
  105. }
  106. else
  107. {
  108. keyBytes = secretKey.getBytes();
  109. }
  111. SM4 sm4 = new SM4();
  112. sm4.sm4_setkey_dec(ctx, keyBytes);
  113. byte[] decrypted = sm4.sm4_crypt_ecb(ctx, new BASE64Decoder().decodeBuffer(cipherText));
  114. return new String(decrypted, “GBK”);
  115. }
  116. catch (Exception e)
  117. {
  118. e.printStackTrace();
  119. return null;
  120. }
  121. }
  123. public String encryptData_CBC(String plainText)
  124. {
  125. try
  126. {
  127. SM4_Context ctx = new SM4_Context();
  128. ctx.isPadding = true;
  129. ctx.mode = SM4.SM4_ENCRYPT;
  131. byte[] keyBytes;
  132. byte[] ivBytes;
  133. if (hexString)
  134. {
  135. keyBytes = Util.hexStringToBytes(secretKey);
  136. ivBytes = Util.hexStringToBytes(iv);
  137. }
  138. else
  139. {
  140. keyBytes = secretKey.getBytes();
  141. ivBytes = iv.getBytes();
  142. }
  144. SM4 sm4 = new SM4();
  145. sm4.sm4_setkey_enc(ctx, keyBytes);
  146. byte[] encrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, plainText.getBytes(“GBK”));
  147. String cipherText = new BASE64Encoder().encode(encrypted);
  148. if (cipherText != null && cipherText.trim().length() > 0)
  149. {
  150. Pattern p = Pattern.compile(“\\s*|\t|\r|\n”);
  151. Matcher m = p.matcher(cipherText);
  152. cipherText = m.replaceAll(“”);
  153. }
  154. return cipherText;
  155. }
  156. catch (Exception e)
  157. {
  158. e.printStackTrace();
  159. return null;
  160. }
  161. }
  163. public String decryptData_CBC(String cipherText)
  164. {
  165. try
  166. {
  167. SM4_Context ctx = new SM4_Context();
  168. ctx.isPadding = true;
  169. ctx.mode = SM4.SM4_DECRYPT;
  171. byte[] keyBytes;
  172. byte[] ivBytes;
  173. if (hexString)
  174. {
  175. keyBytes = Util.hexStringToBytes(secretKey);
  176. ivBytes = Util.hexStringToBytes(iv);
  177. }
  178. else
  179. {
  180. keyBytes = secretKey.getBytes();
  181. ivBytes = iv.getBytes();
  182. }
  184. SM4 sm4 = new SM4();
  185. sm4.sm4_setkey_dec(ctx, keyBytes);
  186. byte[] decrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, new BASE64Decoder().decodeBuffer(cipherText));
  187. return new String(decrypted, “GBK”);
  188. }
  189. catch (Exception e)
  190. {
  191. e.printStackTrace();
  192. return null;
  193. }
  194. }
  196. public static void main(String[] args) throws IOException
  197. {
  198. String plainText = “ererfeiisgod”;
  200. SM4Utils sm4 = new SM4Utils();
  201. sm4.secretKey = “JeF8U9wHFOMfs2Y8”;
  202. sm4.hexString = false;
  204. System.out.println(“ECB模式加密”);
  205. String cipherText = sm4.encryptData_ECB(plainText);
  206. System.out.println(“密文: “ + cipherText);
  207. System.out.println(“”);
  209. plainText = sm4.decryptData_ECB(cipherText);
  210. System.out.println(“明文: “ + plainText);
  211. System.out.println(“”);
  213. System.out.println(“CBC模式加密”);
  214. sm4.iv = “UISwD9fW6cFh9SNS”;
  215. cipherText = sm4.encryptData_CBC(plainText);
  216. System.out.println(“密文: “ + cipherText);
  217. System.out.println(“”);
  219. plainText = sm4.decryptData_CBC(cipherText);
  220. System.out.println(“明文: “ + plainText);
  222. System.out.println(“CBC模式解密”);
  223. System.out.println(“密文：4esGgDn/snKraRDe6uM0jQ==”);
  224. String cipherText2 = “4esGgDn/snKraRDe6uM0jQ==”;
  225. plainText = sm4.decryptData_CBC(cipherText2);
  226. System.out.println(“明文: “ + plainText);
  227. }
  228. }

Utils.java

  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 String
  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 String
  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. }
© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
开发
喜欢就支持一下吧
点赞0 分享
管理员的头像-第五维钻石会员
Delphi下使用ffmpeg的解决方案-第五维
Delphi下使用ffmpeg的解决方案
Delphi下使用ffmpeg的解决方案
9年前 46
DELPHI XE8,C++ BUILDER XE8,RAD STUDIO XE8 精简版 Embarcadero Delphi XE8 Lite v11.x-第五维
DELPHI XE8,C++ BUILDER XE8,RAD STUDIO XE8 精简版 Embarcadero Delphi XE8 Lite v11.x
DELPHI XE8,C++ BUILDER XE8,RAD STUDIO XE8 精简版 Embarcadero Del...
9年前 32
在未越狱的iOS设备上安装Kodi播放器教程-第五维
在未越狱的iOS设备上安装Kodi播放器教程
在未越狱的iOS设备上安装Kodi播放器教程
5年前 23
科腾系列方向盘驱动-第五维
科腾系列方向盘驱动
科腾系列方向盘驱动
1年前 23
wordpress修改固定链接之后无法访问的解决办法-第五维
wordpress修改固定链接之后无法访问的解决办法
wordpress修改固定链接之后无法访问的解决办法
9年前 20
利用ffmpeg进行音频转换及将DTS转成AC3的命令-第五维
利用ffmpeg进行音频转换及将DTS转成AC3的命令
利用ffmpeg进行音频转换及将DTS转成AC3的命令
9年前 19
相关推荐
在未越狱的iOS设备上安装Kodi播放器教程-第五维
在未越狱的iOS设备上安装Kodi播放器教程
在未越狱的iOS设备上安装Kodi播放器教程
5年前 23
Minio分布式集群搭建-第五维
Minio分布式集群搭建
Minio分布式集群搭建
5年前 17
Ardunio使用LCD1602 I2C显示汉字-第五维
Ardunio使用LCD1602 I2C显示汉字
Ardunio使用LCD1602 I2C显示汉字
5年前 16
CentOS部署MinIO 后台启动-第五维
CentOS部署MinIO 后台启动
CentOS部署MinIO 后台启动
5年前 11
编译scratch3.0桌面程序（根据原创进行了一点修改）-第五维
编译scratch3.0桌面程序（根据原创进行了一点修改）
编译scratch3.0桌面程序（根据原创进行了一点修改）
5年前 10
SpringBoot 统一时区的方案-第五维
SpringBoot 统一时区的方案
SpringBoot 统一时区的方案
6年前 10
Delphi下使用ffmpeg的解决方案-第五维
46人已阅读
Delphi下使用ffmpeg的解决方案
TOP1
DELPHI XE8,C++ BUILDER XE8,RAD STUDIO XE8 精简版 Embarcadero Delphi XE8 Lite v11.x-第五维
DELPHI XE8,C++ BUILDER XE8,RAD STUDIO XE8 精简版 Embarcadero Delphi XE8 Lite v11.x
9年前32人已阅读
TOP2
在未越狱的iOS设备上安装Kodi播放器教程-第五维
在未越狱的iOS设备上安装Kodi播放器教程
5年前23人已阅读
TOP3
科腾系列方向盘驱动-第五维
科腾系列方向盘驱动
1年前23人已阅读
TOP4
wordpress修改固定链接之后无法访问的解决办法-第五维
wordpress修改固定链接之后无法访问的解决办法
9年前20人已阅读
TOP5
利用ffmpeg进行音频转换及将DTS转成AC3的命令-第五维
利用ffmpeg进行音频转换及将DTS转成AC3的命令
9年前19人已阅读
TOP6
Games for Windows - LIVE 离线安装包-第五维
Games for Windows – LIVE 离线安装包
9年前18人已阅读
TOP7
星际争霸1完整硬盘版，带背景音乐，版本切换，WIN7花屏补丁-第五维
星际争霸1完整硬盘版，带背景音乐，版本切换，WIN7花屏补丁
9年前17人已阅读
TOP8
Minio分布式集群搭建-第五维
Minio分布式集群搭建
5年前17人已阅读
TOP9
Ardunio使用LCD1602 I2C显示汉字-第五维
Ardunio使用LCD1602 I2C显示汉字
5年前16人已阅读
TOP10
标签云
驱动 (3)面试 (1)防盗链 (1)银联 (1)重定向 (1)运行库 (1)跨平台 (1)越狱 (1)调试 (1)设计模式 (1)视频剪辑 (1)规范 (1)表达式 (1)补丁 (1)蓝牙 (1)网络 (1)网易云音乐 (1)终端 (1)纯真IP (1)算法题 (1)