1 sha-1的核心计算类
package com.encryption.presentationTool.encryptionTool;
import java.util.Arrays;
public class SHA1 {
private static final boolean hexcase = false;
private static final String b64pad = "=";
private static final int chrsz = 8;
// 得到字符串SHA-1值的方法
public String hex_sha1(String s) {
s = (s == null) ? "" : s;
int[][] result = core_sha1(str2binb(s), s.length() * chrsz);
int[] final_result = new int[5];
for (int i = 0; i <5 ; i++){
final_result[i] = result[0][i];
}
return binb2hex(final_result);
}
public String binb2b64(int[] binarray) {
String tab = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/";
StringBuilder str = new StringBuilder();
binarray = strechbinarray(binarray, binarray.length * 4);
for (int i = 0; i < binarray.length * 4; i += 3) {
int triplet = (((binarray[i >> 2] >> 8 * (3 - i % 4)) & 0xff) << 16)
| (((binarray[i + 1 >> 2] >> 8 * (3 - (i + 1) % 4)) & 0xff) << 8)
| ((binarray[i + 2 >> 2] >> 8 * (3 - (i + 2) % 4)) & 0xff);
for (int j = 0; j < 4; j++) {
if (i * 8 + j * 6 > binarray.length * 32) {
str.append(b64pad);
} else {
str.append(tab.charAt((triplet >> 6 * (3 - j)) & 0x3f));
}
}
}
return cleanb64str(str.toString());
}
public String binb2hex(int[] binarray) {
String hex_tab = hexcase ? "0123456789abcdef" : "0123456789abcdef";
StringBuilder str = new StringBuilder();
for (int i = 0; i < binarray.length * 4; i++) {
char a = (char) hex_tab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8 + 4)) & 0xf);
char b = (char) hex_tab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8)) & 0xf);
str.append(Character.toString(a)).append(Character.toString(b));
}
return str.toString();
}
public String cleanb64str(String str) {
str = (str == null) ? "" : str;
int len = str.length();
if (len <= 1) {
return str;
}
char trailchar = str.charAt(len - 1);
StringBuilder trailstr = new StringBuilder();
for (int i = len - 1; i >= 0 && str.charAt(i) == trailchar; i--) {
trailstr.append(str.charAt(i));
}
return str.substring(0, str.indexOf(trailstr.toString()));
}
/**
* 原文填充为完整的512bit分组长度的16进制字符串
* @param x
* @param len
* @return
*/
public String getInputStretchHexStr(int[] x, int len){
System.out.println("x:"+ Arrays.toString(x)+"len:"+len);
int size = (len >> 5);
x = strechbinarray(x, size); //填充
x[len >> 5] |= 0x80 << (24 - len % 32);
size = ((len + 64 >> 9) << 4) + 15;
x = strechbinarray(x, size); // 原文尾部加1
x[((len + 64 >> 9) << 4) + 15] = len; // 分组末尾加上原文bit长度
return binb2hex(x);
}
/**
* 执行哈希算法的核心调度类
* @param x
* @param len
* @return retval[0][0-4]:散列结果。10进制，retval[1][0-4]为80轮操作的第一轮结果
*/
public int[][] core_sha1(int[] x, int len) {
int[][] retval = new int[2][5];
System.out.println("x:"+ Arrays.toString(x)+"len:"+len);
int size = (len >> 5);
x = strechbinarray(x, size); //填充
// System.out.println("填充后的x = strechbinarray(x, size):"+ Arrays.toString(x)+" size:"+size);
x[len >> 5] |= 0x80 << (24 - len % 32);
size = ((len + 64 >> 9) << 4) + 15;
// System.out.println("x[len >> 5] |= 0x80 << (24 - len % 32):"+ x[len >> 5]+" size:"+size);
x = strechbinarray(x, size); // 原文尾部加1
// System.out.println("x = strechbinarray(x, size):"+ Arrays.toString(x)+" x.len:"+x.length);
x[((len + 64 >> 9) << 4) + 15] = len; // 分组末尾加上原文bit长度
// System.out.println("完整填充的x:"+ Arrays.toString(x)+" x.len:"+x.length);
// System.out.println("完整填充的x:"+ binb2hex(x) +" x.len:"+x.length);
//初始IV变量，共160bit
int[] w = new int[80];
// int a = 1732584193; //10进制
// int b = -271733879;
// int c = -1732584194;
// int d = 271733878;
// int e = -1009589776;
int a = 0x67452301;
int b = 0xEFCDAB89;
int c = 0x98BADCFE;
int d = 0x10325476;
int e = 0xC3D2E1F0;
//512bit分组，每32bit一组，共16组
for (int i = 0; i < x.length; i += 16) {
int olda = a;
int oldb = b;
int oldc = c;
int oldd = d;
int olde = e;
//每512bit的处理流程
for (int j = 0; j < 80; j++) {
//数据扩展:[0,15] [16,79]
if (j < 16) {
w[j] = x[i + j];
} else {
w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
}
//压缩函数，变换寄存器值
int t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)), safe_add(safe_add(e, w[j]), sha1_kt(j)));
e = d;
d = c;
c = rol(b, 30);
b = a;
a = t;
retval[1][0] = a;
retval[1][1] = b;
retval[1][2] = c;
retval[1][3] = d;
retval[1][4] = e;
}
a = safe_add(a, olda);
b = safe_add(b, oldb);
c = safe_add(c, oldc);
d = safe_add(d, oldd);
e = safe_add(e, olde);
}
//返回散列的结果，10进制
retval[0][0] = a;
retval[0][1] = b;
retval[0][2] = c;
retval[0][3] = d;
retval[0][4] = e;
return retval;
}
//32位二进制数循环左移
public int rol(int num, int cnt) {
return (num << cnt) | (num >>> (32 - cnt));
}
//将32位数拆成高16位和低16位分别进行相加，从而实现 mod 2^32 的加法
public int safe_add(int x, int y) {
int lsw = (int) (x & 0xffff) + (int) (y & 0xffff);
System.out.println("lsw:" + lsw);
int msw = (x >> 16) + (y >> 16) + (lsw >> 16);
System.out.println("msw:" + msw);
return (msw << 16) | (lsw & 0xffff);
}
//分块处理中的4个基本逻辑函数:[0,19] [20,39] [40,59] [60,79]
//返回对应F函数的值
public int sha1_ft(int t, int b, int c, int d) {
if (t < 20)
return (b & c) | ((~b) & d);
if (t < 40)
return b ^ c ^ d;
if (t < 60)
return (b & c) | (b & d) | (c & d);
return b ^ c ^ d;
}
//返回对应的Kt值
public int sha1_kt(int t) {
return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : (t < 60) ? -1894007588 : -899497514;
}
public boolean sha1_vm_test() {
return hexcase ? hex_sha1("abc").equals("a9993e364706816aba3e25717850c26c9cd0d89d") : hex_sha1("abc").equals(
"a9993e364706816aba3e25717850c26c9cd0d89d");
}
//字符串转为二进制数组，只返回有效值，填充的为0的部分不做返回，且返回的值为10进制数
public int[] str2binb(String str) {
str = (str == null) ? "" : str; //判断str是否为空
int[] tmp = new int[str.length() * chrsz];
int mask = (1 << chrsz) - 1; //二进制左移8位 ,结果为255
for (int i = 0; i < str.length() * chrsz; i += chrsz) {
System.out.println("tmp:"+ Arrays.toString(tmp));
tmp[i >> 5] |= ((int) (str.charAt(i / chrsz)) & mask) << (24 - i % 32);
}
int len = 0;
System.out.println("tmp.length:"+ tmp.length);
for (int i = 0; i < tmp.length && tmp[i] != 0; i++, len++); //满足第二个条件时，len++
System.out.println("tmp:"+ Arrays.toString(tmp));
System.out.println("len:"+len);
int[] bin = new int[len];
for (int i = 0; i < len; i++) {
bin[i] = tmp[i];
}
return bin;
}
public int[] strechbinarray(int[] oldbin, int size) {
int currlen = oldbin.length;
if (currlen >= size + 1) {
return oldbin;
}
int[] newbin = new int[size + 1];
for (int i = 0; i < size; newbin[i] = 0, i++);
for (int i = 0; i < currlen; i++) {
newbin[i] = oldbin[i];
}
return newbin;
}
public static void main(String[] args) {
SHA1 sha1 = new SHA1();
System.out.println(sha1.hex_sha1("123456"));
// int lsw = (int) (12345678 & 0xffff) + (int) (98765432 & 0xffff);
// System.out.println("12345678 & 0xffff:" + (12345678 & 0xffff));
// System.out.println("(98765432 & 0xffff):" + (98765432 & 0xffff));
// System.out.println("(lsw):" + (lsw));
// int msw = (12345678 >> 16) + (98765432 >> 16) + (lsw >> 16);
// System.out.println("(12345678 >> 16):" + (12345678 >> 16));
// System.out.println("(98765432 >> 16):" + (98765432 >> 16));
// System.out.println("(lsw >> 16):" + (lsw >> 16));
// System.out.println("msw:" + msw);
// System.out.println( (msw << 16) | (lsw & 0xffff));
// System.out.println("(msw << 16):" + (msw << 16));
// System.out.println("(lsw & 0xffff):" + (lsw & 0xffff));
// System.out.println("xxxxxxxx:" + ( (msw << 16) | (lsw & 0xffff)));
}
}
2 直接运行hex_sha1()方法
3 获得算法的中间过程
3.1 视图（VO）封装类
package com.encryption.presentationTool.VO;
import java.util.Arrays;
/**
* sha-1散列函数的视图映射
*/
public class SHA1VO {
//80轮寄存器处理的第一轮结果
private int[] first_80;
//80轮寄存器处理的第一轮结果,数组内是int[] first_80对应的16进制
private String[] first_80_hex;
//最终的10进制的哈希结果，160bit = 32 * 5
private int[] retval;
//最终的base64的哈希结果
private String retval_base64Str;
//最终的string[]，哈希结果，数组内是int[] retval对应的16进制结果
private String[] retval_hex;
//原文
private String input;
//原文字符串转为ASCII码16进制字符串
private String input_hexStr ;
//原文填充为完整的512bit分组长度的16进制字符串
private String input_stretch_hexStr;
public int[] getFirst_80() {
return first_80;
}
public void setFirst_80(int[] first_80) {
this.first_80 = first_80;
}
public String[] getFirst_80_hex() {
return first_80_hex;
}
public void setFirst_80_hex(String[] first_80_hex) {
this.first_80_hex = first_80_hex;
}
public int[] getRetval() {
return retval;
}
public void setRetval(int[] retval) {
this.retval = retval;
}
public String getRetval_base64Str() {
return retval_base64Str;
}
public void setRetval_base64Str(String retval_base64Str) {
this.retval_base64Str = retval_base64Str;
}
public String[] getRetval_hex() {
return retval_hex;
}
public void setRetval_hex(String[] retval_hex) {
this.retval_hex = retval_hex;
}
public String getInput_hexStr() {
return input_hexStr;
}
public void setInput_hexStr(String input_hexStr) {
this.input_hexStr = input_hexStr;
}
public String getInput_stretch_hexStr() {
return input_stretch_hexStr;
}
public void setInput_stretch_hexStr(String input_stretch_hexStr) {
this.input_stretch_hexStr = input_stretch_hexStr;
}
public String getInput() {
return input;
}
public void setInput(String input) {
this.input = input;
}
@Override
public String toString() {
return "SHA1VO{" +
"first_80=" + Arrays.toString(first_80) +
", first_80_hex=" + Arrays.toString(first_80_hex) +
", retval=" + Arrays.toString(retval) +
", retval_base64Str='" + retval_base64Str + '\'' +
", retval_hex=" + Arrays.toString(retval_hex) +
", input='" + input + '\'' +
", input_hexStr='" + input_hexStr + '\'' +
", input_stretch_hexStr='" + input_stretch_hexStr + '\'' +
'}';
}
}
3.2 调用VO封装计算过程
SHA1VO sha1VO = new SHA1VO();
//1.原文
sha1VO.setInput(input);
//2.原文字符串转为ASCII码16进制字符串
codeTool codeTool = new codeTool();
sha1VO.setInput_hexStr(codeTool.strToAsciiHexStr(input));
//3.原文填充为完整的512bit分组长度的16进制字符串
SHA1 sha1 = new SHA1();
sha1VO.setInput_stretch_hexStr(sha1.getInputStretchHexStr(sha1.str2binb(input),input.length() * 8));
//4.80轮寄存器处理的第一轮结果
int[][] result = sha1.core_sha1(sha1.str2binb(input),input.length() * 8);
sha1VO.setFirst_80(result[1]);
//5.80轮寄存器处理的第一轮结果,数组内是int[] first_80对应的16进制字符串
sha1VO.setFirst_80_hex(codeTool.intToAsciiHexStr(result[1]));
//6.最终的10进制的哈希结果，160bit = 32 * 5
sha1VO.setRetval(result[0]);
//7.最终的base64的哈希结果
sha1VO.setRetval_base64Str(sha1.binb2b64(result[0]));
//8.最终的string[]，哈希结果，数组内是int[] retval对应的16进制结果
sha1VO.setRetval_hex(codeTool.intToAsciiHexStr(result[0]));
3.3 结合前端页面的测试结果
版权声明：本文为weixin_43657383原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。