国密算法Java代码的标准实现

 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 }

  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 }

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 }

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 }

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 }

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 }

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 }

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 }

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*|	|
|
").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*|	|
|
").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 }

  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*|	|
|
").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*|	|
|
").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 }