SHA1计算过程
参考资料，按字节的角度（加密的数据是字节数组，不是位数组），理解大致过程是：
1. 原字节数组补字节，使得字节数为64的倍数，且补的部分第一个字节是0x80，最后的8个字节存储原字节数组的总位数。
2. 补后的字节数组，每64字节为一块，循环计算。
3. 每64字节的一块再分16份，每份4字节，这16份会扩展计算，和自身的16分，组成80份，再循环计算。
4. 这80份的每份，按公式计算得到结果。
5. 之前各处计算的结果不断累计，即为结果。
import org.apache.commons.codec.digest.DigestUtils;
public class MySHA1Test {
public static void main(String[] args) {
String str = "hello";
// System.out.println(DigestUtils.md5Hex("hello"));
System.out.println(DigestUtils.shaHex(str));
byte[] data = str.getBytes();
// data = new byte[448];
System.out.println(hexToString(sha(data)));
}
public static String sha(String data) {
return hexToString(sha(data.getBytes()));
}
public static byte[] sha(byte[] bytes_data) {
byte[] bytes_all = appendBytes(bytes_data);
return computeBytes(bytes_all);
}
public static byte[] appendBytes(byte[] bytes_src) {
// 原始数据补字节，补后整体是64字节（512位）的整数倍。
// 补的部分，第一bit是1，后面至少有8个字节（64位）用来存放原始数据长度，这样至少补9字节
int length_src = bytes_src.length;
int length_append = 64 - length_src % 64;
if (length_append < 9) {
length_append = 64 + length_append;
}
// 补的数据
byte[] bytes_append = new byte[length_append];
// 第一位是1，其他位是0
bytes_append[0] = (byte) 0x80;
// 后面8字节（64位）存储的是按bit算的长度
long length_src1 = length_src * 8;
bytes_append[length_append - 8] = (byte)(length_src1 >>> 56);
bytes_append[length_append - 7] = (byte)(length_src1 >>> 48);
bytes_append[length_append - 6] = (byte)(length_src1 >>> 40);
bytes_append[length_append - 5] = (byte)(length_src1 >>> 32);
bytes_append[length_append - 4] = (byte)(length_src1 >>> 24);
bytes_append[length_append - 3] = (byte)(length_src1 >>> 16);
bytes_append[length_append - 2] = (byte)(length_src1 >>> 8);
bytes_append[length_append - 1] = (byte)(length_src1 >>> 0);
// 组装完整数据
byte[] bytes_all = new byte[length_src + length_append];
System.arraycopy(bytes_src, 0, bytes_all, 0, length_src);
System.arraycopy(bytes_append, 0, bytes_all, length_src, length_append);
// System.out.println("原始：" + hexToString(bytes_data));
// System.out.println("扩充：" + hexToString(bytes_append));
// System.out.println("结果：" + hexToString(bytes_all));
return bytes_all;
}
public static byte[] computeBytes(byte[] bytes_all) {
int k0 = 0x5A827999; // (0 <= t <= 19)
int k1 = 0x6ED9EBA1; // (20 <= t <= 39)
int k2 = 0x8F1BBCDC; // (40 <= t <= 59)
int k3 = 0xCA62C1D6; // (60 <= t <= 79).
int H0 = 0x67452301;
int H1 = 0xEFCDAB89;
int H2 = 0x98BADCFE;
int H3 = 0x10325476;
int H4 = 0xC3D2E1F0;
int A = 0;
int B = 0;
int C = 0;
int D = 0;
int E = 0;
int A1 = 0;
// 整体数据，按每块64字节512位切分，循环处理每个分块
int block_size = 64;
int block_count = bytes_all.length / block_size;
byte[] block_data = new byte[block_size];
int[] W = new int[80];
for (int block_index = 0; block_index < block_count; block_index++) {
// 取得分块数据
System.arraycopy(bytes_all, block_index * block_size, block_data, 0, block_size);
// 分块数据转为80个子分块
for (int t = 0; t < 80; t++) {
if (t < 16) {
// 前16个子分块，切分16分直接转换得到
int tmp = t * 4;
W[t] = (
((block_data[0 + tmp] << 24) & 0xff000000)
+ ((block_data[1 + tmp] << 16) & 0xff0000)
+ ((block_data[2 + tmp] << 8) & 0xff00)
+ ((block_data[3 + tmp] << 0) & 0xff)
);
} else {
// 后面的子分块，计算得到
// W[t] = S1(W[t-3] XOR W[t-8] XOR W[t-14] XOR W[t-16]).
W[t] = leftShiftLoop((W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]), 1);
}
}
// 80个子分块计算ABCDE，并累加
A = H0;
B = H1;
C = H2;
D = H3;
E = H4;
for (int t = 0; t < 80; t++) {
// 计算ABCDE：A, B, C, D, E ← [(A<<<5)+ ft(B,C,D)+E+Wt+Kt], A, (B<<<30), C, D
if (t < 20) {
A1 = leftShiftLoop(A, 5)
+ ((B & C) | ((~B) & D)) // (B AND C) or ((NOT B) AND D)
+ E + W[t] + k0;
} else if (t < 40) {
A1 = leftShiftLoop(A, 5)
+ (B ^ C ^ D) // B XOR C XOR D
+ E + W[t] + k1;
} else if (t < 60) {
A1 = leftShiftLoop(A, 5)
+ ((B & C) | (B & D) | (C & D)) // (B AND C) or (B AND D) or (C AND D)
+ E + W[t] + k2;
} else {
A1 = leftShiftLoop(A, 5)
+ (B ^ C ^ D) // B XOR C XOR D
+ E + W[t] + k3;
}
E = D;
D = C;
C = leftShiftLoop(B, 30);
B = A;
A = A1;
}
H0 = H0 + A;
H1 = H1 + B;
H2 = H2 + C;
H3 = H3 + D;
H4 = H4 + E;
}
// ABCDE转为结果
byte[] bytes_ret = new byte[20];
int index_ret = 0;
A1 = H0;
bytes_ret[index_ret++] = (byte) ((A1 >>> 24) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 16) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 8) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 0) & 0xFF);
A1 = H1;
bytes_ret[index_ret++] = (byte) ((A1 >>> 24) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 16) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 8) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 0) & 0xFF);
A1 = H2;
bytes_ret[index_ret++] = (byte) ((A1 >>> 24) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 16) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 8) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 0) & 0xFF);
A1 = H3;
bytes_ret[index_ret++] = (byte) ((A1 >>> 24) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 16) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 8) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 0) & 0xFF);
A1 = H4;
bytes_ret[index_ret++] = (byte) ((A1 >>> 24) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 16) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 8) & 0xFF);
bytes_ret[index_ret++] = (byte) ((A1 >>> 0) & 0xFF);
//
return bytes_ret;
}
public static int leftShiftLoop(int d, int n) {
return (d << n) | (d >>> (32 - n));
}
//
private static char[] digits = { '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
public static String hexToString(byte[] data) {
int l = data.length;
char[] out = new char[l << 1];
int i = 0;
for (int j = 0; i < l; ++i) {
out[(j++)] = digits[((0xF0 & data[i]) >>> 4)];
out[(j++)] = digits[(0xF & data[i])];
}
return new String(out);
}
}