mirror of
https://gitee.com/egzosn/pay-java-parent.git
synced 2026-05-12 00:24:19 +08:00
#新增#
新增退款接口 新增接口等注释 #修改# 更新新的支付接口
This commit is contained in:
Actinia-517
@@ -0,0 +1,310 @@
|
||||
package com.egzosn.pay.common.util.sign.SM3;
|
||||
|
||||
public class SM3
|
||||
{
|
||||
public static final byte[] iv = { 0x73, (byte) 0x80, 0x16, 0x6f, 0x49,
|
||||
0x14, (byte) 0xb2, (byte) 0xb9, 0x17, 0x24, 0x42, (byte) 0xd7,
|
||||
(byte) 0xda, (byte) 0x8a, 0x06, 0x00, (byte) 0xa9, 0x6f, 0x30,
|
||||
(byte) 0xbc, (byte) 0x16, 0x31, 0x38, (byte) 0xaa, (byte) 0xe3,
|
||||
(byte) 0x8d, (byte) 0xee, 0x4d, (byte) 0xb0, (byte) 0xfb, 0x0e,
|
||||
0x4e };
|
||||
|
||||
public static int[] Tj = new int[64];
|
||||
|
||||
static
|
||||
{
|
||||
for (int i = 0; i < 16; i++)
|
||||
{
|
||||
Tj[i] = 0x79cc4519;
|
||||
}
|
||||
|
||||
for (int i = 16; i < 64; i++)
|
||||
{
|
||||
Tj[i] = 0x7a879d8a;
|
||||
}
|
||||
}
|
||||
|
||||
public static byte[] CF(byte[] V, byte[] B)
|
||||
{
|
||||
int[] v, b;
|
||||
v = convert(V);
|
||||
b = convert(B);
|
||||
return convert(CF(v, b));
|
||||
}
|
||||
|
||||
private static int[] convert(byte[] arr)
|
||||
{
|
||||
int[] out = new int[arr.length / 4];
|
||||
byte[] tmp = new byte[4];
|
||||
for (int i = 0; i < arr.length; i += 4)
|
||||
{
|
||||
System.arraycopy(arr, i, tmp, 0, 4);
|
||||
out[i / 4] = bigEndianByteToInt(tmp);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
private static byte[] convert(int[] arr)
|
||||
{
|
||||
byte[] out = new byte[arr.length * 4];
|
||||
byte[] tmp = null;
|
||||
for (int i = 0; i < arr.length; i++)
|
||||
{
|
||||
tmp = bigEndianIntToByte(arr[i]);
|
||||
System.arraycopy(tmp, 0, out, i * 4, 4);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
public static int[] CF(int[] V, int[] B)
|
||||
{
|
||||
int a, b, c, d, e, f, g, h;
|
||||
int ss1, ss2, tt1, tt2;
|
||||
a = V[0];
|
||||
b = V[1];
|
||||
c = V[2];
|
||||
d = V[3];
|
||||
e = V[4];
|
||||
f = V[5];
|
||||
g = V[6];
|
||||
h = V[7];
|
||||
|
||||
int[][] arr = expand(B);
|
||||
int[] w = arr[0];
|
||||
int[] w1 = arr[1];
|
||||
|
||||
for (int j = 0; j < 64; j++)
|
||||
{
|
||||
ss1 = (bitCycleLeft(a, 12) + e + bitCycleLeft(Tj[j], j));
|
||||
ss1 = bitCycleLeft(ss1, 7);
|
||||
ss2 = ss1 ^ bitCycleLeft(a, 12);
|
||||
tt1 = FFj(a, b, c, j) + d + ss2 + w1[j];
|
||||
tt2 = GGj(e, f, g, j) + h + ss1 + w[j];
|
||||
d = c;
|
||||
c = bitCycleLeft(b, 9);
|
||||
b = a;
|
||||
a = tt1;
|
||||
h = g;
|
||||
g = bitCycleLeft(f, 19);
|
||||
f = e;
|
||||
e = P0(tt2);
|
||||
|
||||
/*System.out.print(j+" ");
|
||||
System.out.print(Integer.toHexString(a)+" ");
|
||||
System.out.print(Integer.toHexString(b)+" ");
|
||||
System.out.print(Integer.toHexString(c)+" ");
|
||||
System.out.print(Integer.toHexString(d)+" ");
|
||||
System.out.print(Integer.toHexString(e)+" ");
|
||||
System.out.print(Integer.toHexString(f)+" ");
|
||||
System.out.print(Integer.toHexString(g)+" ");
|
||||
System.out.print(Integer.toHexString(h)+" ");
|
||||
System.out.println("");*/
|
||||
}
|
||||
// System.out.println("");
|
||||
|
||||
int[] out = new int[8];
|
||||
out[0] = a ^ V[0];
|
||||
out[1] = b ^ V[1];
|
||||
out[2] = c ^ V[2];
|
||||
out[3] = d ^ V[3];
|
||||
out[4] = e ^ V[4];
|
||||
out[5] = f ^ V[5];
|
||||
out[6] = g ^ V[6];
|
||||
out[7] = h ^ V[7];
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
private static int[][] expand(int[] B)
|
||||
{
|
||||
int W[] = new int[68];
|
||||
int W1[] = new int[64];
|
||||
for (int i = 0; i < B.length; i++)
|
||||
{
|
||||
W[i] = B[i];
|
||||
}
|
||||
|
||||
for (int i = 16; i < 68; i++)
|
||||
{
|
||||
W[i] = P1(W[i - 16] ^ W[i - 9] ^ bitCycleLeft(W[i - 3], 15))
|
||||
^ bitCycleLeft(W[i - 13], 7) ^ W[i - 6];
|
||||
}
|
||||
|
||||
for (int i = 0; i < 64; i++)
|
||||
{
|
||||
W1[i] = W[i] ^ W[i + 4];
|
||||
}
|
||||
|
||||
int arr[][] = new int[][] { W, W1 };
|
||||
return arr;
|
||||
}
|
||||
|
||||
private static byte[] bigEndianIntToByte(int num)
|
||||
{
|
||||
return back(Util.intToBytes(num));
|
||||
}
|
||||
|
||||
private static int bigEndianByteToInt(byte[] bytes)
|
||||
{
|
||||
return Util.byteToInt(back(bytes));
|
||||
}
|
||||
|
||||
private static int FFj(int X, int Y, int Z, int j)
|
||||
{
|
||||
if (j >= 0 && j <= 15)
|
||||
{
|
||||
return FF1j(X, Y, Z);
|
||||
}
|
||||
else
|
||||
{
|
||||
return FF2j(X, Y, Z);
|
||||
}
|
||||
}
|
||||
|
||||
private static int GGj(int X, int Y, int Z, int j)
|
||||
{
|
||||
if (j >= 0 && j <= 15)
|
||||
{
|
||||
return GG1j(X, Y, Z);
|
||||
}
|
||||
else
|
||||
{
|
||||
return GG2j(X, Y, Z);
|
||||
}
|
||||
}
|
||||
|
||||
// 逻辑位运算函数
|
||||
private static int FF1j(int X, int Y, int Z)
|
||||
{
|
||||
int tmp = X ^ Y ^ Z;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
private static int FF2j(int X, int Y, int Z)
|
||||
{
|
||||
int tmp = ((X & Y) | (X & Z) | (Y & Z));
|
||||
return tmp;
|
||||
}
|
||||
|
||||
private static int GG1j(int X, int Y, int Z)
|
||||
{
|
||||
int tmp = X ^ Y ^ Z;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
private static int GG2j(int X, int Y, int Z)
|
||||
{
|
||||
int tmp = (X & Y) | (~X & Z);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
private static int P0(int X)
|
||||
{
|
||||
int y = rotateLeft(X, 9);
|
||||
y = bitCycleLeft(X, 9);
|
||||
int z = rotateLeft(X, 17);
|
||||
z = bitCycleLeft(X, 17);
|
||||
int t = X ^ y ^ z;
|
||||
return t;
|
||||
}
|
||||
|
||||
private static int P1(int X)
|
||||
{
|
||||
int t = X ^ bitCycleLeft(X, 15) ^ bitCycleLeft(X, 23);
|
||||
return t;
|
||||
}
|
||||
|
||||
/**
|
||||
* 对最后一个分组字节数据padding
|
||||
*
|
||||
* @param in
|
||||
* @param bLen
|
||||
* 分组个数
|
||||
* @return
|
||||
*/
|
||||
public static byte[] padding(byte[] in, int bLen)
|
||||
{
|
||||
int k = 448 - (8 * in.length + 1) % 512;
|
||||
if (k < 0)
|
||||
{
|
||||
k = 960 - (8 * in.length + 1) % 512;
|
||||
}
|
||||
k += 1;
|
||||
byte[] padd = new byte[k / 8];
|
||||
padd[0] = (byte) 0x80;
|
||||
long n = in.length * 8 + bLen * 512;
|
||||
byte[] out = new byte[in.length + k / 8 + 64 / 8];
|
||||
int pos = 0;
|
||||
System.arraycopy(in, 0, out, 0, in.length);
|
||||
pos += in.length;
|
||||
System.arraycopy(padd, 0, out, pos, padd.length);
|
||||
pos += padd.length;
|
||||
byte[] tmp = back(Util.longToBytes(n));
|
||||
System.arraycopy(tmp, 0, out, pos, tmp.length);
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* 字节数组逆序
|
||||
*
|
||||
* @param in
|
||||
* @return
|
||||
*/
|
||||
private static byte[] back(byte[] in)
|
||||
{
|
||||
byte[] out = new byte[in.length];
|
||||
for (int i = 0; i < out.length; i++)
|
||||
{
|
||||
out[i] = in[out.length - i - 1];
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
public static int rotateLeft(int x, int n)
|
||||
{
|
||||
return (x << n) | (x >> (32 - n));
|
||||
}
|
||||
|
||||
private static int bitCycleLeft(int n, int bitLen)
|
||||
{
|
||||
bitLen %= 32;
|
||||
byte[] tmp = bigEndianIntToByte(n);
|
||||
int byteLen = bitLen / 8;
|
||||
int len = bitLen % 8;
|
||||
if (byteLen > 0)
|
||||
{
|
||||
tmp = byteCycleLeft(tmp, byteLen);
|
||||
}
|
||||
|
||||
if (len > 0)
|
||||
{
|
||||
tmp = bitSmall8CycleLeft(tmp, len);
|
||||
}
|
||||
|
||||
return bigEndianByteToInt(tmp);
|
||||
}
|
||||
|
||||
private static byte[] bitSmall8CycleLeft(byte[] in, int len)
|
||||
{
|
||||
byte[] tmp = new byte[in.length];
|
||||
int t1, t2, t3;
|
||||
for (int i = 0; i < tmp.length; i++)
|
||||
{
|
||||
t1 = (byte) ((in[i] & 0x000000ff) << len);
|
||||
t2 = (byte) ((in[(i + 1) % tmp.length] & 0x000000ff) >> (8 - len));
|
||||
t3 = (byte) (t1 | t2);
|
||||
tmp[i] = (byte) t3;
|
||||
}
|
||||
|
||||
return tmp;
|
||||
}
|
||||
|
||||
private static byte[] byteCycleLeft(byte[] in, int byteLen)
|
||||
{
|
||||
byte[] tmp = new byte[in.length];
|
||||
System.arraycopy(in, byteLen, tmp, 0, in.length - byteLen);
|
||||
System.arraycopy(in, 0, tmp, in.length - byteLen, byteLen);
|
||||
return tmp;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,143 @@
|
||||
package com.egzosn.pay.common.util.sign.SM3;
|
||||
|
||||
public class SM3Digest
|
||||
{
|
||||
/** SM3值的长度 */
|
||||
private static final int BYTE_LENGTH = 32;
|
||||
|
||||
/** SM3分组长度 */
|
||||
private static final int BLOCK_LENGTH = 64;
|
||||
|
||||
/** 缓冲区长度 */
|
||||
private static final int BUFFER_LENGTH = BLOCK_LENGTH * 1;
|
||||
|
||||
/** 缓冲区 */
|
||||
private byte[] xBuf = new byte[BUFFER_LENGTH];
|
||||
|
||||
/** 缓冲区偏移量 */
|
||||
private int xBufOff;
|
||||
|
||||
/** 初始向量 */
|
||||
private byte[] V = SM3.iv.clone();
|
||||
|
||||
private int cntBlock = 0;
|
||||
|
||||
public SM3Digest() {
|
||||
}
|
||||
|
||||
public SM3Digest(SM3Digest t)
|
||||
{
|
||||
System.arraycopy(t.xBuf, 0, this.xBuf, 0, t.xBuf.length);
|
||||
this.xBufOff = t.xBufOff;
|
||||
System.arraycopy(t.V, 0, this.V, 0, t.V.length);
|
||||
}
|
||||
|
||||
/**
|
||||
* SM3结果输出
|
||||
*
|
||||
* @param out 保存SM3结构的缓冲区
|
||||
* @param outOff 缓冲区偏移量
|
||||
* @return
|
||||
*/
|
||||
public int doFinal(byte[] out, int outOff)
|
||||
{
|
||||
byte[] tmp = doFinal();
|
||||
System.arraycopy(tmp, 0, out, 0, tmp.length);
|
||||
return BYTE_LENGTH;
|
||||
}
|
||||
|
||||
public void reset()
|
||||
{
|
||||
xBufOff = 0;
|
||||
cntBlock = 0;
|
||||
V = SM3.iv.clone();
|
||||
}
|
||||
|
||||
/**
|
||||
* 明文输入
|
||||
*
|
||||
* @param in
|
||||
* 明文输入缓冲区
|
||||
* @param inOff
|
||||
* 缓冲区偏移量
|
||||
* @param len
|
||||
* 明文长度
|
||||
*/
|
||||
public void update(byte[] in, int inOff, int len)
|
||||
{
|
||||
int partLen = BUFFER_LENGTH - xBufOff;
|
||||
int inputLen = len;
|
||||
int dPos = inOff;
|
||||
if (partLen < inputLen)
|
||||
{
|
||||
System.arraycopy(in, dPos, xBuf, xBufOff, partLen);
|
||||
inputLen -= partLen;
|
||||
dPos += partLen;
|
||||
doUpdate();
|
||||
while (inputLen > BUFFER_LENGTH)
|
||||
{
|
||||
System.arraycopy(in, dPos, xBuf, 0, BUFFER_LENGTH);
|
||||
inputLen -= BUFFER_LENGTH;
|
||||
dPos += BUFFER_LENGTH;
|
||||
doUpdate();
|
||||
}
|
||||
}
|
||||
|
||||
System.arraycopy(in, dPos, xBuf, xBufOff, inputLen);
|
||||
xBufOff += inputLen;
|
||||
}
|
||||
|
||||
private void doUpdate()
|
||||
{
|
||||
byte[] B = new byte[BLOCK_LENGTH];
|
||||
for (int i = 0; i < BUFFER_LENGTH; i += BLOCK_LENGTH)
|
||||
{
|
||||
System.arraycopy(xBuf, i, B, 0, B.length);
|
||||
doHash(B);
|
||||
}
|
||||
xBufOff = 0;
|
||||
}
|
||||
|
||||
private void doHash(byte[] B)
|
||||
{
|
||||
byte[] tmp = SM3.CF(V, B);
|
||||
System.arraycopy(tmp, 0, V, 0, V.length);
|
||||
cntBlock++;
|
||||
}
|
||||
|
||||
private byte[] doFinal()
|
||||
{
|
||||
byte[] B = new byte[BLOCK_LENGTH];
|
||||
byte[] buffer = new byte[xBufOff];
|
||||
System.arraycopy(xBuf, 0, buffer, 0, buffer.length);
|
||||
byte[] tmp = SM3.padding(buffer, cntBlock);
|
||||
for (int i = 0; i < tmp.length; i += BLOCK_LENGTH)
|
||||
{
|
||||
System.arraycopy(tmp, i, B, 0, B.length);
|
||||
doHash(B);
|
||||
}
|
||||
return V;
|
||||
}
|
||||
|
||||
public void update(byte in)
|
||||
{
|
||||
byte[] buffer = new byte[] { in };
|
||||
update(buffer, 0, 1);
|
||||
}
|
||||
|
||||
public int getDigestSize()
|
||||
{
|
||||
return BYTE_LENGTH;
|
||||
}
|
||||
//
|
||||
// public static void main(String[] args)
|
||||
// {
|
||||
// byte[] md = new byte[32];
|
||||
// byte[] msg1 = "ererfeiisgod".getBytes();
|
||||
// SM3Digest sm3 = new SM3Digest();
|
||||
// sm3.update(msg1, 0, msg1.length);
|
||||
// sm3.doFinal(md, 0);
|
||||
// String s = new String(Hex.encode(md));
|
||||
// System.out.println(s.toUpperCase());
|
||||
// }
|
||||
}
|
||||
@@ -0,0 +1,662 @@
|
||||
package com.egzosn.pay.common.util.sign.SM3;
|
||||
|
||||
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.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;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
package com.egzosn.pay.common.util.sign;
|
||||
|
||||
import com.egzosn.pay.common.util.sign.SM3.SM3Digest;
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
|
||||
import java.io.UnsupportedEncodingException;
|
||||
import java.security.MessageDigest;
|
||||
import java.security.PublicKey;
|
||||
import java.security.Signature;
|
||||
|
||||
public class SecureUtil {
|
||||
//日志
|
||||
protected static final Log log = LogFactory.getLog(SecureUtil.class);
|
||||
/**
|
||||
* 算法常量： SHA1
|
||||
*/
|
||||
private static final String ALGORITHM_SHA1 = "SHA-1";
|
||||
/**
|
||||
* 算法常量： SHA256
|
||||
*/
|
||||
private static final String ALGORITHM_SHA256 = "SHA-256";
|
||||
/**
|
||||
* 算法常量：SHA1withRSA
|
||||
*/
|
||||
private static final String BC_PROV_ALGORITHM_SHA1RSA = "SHA1withRSA";
|
||||
/**
|
||||
* 算法常量：SHA256withRSA
|
||||
*/
|
||||
private static final String BC_PROV_ALGORITHM_SHA256RSA = "SHA256withRSA";
|
||||
|
||||
/**
|
||||
* 获取摘要
|
||||
*
|
||||
* @param data 待计算的数据
|
||||
* @param algorithm 算法名
|
||||
* @return 计算结果
|
||||
*/
|
||||
private static byte[] digestByData (byte[] data,String algorithm) {
|
||||
MessageDigest md = null;
|
||||
try {
|
||||
md = MessageDigest.getInstance(algorithm);
|
||||
md.reset();
|
||||
md.update(data);
|
||||
return md.digest();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* sha1计算后进行16进制转换
|
||||
*
|
||||
* @param data 待计算的数据
|
||||
* @param encoding 编码
|
||||
* @return 计算结果
|
||||
*/
|
||||
public static byte[] sha1X16 (String data, String encoding) {
|
||||
try {
|
||||
byte[] bytes = digestByData(data.getBytes(encoding),ALGORITHM_SHA1);
|
||||
StringBuilder sha1StrBuff = new StringBuilder();
|
||||
for (int i = 0; i < bytes.length; i++) {
|
||||
if (Integer.toHexString(0xFF & bytes[i]).length() == 1) {
|
||||
sha1StrBuff.append("0").append(
|
||||
Integer.toHexString(0xFF & bytes[i]));
|
||||
} else {
|
||||
sha1StrBuff.append(Integer.toHexString(0xFF & bytes[i]));
|
||||
}
|
||||
}
|
||||
return sha1StrBuff.toString().getBytes(encoding);
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* sha256计算后进行16进制转换
|
||||
*
|
||||
* @param data
|
||||
* 待计算的数据
|
||||
* @param encoding
|
||||
* 编码
|
||||
* @return 计算结果
|
||||
*/
|
||||
public static String sha256X16Str(String data, String encoding) {
|
||||
byte[] bytes =null;
|
||||
try {
|
||||
bytes = digestByData(data.getBytes(encoding),ALGORITHM_SHA1);
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
StringBuilder sha256StrBuff = new StringBuilder();
|
||||
for (int i = 0; i < bytes.length; i++) {
|
||||
if (Integer.toHexString(0xFF & bytes[i]).length() == 1) {
|
||||
sha256StrBuff.append("0").append(
|
||||
Integer.toHexString(0xFF & bytes[i]));
|
||||
} else {
|
||||
sha256StrBuff.append(Integer.toHexString(0xFF & bytes[i]));
|
||||
}
|
||||
}
|
||||
return sha256StrBuff.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* SM3计算.
|
||||
*
|
||||
* @param data
|
||||
* 待计算的数据
|
||||
* @return 计算结果
|
||||
*/
|
||||
private static byte[] sm3(byte[] data) {
|
||||
|
||||
SM3Digest sm3 = new SM3Digest();
|
||||
sm3.update(data, 0, data.length);
|
||||
byte[] result = new byte[sm3.getDigestSize()];
|
||||
sm3.doFinal(result, 0);
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* sm3计算后进行16进制转换
|
||||
*
|
||||
* @param data
|
||||
* 待计算的数据
|
||||
* @param encoding
|
||||
* 编码
|
||||
* @return 计算结果
|
||||
*/
|
||||
public static String sm3X16Str(String data, String encoding) {
|
||||
byte[] bytes = new byte[new SM3Digest().getDigestSize()];
|
||||
try {
|
||||
bytes = SecureUtil.sm3(data.getBytes(encoding));
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
StringBuilder sm3StrBuff = new StringBuilder();
|
||||
for (int i = 0; i < bytes.length; i++) {
|
||||
if (Integer.toHexString(0xFF & bytes[i]).length() == 1) {
|
||||
sm3StrBuff.append("0").append(
|
||||
Integer.toHexString(0xFF & bytes[i]));
|
||||
} else {
|
||||
sm3StrBuff.append(Integer.toHexString(0xFF & bytes[i]));
|
||||
}
|
||||
}
|
||||
return sm3StrBuff.toString();
|
||||
}
|
||||
|
||||
public static boolean validateSignBySoft256(PublicKey publicKey, byte[] signData, byte[] srcData) throws Exception {
|
||||
Signature st = Signature.getInstance(BC_PROV_ALGORITHM_SHA256RSA, "BC");
|
||||
st.initVerify(publicKey);
|
||||
st.update(srcData);
|
||||
return st.verify(signData);
|
||||
}
|
||||
|
||||
public static boolean validateSignBySoft(PublicKey publicKey,
|
||||
byte[] signData, byte[] srcData) throws Exception {
|
||||
Signature st = Signature.getInstance(BC_PROV_ALGORITHM_SHA1RSA, "BC");
|
||||
st.initVerify(publicKey);
|
||||
st.update(srcData);
|
||||
return st.verify(signData);
|
||||
}
|
||||
}
|
||||
@@ -47,6 +47,29 @@ public class RSA{
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* RSA签名
|
||||
* @param content 待签名数据
|
||||
* @param privateKey 私钥
|
||||
* @return 签名值
|
||||
*/
|
||||
public static String sign(byte[] content,PrivateKey privateKey) {
|
||||
try {
|
||||
|
||||
java.security.Signature signature = java.security.Signature.getInstance(privateKey.getAlgorithm());
|
||||
|
||||
signature.initSign(privateKey);
|
||||
signature.update(content);
|
||||
|
||||
byte[] signed = signature.sign();
|
||||
|
||||
return Base64.encode(signed);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* RSA签名
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
package com.egzosn.pay.common.util.sign.encrypt;/**
|
||||
* Description：
|
||||
* author: Fuzx
|
||||
* date: 2017/11/27 0027
|
||||
*/
|
||||
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
|
||||
import java.io.UnsupportedEncodingException;
|
||||
import java.security.MessageDigest;
|
||||
|
||||
/**
|
||||
* @author Actinia
|
||||
* @email hayesfu@qq.com
|
||||
* @create 2017 2017/11/27 0027
|
||||
*/
|
||||
public class SHA256 {
|
||||
//日志
|
||||
protected static final Log log = LogFactory.getLog(SHA256.class);
|
||||
|
||||
/**
|
||||
* 算法常量： SHA256
|
||||
*/
|
||||
private static final String ALGORITHM_SHA256 = "SHA-256";
|
||||
/**
|
||||
* sha256计算后进行16进制转换
|
||||
*
|
||||
* @param data
|
||||
* 待计算的数据
|
||||
* @param encoding
|
||||
* 编码
|
||||
* @return 计算结果
|
||||
*/
|
||||
public static byte[] sha256X16(String data, String encoding) {
|
||||
byte[] bytes = sha256(data, encoding);
|
||||
StringBuilder sha256StrBuff = new StringBuilder();
|
||||
for (int i = 0; i < bytes.length; i++) {
|
||||
if (Integer.toHexString(0xFF & bytes[i]).length() == 1) {
|
||||
sha256StrBuff.append("0").append(
|
||||
Integer.toHexString(0xFF & bytes[i]));
|
||||
} else {
|
||||
sha256StrBuff.append(Integer.toHexString(0xFF & bytes[i]));
|
||||
}
|
||||
}
|
||||
try {
|
||||
return sha256StrBuff.toString().getBytes(encoding);
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
log.error(e.getMessage(), e);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* sha256计算
|
||||
*
|
||||
* @param datas
|
||||
* 待计算的数据
|
||||
* @param encoding
|
||||
* 字符集编码
|
||||
* @return
|
||||
*/
|
||||
private static byte[] sha256(String datas, String encoding) {
|
||||
try {
|
||||
return sha256(datas.getBytes(encoding));
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
log.error("SHA256计算失败", e);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* sha256计算.
|
||||
*
|
||||
* @param data
|
||||
* 待计算的数据
|
||||
* @return 计算结果
|
||||
*/
|
||||
private static byte[] sha256(byte[] data) {
|
||||
MessageDigest md = null;
|
||||
try {
|
||||
md = MessageDigest.getInstance(ALGORITHM_SHA256);
|
||||
md.reset();
|
||||
md.update(data);
|
||||
return md.digest();
|
||||
} catch (Exception e) {
|
||||
log.error("SHA256计算失败", e);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user