+ * ECB 加密模式 + * 不使用自定义 secretKey，一般用于后端自行加解密,如果是前端加密后端解密，则需要自定义secretKey，前后端一致才能正确解密 + * 经过ECB加密的密文为：SM4Utils.encryptData_ECB("123456"); + * 经过ECB解密的密文为：SM4Utils.decryptData_ECB("UQZqWWcVSu7MIrMzWRD/wA=="); + * 使用自定义 secretKey，传入的 secretKey 必须为16位，可包含字母、数字、标点 + * 经过ECB加密的密文为：SM4Utils.encryptData_ECB("123456"); + * 经过ECB解密的密文为：SM4Utils.decryptData_ECB("UQZqWWcVSu7MIrMzWRD/wA=="); + *
+ * CBC 加密模式（更加安全），需要两个密钥
+ * 经过CBC加密的密文为：SM4Utils.encryptData_CBC("123456");
+ * 经过CBC解密的密文为：SM4Utils.decryptData_CBC("hbMK6/IeJ3UTzaTgLb3f3A==");
+ * 同样可以自定义 secretKey 和 iv，需要两个密钥前后端都一致
+ * 经过CBC加密的密文为：SM4Utils.encryptData_CBC("123456","asdfghjklzxcvb!_","1234567890123456");
+ * 经过CBC解密的密文为：SM4Utils.decryptData_CBC("sTyCl3G6TF311kIENzsKNg==","asdfghjklzxcvb!_","1234567890123456");
+ */
+public class SM4Utils {
+ private SM4Utils() {
+
+ }
+
+ private static final Logger logger = Logger.getLogger(SM4Utils.class.getPackage().getName());
+
+ /**
+ * 默认 SECRET_KEY
+ * 当时用ECB模式的时候，和前端key一致
+ * secretKey 必须为16位，可包含字母、数字、标点
+ */
+ private static final String SECRET_KEY = "zhgd@bonus123456";
+
+ /**
+ * 默认 IV
+ * 当时用CBC模式的时候，SECRET_KEY和IV都需要传值，解密要和加密的SECRET_KEY和IV一致，更加安全
+ * iv 必须为 16 位，可包含字母、数字、标点
+ */
+ private static final String IV = "1234567812345678";
+
+ static final String ECB = "ECB";
+
+ static final String CBC = "CBC";
+
+ private static final boolean HEX_STRING = false;
+
+ private static final Pattern P = Pattern.compile("\\s*|\t|\r|\n");
+
+ private static String encryptData(String type, String plainText, String secretKey, String iv) {
+ try {
+ SM4Context ctx = new SM4Context();
+ ctx.isPadding = true;
+ ctx.mode = SM4.SM4_ENCRYPT;
+
+ byte[] keyBytes = secretKey == null ? SECRET_KEY.getBytes() : secretKey.getBytes();
+ SM4 sm4 = new SM4();
+ sm4.sm4SetKeyEnc(ctx, keyBytes);
+
+ String cipherText;
+ if (ECB.equals(type)) {
+ byte[] encrypted = sm4.sm4CryptEcb(ctx, plainText.getBytes(StandardCharsets.UTF_8));
+ cipherText = Base64.getEncoder().encodeToString(encrypted);
+ if (cipherText != null && !cipherText.trim().isEmpty()) {
+ Matcher m = P.matcher(cipherText);
+ cipherText = m.replaceAll("");
+ }
+ } else {
+ byte[] ivBytes = iv == null ? IV.getBytes() : iv.getBytes();
+ byte[] encrypted = sm4.sm4CryptCbc(ctx, ivBytes, plainText.getBytes(StandardCharsets.UTF_8));
+ cipherText = Base64.getEncoder().encodeToString(encrypted);
+ if (cipherText != null && !cipherText.trim().isEmpty()) {
+ Matcher m = P.matcher(cipherText);
+ cipherText = m.replaceAll("");
+ }
+ }
+ return cipherText;
+ } catch (Exception e) {
+ logger.log(Level.WARNING, "加密失败！", e);
+ return null;
+ }
+ }
+
+ public static void main(String[] args) {
+ System.err.println( decryptData_CBC("VlWYLrghArikg+SQKS4obg=="));
+ }
+ private static String decryptData(String type, String cipherText, String secretKey, String iv) {
+ try {
+ SM4Context ctx = new SM4Context();
+ ctx.isPadding = true;
+ ctx.mode = SM4.SM4_DECRYPT;
+
+ SM4 sm4 = new SM4();
+ byte[] bytes = secretKey == null ? SECRET_KEY.getBytes() : secretKey.getBytes();
+ if (ECB.equals(type)) {
+ sm4.sm4SetKeyDec(ctx, bytes);
+ byte[] decrypted = sm4.sm4CryptEcb(ctx, Base64.getDecoder().decode(cipherText));
+ return new String(decrypted, StandardCharsets.UTF_8);
+ } else {
+ byte[] keyBytes;
+ byte[] ivBytes;
+ if (HEX_STRING) {
+ keyBytes = Util.hexStringToBytes(secretKey);
+ ivBytes = Util.hexStringToBytes(iv);
+ } else {
+ keyBytes = bytes;
+ ivBytes = iv == null ? IV.getBytes() : iv.getBytes();
+ }
+ sm4.sm4SetKeyDec(ctx, keyBytes);
+ byte[] decrypted = sm4.sm4CryptCbc(ctx, ivBytes, Base64.getDecoder().decode(cipherText));
+ return new String(decrypted, StandardCharsets.UTF_8);
+ }
+ } catch (Exception e) {
+ logger.log(Level.WARNING, "解密失败！请检查密钥和密文是否对应", e);
+ return null;
+ }
+ }
+
+
+ /**
+ * ECB模式加密，自定义密钥，加解密密钥需一致
+ *
+ * @param plainText 要加密的数据
+ * @param secretKey 密钥，必须为 16 位，可包含字母、数字、标点
+ * @return 加密后的字符串
+ */
+ public static String encryptData_ECB(String plainText, String secretKey) {
+ return encryptData(ECB, plainText, secretKey, null);
+ }
+
+ /**
+ * ECB模式加密，默认密钥
+ *
+ * @param plainText 要加密的数据
+ * @return 加密后的字符串
+ */
+ public static String encryptData_ECB(String plainText) {
+ return encryptData(ECB, plainText, null, null);
+ }
+
+ /**
+ * ECB模式解密，自定义密钥，加解密密钥需一致
+ *
+ * @param cipherText 要解密的数据
+ * @param secretKey 密钥，必须为 16 位，可包含字母、数字、标点
+ * @return 解密后的字符串
+ */
+ public static String decryptData_ECB(String cipherText, String secretKey) {
+ return decryptData(ECB, cipherText, secretKey, null);
+ }
+
+ /**
+ * ECB模式解密，默认密钥
+ *
+ * @param cipherText 要解密的数据
+ * @return 解密后的字符串
+ */
+ public static String decryptData_ECB(String cipherText) {
+ return decryptData(ECB, cipherText, null, null);
+ }
+
+ /**
+ * CBC模式加密，SECRET_KEY和IV都需要传值，解密要和加密的SECRET_KEY和IV一致，更加安全
+ *
+ * @param plainText 要加密的数据
+ * @param secretKey 密钥一，必须为 16 位，可包含字母、数字、标点
+ * @param iv 密钥二，必须为 16 位，可包含字母、数字、标点
+ * @return 加密后的字符串
+ */
+ public static String encryptData_CBC(String plainText, String secretKey, String iv) {
+ return encryptData(CBC, plainText, secretKey, iv);
+ }
+
+ /**
+ * CBC模式加密，SECRET_KEY和IV都需要传值，解密要和加密的SECRET_KEY和IV一致，更加安全
+ *
+ * @param plainText 要加密的数据
+ * @return 加密后的字符串
+ */
+ public static String encryptData_CBC(String plainText) {
+ return encryptData(CBC, plainText, null, null);
+ }
+
+ /**
+ * CBC模式解密，SECRET_KEY和IV都需要传值，解密要和加密的SECRET_KEY和IV一致，更加安全
+ *
+ * @param cipherText 要解密的数据
+ * @param secretKey 密钥一，必须为 16 位，可包含字母、数字、标点
+ * @param iv 密钥二，必须为 16 位，可包含字母、数字、标点
+ * @return 解密后的字符串
+ */
+ public static String decryptData_CBC(String cipherText, String secretKey, String iv) {
+ return decryptData(CBC, cipherText, secretKey, iv);
+ }
+
+ /**
+ * CBC模式解密，SECRET_KEY和IV都需要传值，解密要和加密的SECRET_KEY和IV一致，更加安全
+ *
+ * @param cipherText 要解密的数据
+ * @return 解密后的字符串
+ */
+ public static String decryptData_CBC(String cipherText) {
+ return decryptData(CBC, cipherText, null, null);
+ }
+
+// public static void main(String[] args) {
+// System.out.println("经过ECB加密的密文为：" + SM4Utils.encryptData_ECB("41150320000416041X"));
+// System.out.println("经过ECB解密的密文为：" + SM4Utils.decryptData_ECB("ZaCySfpl8DLflqpnM67eqBuFHqHevz6NvJY7i77t4zk="));
+// System.out.println("经过CBC自定义密钥加密的密文为：" + SM4Utils.encryptData_CBC("41150320000416041X", "1sdfghjklzxcvbnm", ".234567890@$^-_*"));
+// System.out.println("经过CBC自定义密钥解密的密文为：" + SM4Utils.decryptData_CBC("eB/OnKKFHwNLBl7s4QvGX7rtqS0LqfmU8AuXnhqjCbM=", "1sdfghjklzxcvbnm", ".234567890@$^-_*"));
+// System.out.println(SM4Utils.encryptData_CBC("圣诞卡是你打死你"));
+// System.out.println(SM4Utils.decryptData_CBC("fhMAEzAxdPNTe9I346GNTgQmnjpBfjJHQCFj+TxQDUg="));
+// }
+}
diff --git a/securitycontrol-commons/securitycontrol-commons-core/src/main/java/com/securitycontrol/common/core/utils/aes/Util.java b/securitycontrol-commons/securitycontrol-commons-core/src/main/java/com/securitycontrol/common/core/utils/aes/Util.java
new file mode 100644
index 0000000..220ec70
--- /dev/null
+++ b/securitycontrol-commons/securitycontrol-commons-core/src/main/java/com/securitycontrol/common/core/utils/aes/Util.java
@@ -0,0 +1,619 @@
+package com.securitycontrol.common.core.utils.aes;
+
+
+import java.math.BigInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * @author 徐一杰
+ * @date 2022/10/11
+ */
+class Util {
+ private Util() {
+
+ }
+
+ private static final Logger logger = Logger.getLogger(Util.class.getPackage().getName());
+
+ /**
+ * 整形转换成网络传输的字节流（字节数组）型数据
+ *
+ * @param num 一个整型数据
+ * @return 4个字节的自己数组
+ */
+ public static byte[] intToBytes(int num) {
+ byte[] bytes = new byte[4];
+ bytes[0] = (byte) (0xff & (num));
+ 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]));
+ 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[] tmp;
+ if (n == null) {
+ return null;
+ }
+
+ if (n.toByteArray().length == 33) {
+ tmp = new byte[32];
+ System.arraycopy(n.toByteArray(), 1, tmp, 0, 32);
+ } else if (n.toByteArray().length == 32) {
+ tmp = n.toByteArray();
+ } else {
+ tmp = new byte[32];
+ for (int i = 0; i < 32 - n.toByteArray().length; i++) {
+ tmp[i] = 0;
+ }
+ System.arraycopy(n.toByteArray(), 0, tmp, 32 - n.toByteArray().length, n.toByteArray().length);
+ }
+ return tmp;
+ }
+
+ /**
+ * 字节流（字节数组）型数据转大数字
+ *
+ * @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) {
+ StringBuilder ret = new StringBuilder();
+ for (byte aByte : bytes) {
+ ret.append(Integer.toString((aByte & 0xff) + 0x100, 16).substring(1));
+ }
+ return upperCase ? ret.toString().toUpperCase() : ret.toString();
+ }
+
+ /**
+ * 打印十六进制字符串
+ *
+ * @param bytes 字节数组
+ */
+ public static void printHexString(byte[] bytes) {
+ for (byte aByte : bytes) {
+ String hex = Integer.toHexString(aByte & 0xFF);
+ if (hex.length() == 1) {
+ hex = '0' + hex;
+ }
+ System.out.println("0x" + hex.toUpperCase() + ",");
+ }
+ }
+
+ /**
+ * Convert hex string to byte[]
+ *
+ * @param hexString the hex string
+ * @return byte[]
+ */
+ public static byte[] hexStringToBytes(String hexString) {
+ if (hexString == null || hexString.isEmpty()) {
+ 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]) & 0xff);
+ }
+ 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 true 传换成小写格式 ， false 传换成大写格式
+ * @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.
+ int j = 0;
+ for (byte datum : data) {
+ out[j++] = toDigits[(0xF0 & datum) >>> 4];
+ out[j++] = toDigits[0x0F & datum];
+ }
+ return out;
+ }
+
+ /**
+ * 将字节数组转换为十六进制字符串
+ *
+ * @param data byte[]
+ * @return 十六进制String
+ */
+ public static String encodeHexString(byte[] data) {
+ return encodeHexString(data, true);
+ }
+
+ /**
+ * 将字节数组转换为十六进制字符串
+ *
+ * @param data byte[]
+ * @param toLowerCase true 传换成小写格式 ， false 传换成大写格式
+ * @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 IllegalArgumentException("十六进制char[]不合法");
+ }
+ byte[] out = new byte[len >> 1];
+ // two characters form the hex value.
+ int j = 0;
+ for (int i = 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 IllegalArgumentException("Illegal hexadecimal character " + ch + " at index " + index);
+ }
+ return digit;
+ }
+
+ /**
+ * 数字字符串转ASCII码字符串
+ *
+ * @param content 字符串
+ * @return ASCII字符串
+ */
+ public static String stringToAsciiString(String content) {
+ StringBuilder result = new StringBuilder();
+ int max = content.length();
+ for (int i = 0; i < max; i++) {
+ char c = content.charAt(i);
+ String b = Integer.toHexString(c);
+ result.append(b);
+ }
+ return result.toString();
+ }
+
+ /**
+ * 十六进制转字符串
+ *
+ * @param hexString 十六进制字符串
+ * @param encodeType 编码类型4：Unicode，2：普通编码
+ * @return 字符串
+ */
+ public static String hexStringToString(String hexString, int encodeType) {
+ StringBuilder result = new StringBuilder();
+ int max = hexString.length() / encodeType;
+ for (int i = 0; i < max; i++) {
+ char c = (char) hexStringToAlgorism(hexString.substring(i * encodeType, (i + 1) * encodeType));
+ result.append(c);
+ }
+ return result.toString();
+ }
+
+ /**
+ * 十六进制字符串转换十进制
+ *
+ * @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 algorithm;
+ if (c >= '0' && c <= '9') {
+ algorithm = c - '0';
+ } else {
+ algorithm = c - 55;
+ }
+ result += (int) (Math.pow(16, (max - i)) * algorithm);
+ }
+ return result;
+ }
+
+ /**
+ * 十六转二进制
+ *
+ * @param hex 十六进制字符串
+ * @return 二进制字符串
+ */
+ public static String hexStringToBinary(String hex) {
+ hex = hex.toUpperCase();
+ StringBuilder result = new StringBuilder();
+ int max = hex.length();
+ for (int i = 0; i < max; i++) {
+ char c = hex.charAt(i);
+ switch (c) {
+ case '0':
+ result.append("0000");
+ break;
+ case '1':
+ result.append("0001");
+ break;
+ case '2':
+ result.append("0010");
+ break;
+ case '3':
+ result.append("0011");
+ break;
+ case '4':
+ result.append("0100");
+ break;
+ case '5':
+ result.append("0101");
+ break;
+ case '6':
+ result.append("0110");
+ break;
+ case '7':
+ result.append("0111");
+ break;
+ case '8':
+ result.append("1000");
+ break;
+ case '9':
+ result.append("1001");
+ break;
+ case 'A':
+ result.append("1010");
+ break;
+ case 'B':
+ result.append("1011");
+ break;
+ case 'C':
+ result.append("1100");
+ break;
+ case 'D':
+ result.append("1101");
+ break;
+ case 'E':
+ result.append("1110");
+ break;
+ case 'F':
+ result.append("1111");
+ break;
+ default:
+ logger.log(Level.WARNING, "hexStringToBinary无匹配项");
+ break;
+ }
+ }
+ return result.toString();
+ }
+
+ /**
+ * ASCII码字符串转数字字符串
+ *
+ * @param content ASCII字符串
+ * @return 字符串
+ */
+ public static String asciiStringToString(String content) {
+ StringBuilder result = new StringBuilder();
+ 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.append(d);
+ }
+ return result.toString();
+ }
+
+ /**
+ * 将十进制转换为指定长度的十六进制字符串
+ *
+ * @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) {
+ StringBuilder result = new StringBuilder();
+ char temp;
+
+ for (byte b : bytearray) {
+ temp = (char) b;
+ result.append(temp);
+ }
+ return result.toString();
+ }
+
+ /**
+ * 二进制字符串转十进制
+ *
+ * @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 += (int) (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 补充结果
+ */
+ public static String patchHexString(String str, int maxLength) {
+ StringBuilder temp = new StringBuilder();
+ for (int i = 0; i < maxLength - str.length(); i++) {
+ temp.insert(0, "0");
+ }
+ 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;
+ 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;
+ 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 = String.valueOf(arr[i++]) + arr[i];
+ int byteInt = Integer.parseInt(swap, 16) & 0xFF;
+ b[j] = (byte) byteInt;
+ }
+ 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! ");
+ }
+ StringBuilder hs = new StringBuilder();
+ String stmp;
+ for (byte value : b) {
+ stmp = Integer.toHexString(value & 0xff);
+ if (stmp.length() == 1) {
+ hs.append("0").append(stmp);
+ } else {
+ hs.append(stmp);
+ }
+ }
+ return hs.toString().toUpperCase();
+ }
+
+ public static byte[] subByte(byte[] input, int startIndex, int length) {
+ byte[] bt = new byte[length];
+ System.arraycopy(input, startIndex, bt, 0, length);
+ return bt;
+ }
+
+}