1.简介
SHA即安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。
SHA1有如下特性：不可以从消息摘要中复原信息；两个不同的消息不会产生同样的消息摘要。
2.Java实现代码
public class SHA1Util {
private static final boolean hexcase = false;
private static final String b64pad = "=";
private static final int chrsz = 8;
//得到字符串SHA-1值的方法
public static String hex_sha1(String s)
{
s = (s == null) ? "" : s;
return binb2hex(core_sha1(str2binb(s), s.length() * chrsz));
}
public static String b64_hmac_sha1(String key, String data)
{
return binb2b64(core_hmac_sha1(key, data));
}
public static String b64_sha1(String s)
{
s = (s==null) ? "" : s;
return binb2b64(core_sha1(str2binb(s), s.length() * chrsz));
}
private static String binb2b64(int[] binarray)
{
String tab = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/";
String str = "";
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 += b64pad;
}
else
{
str += tab.charAt((triplet >> 6 * (3 - j)) & 0x3f);
}
}
}
return cleanb64str(str);
}
private static String binb2hex(int[] binarray)
{
String hex_tab = hexcase ? "0123456789abcdef" : "0123456789abcdef";
String str = "";
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 += (new Character(a).toString() + new Character(b).toString());
}
return str;
}
private static String binb2str(int[] bin)
{
String str = "";
int mask = (1 << chrsz) - 1;
for (int i = 0; i < bin.length * 32; i += chrsz)
{
str += (char) ((bin[i >> 5] >>> (24 - i % 32)) & mask);
}
return str;
}
private static int bit_rol(int num, int cnt)
{
return (num << cnt) | (num >>> (32 - cnt));
}
private static String cleanb64str(String str)
{
str = (str==null) ? "" : str;
int len = str.length();
if (len <= 1)
{
return str;
}
char trailchar = str.charAt(len - 1);
String trailstr="";
for (int i=len-1;i>=0 && str.charAt(i)==trailchar;i--)
{
trailstr += str.charAt(i);
}
return str.substring(0,str.indexOf(trailstr));
}
private static int[] complete216(int[] oldbin)
{
if (oldbin.length >= 16)
{
return oldbin;
}
int[] newbin = new int[16 - oldbin.length];
for (int i = 0; i<newbin.length; newbin[i]=0,i++);
return concat(oldbin, newbin);
}
private static int[] concat(int[] oldbin, int[] newbin)
{
int[] retval = new int[oldbin.length + newbin.length];
for (int i = 0; i < (oldbin.length + newbin.length); i++)
{
if (i < oldbin.length)
{
retval[i] = oldbin[i];
}
else
{
retval[i] = newbin[i - oldbin.length];
}
}
return retval;
}
private static int[] core_hmac_sha1(String key, String data)
{
key = (key == null) ? "" : key;
data = (data == null) ? "" : data;
int[] bkey = complete216(str2binb(key));
if (bkey.length > 16)
{
bkey = core_sha1(bkey, key.length() * chrsz);
}
int[] ipad = new int[16];
int[] opad = new int[16];
for (int i = 0; i < 16; ipad[i] = 0, opad[i] = 0, i++);
for (int i = 0; i < 16; i++)
{
ipad[i] = bkey[i] ^ 0x36363636;
opad[i] = bkey[i] ^ 0x5c5c5c5c;
}
int[] hash = core_sha1(concat(ipad, str2binb(data)), 512 + data.length() * chrsz);
return core_sha1(concat(opad, hash), 512 + 160);
}
private static int[] core_sha1(int[] x, int 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);
x[((len + 64 >> 9) << 4) + 15] = len;
int[] w = new int[80];
int a = 1732584193;
int b = -271733879;
int c = -1732584194;
int d = 271733878;
int e = -1009589776;
for (int i = 0; i < x.length; i += 16)
{
int olda = a;
int oldb = b;
int oldc = c;
int oldd = d;
int olde = e;
for (int j = 0; j < 80; j++)
{
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;
}
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);
}
int[] retval = new int[5];
retval[0] = a;
retval[1] = b;
retval[2] = c;
retval[3] = d;
retval[4] = e;
return retval;
}
private static void dotest()
{
String key="key";
String data="data";
System.out.println("hex_sha1(" + data + ")=" + hex_sha1(data));
System.out.println("b64_sha1(" + data + ")=" + b64_sha1(data));
System.out.println("str_sha1(" + data + ")=" + str_sha1(data));
System.out.println("hex_hmac_sha1(" + key + "," + data + ")=" + hex_hmac_sha1(key, data));
System.out.println("b64_hmac_sha1(" + key + "," + data + ")=" + b64_hmac_sha1(key, data));
System.out.println("str_hmac_sha1(" + key + "," + data + ")=" + str_hmac_sha1(key, data));
}
public static String hex_hmac_sha1(String key, String data)
{
return binb2hex(core_hmac_sha1(key, data));
}
private static int rol(int num, int cnt)
{
return (num << cnt) | (num >>> (32 - cnt));
}
private static int safe_add(int x, int y)
{
int lsw = (int) (x & 0xffff) + (int) (y & 0xffff);
int msw = (x >> 16) + (y >> 16) + (lsw >> 16);
return (msw << 16) | (lsw & 0xffff);
}
private static 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;
}
private static int sha1_kt(int t)
{
return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : (t < 60) ? -1894007588 : -899497514;
}
private static boolean sha1_vm_test()
{
return hexcase ? hex_sha1("abc").equals("a9993e364706816aba3e25717850c26c9cd0d89d") : hex_sha1("abc").equals("a9993e364706816aba3e25717850c26c9cd0d89d");
}
public static String str_hmac_sha1(String key, String data)
{
return binb2str(core_hmac_sha1(key, data));
}
public static String str_sha1(String s)
{
s = (s == null) ? "" : s;
return binb2str(core_sha1(str2binb(s), s.length() * chrsz));
}
private static int[] str2binb(String str)
{
str = (str==null) ? "" : str;
int[] tmp = new int[str.length() * chrsz];
int mask = (1 << chrsz) - 1;
for(int i = 0; i < str.length() * chrsz; i += chrsz)
{
tmp[i>>5] |= ( (int)(str.charAt(i / chrsz)) & mask) << (24 - i%32);
}
int len = 0;
for (int i=0;i<tmp.length&&tmp[i]!=0;i++,len++);
int[] bin = new int[len];
for (int i=0;i<len;i++)
{
bin[i] = tmp[i];
}
return bin;
}
private static 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[])
{
System.out.println("admin的SHA1的值为："+hex_sha1("admin") + ",length="+hex_sha1("admin").length());
}
}
分享到：
相关推荐
在Java中实现SHA-256加密算法，可以使用内置的`java.security.MessageDigest`类。这个过程涉及到几个关键步骤，包括创建`MessageDigest`实例、更新输入数据和获取哈希值。 首先，我们需要导入必要的Java库： ```...
本篇文章将深入探讨如何使用Java语言来实现SHA1加密算法。 首先，了解SHA1的基本原理。SHA1算法将输入数据（也称为“消息”）通过一系列的数学运算（如位操作、异或、加法等）转化为一个160位的数字，即160比特的...
总之，SHA-256加密算法在JavaScript和Java中的使用方式虽然有所不同，但核心思想都是将明文信息转化为不可逆的摘要，以此来保护敏感数据，如用户密码。在实际项目中，应结合盐值和多次迭代等安全策略，以增强密码的...
SHA1的主要特点是不可逆，即无法从摘要恢复原始数据，因此常用于验证数据完整性。例如，在软件下载时，提供者会公布文件的SHA1哈希值，用户可以计算下载后的文件的哈希值并比对，确保文件在传输过程中未被篡改。 ...
MD5是一种广泛使用的不可逆加密算法，全称为Message-Digest Algorithm 5，它将任意长度的输入（也叫做预映射或message）转化为一个固定长度的输出，即128位（16字节）的摘要。这个摘要值通常表示为32个十六进制数字...
本文将详细介绍如何使用Java语言来实现三种常见的加密算法：DES（Data Encryption Standard）、RSA（Rivest-Shamir-Adleman）以及SHA（Secure Hash Algorithm）。这些算法在网络安全、数据保护和身份验证等方面有着...
本资源提供了base64、MD5、RSA和SHA1这四种常见加密算法的Java实现，并附带了相应的jar包，便于学习和应用。 首先，Base64是一种简单的编码方式，主要用于将二进制数据转换为可打印的ASCII字符，以便在网络传输或...
【单向加密算法在Java中的实现】 在信息技术领域，单向加密算法，也称为哈希函数或散列函数，是一种将任意长度的数据转化为固定长度输出的算法。这种转化过程是不可逆的，也就是说，一旦数据经过哈希处理，无法通过...
在Java中实现加密算法涉及到多个重要的概念和技术，包括单钥密码体制、消息摘要、Diffie-Hellman密钥一致协议、非对称算法和公钥体系以及数字签名。下面将详细阐述这些知识点。 **1. 单钥密码体制** 单钥密码体制，...
总结，SHA系列加密算法在Java编程中具有重要地位，它们提供了数据的不可逆性哈希，确保了数据的完整性和安全性。开发者应根据项目需求，合理选择并正确使用这些算法，以满足不断提升的信息安全标准。在学习和研究...
本文将详细介绍几种常用的Java加密算法及其应用实例，包括MD5、SHA及RSA。 #### 1. MD5加密 **简介**：MD5（Message-Digest Algorithm 5）是一种广泛使用的散列函数，能够将任意长度的数据转换成一个固定长度...
它能将任意长度的信息转化为固定长度的摘要值，具有抗碰撞性和不可逆性，常用于消息完整性校验和数字签名的生成。在描述的链接中，你可以找到如何在Java中使用SM3算法进行哈希计算的详细步骤。 在实际应用中，通常...
在Java编程环境中，SHA256withRSA是一种广泛使用的安全算法，它结合了SHA-256哈希函数和RSA非对称加密算法，用于确保数据的完整性和身份验证。这个"JAVA-SHA256withRSA.java"文件提供了一个完整的工具类RSAUtils，...
### 使用Java实现数据加密算法详解 #### 一、基础知识概览 ##### 1.1 单钥密码体制 单钥密码体制，又称对称加密，是一种广泛应用的传统加密方式。其核心在于加密和解密过程中使用相同的密钥。这种方式的优点包括...
通过阅读《Java加密 消息摘要算法SHA实现详解.pdf》这份文档，读者将深入理解SHA算法的工作原理、如何在Java中实现以及其在安全领域的应用。这份资料对于Java和C#开发者来说都是一份宝贵的资源，有助于提升他们在...
本文将详细介绍Java中常见的四种加密算法：对称加密算法、非对称加密算法、散列算法以及数字签名算法，并探讨它们的实现原理与应用场景。 1. 对称加密算法 对称加密算法使用同一密钥进行加密和解密，其优点在于速度...
#### 四、加密算法在Java中的实现 Java平台提供了丰富的加密算法支持，包括但不限于： - **DES**：Data Encryption Standard，一种对称加密算法，虽然现在已被认为不太安全，但在某些场景下仍有应用。 - **3DES**...
除了上述不可逆加密算法，Java还提供了对称加密和非对称加密算法，如DES（Data Encryption Standard）、3DES（Triple DES）、AES（Advanced Encryption Standard）等对称加密，以及RSA、DSA等非对称加密。...