SM4对称加密算法及Java实现

文章来源：https://www.jianshu.com/p/5ec8464b0a1b

一、简介

  • 与DES和AES算法类似，SM4算法是一种分组密码算法。

  • 其分组长度为128bit，密钥长度也为128bit。

  • 加密算法与密钥扩展算法均采用32轮非线性迭代结构，以字（32位）为单位进行加密运算，每一次迭代运算均为一轮变换函数F。

  • SM4算法加/解密算法的结构相同，只是使用轮密钥相反，其中解密轮密钥是加密轮密钥的逆序。

二、原理

首先，将明文转化为字节，由于SM4加密算法按照128个位进行分组，所以很大几率会出现最后一个分组不够128位的情况，需要进行填充，填充方式有很多，比如ZeroPadding、PKCS7Padding、PKCS5Padding，不管使用哪种方式，最后每个分组都是128位。然后对每个分组执行上面的操作，每个分组按照32位一个字分成四个字，根据一定的规则计算出下一轮的结果。进行32轮的计算，最后将加密的结果逆序之后就可以了。

解密时只是将轮密钥的使用顺序进行逆向进行。

三、ECB模式与CBC模式

1、ECB模式

  • 电子密码本模式，最古老，最简单的模式，将加密的数据分成若干组，每组的大小跟加密密钥相同。不足的部分进行填充。
  • 按照顺序将计算所得的数据连在一起即可，各段数据之间互不影响。

•优点：

•简单

•有利于并行计算

•误差不会被传递

•缺点：

•不能隐藏明文的模式

•可能对明文进行主动攻击

2、CBC模式

  • 密文分组链接模式，也需要进行分组，不足的部分按照指定的数据进行填充。
  • 需要一个初始化向量，每个分组数据与上一个分组数据加密的结果进行异或运算，最后再进行加密。将所有分组加密的结果连接起来就形成了最终的结果。

•优点：

•不容易进行主动攻击

•安全性好于ECB

•缺点：

•不利于并行计算

•误差传递

•需要初始化向量

四、三种填充方式的比较

某些加密算法要求明文需要按一定长度对齐，叫做块大小(BlockSize)，比如16字节，那么对于一段任意的数据，加密前需要对最后一个块填充到16 字节，解密后需要删除掉填充的数据。

ZeroPadding，数据长度不对齐时使用0填充，否则不填充。

PKCS7Padding，假设数据长度需要填充n(n>0)个字节才对齐，那么填充n个字节，每个字节都是n;如果数据本身就已经对齐了，则填充一块长度为块大小的数据，每个字节都是块大小。

PKCS5Padding，PKCS7Padding的子集，块大小固定为8字节。

由于使用PKCS7Padding/PKCS5Padding填充时，最后一个字节肯定为填充数据的长度，所以在解密后可以准确删除填充的数据，而使用ZeroPadding填充时，没办法区分真实数据与填充数据，所以只适合以\0结尾的字符串加解密。

五、代码实现

SM4.java

import Util;import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.Arrays;public class SM4 {public static final int SM4_ENCRYPT = 1;public static final int SM4_DECRYPT = 0;private long GET_ULONG_BE(byte[] b, int i) {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;return n;}private void PUT_ULONG_BE(long n, byte[] b, int i) {b[i] = (byte) (int) (0xFF & n >> 24);b[i + 1] = (byte) (int) (0xFF & n >> 16);b[i + 2] = (byte) (int) (0xFF & n >> 8);b[i + 3] = (byte) (int) (0xFF & n);}private long SHL(long x, int n) {return (x & 0xFFFFFFFF) << n;}private long ROTL(long x, int n) {return SHL(x, n) | x >> (32 - n);}private void SWAP(long[] sk, int i) {long t = sk[i];sk[i] = sk[(31 - i)];sk[(31 - i)] = t;}public static final byte[] SboxTable = {(byte) 0xd6, (byte) 0x90, (byte) 0xe9, (byte) 0xfe,(byte) 0xcc, (byte) 0xe1, 0x3d, (byte) 0xb7, 0x16, (byte) 0xb6,0x14, (byte) 0xc2, 0x28, (byte) 0xfb, 0x2c, 0x05, 0x2b, 0x67,(byte) 0x9a, 0x76, 0x2a, (byte) 0xbe, 0x04, (byte) 0xc3,(byte) 0xaa, 0x44, 0x13, 0x26, 0x49, (byte) 0x86, 0x06,(byte) 0x99, (byte) 0x9c, 0x42, 0x50, (byte) 0xf4, (byte) 0x91,(byte) 0xef, (byte) 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43,(byte) 0xed, (byte) 0xcf, (byte) 0xac, 0x62, (byte) 0xe4,(byte) 0xb3, 0x1c, (byte) 0xa9, (byte) 0xc9, 0x08, (byte) 0xe8,(byte) 0x95, (byte) 0x80, (byte) 0xdf, (byte) 0x94, (byte) 0xfa,0x75, (byte) 0x8f, 0x3f, (byte) 0xa6, 0x47, 0x07, (byte) 0xa7,(byte) 0xfc, (byte) 0xf3, 0x73, 0x17, (byte) 0xba, (byte) 0x83,0x59, 0x3c, 0x19, (byte) 0xe6, (byte) 0x85, 0x4f, (byte) 0xa8,0x68, 0x6b, (byte) 0x81, (byte) 0xb2, 0x71, 0x64, (byte) 0xda,(byte) 0x8b, (byte) 0xf8, (byte) 0xeb, 0x0f, 0x4b, 0x70, 0x56,(byte) 0x9d, 0x35, 0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, (byte) 0xd1,(byte) 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, (byte) 0x87,(byte) 0xd4, 0x00, 0x46, 0x57, (byte) 0x9f, (byte) 0xd3, 0x27,0x52, 0x4c, 0x36, 0x02, (byte) 0xe7, (byte) 0xa0, (byte) 0xc4,(byte) 0xc8, (byte) 0x9e, (byte) 0xea, (byte) 0xbf, (byte) 0x8a,(byte) 0xd2, 0x40, (byte) 0xc7, 0x38, (byte) 0xb5, (byte) 0xa3,(byte) 0xf7, (byte) 0xf2, (byte) 0xce, (byte) 0xf9, 0x61, 0x15,(byte) 0xa1, (byte) 0xe0, (byte) 0xae, 0x5d, (byte) 0xa4,(byte) 0x9b, 0x34, 0x1a, 0x55, (byte) 0xad, (byte) 0x93, 0x32,0x30, (byte) 0xf5, (byte) 0x8c, (byte) 0xb1, (byte) 0xe3, 0x1d,(byte) 0xf6, (byte) 0xe2, 0x2e, (byte) 0x82, 0x66, (byte) 0xca,0x60, (byte) 0xc0, 0x29, 0x23, (byte) 0xab, 0x0d, 0x53, 0x4e, 0x6f,(byte) 0xd5, (byte) 0xdb, 0x37, 0x45, (byte) 0xde, (byte) 0xfd,(byte) 0x8e, 0x2f, 0x03, (byte) 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b,0x51, (byte) 0x8d, 0x1b, (byte) 0xaf, (byte) 0x92, (byte) 0xbb,(byte) 0xdd, (byte) 0xbc, 0x7f, 0x11, (byte) 0xd9, 0x5c, 0x41,0x1f, 0x10, 0x5a, (byte) 0xd8, 0x0a, (byte) 0xc1, 0x31,(byte) 0x88, (byte) 0xa5, (byte) 0xcd, 0x7b, (byte) 0xbd, 0x2d,0x74, (byte) 0xd0, 0x12, (byte) 0xb8, (byte) 0xe5, (byte) 0xb4,(byte) 0xb0, (byte) 0x89, 0x69, (byte) 0x97, 0x4a, 0x0c,(byte) 0x96, 0x77, 0x7e, 0x65, (byte) 0xb9, (byte) 0xf1, 0x09,(byte) 0xc5, 0x6e, (byte) 0xc6, (byte) 0x84, 0x18, (byte) 0xf0,0x7d, (byte) 0xec, 0x3a, (byte) 0xdc, 0x4d, 0x20, 0x79,(byte) 0xee, 0x5f, 0x3e, (byte) 0xd7, (byte) 0xcb, 0x39, 0x48};public static final int[] FK = {0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc};public static final int[] CK = {0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279};private byte sm4Sbox(byte inch) {int i = inch & 0xFF;byte retVal = SboxTable[i];return retVal;}private long sm4Lt(long ka) {long bb = 0L;long c = 0L;byte[] a = new byte[4];byte[] b = new byte[4];PUT_ULONG_BE(ka, a, 0);b[0] = sm4Sbox(a[0]);b[1] = sm4Sbox(a[1]);b[2] = sm4Sbox(a[2]);b[3] = sm4Sbox(a[3]);bb = GET_ULONG_BE(b, 0);c = bb ^ ROTL(bb, 2) ^ ROTL(bb, 10) ^ ROTL(bb, 18) ^ ROTL(bb, 24);return c;}private long sm4F(long x0, long x1, long x2, long x3, long rk) {return x0 ^ sm4Lt(x1 ^ x2 ^ x3 ^ rk);}private long sm4CalciRK(long ka) {long bb = 0L;long rk = 0L;byte[] a = new byte[4];byte[] b = new byte[4];PUT_ULONG_BE(ka, a, 0);b[0] = sm4Sbox(a[0]);b[1] = sm4Sbox(a[1]);b[2] = sm4Sbox(a[2]);b[3] = sm4Sbox(a[3]);bb = GET_ULONG_BE(b, 0);rk = bb ^ ROTL(bb, 13) ^ ROTL(bb, 23);return rk;}private void sm4_setkey(long[] SK, byte[] key) {long[] MK = new long[4];long[] k = new long[36];int i = 0;MK[0] = GET_ULONG_BE(key, 0);MK[1] = GET_ULONG_BE(key, 4);MK[2] = GET_ULONG_BE(key, 8);MK[3] = GET_ULONG_BE(key, 12);k[0] = MK[0] ^ (long) FK[0];k[1] = MK[1] ^ (long) FK[1];k[2] = MK[2] ^ (long) FK[2];k[3] = MK[3] ^ (long) FK[3];for (; i < 32; i++) {k[(i + 4)] = (k[i] ^ sm4CalciRK(k[(i + 1)] ^ k[(i + 2)] ^ k[(i + 3)] ^ (long) CK[i]));SK[i] = k[(i + 4)];}}private void sm4_one_round(long[] sk, byte[] input, byte[] output) {int i = 0;long[] ulbuf = new long[36];ulbuf[0] = GET_ULONG_BE(input, 0);ulbuf[1] = GET_ULONG_BE(input, 4);ulbuf[2] = GET_ULONG_BE(input, 8);ulbuf[3] = GET_ULONG_BE(input, 12);while (i < 32) {ulbuf[(i + 4)] = sm4F(ulbuf[i], ulbuf[(i + 1)], ulbuf[(i + 2)], ulbuf[(i + 3)], sk[i]);i++;}PUT_ULONG_BE(ulbuf[35], output, 0);PUT_ULONG_BE(ulbuf[34], output, 4);PUT_ULONG_BE(ulbuf[33], output, 8);PUT_ULONG_BE(ulbuf[32], output, 12);}public static byte[] PKCS5Padding(byte[] inputByte) {// 获字节长度int length = inputByte.length;// 补齐位数int leftLength = 16 - (length % 16);// 定义新字节byte[] arrayReturn = new byte[length + leftLength];// 定义填充字节byte[] plusbyte = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,0x0f,0x10 };// 是否满足为16字节倍数//if (leftLength < 16) {// 不满足16倍数自动填充for (int i = 0; i < length + leftLength; i++) {if (i < length) {// 赋值arrayReturn[i] = inputByte[i];} else {// 补齐位数arrayReturn[i] = (byte)leftLength;}}// System.out.println("填充的字节："+plusbyte[leftLength]);
//        } else {
//            for (int i = 0; i < length + 16; i++) {
//                if (i < length) {
//                    // 赋值
//                    arrayReturn[i] = inputByte[i];
//                } else {
//                    // 补齐位数
//                    arrayReturn[i] = (byte)16;
//                }
//            }
//        }return arrayReturn;}public static byte[] PKCS7PaddingRestore(byte[] paramArray) throws Exception {//try {// 定义是否需要消除填充数据//boolean needRestore = true;int length = paramArray.length;// 获取字节长度// 拆分并获取最后一组16倍数数值byte[] paramByteLast = Arrays.copyOfRange(paramArray, length - 16, length);// 获取最后一个字节byte byteLast = paramByteLast[paramByteLast.length - 1];return Arrays.copyOfRange(paramArray,0,length-byteLast);
//            // 开始填充字节位置
//            int paddingNum = paramByteLast.length - byteLast;
//            if (paddingNum > 0) {
//               // 判断数组字节位数的字节是否与最后字节相等
//               for (int i = paddingNum; i < paramByteLast.length; i++) {
//                  byte paramSon = paramByteLast[i];
//                  if (byteLast != paramSon) {
//                     needRestore = false;
//                  }
//               }
//            } else {
//               needRestore = false;
//            }
//            if (needRestore) {
//               // 组合新数组并返回
//               byte[] resultArray = Arrays.copyOfRange(paramArray, 0, length - byteLast);
//               return resultArray;
//            }
//            return paramArray;
//         } catch (Exception e) {
//            throw new Exception("数据异常，字节填充还原错误，异常抛出！" + e.getMessage());
//         }}//修改了填充模式,为模式private byte[] padding(byte[] input, int mode) {byte[] ret = (byte[]) null;if (mode == SM4_ENCRYPT) {//填充:hex必须是32的整数倍填充 ,填充的是80  00 00 00
//            int p = 16 - input.length % 16;
//            String inputHex = Util.byteToHex(input)+ "80";
//            StringBuffer stringBuffer =new StringBuffer(inputHex);
//            for (int i = 0; i <p-1 ; i++) {
//                stringBuffer.append("00");
//            }
//            ret= Util.hexToByte(stringBuffer.toString());try {ret = PKCS5Padding(input);} catch (Exception e) {e.printStackTrace();}//ret = new byte[input.length + p];/*System.arraycopy(input, 0, ret, 0, input.length);for (int i = 0; i < p; i++) {ret[input.length + i] = (byte) '�';}*/} else {/*int p = input[input.length - 1];ret = new byte[input.length - p];System.arraycopy(input, 0, ret, 0, input.length - p);*///            String inputHex =Util.byteToHex(input);
//            int i = inputHex.lastIndexOf("80");
//            String substring = inputHex.substring(0, i);
//            ret= Util.hexToByte(substring);try {ret = PKCS7PaddingRestore(input);} catch (Exception e) {e.printStackTrace();}}return ret;}public void sm4_setkey_enc(SM4_Context ctx, byte[] key) throws Exception {if (ctx == null) {throw new Exception("ctx is null!");}if (key == null || key.length != 16) {throw new Exception("key error!");}ctx.mode = SM4_ENCRYPT;sm4_setkey(ctx.sk, key);}public void sm4_setkey_dec(SM4_Context ctx, byte[] key) throws Exception {if (ctx == null) {throw new Exception("ctx is null!");}if (key == null || key.length != 16) {throw new Exception("key error!");}int i = 0;ctx.mode = SM4_DECRYPT;sm4_setkey(ctx.sk, key);for (i = 0; i < 16; i++) {SWAP(ctx.sk, i);}}public byte[] sm4_crypt_ecb(SM4_Context ctx, byte[] input) throws Exception {if (input == null) {throw new Exception("input is null!");}if ((ctx.isPadding) && (ctx.mode == SM4_ENCRYPT)) {input = padding(input, SM4_ENCRYPT);}int length = input.length;ByteArrayInputStream bins = new ByteArrayInputStream(input);ByteArrayOutputStream bous = new ByteArrayOutputStream();for (; length > 0; length -= 16) {byte[] in = new byte[16];byte[] out = new byte[16];bins.read(in);sm4_one_round(ctx.sk, in, out);bous.write(out);}byte[] output = bous.toByteArray();if (ctx.isPadding && ctx.mode == SM4_DECRYPT) {output = padding(output, SM4_DECRYPT);}bins.close();bous.close();return output;}public byte[] sm4_crypt_cbc(SM4_Context ctx, byte[] iv, byte[] input) throws Exception {if (iv == null || iv.length != 16) {throw new Exception("iv error!");}if (input == null) {throw new Exception("input is null!");}if (ctx.isPadding && ctx.mode == SM4_ENCRYPT) {input = padding(input, SM4_ENCRYPT);}int i = 0;int length = input.length;ByteArrayInputStream bins = new ByteArrayInputStream(input);ByteArrayOutputStream bous = new ByteArrayOutputStream();if (ctx.mode == SM4_ENCRYPT) {for (; length > 0; length -= 16) {byte[] in = new byte[16];byte[] out = new byte[16];byte[] out1 = new byte[16];bins.read(in);for (i = 0; i < 16; i++) {out[i] = ((byte) (in[i] ^ iv[i]));}sm4_one_round(ctx.sk, out, out1);System.arraycopy(out1, 0, iv, 0, 16);bous.write(out1);}} else {byte[] temp = new byte[16];for (; length > 0; length -= 16) {byte[] in = new byte[16];byte[] out = new byte[16];byte[] out1 = new byte[16];bins.read(in);System.arraycopy(in, 0, temp, 0, 16);sm4_one_round(ctx.sk, in, out);for (i = 0; i < 16; i++) {out1[i] = ((byte) (out[i] ^ iv[i]));}System.arraycopy(temp, 0, iv, 0, 16);bous.write(out1);}}byte[] output = bous.toByteArray();if (ctx.isPadding && ctx.mode == SM4_DECRYPT) {output = padding(output, SM4_DECRYPT);}bins.close();bous.close();return output;}
}

SM4_Context.java

/*** Created by $(USER) on $(DATE)*/
public class SM4_Context {public int mode;public long[] sk;public boolean isPadding;public SM4_Context(){this.mode = 1;this.isPadding = true;this.sk = new long[32];}
}

Util.java

package cn.xjfme.encrypt.utils;import java.math.BigInteger;public class Util {/*** 整形转换成网络传输的字节流（字节数组）型数据** @param num 一个整型数据* @return 4个字节的自己数组*/public static byte[] intToBytes(int num) {byte[] bytes = new byte[4];bytes[0] = (byte) (0xff & (num >> 0));bytes[1] = (byte) (0xff & (num >> 8));bytes[2] = (byte) (0xff & (num >> 16));bytes[3] = (byte) (0xff & (num >> 24));return bytes;}/*** 四个字节的字节数据转换成一个整形数据** @param bytes 4个字节的字节数组* @return 一个整型数据*/public static int byteToInt(byte[] bytes) {int num = 0;int temp;temp = (0x000000ff & (bytes[0])) << 0;num = num | temp;temp = (0x000000ff & (bytes[1])) << 8;num = num | temp;temp = (0x000000ff & (bytes[2])) << 16;num = num | temp;temp = (0x000000ff & (bytes[3])) << 24;num = num | temp;return num;}/*** 长整形转换成网络传输的字节流（字节数组）型数据** @param num 一个长整型数据* @return 4个字节的自己数组*/public static byte[] longToBytes(long num) {byte[] bytes = new byte[8];for (int i = 0; i < 8; i++) {bytes[i] = (byte) (0xff & (num >> (i * 8)));}return bytes;}/*** 大数字转换字节流（字节数组）型数据** @param n* @return*/public static byte[] byteConvert32Bytes(BigInteger n) {byte tmpd[] = (byte[]) null;if (n == null) {return null;}if (n.toByteArray().length == 33) {tmpd = new byte[32];System.arraycopy(n.toByteArray(), 1, tmpd, 0, 32);} else if (n.toByteArray().length == 32) {tmpd = n.toByteArray();} else {tmpd = new byte[32];for (int i = 0; i < 32 - n.toByteArray().length; i++) {tmpd[i] = 0;}System.arraycopy(n.toByteArray(), 0, tmpd, 32 - n.toByteArray().length, n.toByteArray().length);}return tmpd;}/*** 换字节流（字节数组）型数据转大数字** @param b* @return*/public static BigInteger byteConvertInteger(byte[] b) {if (b[0] < 0) {byte[] temp = new byte[b.length + 1];temp[0] = 0;System.arraycopy(b, 0, temp, 1, b.length);return new BigInteger(temp);}return new BigInteger(b);}/*** 根据字节数组获得值(十六进制数字)** @param bytes* @return*/public static String getHexString(byte[] bytes) {return getHexString(bytes, true);}/*** 根据字节数组获得值(十六进制数字)** @param bytes* @param upperCase* @return*/public static String getHexString(byte[] bytes, boolean upperCase) {String ret = "";for (int i = 0; i < bytes.length; i++) {ret += Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1);}return upperCase ? ret.toUpperCase() : ret;}/*** 打印十六进制字符串** @param bytes*/public static void printHexString(byte[] bytes) {for (int i = 0; i < bytes.length; i++) {String hex = Integer.toHexString(bytes[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}System.out.print("0x" + hex.toUpperCase() + ",");}System.out.println("");}/*** Convert hex string to byte[]** @param hexString the hex string* @return byte[]*/public static byte[] hexStringToBytes(String hexString) {if (hexString == null || hexString.equals("")) {return null;}hexString = hexString.toUpperCase();int length = hexString.length() / 2;char[] hexChars = hexString.toCharArray();byte[] d = new byte[length];for (int i = 0; i < length; i++) {int pos = i * 2;d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));}return d;}/*** Convert char to byte** @param c char* @return byte*/public static byte charToByte(char c) {return (byte) "0123456789ABCDEF".indexOf(c);}/*** 用于建立十六进制字符的输出的小写字符数组*/private static final char[] DIGITS_LOWER = {'0', '1', '2', '3', '4', '5','6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};/*** 用于建立十六进制字符的输出的大写字符数组*/private static final char[] DIGITS_UPPER = {'0', '1', '2', '3', '4', '5','6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};/*** 将字节数组转换为十六进制字符数组** @param data byte[]* @return 十六进制char[]*/public static char[] encodeHex(byte[] data) {return encodeHex(data, true);}/*** 将字节数组转换为十六进制字符数组** @param data        byte[]* @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式* @return 十六进制char[]*/public static char[] encodeHex(byte[] data, boolean toLowerCase) {return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);}/*** 将字节数组转换为十六进制字符数组** @param data     byte[]* @param toDigits 用于控制输出的char[]* @return 十六进制char[]*/protected static char[] encodeHex(byte[] data, char[] toDigits) {int l = data.length;char[] out = new char[l << 1];// two characters form the hex value.for (int i = 0, j = 0; i < l; i++) {out[j++] = toDigits[(0xF0 & data[i]) >>> 4];out[j++] = toDigits[0x0F & data[i]];}return out;}/*** 将字节数组转换为十六进制字符串** @param data byte[]* @return 十六进制String*/public static String encodeHexString(byte[] data) {return encodeHexString(data, true);}/*** 将字节数组转换为十六进制字符串** @param data        byte[]* @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式* @return 十六进制String*/public static String encodeHexString(byte[] data, boolean toLowerCase) {return encodeHexString(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);}/*** 将字节数组转换为十六进制字符串** @param data     byte[]* @param toDigits 用于控制输出的char[]* @return 十六进制String*/protected static String encodeHexString(byte[] data, char[] toDigits) {return new String(encodeHex(data, toDigits));}/*** 将十六进制字符数组转换为字节数组** @param data 十六进制char[]* @return byte[]* @throws RuntimeException 如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常*/public static byte[] decodeHex(char[] data) {int len = data.length;if ((len & 0x01) != 0) {throw new RuntimeException("Odd number of characters.");}byte[] out = new byte[len >> 1];// two characters form the hex value.for (int i = 0, j = 0; j < len; i++) {int f = toDigit(data[j], j) << 4;j++;f = f | toDigit(data[j], j);j++;out[i] = (byte) (f & 0xFF);}return out;}/*** 将十六进制字符转换成一个整数** @param ch    十六进制char* @param index 十六进制字符在字符数组中的位置* @return 一个整数* @throws RuntimeException 当ch不是一个合法的十六进制字符时，抛出运行时异常*/protected static int toDigit(char ch, int index) {int digit = Character.digit(ch, 16);if (digit == -1) {throw new RuntimeException("Illegal hexadecimal character " + ch+ " at index " + index);}return digit;}/*** 数字字符串转ASCII码字符串** @param String 字符串* @return ASCII字符串*/public static String StringToAsciiString(String content) {String result = "";int max = content.length();for (int i = 0; i < max; i++) {char c = content.charAt(i);String b = Integer.toHexString(c);result = result + b;}return result;}/*** 十六进制转字符串** @param hexString  十六进制字符串* @param encodeType 编码类型4：Unicode，2：普通编码* @return 字符串*/public static String hexStringToString(String hexString, int encodeType) {String result = "";int max = hexString.length() / encodeType;for (int i = 0; i < max; i++) {char c = (char) hexStringToAlgorism(hexString.substring(i * encodeType, (i + 1) * encodeType));result += c;}return result;}/*** 十六进制字符串装十进制** @param hex 十六进制字符串* @return 十进制数值*/public static int hexStringToAlgorism(String hex) {hex = hex.toUpperCase();int max = hex.length();int result = 0;for (int i = max; i > 0; i--) {char c = hex.charAt(i - 1);int algorism = 0;if (c >= '0' && c <= '9') {algorism = c - '0';} else {algorism = c - 55;}result += Math.pow(16, max - i) * algorism;}return result;}/*** 十六转二进制** @param hex 十六进制字符串* @return 二进制字符串*/public static String hexStringToBinary(String hex) {hex = hex.toUpperCase();String result = "";int max = hex.length();for (int i = 0; i < max; i++) {char c = hex.charAt(i);switch (c) {case '0':result += "0000";break;case '1':result += "0001";break;case '2':result += "0010";break;case '3':result += "0011";break;case '4':result += "0100";break;case '5':result += "0101";break;case '6':result += "0110";break;case '7':result += "0111";break;case '8':result += "1000";break;case '9':result += "1001";break;case 'A':result += "1010";break;case 'B':result += "1011";break;case 'C':result += "1100";break;case 'D':result += "1101";break;case 'E':result += "1110";break;case 'F':result += "1111";break;}}return result;}/*** ASCII码字符串转数字字符串** @param String ASCII字符串* @return 字符串*/public static String AsciiStringToString(String content) {String result = "";int length = content.length() / 2;for (int i = 0; i < length; i++) {String c = content.substring(i * 2, i * 2 + 2);int a = hexStringToAlgorism(c);char b = (char) a;String d = String.valueOf(b);result += d;}return result;}/*** 将十进制转换为指定长度的十六进制字符串** @param algorism  int 十进制数字* @param maxLength int 转换后的十六进制字符串长度* @return String 转换后的十六进制字符串*/public static String algorismToHexString(int algorism, int maxLength) {String result = "";result = Integer.toHexString(algorism);if (result.length() % 2 == 1) {result = "0" + result;}return patchHexString(result.toUpperCase(), maxLength);}/*** 字节数组转为普通字符串（ASCII对应的字符）** @param bytearray byte[]* @return String*/public static String byteToString(byte[] bytearray) {String result = "";char temp;int length = bytearray.length;for (int i = 0; i < length; i++) {temp = (char) bytearray[i];result += temp;}return result;}/*** 二进制字符串转十进制** @param binary 二进制字符串* @return 十进制数值*/public static int binaryToAlgorism(String binary) {int max = binary.length();int result = 0;for (int i = max; i > 0; i--) {char c = binary.charAt(i - 1);int algorism = c - '0';result += Math.pow(2, max - i) * algorism;}return result;}/*** 十进制转换为十六进制字符串** @param algorism int 十进制的数字* @return String 对应的十六进制字符串*/public static String algorismToHEXString(int algorism) {String result = "";result = Integer.toHexString(algorism);if (result.length() % 2 == 1) {result = "0" + result;}result = result.toUpperCase();return result;}/*** HEX字符串前补0，主要用于长度位数不足。** @param str       String 需要补充长度的十六进制字符串* @param maxLength int 补充后十六进制字符串的长度* @return 补充结果*/static public String patchHexString(String str, int maxLength) {String temp = "";for (int i = 0; i < maxLength - str.length(); i++) {temp = "0" + temp;}str = (temp + str).substring(0, maxLength);return str;}/*** 将一个字符串转换为int** @param s          String 要转换的字符串* @param defaultInt int 如果出现异常,默认返回的数字* @param radix      int 要转换的字符串是什么进制的,如16 8 10.* @return int 转换后的数字*/public static int parseToInt(String s, int defaultInt, int radix) {int i = 0;try {i = Integer.parseInt(s, radix);} catch (NumberFormatException ex) {i = defaultInt;}return i;}/*** 将一个十进制形式的数字字符串转换为int** @param s          String 要转换的字符串* @param defaultInt int 如果出现异常,默认返回的数字* @return int 转换后的数字*/public static int parseToInt(String s, int defaultInt) {int i = 0;try {i = Integer.parseInt(s);} catch (NumberFormatException ex) {i = defaultInt;}return i;}/*** 十六进制串转化为byte数组** @return the array of byte*/public static byte[] hexToByte(String hex)throws IllegalArgumentException {if (hex.length() % 2 != 0) {throw new IllegalArgumentException();}char[] arr = hex.toCharArray();byte[] b = new byte[hex.length() / 2];for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {String swap = "" + arr[i++] + arr[i];int byteint = Integer.parseInt(swap, 16) & 0xFF;b[j] = new Integer(byteint).byteValue();}return b;}/*** 字节数组转换为十六进制字符串** @param b byte[] 需要转换的字节数组* @return String 十六进制字符串*/public static String byteToHex(byte b[]) {if (b == null) {throw new IllegalArgumentException("Argument b ( byte array ) is null! ");}String hs = "";String stmp = "";for (int n = 0; n < b.length; n++) {stmp = Integer.toHexString(b[n] & 0xff);if (stmp.length() == 1) {hs = hs + "0" + stmp;} else {hs = hs + stmp;}}return hs.toLowerCase();//return hs.toUpperCase();}public static byte[] subByte(byte[] input, int startIndex, int length) {byte[] bt = new byte[length];for (int i = 0; i < length; i++) {bt[i] = input[i + startIndex];}return bt;}
}

SM4Utils.java

import Util;
import org.apache.commons.codec.binary.Base64;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class SM4Utils {public String secretKey = "";public String iv = "";public boolean hexString = false;public SM4Utils() {}public String encryptData_ECB(String plainText) {try {SM4_Context ctx = new SM4_Context();ctx.isPadding = true;ctx.mode = SM4.SM4_ENCRYPT;byte[] keyBytes;if (hexString) {keyBytes = Util.hexStringToBytes(secretKey);} else {//keyBytes = secretKey.getBytes();keyBytes = Util.hexStringToBytes(secretKey);}SM4 sm4 = new SM4();sm4.sm4_setkey_enc(ctx, keyBytes);byte[] encrypted = sm4.sm4_crypt_ecb(ctx, plainText.getBytes("UTF-8"));return Util.byteToHex(encrypted);} catch (Exception e) {e.printStackTrace();return null;}}public String decryptData_ECB(String cipherText) {try {byte[] encrypted = Util.hexToByte(cipherText);cipherText=Base64.encodeBase64String(encrypted);;//cipherText = new BASE64Encoder().encode(encrypted);if (cipherText != null && cipherText.trim().length() > 0) {Pattern p = Pattern.compile("\\s*|\t|\r|\n");Matcher m = p.matcher(cipherText);cipherText = m.replaceAll("");}SM4_Context ctx = new SM4_Context();ctx.isPadding = true;ctx.mode = SM4.SM4_DECRYPT;byte[] keyBytes;if (hexString) {keyBytes = Util.hexStringToBytes(secretKey);} else {keyBytes = secretKey.getBytes();}SM4 sm4 = new SM4();sm4.sm4_setkey_dec(ctx, keyBytes);byte[] decrypted = sm4.sm4_crypt_ecb(ctx, Base64.decodeBase64(cipherText));//byte[] decrypted = sm4.sm4_crypt_ecb(ctx, new BASE64Decoder().decodeBuffer(cipherText));return new String(decrypted, "UTF-8");} catch (Exception e) {e.printStackTrace();return null;}}public String encryptData_CBC(String plainText) {try {SM4_Context ctx = new SM4_Context();ctx.isPadding = true;ctx.mode = SM4.SM4_ENCRYPT;byte[] keyBytes;byte[] ivBytes;if (hexString) {keyBytes = Util.hexStringToBytes(secretKey);ivBytes = Util.hexStringToBytes(iv);} else {keyBytes = secretKey.getBytes();ivBytes = iv.getBytes();}SM4 sm4 = new SM4();sm4.sm4_setkey_enc(ctx, keyBytes);byte[] encrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, plainText.getBytes("UTF-8"));return Util.byteToHex(encrypted);} catch (Exception e) {e.printStackTrace();return null;}}public String decryptData_CBC(String cipherText) {try {byte[] encrypted = Util.hexToByte(cipherText);cipherText=Base64.encodeBase64String(encrypted);;//cipherText = new BASE64Encoder().encode(encrypted);if (cipherText != null && cipherText.trim().length() > 0) {Pattern p = Pattern.compile("\\s*|\t|\r|\n");Matcher m = p.matcher(cipherText);cipherText = m.replaceAll("");}SM4_Context ctx = new SM4_Context();ctx.isPadding = true;ctx.mode = SM4.SM4_DECRYPT;byte[] keyBytes;byte[] ivBytes;if (hexString) {keyBytes = Util.hexStringToBytes(secretKey);ivBytes = Util.hexStringToBytes(iv);} else {keyBytes = secretKey.getBytes();ivBytes = iv.getBytes();}SM4 sm4 = new SM4();sm4.sm4_setkey_dec(ctx, keyBytes);//byte[] decrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, new BASE64Decoder().decodeBuffer(cipherText));byte[] decrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, Base64.decodeBase64(cipherText));/*String text = new String(decrypted, "UTF-8");return text.substring(0,text.length()-1);*/return new String(decrypted, "UTF-8");} catch (Exception e) {e.printStackTrace();return null;}}public static void main(String[] args) throws IOException {String plainText = "I Love You Every Day";String s = Util.byteToHex(plainText.getBytes());System.out.println("原文" + s);SM4Utils sm4 = new SM4Utils();//sm4.secretKey = "JeF8U9wHFOMfs2Y8";sm4.secretKey = "64EC7C763AB7BF64E2D75FF83A319918";sm4.hexString = true;System.out.println("ECB模式加密");String cipherText = sm4.encryptData_ECB(plainText);System.out.println("密文: " + cipherText);System.out.println("");String plainText2 = sm4.decryptData_ECB(cipherText);System.out.println("明文: " + plainText2);System.out.println("");System.out.println("CBC模式加密");sm4.iv = "31313131313131313131313131313131";String cipherText2 = sm4.encryptData_CBC(plainText);System.out.println("加密密文: " + cipherText2);System.out.println("");String plainText3 = sm4.decryptData_CBC(cipherText2);System.out.println("解密明文: " + plainText3);}
}

我上面是自己实现的方式，基本没有依赖第三方包。有一个加密包：BouncyCastle可以很方便的实现加密与解密。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/436404.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【转】DICOM网络协议（一）概述

【转】DICOM网络协议（一）概述

转自&#xff1a;https://www.jianshu.com/p/8a0f0fe6a738 作者&#xff1a;我住的城市没有福合埕 DICOM (Digital Imaging and Communications in Medicine)即医学数字成像和通信&#xff0c;DICOM网络是基于TCP/IP的网络协议。通过DICOM将影像设备和存储管理设备连接起来。…
阅读更多...
Windows进程系列(2) -- Svchost进程

Windows进程系列(2) -- Svchost进程

在基于NT内核的Windows操作系统家族中&#xff0c;Svchost.exe是一个非常重要的进程。很多病毒、木马驻留系统与这个进程密切相关&#xff0c;因此深入了解该进程是非常有必要的。本文主要介绍Svchost进程的功能&#xff0c;以及与该进程相关的知识。 　　 　　Svchost进程概述…
阅读更多...
【转】DICOM入门(一)——语法

【转】DICOM入门(一)——语法

转自&#xff1a;https://www.jianshu.com/p/5db8933a25a4 作者&#xff1a;我住的城市没有福合埕 1.什么是DICOM DICOM(Digital Imaging and Communications in Medicine)即医学数字成像和传输协议&#xff0c;是用医疗影像&#xff08;CT 核磁共振 DR CR 超声等&#xff0…
阅读更多...
1000并发 MySQL数据库_再送一波干货，测试2000线程并发下同时查询1000万条数据库表及索引优化...

1000并发 MySQL数据库_再送一波干货，测试2000线程并发下同时查询1000万条数据库表及索引优化...

继上篇文章《绝对干货&#xff0c;教你4分钟插入1000万条数据到mysql数据库表&#xff0c;快快进来》发布后在博客园首页展示得到了挺多的阅读量&#xff0c;我这篇文章就是对上篇文章的千万级数据库表在高并发访问下如何进行测试访问这篇文章的知识点如下:1.如何自写几十行代码…
阅读更多...
【转】VTK修炼之道1_初识VTK

【转】VTK修炼之道1_初识VTK

1.VTK是什么&#xff1f; Visualization ToolKit 3D计算机图形学、图象处理及可视化工具包 VTK使用C、面向对象技术开发&#xff1b;基于OpenGL&#xff0c;封装了OpenGL中的功能&#xff0c;屏蔽细节、便于交互、易于使用提供多种语言接口C&#xff0b;&#xff0b; 、Java 、…
阅读更多...
HTTPS原理和对中间件攻击的预防

HTTPS原理和对中间件攻击的预防

一、https/tls原理 HTTPS访问的三个阶段 第一阶段 认证站点 客户端向站点发起HTTPS请求&#xff0c;站点返回数字证书。客户端通过数字证书验证所访问的站点是真实的目标站点。 第二阶段 协商密钥 客户端与站点服务器协商此次会话的对称加密密钥&#xff0c;用于下一阶段的加…
阅读更多...
HTTPS原理全面介绍【备查】

HTTPS原理全面介绍【备查】

来源&#xff1a;https://www.cnblogs.com/haimishasha/p/11373034.html 目录 应用层协议&#xff1a;HTTPS 1. HTTPS定义 2. 密码学基础　 3. HTTP通信问题 4. SSL/TLS协议 5. HTTP 向 HTTPS 演化的过程 5.1 对称加密 5.2 非对称加密 5.3 对称加密非对称加密 5.4 安…
阅读更多...
【转】VTK修炼之道2_VTK体系结构1

【转】VTK修炼之道2_VTK体系结构1

1.OverView综述 The Visualization Toolkit consists of two basic subsystems: a compiled C class library &#xff08;一个已经编译好的C类库&#xff09;and an “interpreted” wrapper layer&#xff08;一个用于解释的语言层&#xff09; that lets you manipulate the…
阅读更多...
WINCE6.0 DM.EXE 激活驱动失败的原因之一

WINCE6.0 DM.EXE 激活驱动失败的原因之一

前些天把WINCE6.0的开发环境建好了&#xff0c;今天定制了一个系统&#xff0c;练习了一下驱动的编写和调试。把DLL文件通过VS2005部署到开发板上&#xff0c;用一位大侠写的DM.EXE工具进行激活&#xff0c;但是发现点击激活按钮式无反应&#xff0c;驱动还是停在“停用”状态&…
阅读更多...
Linux：tomcat安装/版本升级

Linux：tomcat安装/版本升级

本文适用于安装或更新tomcat版本。 1.进入tomcat目录&#xff0c;查看当前tomcat版本 cd /usr/local/tomcat/bin ./version.sh 2.备份原tomcat 可以拷贝原tomcat&#xff0c;或者直接修改原tomcat的文件夹名称作为备份。 cd /usr/local/ #方法1&#xff1a;创建目录&…
阅读更多...
【转】VTK与Qt整合的示例

【转】VTK与Qt整合的示例

VTK与Qt整合的示例 VTK附带的程序示例中大多是基于控制台的&#xff0c;作为可视化开发工具包&#xff0c;VTK也可以与很多流行的GUI开发工具整合&#xff0c;比如MFC、Qt(题外话&#xff1a;Qt已经被Digia从诺基亚手中收购了&#xff0c;Qt现在的链接是&#xff1a;http://qt…
阅读更多...
WinCE驱动调试助手V2.5

WinCE驱动调试助手V2.5

http://www.cnblogs.com/we-hjb/archive/2008/12/15/1280822.html http://blog.chinaunix.net/u1/49088/showart.php?id1279989 工欲善其事&#xff0c;必先利其器。做WinCE驱动的开发已有一段时间了&#xff0c;WinCE驱动调试助手也跟着更新了很多功能。现在只要做驱动&#…
阅读更多...
Web应用系统中数据传递的方式汇总

Web应用系统中数据传递的方式汇总

本文转载自sina_blog(siangzhang) 目录 1 Socket方式 2 ftp/文件共享服务器方式 3 数据库共享数据方式 4 message方式 5 案例 随着近年来SOA&#xff08;面向服务技术架构&#xff09;的兴起&#xff0c;越来越多的应用系统开始进行分布式的设计和部署。 系统由原来单一…
阅读更多...
【转】CT （电子计算机断层扫描）

【转】CT （电子计算机断层扫描）

CT(Computed Tomography)&#xff0c;即电子计算机断层扫描&#xff0c;它是利用精确准直的X线束、γ射线、超声波等&#xff0c;与灵敏度极高的探测器一同围绕人体的某一部位作一个接一个的断面扫描&#xff0c;具有扫描速度快&#xff0c;图像清晰等特点&#xff0c;可用于多…
阅读更多...
Linux：chmod命令-修改文件或目录的权限

Linux：chmod命令-修改文件或目录的权限

给新安装的tomcat/bin目录下的所有文件增加执行权限&#xff08;所有用户、组&#xff09; chmod -R ax /usr/local/tomcat/bin ------------------------------------------------------------------------------------------------------------------- 关于具体的chmod命令…
阅读更多...
【转】详解冠状面_水平面_矢状面_窗宽_窗位

【转】详解冠状面_水平面_矢状面_窗宽_窗位

在接触人工智能医疗方面时&#xff0c;单是学习算法和代码原理还不够&#xff0c;需要一定的医学影像知识储备。 B超、CT、MR等都算是医疗影像&#xff0c;在现实生活中&#xff0c;从医院检查身体后拿到的胶片是处理过后的二维图像。这些医疗影像其实是三维的。 最常见的图片格…
阅读更多...
js+ asp.Net ajax开发163邮箱效果（列表底色、多选拖动等)--checkBox多选

js+ asp.Net ajax开发163邮箱效果（列表底色、多选拖动等)--checkBox多选

163邮件一个比较爽的功能就是可以通过多选邮件&#xff0c;拖动到左侧的文件夹列表&#xff0c;实现邮件归类的功能关于我对拖动分配的实现将在后文写出这里说说在CheckBox的选择中做得尝试和实现的效果、方法1。点击表格Title实现全选每行这个早有人做了,我这里借鉴一下 一块贴…
阅读更多...
【转】医学图像中的窗宽、窗位！！

【转】医学图像中的窗宽、窗位！！

在CT等医学影像显示领域&#xff0c;我们经常会听到窗宽&#xff08;Window Width,简写WW&#xff09;、窗位&#xff08;Window Level,简写WL&#xff09;的概念&#xff0c;那么到底什么是窗宽、窗位&#xff0c;它们跟医学图像之间的关系又是什么&#xff1f; 先说一下CT值…
阅读更多...
【Excel】使用VLOOKUP+IF实现多列条件匹配查询

【Excel】使用VLOOKUP+IF实现多列条件匹配查询

excel中vlookup函数为精准匹配查找&#xff0c;但此函数局限于单列的精准匹配&#xff0c;如果需求是多列条件进行匹配&#xff0c;怎么通过vlookup函数实现呢&#xff1f; 思路&#xff1a;通过if函数将多列拼成一列再通过vlookup函数进行精准匹配 具体公式为VLOOKUP($F2&…
阅读更多...
【转】解密Qt安装目录的结构

【转】解密Qt安装目录的结构

转自&#xff1a;C语言中文网 强力推荐 网址&#xff1a;http://c.biancheng.net/view/3866.html 了解 Qt 安装目录的结构虽然不是编程必须的&#xff0c;但是它能练就我们的内功&#xff0c;让我们对 Qt 的编程环境了如指掌。Windows 和 Linux 下 Qt 安装目录的结构非常相似…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023