国密算法Java代码的标准实现
前一阵子做的项目，越来越多的金融类应用使用国密算法进行加解密的运算。
国密即国家密码局认定的国产密码算法。主要有SM1，SM2，SM3，SM4。密钥长度和分组长度均为128位。
SM1 为对称加密。其加密强度与AES相当。该算法不公开，调用该算法时，需要通过加密芯片的接口进行调用。
SM2为非对称加密，基于ECC。该算法已公开。由于该算法基于ECC，故其签名速度与秘钥生成速度都快于RSA。ECC 256位（SM2采用的就是ECC 256位的一种）安全强度比RSA 2048位高，但运算速度快于RSA。
SM3 消息摘要。可以用MD5作为对比理解。该算法已公开。校验结果为256位。
SM4 无线局域网标准的分组数据算法。对称加密，密钥长度和分组长度均为128位。
由于SM1、SM4加解密的分组大小为128bit，故对消息进行加解密时，若消息长度过长，需要进行分组，要消息长度不足，则要进行填充。
JAVA代码：Util:
1 import javax.crypto.SecretKey; 2 import javax.crypto.SecretKeyFactory; 3 import javax.crypto.spec.PBEKeySpec; 4 import javax.crypto.spec.SecretKeySpec; 5 import java.math.BigInteger; 6 import java.security.NoSuchAlgorithmException; 7 import java.security.SecureRandom; 8 import java.security.spec.InvalidKeySpecException; 9 import java.security.spec.KeySpec; 10 11 public class Util { 12 public static final byte MAX_VALUE = -1; 13 public static byte[] hexToByte(String arg8) { 14 if(arg8.length() % 2 == 0) { 15 char[] v0 = arg8.toCharArray(); 16 byte[] v1 = new byte[arg8.length() / 2]; 17 int v2 = 0; 18 int v3 = 0; 19 int v4 = arg8.length(); 20 while(v2 < v4) { 21 StringBuilder v5 = new StringBuilder(); 22 v5.append(""); 23 int v6 = v2 + 1; 24 v5.append(v0[v2]); 25 v5.append(v0[v6]); 26 v1[v3] = new Integer(Integer.parseInt(v5.toString(), 16) & 255).byteValue(); 27 v2 = v6 + 1; 28 ++v3; 29 } 30 31 return v1; 32 } 33 throw new IllegalArgumentException(); 34 } 35 public static String byteToHex(byte[] arg5) { 36 if(arg5 != null) { 37 String v0 = ""; 38 int v2; 39 for(v2 = 0; v2 < arg5.length; ++v2) { 40 String v1 = Integer.toHexString(arg5[v2] & 255); 41 v0 = v1.length() == 1 ? v0 + "0" + v1 : v0 + v1; 42 } 43 44 return v0.toUpperCase(); 45 } 46 throw new IllegalArgumentException("Argument b ( byte array ) is null! "); 47 } 48 49 public static byte[] byteConvert32Bytes(BigInteger arg5) { 50 byte[] v0 = null; 51 if(arg5 == null) { 52 return v0; 53 } 54 55 int v4 = 32; 56 if(arg5.toByteArray().length == 33) { 57 v0 = new byte[v4]; 58 System.arraycopy(arg5.toByteArray(), 1, v0, 0, v4); 59 } 60 else if(arg5.toByteArray().length == v4) { 61 v0 = arg5.toByteArray(); 62 } 63 else { 64 v0 = new byte[v4]; 65 int v1; 66 for(v1 = 0; v1 < 32 - arg5.toByteArray().length; ++v1) { 67 v0[v1] = 0; 68 } 69 70 System.arraycopy(arg5.toByteArray(), 0, v0, v4 - arg5.toByteArray().length, arg5.toByteArray().length); 71 } 72 73 return v0; 74 } 75 76 public static byte[] hexStringToBytes(String arg7) { 77 if(arg7 != null) { 78 if(arg7.equals("")) { 79 } 80 else { 81 arg7 = arg7.toUpperCase(); 82 int v0 = arg7.length() / 2; 83 char[] v1 = arg7.toCharArray(); 84 byte[] v2 = new byte[v0]; 85 int v3; 86 for(v3 = 0; v3 < v0; ++v3) { 87 int v4 = v3 * 2; 88 v2[v3] = ((byte)(Util.charToByte(v1[v4]) << 4 | Util.charToByte(v1[v4 + 1]))); 89 } 90 91 return v2; 92 } 93 } 94 95 return null; 96 } 97 98 public static byte charToByte(char arg1) { 99 return ((byte)"0123456789ABCDEF".indexOf(arg1)); 100 } 101 102 }
SM2:
1 import org.bouncycastle.crypto.generators.ECKeyPairGenerator; 2 import org.bouncycastle.crypto.params.ECDomainParameters; 3 import org.bouncycastle.crypto.params.ECKeyGenerationParameters; 4 import org.bouncycastle.math.ec.ECCurve; 5 import org.bouncycastle.math.ec.ECFieldElement; 6 import org.bouncycastle.math.ec.ECPoint; 7 8 import java.math.BigInteger; 9 import java.security.SecureRandom; 10 11 public class SM2 { 12 public static String[] ecc_param = {"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF", "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC", "28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93", "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123", "32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7", "BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0"}; 13 public final BigInteger ecc_p = new BigInteger(ecc_param[0], 16); 14 public final BigInteger ecc_a = new BigInteger(ecc_param[1], 16); 15 public final BigInteger ecc_b = new BigInteger(ecc_param[2], 16); 16 public final BigInteger ecc_n = new BigInteger(ecc_param[3], 16); 17 public final BigInteger ecc_gx = new BigInteger(ecc_param[4], 16); 18 public final BigInteger ecc_gy = new BigInteger(ecc_param[5], 16); 19 public final ECFieldElement ecc_gx_fieldelement = new ECFieldElement.Fp(this.ecc_p, this.ecc_gx); 20 public final ECFieldElement ecc_gy_fieldelement = new ECFieldElement.Fp(this.ecc_p, this.ecc_gy); 21 public final ECCurve ecc_curve = new ECCurve.Fp(this.ecc_p, this.ecc_a, this.ecc_b); 22 public final ECPoint ecc_point_g = new ECPoint.Fp(this.ecc_curve, this.ecc_gx_fieldelement, this.ecc_gy_fieldelement); 23 public final ECDomainParameters ecc_bc_spec = new ECDomainParameters(this.ecc_curve, this.ecc_point_g, this.ecc_n); 24 public final ECKeyPairGenerator ecc_key_pair_generator; 25 26 public static SM2 Instance() { 27 return new SM2(); 28 } 29 30 public SM2() { 31 ECKeyGenerationParameters ecc_ecgenparam = new ECKeyGenerationParameters(this.ecc_bc_spec, new SecureRandom()); 32 this.ecc_key_pair_generator = new ECKeyPairGenerator(); 33 this.ecc_key_pair_generator.init(ecc_ecgenparam); 34 } 35 }
SM2Util：
1 import org.bouncycastle.crypto.AsymmetricCipherKeyPair; 2 import org.bouncycastle.crypto.params.AsymmetricKeyParameter; 3 import org.bouncycastle.crypto.params.ECPrivateKeyParameters; 4 import org.bouncycastle.crypto.params.ECPublicKeyParameters; 5 import org.bouncycastle.math.ec.ECPoint; 6 7 import java.io.IOException; 8 import java.math.BigInteger; 9 10 public class SM2Util { 11 public static final String PUBLIC_KEY = "你的公钥1"; 12 public static final String PUBLIC_KEY_2 = "你的公钥2"; 13 public static String encrypt(String key, String mes) { 14 byte[] arg9 = mes.getBytes(); 15 byte[] arg8 = Util.hexToByte(key); 16 String v0 = null; 17 if(arg8 != null) { 18 if(arg8.length == 0) { 19 } 20 else { 21 if(arg9 != null) { 22 if(arg9.length == 0) { 23 } 24 else { 25 byte[] v0_1 = new byte[arg9.length]; 26 System.arraycopy(arg9, 0, v0_1, 0, arg9.length); 27 Cipher v1 = new Cipher(); 28 SM2 v2 = SM2.Instance(); 29 ECPoint v4 = v1.Init_enc(v2, v2.ecc_curve.decodePoint(arg8)); 30 v1.Encrypt(v0_1); 31 byte[] v5 = new byte[32]; 32 v1.Dofinal(v5); 33 return Util.byteToHex(v4.getEncoded()) + Util.byteToHex(v5) + Util.byteToHex(v0_1); 34 } 35 } 36 return v0; 37 } 38 } 39 return v0; 40 } 41 42 public static String decrypt(String key, String mes) throws IOException { 43 byte[] arg9 = Util.hexToByte(key); 44 byte[] arg10 = Util.hexToByte(mes); 45 byte[] v0 = null; 46 if(arg9 != null) { 47 if(arg9.length == 0) { 48 } 49 else { 50 if(arg10 != null) { 51 if(arg10.length == 0) { 52 } 53 else { 54 String v0_1 = Util.byteToHex(arg10); 55 byte[] v1 = Util.hexToByte(v0_1.substring(0, 130)); 56 int v3 = arg10.length - 97; 57 byte[] v2 = Util.hexToByte(v0_1.substring(130, 194)); 58 byte[] v4 = Util.hexToByte(v0_1.substring(194, v3 * 2 + 194)); 59 SM2 v5 = SM2.Instance(); 60 BigInteger v6 = new BigInteger(1, arg9); 61 ECPoint v7 = v5.ecc_curve.decodePoint(v1); 62 Cipher v8 = new Cipher(); 63 v8.Init_dec(v6, v7); 64 v8.Decrypt(v4); 65 v8.Dofinal(v2); 66 return new String(v4); 67 } 68 } 69 70 return new String(v0); 71 } 72 } 73 return new String(v0); 74 } 75 76 // public static SM2KeyVO generateKeyPair() { 77 // AsymmetricCipherKeyPair v1; 78 // SM2 v0 = SM2.Instance(); 79 // while(true) { 80 // v1 = v0.ecc_key_pair_generator.generateKeyPair(); 81 // if(v1.getPrivate().getD().toByteArray().length == 32) { 82 // break; 83 // } 84 // } 85 // 86 // AsymmetricKeyParameter v2 = v1.getPrivate(); 87 // AsymmetricKeyParameter v3 = v1.getPublic(); 88 // BigInteger v4 = ((ECPrivateKeyParameters)v2).getD(); 89 // ECPoint v5 = ((ECPublicKeyParameters)v3).getQ(); 90 // SM2KeyVO v6 = new SM2KeyVO(); 91 // v6.setPublicKey(v5); 92 // v6.setPrivateKey(v4); 93 // return v6; 94 // } 95 96 }
SM2KeyVO:
1 import org.bouncycastle.math.ec.ECPoint; 2 3 import java.math.BigInteger; 4 5 public class SM2KeyVO { 6 BigInteger privateKey; 7 ECPoint publicKey; 8 9 public String getPriHexInSoft() { 10 return Util.byteToHex(this.privateKey.toByteArray()); 11 } 12 13 public BigInteger getPrivateKey() { 14 return this.privateKey; 15 } 16 17 public String getPubHexInSoft() { 18 return Util.byteToHex(this.publicKey.getEncoded()); 19 } 20 21 public ECPoint getPublicKey() { 22 return this.publicKey; 23 } 24 25 public void setPrivateKey(BigInteger arg1) { 26 this.privateKey = arg1; 27 } 28 29 public void setPublicKey(ECPoint arg1) { 30 this.publicKey = arg1; 31 } 32 }
SM3Util:
1 import org.bouncycastle.crypto.digests.SM3Digest; 2 import org.bouncycastle.util.encoders.Hex; 3 4 public class SM3Util { 5 public static String sm3(String arg5) { 6 byte[] v0 = new byte[32]; 7 byte[] v1 = arg5.getBytes(); 8 SM3Digest v2 = new SM3Digest(); 9 v2.update(v1, 0, v1.length); 10 v2.doFinal(v0, 0); 11 return new String(Hex.encode(v0)).toUpperCase(); 12 } 13 }
SM4:
1 import java.io.ByteArrayInputStream; 2 import java.io.ByteArrayOutputStream; 3 4 public class SM4 { 5 public static final int[] CK = new int[]{462357, 472066609, 943670861, 1415275113, 1886879365, -1936483679, -1464879427, -993275175, -521670923, -66909679, 404694573, 876298825, 1347903077, 1819507329, -2003855715, -1532251463, -1060647211, -589042959, -117504499, 337322537, 808926789, 1280531041, 1752135293, -2071227751, -1599623499, -1128019247, -656414995, -184876535, 269950501, 741554753, 1213159005, 1684763257}; 6 public static final int[] FK = new int[]{-1548633402, 1453994832, 1736282519, -1301273892}; 7 public static final int SM4_DECRYPT = 0; 8 public static final int SM4_ENCRYPT = 1; 9 public static final byte[] SboxTable = new byte[]{-42, -112, -23, -2, -52, -31, 61, -73, 22, -74, 20, -62, 40, -5, 44, 5, 43, 103, -102, 118, 42, -66, 4, -61, -86, 68, 19, 38, 73, -122, 6, -103, -100, 66, 80, -12, -111, -17, -104, 122, 51, 84, 11, 67, -19, -49, -84, 98, -28, -77, 28, -87, -55, 8, -24, -107, -128, -33, -108, -6, 117, -113, 63, -90, 71, 7, -89, -4, -13, 115, 23, -70, -125, 89, 60, 25, -26, -123, 79, -88, 104, 107, -127, -78, 113, 100, -38, -117, -8, -21, 15, 75, 112, 86, -99, 53, 30, 36, 14, 94, 99, 88, -47, -94, 37, 34, 124, 59, 1, 33, 120, -121, -44, 0, 70, 87, -97, -45, 39, 82, 76, 54, 2, -25, -96, -60, -56, -98, -22, -65, -118, -46, 64, -57, 56, -75, -93, -9, -14, -50, -7, 97, 21, -95, -32, -82, 93, -92, -101, 52, 26, 85, -83, -109, 50, 48, -11, -116, -79, -29, 29, -10, -30, 46, -126, 102, -54, 96, -64, 41, 35, -85, 13, 83, 78, 111, -43, -37, 55, 69, -34, -3, -114, 47, 3, -1, 106, 114, 109, 108, 91, 81, -115, 27, -81, -110, -69, -35, -68, 127, 17, -39, 92, 65, 31, 16, 90, -40, 10, -63, 49, -120, -91, -51, 123, -67, 45, 116, -48, 18, -72, -27, -76, -80, -119, 105, -105, 74, 12, -106, 119, 126, 101, -71, -15, 9, -59, 110, -58, -124, 24, -16, 125, -20, 58, -36, 77, 32, 121, -18, 95, 62, -41, -53, 57, 72}; 10 11 public SM4() { 12 super(); 13 } 14 15 private long GET_ULONG_BE(byte[] arg7, int arg8) { 16 return (((long)(arg7[arg8] & 255))) << 24 | (((long)((arg7[arg8 + 1] & 255) << 16))) | (((long)((arg7[arg8 + 2] & 255) << 8))) | (((long)(arg7[arg8 + 3] & 255))) & 4294967295L; 17 } 18 19 private void PUT_ULONG_BE(long arg7, byte[] arg9, int arg10) { 20 arg9[arg10] = ((byte)(((int)(arg7 >> 24 & 255)))); 21 arg9[arg10 + 1] = ((byte)(((int)(arg7 >> 16 & 255)))); 22 arg9[arg10 + 2] = ((byte)(((int)(arg7 >> 8 & 255)))); 23 arg9[arg10 + 3] = ((byte)(((int)(arg7 & 255)))); 24 } 25 26 private long ROTL(long arg5, int arg7) { 27 return this.SHL(arg5, arg7) | arg5 >> 32 - arg7; 28 } 29 30 private long SHL(long arg3, int arg5) { 31 return (-1 & arg3) << arg5; 32 } 33 34 private void SWAP(long[] arg5, int arg6) { 35 long v0 = arg5[arg6]; 36 arg5[arg6] = arg5[31 - arg6]; 37 arg5[31 - arg6] = v0; 38 } 39 40 private byte[] padding(byte[] arg6, int arg7) { 41 int v1; 42 byte[] v0 = null; 43 if(arg6 == null) { 44 return v0; 45 } 46 47 if(arg7 == 1) { 48 v1 = 16 - arg6.length % 16; 49 v0 = new byte[arg6.length + v1]; 50 System.arraycopy(arg6, 0, v0, 0, arg6.length); 51 int v2; 52 for(v2 = 0; v2 < v1; ++v2) { 53 v0[arg6.length + v2] = ((byte)v1); 54 } 55 } 56 else { 57 v1 = arg6[arg6.length - 1]; 58 v0 = new byte[arg6.length - v1]; 59 System.arraycopy(arg6, 0, v0, 0, arg6.length - v1); 60 } 61 62 return v0; 63 } 64 65 private long sm4CalciRK(long arg11) { 66 byte[] v5 = new byte[4]; 67 byte[] v4 = new byte[4]; 68 this.PUT_ULONG_BE(arg11, v5, 0); 69 v4[0] = this.sm4Sbox(v5[0]); 70 v4[1] = this.sm4Sbox(v5[1]); 71 v4[2] = this.sm4Sbox(v5[2]); 72 v4[3] = this.sm4Sbox(v5[3]); 73 long v0 = this.GET_ULONG_BE(v4, 0); 74 return this.ROTL(v0, 13) ^ v0 ^ this.ROTL(v0, 23); 75 } 76 77 private long sm4F(long arg3, long arg5, long arg7, long arg9, long arg11) { 78 return this.sm4Lt(arg5 ^ arg7 ^ arg9 ^ arg11) ^ arg3; 79 } 80 81 private long sm4Lt(long arg11) { 82 byte[] v5 = new byte[4]; 83 byte[] v4 = new byte[4]; 84 this.PUT_ULONG_BE(arg11, v5, 0); 85 v4[0] = this.sm4Sbox(v5[0]); 86 v4[1] = this.sm4Sbox(v5[1]); 87 v4[2] = this.sm4Sbox(v5[2]); 88 v4[3] = this.sm4Sbox(v5[3]); 89 long v0 = this.GET_ULONG_BE(v4, 0); 90 return this.ROTL(v0, 2) ^ v0 ^ this.ROTL(v0, 10) ^ this.ROTL(v0, 18) ^ this.ROTL(v0, 24); 91 } 92 93 private byte sm4Sbox(byte arg3) { 94 return SM4.SboxTable[arg3 & 255]; 95 } 96 97 public byte[] sm4_crypt_cbc(SM4_Context arg13, byte[] arg14, byte[] arg15) throws Exception { 98 byte[] v8; 99 byte[] v6; 100 byte[] v2; 101 if(arg14 != null) { 102 int v1 = 16; 103 if(arg14.length == v1) { 104 if(arg15 != null) { 105 if((arg13.isPadding) && arg13.mode == 1) { 106 arg15 = this.padding(arg15, 1); 107 } 108 109 int v3 = arg15.length; 110 ByteArrayInputStream v4 = new ByteArrayInputStream(arg15); 111 ByteArrayOutputStream v5 = new ByteArrayOutputStream(); 112 if(arg13.mode == 1) { 113 while(v3 > 0) { 114 v2 = new byte[v1]; 115 v6 = new byte[v1]; 116 v8 = new byte[v1]; 117 v4.read(v2); 118 int v0; 119 for(v0 = 0; v0 < v1; ++v0) { 120 v6[v0] = ((byte)(v2[v0] ^ arg14[v0])); 121 } 122 123 this.sm4_one_round(arg13.sk, v6, v8); 124 System.arraycopy(v8, 0, arg14, 0, v1); 125 v5.write(v8); 126 v3 += -16; 127 } 128 } 129 else { 130 v2 = new byte[v1]; 131 while(v3 > 0) { 132 v6 = new byte[v1]; 133 v8 = new byte[v1]; 134 byte[] v9 = new byte[v1]; 135 v4.read(v6); 136 System.arraycopy(v6, 0, v2, 0, v1); 137 this.sm4_one_round(arg13.sk, v6, v8); 138 int v0; 139 for(v0 = 0; v0 < v1; ++v0) { 140 v9[v0] = ((byte)(v8[v0] ^ arg14[v0])); 141 } 142 143 System.arraycopy(v2, 0, arg14, 0, v1); 144 v5.write(v9); 145 v3 += -16; 146 } 147 } 148 149 byte[] v1_1 = v5.toByteArray(); 150 if((arg13.isPadding) && arg13.mode == 0) { 151 v1_1 = this.padding(v1_1, 0); 152 } 153 154 v4.close(); 155 v5.close(); 156 return v1_1; 157 } 158 else { 159 throw new Exception("input is null!"); 160 } 161 } 162 } 163 164 throw new Exception("iv error!"); 165 } 166 167 public byte[] sm4_crypt_ecb(SM4_Context arg7, byte[] arg8) throws Exception { 168 byte[] v3; 169 if(arg8 != null) { 170 if((arg7.isPadding) && arg7.mode == 1) { 171 arg8 = this.padding(arg8, 1); 172 } 173 174 int v0 = arg8.length; 175 ByteArrayInputStream v1 = new ByteArrayInputStream(arg8); 176 ByteArrayOutputStream v2 = new ByteArrayOutputStream(); 177 while(v0 > 0) { 178 byte[] v4 = new byte[16]; 179 v3 = new byte[16]; 180 v1.read(v4); 181 this.sm4_one_round(arg7.sk, v4, v3); 182 v2.write(v3); 183 v0 += -16; 184 } 185 186 v3 = v2.toByteArray(); 187 if((arg7.isPadding) && arg7.mode == 0) { 188 v3 = this.padding(v3, 0); 189 } 190 191 v1.close(); 192 v2.close(); 193 return v3; 194 } 195 196 throw new Exception("input is null!"); 197 } 198 199 private void sm4_one_round(long[] arg23, byte[] arg24, byte[] arg25) { 200 int v0; 201 SM4 v11 = this; 202 byte[] v13 = arg25; 203 long[] v14 = new long[36]; 204 v14[0] = v11.GET_ULONG_BE(arg24, 0); 205 v14[1] = v11.GET_ULONG_BE(arg24, 4); 206 v14[2] = v11.GET_ULONG_BE(arg24, 8); 207 v14[3] = v11.GET_ULONG_BE(arg24, 12); 208 int v8; 209 for(v8 = 0; true; ++v8) { 210 v0 = 32; 211 if(v8 >= v0) { 212 break; 213 } 214 215 v14[v8 + 4] = this.sm4F(v14[v8], v14[v8 + 1], v14[v8 + 2], v14[v8 + 3], arg23[v8]); 216 } 217 218 v11.PUT_ULONG_BE(v14[35], v13, 0); 219 v11.PUT_ULONG_BE(v14[34], v13, 4); 220 v11.PUT_ULONG_BE(v14[33], v13, 8); 221 v11.PUT_ULONG_BE(v14[v0], v13, 12); 222 } 223 224 private void sm4_setkey(long[] arg13, byte[] arg14) { 225 long[] v1 = new long[4]; 226 long[] v2 = new long[36]; 227 int v3 = 0; 228 v1[0] = this.GET_ULONG_BE(arg14, 0); 229 v1[1] = this.GET_ULONG_BE(arg14, 4); 230 v1[2] = this.GET_ULONG_BE(arg14, 8); 231 v1[3] = this.GET_ULONG_BE(arg14, 12); 232 long v5 = v1[0]; 233 int[] v9 = SM4.FK; 234 v2[0] = v5 ^ (((long)v9[0])); 235 v2[1] = v1[1] ^ (((long)v9[1])); 236 v2[2] = v1[2] ^ (((long)v9[2])); 237 v2[3] = v1[3] ^ (((long)v9[3])); 238 while(v3 < 32) { 239 v2[v3 + 4] = v2[v3] ^ this.sm4CalciRK(v2[v3 + 1] ^ v2[v3 + 2] ^ v2[v3 + 3] ^ (((long)SM4.CK[v3]))); 240 arg13[v3] = v2[v3 + 4]; 241 ++v3; 242 } 243 } 244 245 public void sm4_setkey_dec(SM4_Context arg4, byte[] arg5) throws Exception { 246 if(arg4 != null) { 247 if(arg5 != null) { 248 int v1 = 16; 249 if(arg5.length == v1) { 250 arg4.mode = 0; 251 this.sm4_setkey(arg4.sk, arg5); 252 int v0; 253 for(v0 = 0; v0 < v1; ++v0) { 254 this.SWAP(arg4.sk, v0); 255 } 256 257 return; 258 } 259 } 260 261 throw new Exception("key error!"); 262 } 263 264 throw new Exception("ctx is null!"); 265 } 266 267 public void sm4_setkey_enc(SM4_Context arg3, byte[] arg4) throws Exception { 268 if(arg3 != null) { 269 if(arg4 != null && arg4.length == 16) { 270 arg3.mode = 1; 271 this.sm4_setkey(arg3.sk, arg4); 272 return; 273 } 274 275 throw new Exception("key error!"); 276 } 277 278 throw new Exception("ctx is null!"); 279 } 280 }
SM4_Context:
1 public class SM4_Context { 2 public boolean isPadding; 3 public int mode; 4 public long[] sk; 5 6 public SM4_Context() { 7 super(); 8 this.mode = 1; 9 this.isPadding = true; 10 this.sk = new long[32]; 11 } 12 }
SM4Util:
1 import org.apache.commons.codec.binary.Base64; 2 3 import java.io.IOException; 4 import java.io.PrintStream; 5 import java.util.regex.Pattern; 6 7 public class SM4Utils { 8 public static final String KEY = "你的key"; 9 public static final String IV = "你的IV"; 10 public boolean hexString; 11 public String iv; 12 public String secretKey; 13 14 public SM4Utils() { 15 super(); 16 this.secretKey = ""; 17 this.iv = ""; 18 this.hexString = false; 19 } 20 21 public static String sm4Decrypt(String mes) { 22 SM4Utils v0 = new SM4Utils(); 23 v0.secretKey = KEY; 24 v0.iv = IV; 25 v0.hexString = true; 26 return v0.decryptData_CBC(mes); 27 } 28 29 public static String sm4Encrypt(String mes) { 30 SM4Utils v0 = new SM4Utils(); 31 v0.secretKey = KEY; 32 v0.iv = IV; 33 v0.hexString = true; 34 return v0.encryptData_CBC(mes); 35 } 36 37 public String decryptData_CBC(String arg9) { 38 byte[] v3; 39 byte[] v2; 40 try { 41 arg9 = Base64.encodeBase64String(Util.hexToByte(arg9)); 42 if(arg9 != null && arg9.trim().length() > 0) { 43 arg9 = Pattern.compile("\\s*|\t|\r|\n").matcher(((CharSequence)arg9)).replaceAll(""); 44 } 45 46 SM4_Context v1 = new SM4_Context(); 47 v1.isPadding = true; 48 v1.mode = 0; 49 if(this.hexString) { 50 v2 = Util.hexStringToBytes(this.secretKey); 51 v3 = Util.hexStringToBytes(this.iv); 52 } 53 else { 54 v2 = this.secretKey.getBytes(); 55 v3 = this.iv.getBytes(); 56 } 57 58 SM4 v4 = new SM4(); 59 v4.sm4_setkey_dec(v1, v2); 60 return new String(v4.sm4_crypt_cbc(v1, v3, Base64.decodeBase64(arg9)), "UTF-8"); 61 } 62 catch(Exception v0) { 63 v0.printStackTrace(); 64 return null; 65 } 66 } 67 68 public String encryptData_CBC(String arg7) { 69 byte[] v2; 70 byte[] v1; 71 try { 72 SM4_Context v0_1 = new SM4_Context(); 73 v0_1.isPadding = true; 74 v0_1.mode = 1; 75 if(this.hexString) { 76 v1 = Util.hexStringToBytes(this.secretKey); 77 v2 = Util.hexStringToBytes(this.iv); 78 } 79 else { 80 v1 = this.secretKey.getBytes(); 81 v2 = this.iv.getBytes(); 82 } 83 84 SM4 v3 = new SM4(); 85 v3.sm4_setkey_enc(v0_1, v1); 86 return Util.byteToHex(v3.sm4_crypt_cbc(v0_1, v2, arg7.getBytes("UTF-8"))); 87 } 88 catch(Exception v0) { 89 v0.printStackTrace(); 90 return null; 91 } 92 } 93 94 public String decryptData_ECB(String arg8) { 95 try { 96 arg8 = Base64.encodeBase64String(Util.hexToByte(arg8)); 97 if(arg8 != null && arg8.trim().length() > 0) { 98 arg8 = Pattern.compile("\\s*|\t|\r|\n").matcher(((CharSequence)arg8)).replaceAll(""); 99 } 100 101 SM4_Context v1 = new SM4_Context(); 102 v1.isPadding = true; 103 v1.mode = 0; 104 byte[] v2 = this.hexString ? Util.hexStringToBytes(this.secretKey) : this.secretKey.getBytes(); 105 SM4 v3 = new SM4(); 106 v3.sm4_setkey_dec(v1, v2); 107 return new String(v3.sm4_crypt_ecb(v1, Base64.decodeBase64(arg8)), "UTF-8"); 108 } 109 catch(Exception v0) { 110 v0.printStackTrace(); 111 return null; 112 } 113 } 114 115 public String encryptData_ECB(String arg6) { 116 try { 117 SM4_Context v0_1 = new SM4_Context(); 118 v0_1.isPadding = true; 119 v0_1.mode = 1; 120 byte[] v1 = this.hexString ? Util.hexStringToBytes(this.secretKey) : Util.hexStringToBytes(this.secretKey); 121 SM4 v2 = new SM4(); 122 v2.sm4_setkey_enc(v0_1, v1); 123 return Util.byteToHex(v2.sm4_crypt_ecb(v0_1, arg6.getBytes("UTF-8"))); 124 } 125 catch(Exception v0) { 126 v0.printStackTrace(); 127 return null; 128 } 129 } 130 131 }
需要导入的jar：
链接:https://pan.baidu.com/s/1ywPfsQvWAyN8UHRXoAHodw 密码:x1gy
