189 8069 5689
Java中使用MD5算法计算消息摘要时，输入字符串的格式是有影响的。为了得到正确的结果，你需要确保输入字符串的格式符合一定的要求。比如，如果你使用了多余的空格或其他非法字符，那么你得到的消息摘要可能会与预期不符。
成都创新互联公司是专业的榆社网站建设公司，榆社接单;提供网站制作、做网站,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行榆社网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!
需要注意的是，不同的编码方式可能会导致相同的字符串在计算消息摘要时得到不同的结果。因此，在使用Java的MD5算法时，你应该确保输入字符串的编码方式与你预期的一致。
总之，在Java中使用MD5算法时，输入字符串的格式是有影响的，你需要注意字符串的格式以及编码方式，以确保得到正确的结果。
回答不易，望请采纳
public static String c(String paramString) {
if ((paramString == null) || (paramString.length() == 0)) throw new IllegalArgumentException("String to encript cannot be null or zero length"); // paramString字符串不能为空，否则抛出异常
StringBuffer localStringBuffer1 = newStringBuffer();
try { MessageDigest localMessageDigest = MessageDigest.getInstance("MD5"); //建立一个md5消息摘要对象
byte[] arrayOfByte1 = paramString.getBytes();
localMessageDigest.update(arrayOfByte1); // 把paramString数据放入arrayOfByte1，然后更新消息摘要对象（这边估计update的参数必须是byte类型的，所以才将paramString做了个类型转换）
byte[] arrayOfByte2 = localMessageDigest.digest(); //将更新的摘要内容取出来，这边是已经经过md5运算了。
int i = 0;
while (true) {
int j = arrayOfByte2.length;
if (i = j)
label66: return localStringBuffer1.toString().toUpperCase(); //如果ij。说明是摘要数据的长度为0，返回localStringBuffer1就行了。或者是当前的数据已经取完。
if ((arrayOfByte2[i] 0xFF) = 16) //如果第i个字节大于16，退出循环。
break;
StringBuilder localStringBuilder = new StringBuilder("0"); //新建一个StringBuilder对象。
String str1 = Integer.toHexString(arrayOfByte2[i] 0xFF);//这边的arrayOfByte2[i] 0xFF的意思相当于将字符串转化成16进制的整数了，再把它转化成16进制的字符串。
String str2 = str1;
StringBuffer localStringBuffer2 = localStringBuffer1.append(str2); //将字符串放进 localStringBuffer2里面
i += 1; //循环下一个字节的内容
}
String str3 = Integer.toHexString(arrayOfByte2[i] 0xFF); // 这边的i是跳出循环的i了，次数arrayOfByte2[i] 0xFF) = 16
StringBuffer localStringBuffer3 = localStringBuffer1.append(str3);
}
catch (NoSuchAlgorithmException localNoSuchAlgorithmException)
{ localNoSuchAlgorithmException.printStackTrace(); break label66: } }
完成的大体功能应该是;生成一个摘要，把摘要中的数据按照某种方式存储。具体干什么我没大看懂
/**
* 将指定byte数组转换成16进制字符串
* @param b
* @return
*/
public static String byteToHexString(byte[] b) {
StringBuffer hexString = new StringBuffer();
for (int i = 0; i b.length; i++) {
String hex = Integer.toHexString(b[i] 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
hexString.append(hex.toUpperCase());
}
return hexString.toString();
}
/**
* 获得加密后的16进制形式口令
* @param password
* @return
* @throws NoSuchAlgorithmException
* @throws UnsupportedEncodingException
*/
public static String getEncryptedPwd(String password)
throws NoSuchAlgorithmException, UnsupportedEncodingException {
//声明加密后的口令数组变量
byte[] pwd = null;
//随机数生成器
SecureRandom random = new SecureRandom();
//声明盐数组变量
byte[] salt = new byte[SALT_LENGTH];
//将随机数放入盐变量中
random.nextBytes(salt);
//声明消息摘要对象
MessageDigest md = null;
//创建消息摘要
md = MessageDigest.getInstance("MD5");
//将盐数据传入消息摘要对象
md.update(salt);
//将口令的数据传给消息摘要对象
md.update(password.getBytes("UTF-8"));
//获得消息摘要的字节数组
byte[] digest = md.digest();
//因为要在口令的字节数组中存放盐，所以加上盐的字节长度
pwd = new byte[digest.length + SALT_LENGTH];
//将盐的字节拷贝到生成的加密口令字节数组的前12个字节，以便在验证口令时取出盐
System.arraycopy(salt, 0, pwd, 0, SALT_LENGTH);
//将消息摘要拷贝到加密口令字节数组从第13个字节开始的字节
System.arraycopy(digest, 0, pwd, SALT_LENGTH, digest.length);
//将字节数组格式加密后的口令转化为16进制字符串格式的口令
return byteToHexString(pwd);
}
public static void main(String[] args) {//测试方法
try {
System.out.println(getEncryptedPwd("123456"));
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
在jsp页面中可以调用getEncryptedPwd 方法
Java加密和数字签名编程快速入门
本文主要谈一下密码学中的加密和数字签名，以及其在java中如何进行使用。对密码学有兴趣的伙伴，推荐看Bruce Schneier的著作：Applied Crypotography。在jdk1.5的发行版本中安全性方面有了很大的改进，也提供了对RSA算法的直接支持，现在我们从实例入手解决问题（本文仅是作为简单介绍）：
一、密码学上常用的概念
1）消息摘要：
这是一种与消息认证码结合使用以确保消息完整性的技术。主要使用单向散列函数算法，可用于检验消息的完整性，和通过散列密码直接以文本形式保存等，目前广泛使用的算法有MD4、MD5、SHA-1，jdk1.5对上面都提供了支持，在java中进行消息摘要很简单， java.security.MessageDigest提供了一个简易的操作方法：
/**
*MessageDigestExample.java
*Copyright 2005-2-16
*/
import java.security.MessageDigest;
/**
*单一的消息摘要算法，不使用密码.可以用来对明文消息（如：密码）隐藏保存
*/
public class MessageDigestExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java MessageDigestExample text");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//使用getInstance("算法")来获得消息摘要,这里使用SHA-1的160位算法
MessageDigest messageDigest=MessageDigest.getInstance("SHA-1");
System.out.println("\n"+messageDigest.getProvider().getInfo());
//开始使用算法
messageDigest.update(plainText);
System.out.println("\nDigest:");
//输出算法运算结果
System.out.println(new String(messageDigest.digest(),"UTF8"));
}
}
还可以通过消息认证码来进行加密实现，javax.crypto.Mac提供了一个解决方案，有兴趣者可以参考相关API文档，本文只是简单介绍什么是摘要算法。
2）私钥加密：
消息摘要只能检查消息的完整性，但是单向的，对明文消息并不能加密，要加密明文的消息的话，就要使用其他的算法，要确保机密性，我们需要使用私钥密码术来交换私有消息。
这种最好理解，使用对称算法。比如：A用一个密钥对一个文件加密，而B读取这个文件的话，则需要和A一样的密钥，双方共享一个私钥（而在web环境下，私钥在传递时容易被侦听）：
使用私钥加密的话，首先需要一个密钥，可用javax.crypto.KeyGenerator产生一个密钥(java.security.Key),然后传递给一个加密工具(javax.crypto.Cipher),该工具再使用相应的算法来进行加密，主要对称算法有：DES（实际密钥只用到56位），AES（支持三种密钥长度：128、192、256位），通常首先128位，其他的还有DESede等，jdk1.5种也提供了对对称算法的支持，以下例子使用AES算法来加密：
/**
*PrivateExmaple.java
*Copyright 2005-2-16
*/
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import java.security.Key;
/**
*私鈅加密，保证消息机密性
*/
public class PrivateExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java PrivateExample text");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//通过KeyGenerator形成一个key
System.out.println("\nStart generate AES key");
KeyGenerator keyGen=KeyGenerator.getInstance("AES");
keyGen.init(128);
Key key=keyGen.generateKey();
System.out.println("Finish generating DES key");
//获得一个私鈅加密类Cipher，ECB是加密方式，PKCS5Padding是填充方法
Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
System.out.println("\n"+cipher.getProvider().getInfo());
//使用私鈅加密
System.out.println("\nStart encryption:");
cipher.init(Cipher.ENCRYPT_MODE,key);
byte[] cipherText=cipher.doFinal(plainText);
System.out.println("Finish encryption:");
System.out.println(new String(cipherText,"UTF8"));
System.out.println("\nStart decryption:");
cipher.init(Cipher.DECRYPT_MODE,key);
byte[] newPlainText=cipher.doFinal(cipherText);
System.out.println("Finish decryption:");
System.out.println(new String(newPlainText,"UTF8"));
}
}
3）公钥加密：
上面提到，私钥加密需要一个共享的密钥，那么如何传递密钥呢？web环境下，直接传递的话很容易被侦听到，幸好有了公钥加密的出现。公钥加密也叫不对称加密，不对称算法使用一对密钥对，一个公钥，一个私钥，使用公钥加密的数据，只有私钥能解开（可用于加密）；同时，使用私钥加密的数据，只有公钥能解开（签名）。但是速度很慢（比私钥加密慢100到1000倍），公钥的主要算法有RSA，还包括Blowfish,Diffie-Helman等，jdk1.5种提供了对RSA的支持，是一个改进的地方：
/**
*PublicExample.java
*Copyright 2005-2-16
*/
import java.security.Key;
import javax.crypto.Cipher;
import java.security.KeyPairGenerator;
import java.security.KeyPair;
/**
*一个简单的公鈅加密例子,Cipher类使用KeyPairGenerator生成的公鈅和私鈅
*/
public class PublicExample{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java PublicExample text");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//构成一个RSA密钥
System.out.println("\nStart generating RSA key");
KeyPairGenerator keyGen=KeyPairGenerator.getInstance("RSA");
keyGen.initialize(1024);
KeyPair key=keyGen.generateKeyPair();
System.out.println("Finish generating RSA key");
//获得一个RSA的Cipher类，使用公鈅加密
Cipher cipher=Cipher.getInstance("RSA/ECB/PKCS1Padding");
System.out.println("\n"+cipher.getProvider().getInfo());
System.out.println("\nStart encryption");
cipher.init(Cipher.ENCRYPT_MODE,key.getPublic());
byte[] cipherText=cipher.doFinal(plainText);
System.out.println("Finish encryption:");
System.out.println(new String(cipherText,"UTF8"));
//使用私鈅解密
System.out.println("\nStart decryption");
cipher.init(Cipher.DECRYPT_MODE,key.getPrivate());
byte[] newPlainText=cipher.doFinal(cipherText);
System.out.println("Finish decryption:");
System.out.println(new String(newPlainText,"UTF8"));
}
}
4）数字签名：
数字签名，它是确定交换消息的通信方身份的第一个级别。上面A通过使用公钥加密数据后发给B，B利用私钥解密就得到了需要的数据，问题来了，由于都是使用公钥加密，那么如何检验是A发过来的消息呢？上面也提到了一点，私钥是唯一的，那么A就可以利用A自己的私钥进行加密，然后B再利用A的公钥来解密，就可以了；数字签名的原理就基于此，而通常为了证明发送数据的真实性，通过利用消息摘要获得简短的消息内容，然后再利用私钥进行加密散列数据和消息一起发送。java中为数字签名提供了良好的支持，java.security.Signature类提供了消息签名：
/**
*DigitalSignature2Example.java
*Copyright 2005-2-16
*/
import java.security.Signature;
import java.security.KeyPairGenerator;
import java.security.KeyPair;
import java.security.SignatureException;
/**
*数字签名，使用RSA私钥对对消息摘要签名，然后使用公鈅验证 测试
*/
public class DigitalSignature2Example{
public static void main(String[] args) throws Exception{
if(args.length!=1){
System.err.println("Usage:java DigitalSignature2Example text");
System.exit(1);
}
byte[] plainText=args[0].getBytes("UTF8");
//形成RSA公钥对
System.out.println("\nStart generating RSA key");
KeyPairGenerator keyGen=KeyPairGenerator.getInstance("RSA");
keyGen.initialize(1024);
KeyPair key=keyGen.generateKeyPair();
System.out.println("Finish generating RSA key");
//使用私鈅签名
Signature sig=Signature.getInstance("SHA1WithRSA");
sig.initSign(key.getPrivate());
sig.update(plainText);
byte[] signature=sig.sign();
System.out.println(sig.getProvider().getInfo());
System.out.println("\nSignature:");
System.out.println(new String(signature,"UTF8"));
//使用公鈅验证
System.out.println("\nStart signature verification");
sig.initVerify(key.getPublic());
sig.update(plainText);
try{
if(sig.verify(signature)){
System.out.println("Signature verified");
}else System.out.println("Signature failed");
}catch(SignatureException e){
System.out.println("Signature failed");
}
}
}
5)数字证书。
还有个问题，就是公钥问题，A用私钥加密了，那么B接受到消息后，用A提供的公钥解密；那么现在有个讨厌的C，他把消息拦截了，然后用自己的私钥加密，同时把自己的公钥发给B，并告诉B，那是A的公钥，结果....，这时候就需要一个中间机构出来说话了（相信权威，我是正确的），就出现了Certificate Authority(也即CA），有名的CA机构有Verisign等，目前数字认证的工业标准是：CCITT的X.509：
数字证书：它将一个身份标识连同公钥一起进行封装，并由称为认证中心或 CA 的第三方进行数字签名。
密钥库：java平台为你提供了密钥库，用作密钥和证书的资源库。从物理上讲，密钥库是缺省名称为 .keystore 的文件（有一个选项使它成为加密文件）。密钥和证书可以拥有名称（称为别名），每个别名都由唯一的密码保护。密钥库本身也受密码保护；您可以选择让每个别名密码与主密钥库密码匹配。
使用工具keytool，我们来做一件自我认证的事情吧（相信我的认证）：
1、创建密钥库keytool -genkey -v -alias feiUserKey -keyalg RSA 默认在自己的home目录下（windows系统是c:\documents and settings\你的用户名 目录下的.keystore文件），创建我们用 RSA 算法生成别名为 feiUserKey 的自签名的证书,如果使用了-keystore mm 就在当前目录下创建一个密钥库mm文件来保存密钥和证书。
2、查看证书：keytool -list 列举了密钥库的所有的证书
也可以在dos下输入keytool -help查看帮助。
1. Java版MD5
MD5Util.java
[java] view plain copy
package com.cncounter.util.common;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
/**
* Java消息摘要算法 MD5 工具类,其实其他摘要算法的实现也类似
*/
public class MD5Util {
/**
* 对文本执行 md5 摘要加密, 此算法与 mysql,JavaScript生成的md5摘要进行过一致性对比.
* @param plainText
* @return 返回值中的字母为小写
*/
public static String md5(String plainText) {
if (null == plainText) {
plainText = "";
}
String MD5Str = "";
try {
// JDK 6 支持以下6种消息摘要算法，不区分大小写
// md5,sha(sha-1),md2,sha-256,sha-384,sha-512
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(plainText.getBytes());
byte b[] = md.digest();
int i;
StringBuilder builder = new StringBuilder(32);
for (int offset = 0; offset b.length; offset++) {
i = b[offset];
if (i 0)
i += 256;
if (i 16)
builder.append("0");
builder.append(Integer.toHexString(i));
}
MD5Str = builder.toString();
// LogUtil.println("result: " + buf.toString());// 32位的加密
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return MD5Str;
}
// 一个简版测试
public static void main(String[] args) {
String m1 = md5("1");
String m2 = md5(m1);
/* 输出为
* m1=c4ca4238a0b923820dcc509a6f75849b
* m2=28c8edde3d61a0411511d3b1866f0636
*/
System.out.println("m1="+m1);
System.out.println("m2="+m2);
}
}
2. MySQL版MD5
MySQL直接支持 md5函数调用
[sql] view plain copy
select md5('1') as m1, md5(md5('1')) as m2;
执行结果为:
[plain] view plain copy
MariaDB [(none)] select md5('1') as m1, md5(md5('1')) as m2;
+----------------------------------+----------------------------------+
| m1 | m2 |
+----------------------------------+----------------------------------+
| c4ca4238a0b923820dcc509a6f75849b | 28c8edde3d61a0411511d3b1866f0636 |
+----------------------------------+----------------------------------+
1 row in set (0.00 sec)
3. JavaScript 版MD5函数
md5.js 代码如下:
[javascript] view plain copy
/*! JavaScript 的 MD5 实现 */
// 括号表达式, (xxxxx) 是用来将内部的语句、表达式的结果作为一个结果.
// 常见的是将json字符串用 eval 解析时,需要 eval("(" +jsonstr+ ")");
// () 内部定义了一个空间, 里面定义的变量不会污染到全局空间,很适合做lib
// (function UMD(对象/函数名name, 上下文this, 函数/对象的定义)) 返回一个匿名函数
// 因为第一个括号内 的结果是一个函数,而函数可以这样调用: (function(形参){})(实参);
// 这种匿名函数被浏览器解析后会自动执行一次.
(function UMD(name, context, definition) {
if ( typeof module !== "undefined" module.exports) {
// 如果 module 存在,并且module.exports存在,则将赋值结果赋给 它
// 可以不用管
module.exports = definition();
} else if ( typeof define === "function" define.amd) {
// 如果 define 这个函数存在,应该是另一个基础类库，则使用define
// 可以不用管
define(definition);
} else {
// 简单一点,可以看成: 调用传入的definition函数，将返回的对象绑定到全局空间
// 当然,根据传入的上下文不同,也可以绑定到其他对象下面,成为一个属性方法.
context[name] = definition(name, context);
}
}
)("md5", this, function DEF(name, context) {"use strict";
// 上面的 use strict 表示严格语法模式,有错误就拒绝执行.
// 而普通的JS,是解释执行,不执行的地方,有些错误也不影响其他代码的执行
// 作为类库,使用严格模式是很有必要的.严格模式声明必须放到一个namespace空间的最起始处.
//
var old_public_api = (context || {})[name];
// 最后要返回的对象/函数.
function md5_func(text) {
return hex_md5(text);
};
// 下面一堆是具体的算法... 可以先不用管
/////////////////////////////////////////////////////
//计算MD5
var hexcase = 0;
function hex_md5(a) {
if (a == "")
return a;
return rstr2hex(rstr_md5(str2rstr_utf8(a)))
};
function hex_hmac_md5(a, b) {
return rstr2hex(rstr_hmac_md5(str2rstr_utf8(a), str2rstr_utf8(b)))
};
function md5_vm_test() {
return hex_md5("abc").toLowerCase() == "900150983cd24fb0d6963f7d28e17f72"
};
function rstr_md5(a) {
return binl2rstr(binl_md5(rstr2binl(a), a.length * 8))
};
function rstr_hmac_md5(c, f) {
var e = rstr2binl(c);
if (e.length 16) {
e = binl_md5(e, c.length * 8)
}
var a = Array(16), d = Array(16);
for (var b = 0; b 16; b++) {
a[b] = e[b] ^ 909522486;
d[b] = e[b] ^ 1549556828
}
var g = binl_md5(a.concat(rstr2binl(f)), 512 + f.length * 8);
return binl2rstr(binl_md5(d.concat(g), 512 + 128))
};
function rstr2hex(c) {
try { hexcase
} catch(g) {
hexcase = 0
}
var f = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
var b = "";
var a;
for (var d = 0; d c.length; d++) {
a = c.charCodeAt(d);
b += f.charAt((a 4) 15) + f.charAt(a 15)
}
return b
};
function str2rstr_utf8(c) {
var b = "";
var d = -1;
var a, e;
while (++d c.length) {
a = c.charCodeAt(d);
e = d + 1 c.length ? c.charCodeAt(d + 1) : 0;
if (55296 = a a = 56319 56320 = e e = 57343) {
a = 65536 + ((a 1023) 10) + (e 1023);
d++
}
if (a = 127) {
b += String.fromCharCode(a)
} else {
if (a = 2047) {
b += String.fromCharCode(192 | ((a 6) 31), 128 | (a 63))
} else {
if (a = 65535) {
b += String.fromCharCode(224 | ((a 12) 15), 128 | ((a 6) 63), 128 | (a 63))
} else {
if (a = 2097151) {
b += String.fromCharCode(240 | ((a 18) 7), 128 | ((a 12) 63), 128 | ((a 6) 63), 128 | (a 63))
}
}
}
}
}
return b
};
function rstr2binl(b) {
var a = Array(b.length 2);
for (var c = 0; c a.length; c++) {
a[c] = 0
}
for (var c = 0; c b.length * 8; c += 8) {
a[c 5] |= (b.charCodeAt(c / 8) 255) (c % 32)
}
return a
};
function binl2rstr(b) {
var a = "";
for (var c = 0; c b.length * 32; c += 8) {
a += String.fromCharCode((b[c 5] (c % 32)) 255)
}
return a
};
function binl_md5(p, k) {
p[k 5] |= 128 ((k) % 32);
p[(((k + 64) 9) 4) + 14] = k;
var o = 1732584193;
var n = -271733879;
var m = -1732584194;
var l = 271733878;
for (var g = 0; g p.length; g += 16) {
var j = o;
var h = n;
var f = m;
var e = l;
o = md5_ff(o, n, m, l, p[g + 0], 7, -680876936);
l = md5_ff(l, o, n, m, p[g + 1], 12, -389564586);
m = md5_ff(m, l, o, n, p[g + 2], 17, 606105819);
n = md5_ff(n, m, l, o, p[g + 3], 22, -1044525330);
o = md5_ff(o, n, m, l, p[g + 4], 7, -176418897);
l = md5_ff(l, o, n, m, p[g + 5], 12, 1200080426);
m = md5_ff(m, l, o, n, p[g + 6], 17, -1473231341);
n = md5_ff(n, m, l, o, p[g + 7], 22, -45705983);
o = md5_ff(o, n, m, l, p[g + 8], 7, 1770035416);
l = md5_ff(l, o, n, m, p[g + 9], 12, -1958414417);
m = md5_ff(m, l, o, n, p[g + 10], 17, -42063);
n = md5_ff(n, m, l, o, p[g + 11], 22, -1990404162);
o = md5_ff(o, n, m, l, p[g + 12], 7, 1804603682);
l = md5_ff(l, o, n, m, p[g + 13], 12, -40341101);
m = md5_ff(m, l, o, n, p[g + 14], 17, -1502002290);
n = md5_ff(n, m, l, o, p[g + 15], 22, 1236535329);
o = md5_gg(o, n, m, l, p[g + 1], 5, -165796510);
l = md5_gg(l, o, n, m, p[g + 6], 9, -1069501632);
m = md5_gg(m, l, o, n, p[g + 11], 14, 643717713);
n = md5_gg(n, m, l, o, p[g + 0], 20, -373897302);
o = md5_gg(o, n, m, l, p[g + 5], 5, -701558691);
l = md5_gg(l, o, n, m, p[g + 10], 9, 38016083);
m = md5_gg(m, l, o, n, p[g + 15], 14, -660478335);
n = md5_gg(n, m, l, o, p[g + 4], 20, -405537848);
o = md5_gg(o, n, m, l, p[g + 9], 5, 568446438);
l = md5_gg(l, o, n, m, p[g + 14], 9, -1019803690);
m = md5_gg(m, l, o, n, p[g + 3], 14, -187363961);
n = md5_gg(n, m, l, o, p[g + 8], 20, 1163531501);
o = md5_gg(o, n, m, l, p[g + 13], 5, -1444681467);
l = md5_gg(l, o, n, m, p[g + 2], 9, -51403784);
m = md5_gg(m, l, o, n, p[g + 7], 14, 1735328473);
n = md5_gg(n, m, l, o, p[g + 12], 20, -1926607734);
o = md5_hh(o, n, m, l, p[g + 5], 4, -378558);
l = md5_hh(l, o, n, m, p[g + 8], 11, -2022574463);
m = md5_hh(m, l, o, n, p[g + 11], 16, 1839030562);
n = md5_hh(n, m, l, o, p[g + 14], 23, -35309556);
o = md5_hh(o, n, m, l, p[g + 1], 4, -1530992060);
l = md5_hh(l, o, n, m, p[g + 4], 11, 1272893353);
m = md5_hh(m, l, o, n, p[g + 7], 16, -155497632);
n = md5_hh(n, m, l, o, p[g + 10], 23, -1094730640);
o = md5_hh(o, n, m, l, p[g + 13], 4, 681279174);
l = md5_hh(l, o, n, m, p[g + 0], 11, -358537222);
m = md5_hh(m, l, o, n, p[g + 3], 16, -722521979);
n = md5_hh(n, m, l, o, p[g + 6], 23, 76029189);
数据摘要算法（信息摘要）是密码学算法中非常重要的一个分支，它通过对所有数据提取指纹信息以实现数据签名、数据完整性校验等功能，由于算法具有其不可逆性，有时候也会被用做敏感信息加密。
消息摘要算法（杂凑算法，哈希算法）的主要特征是加密过程不需要密钥，并且经过加密的数据无法被解密，只有输入相同的明文数据经过相同的消息摘要算法才能得到相同的密文。
一般地，把对一个信息的摘要称为该消息的指纹或数字签名，信息摘要算法的主要用途是 信息完整性校验 ，就好比我们接到一个快递，肯定都会先确定快递包装是否完整，有没有被人打开过，里面的东东有没有被人动过。
在计算机领域，我们也希望能知道别人传递的消息是否完整、是否有被篡改，这里就用到信息摘要算法。
举例：我们传递 password 时，需要将 password 加 salt 后做信息摘要，接收方核对摘要，相同则接受处理，不相同则认为本次的 password 传输过程中被篡改，拒绝本次请求。
信息摘要算法来源于 CRC算法 ，最初 CRC算法 是用来验证数据完整性的，即我们常见的 奇偶校验码 、 循环冗余校验 ，在CRC基础上发展出了MD和SHA两大算法家族，CRC比这些算法都要早，MD算法比SHA算法早，SHA算法是对MD算法的改进。再后来则发展出了可以带有密码的信息摘要算法- MAC算法 。
信息摘要算法包括三大类，MD、SHA和MAC算法，MD的分类是按照版本规定的，SHA一般是按照产生的消息长度分类的，但是SHA系列算法在学术上会按照算法版本区分SHA-0、SHA-1、SHA-2、SHA-3，
MAC算法是Hmac加融合的其他算来命名的。
下表是主要的信息摘要算法的特点比较，关于MD5、SHA1等算法的具体过程，非安全、算法专业人士可不学习，如有需要可以参考下面的维基百科：
美国对于算法出口有着严格的限制，Sun公司（现在应该是甲骨文了）限于美国算法出口法律的限制和本身的一些原因，并有提供特别全面的算法支持，不过java的加密模块被设计为：以SPI方式提供算法具体实现，可以用来透明的接入其他算法供应商，通过SPI机制可以直接使用其他算法供应商的jar包工具。
在Java中主要的算法供应商有三类：Sun本身的算法，包含在JDK中，大部分在JDK 1.6之后，Bouncy Castle和Commons Codec。