java撒 加密,国密SM4，javaScript加密 java解密

packagecom.encode.sm4;importjava.math.BigInteger;public classUtil

{/*** 整形转换成网络传输的字节流(字节数组)型数据

*

*@paramnum 一个整型数据

*@return4个字节的自己数组*/

public static byte[] intToBytes(intnum)

{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));returnbytes;

}/*** 四个字节的字节数据转换成一个整形数据

*

*@parambytes 4个字节的字节数组

*@return一个整型数据*/

public static int byteToInt(byte[] bytes)

{int num = 0;inttemp;

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;returnnum;

}/*** 长整形转换成网络传输的字节流(字节数组)型数据

*

*@paramnum 一个长整型数据

*@return4个字节的自己数组*/

public static byte[] longToBytes(longnum)

{byte[] bytes = new byte[8];for (int i = 0; i < 8; i++)

{

bytes[i]= (byte) (0xff & (num >> (i * 8)));

}returnbytes;

}/*** 大数字转换字节流(字节数组)型数据

*

*@paramn

*@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);

}returntmpd;

}/*** 换字节流(字节数组)型数据转大数字

*

*@paramb

*@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 newBigInteger(temp);

}return newBigInteger(b);

}/*** 根据字节数组获得值(十六进制数字)

*

*@parambytes

*@return

*/

public static String getHexString(byte[] bytes)

{return getHexString(bytes, true);

}/*** 根据字节数组获得值(十六进制数字)

*

*@parambytes

*@paramupperCase

*@return

*/

public static String getHexString(byte[] bytes, booleanupperCase)

{

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;

}/*** 打印十六进制字符串

*

*@parambytes*/

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[]

*

*@paramhexString

* the hex string

*@returnbyte[]*/

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]));

}returnd;

}/*** Convert char to byte

*

*@paramc

* char

*@returnbyte*/

public static byte charToByte(charc)

{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'};/*** 将字节数组转换为十六进制字符数组

*

*@paramdata byte[]

*@return十六进制char[]*/

public static char[] encodeHex(byte[] data) {return encodeHex(data, true);

}/*** 将字节数组转换为十六进制字符数组

*

*@paramdata byte[]

*@paramtoLowerCase true 传换成小写格式 ， false 传换成大写格式

*@return十六进制char[]*/

public static char[] encodeHex(byte[] data, booleantoLowerCase) {return encodeHex(data, toLowerCase ?DIGITS_LOWER : DIGITS_UPPER);

}/*** 将字节数组转换为十六进制字符数组

*

*@paramdata byte[]

*@paramtoDigits 用于控制输出的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]];

}returnout;

}/*** 将字节数组转换为十六进制字符串

*

*@paramdata byte[]

*@return十六进制String*/

public static String encodeHexString(byte[] data) {return encodeHexString(data, true);

}/*** 将字节数组转换为十六进制字符串

*

*@paramdata byte[]

*@paramtoLowerCase true 传换成小写格式 ， false 传换成大写格式

*@return十六进制String*/

public static String encodeHexString(byte[] data, booleantoLowerCase) {return encodeHexString(data, toLowerCase ?DIGITS_LOWER : DIGITS_UPPER);

}/*** 将字节数组转换为十六进制字符串

*

*@paramdata byte[]

*@paramtoDigits 用于控制输出的char[]

*@return十六进制String*/

protected static String encodeHexString(byte[] data, char[] toDigits) {return newString(encodeHex(data, toDigits));

}/*** 将十六进制字符数组转换为字节数组

*

*@paramdata 十六进制char[]

*@returnbyte[]

*@throwsRuntimeException 如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常*/

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);

}returnout;

}/*** 将十六进制字符转换成一个整数

*

*@paramch 十六进制char

*@paramindex 十六进制字符在字符数组中的位置

*@return一个整数

*@throwsRuntimeException 当ch不是一个合法的十六进制字符时，抛出运行时异常*/

protected static int toDigit(char ch, intindex) {int digit = Character.digit(ch, 16);if (digit == -1) {throw new RuntimeException("Illegal hexadecimal character " +ch+ " at index " +index);

}returndigit;

}/*** 数字字符串转ASCII码字符串

*

*@paramString

* 字符串

*@returnASCII字符串*/

public staticString 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;

}returnresult;

}/*** 十六进制转字符串

*

*@paramhexString

* 十六进制字符串

*@paramencodeType

* 编码类型4：Unicode，2：普通编码

*@return字符串*/

public static String hexStringToString(String hexString, intencodeType) {

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;

}returnresult;

}/*** 十六进制字符串装十进制

*

*@paramhex

* 十六进制字符串

*@return十进制数值*/

public static inthexStringToAlgorism(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;

}returnresult;

}/*** 十六转二进制

*

*@paramhex

* 十六进制字符串

*@return二进制字符串*/

public staticString 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;

}

}returnresult;

}/*** ASCII码字符串转数字字符串

*

*@paramString

* ASCII字符串

*@return字符串*/

public staticString 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;

}returnresult;

}/*** 将十进制转换为指定长度的十六进制字符串

*

*@paramalgorism

* int 十进制数字

*@parammaxLength

* int 转换后的十六进制字符串长度

*@returnString 转换后的十六进制字符串*/

public static String algorismToHexString(int algorism, intmaxLength) {

String result= "";

result=Integer.toHexString(algorism);if (result.length() % 2 == 1) {

result= "0" +result;

}returnpatchHexString(result.toUpperCase(), maxLength);

}/*** 字节数组转为普通字符串(ASCII对应的字符)

*

*@parambytearray

* byte[]

*@returnString*/

public static String byteToString(byte[] bytearray) {

String result= "";chartemp;int length =bytearray.length;for (int i = 0; i < length; i++) {

temp= (char) bytearray[i];

result+=temp;

}returnresult;

}/*** 二进制字符串转十进制

*

*@parambinary

* 二进制字符串

*@return十进制数值*/

public static intbinaryToAlgorism(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;

}returnresult;

}/*** 十进制转换为十六进制字符串

*

*@paramalgorism

* int 十进制的数字

*@returnString 对应的十六进制字符串*/

public static String algorismToHEXString(intalgorism) {

String result= "";

result=Integer.toHexString(algorism);if (result.length() % 2 == 1) {

result= "0" +result;

}

result=result.toUpperCase();returnresult;

}/*** HEX字符串前补0，主要用于长度位数不足。

*

*@paramstr

* String 需要补充长度的十六进制字符串

*@parammaxLength

* int 补充后十六进制字符串的长度

*@return补充结果*/

static public String patchHexString(String str, intmaxLength) {

String temp= "";for (int i = 0; i < maxLength - str.length(); i++) {

temp= "0" +temp;

}

str= (temp + str).substring(0, maxLength);returnstr;

}/*** 将一个字符串转换为int

*

*@params

* String 要转换的字符串

*@paramdefaultInt

* int 如果出现异常,默认返回的数字

*@paramradix

* int 要转换的字符串是什么进制的,如16 8 10.

*@returnint 转换后的数字*/

public static int parseToInt(String s, int defaultInt, intradix) {int i = 0;try{

i=Integer.parseInt(s, radix);

}catch(NumberFormatException ex) {

i=defaultInt;

}returni;

}/*** 将一个十进制形式的数字字符串转换为int

*

*@params

* String 要转换的字符串

*@paramdefaultInt

* int 如果出现异常,默认返回的数字

*@returnint 转换后的数字*/

public static int parseToInt(String s, intdefaultInt) {int i = 0;try{

i=Integer.parseInt(s);

}catch(NumberFormatException ex) {

i=defaultInt;

}returni;

}/*** 十六进制串转化为byte数组

*

*@returnthe array of byte*/

public static byte[] hexToByte(String hex)throwsIllegalArgumentException {if (hex.length() % 2 != 0) {throw newIllegalArgumentException();

}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]= newInteger(byteint).byteValue();

}returnb;

}/*** 字节数组转换为十六进制字符串

*

*@paramb

* byte[] 需要转换的字节数组

*@returnString 十六进制字符串*/

public static String byteToHex(byteb[]) {if (b == null) {throw newIllegalArgumentException("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;

}

}returnhs.toUpperCase();

}public static byte[] subByte(byte[] input, int startIndex, intlength) {byte[] bt = new byte[length];for (int i = 0; i < length; i++) {

bt[i]= input[i +startIndex];

}returnbt;

}

}