MD5的全称是Message-Digest Algorithm 5(信息-摘要算法),在90年代初由MIT Laboratory for Computer Science和RSA Data Security Inc的Ronald L. Rivest开发出来,经MD2、MD3和MD4发展而来。它的作用是让大容量信息在用数字签名软件签署私人密匙前被”压缩”成一种保密的格式(就是把一个任意长度的字节串变换成一定长的大整数)。不管是MD2、MD4还是MD5,它们都需要获得一个随机长度的信息并产生一个128位的信息摘要。虽然这些算法的结构或多或少有些相似,但MD2的设计与MD4和MD5完全不同,那是因为MD2是为8位机器做过设计优化的,而MD4和MD5却是面向32位的电脑。这三个算法的描述和C语言源代码在Internet RFCs 1321中有详细的描述(http://www.ietf.org/rfc/rfc1321.txt),这是一份最权威的文档,由Ronald L. Rivest在1992年8月向IEFT提交。

Rivest在1989年开发出MD2算法。在这个算法中,首先对信息进行数据补位,使信息的字节长度是16的倍数。然后,以一个16位的检验和追加到信息末尾。并且根据这个新产生的信息计算出散列值。后来,Rogier和Chauvaud发现如果忽略了检验和将产生MD2冲突。MD2算法的加密后结果是唯一的–既没有重复。

为了加强算法的安全性,Rivest在1990年又开发出MD4算法。MD4算法同样需要填补信息以确保信息的字节长度加上448后能被512整除(信息字节长度mod 512 = 448)。然后,一个以64位二进制表示的信息的最初长度被添加进来。信息被处理成512位Damg?rd/Merkle迭代结构的区块,而且每个区块要通过三个不同步骤的处理。Den Boer和Bosselaers以及其他人很快的发现了攻击MD4版本中第一步和第三步的漏洞。Dobbertin向大家演示了如何利用一部普通的个人电脑在几分钟内找到MD4完整版本中的冲突(这个冲突实际上是一种漏洞,它将导致对不同的内容进行加密却可能得到相同的加密后结果)。毫无疑问,MD4就此被淘汰掉了。

尽管MD4算法在安全上有个这么大的漏洞,但它对在其后才被开发出来的好几种信息安全加密算法的出现却有着不可忽视的引导作用。除了MD5以外,其中比较有名的还有SHA-1、RIPE-MD以及HAVAL等。

一年以后,即1991年,Rivest开发出技术上更为趋近成熟的MD5算法。它在MD4的基础上增加了”安全-带子”(Safety-Belts)的概念。虽然MD5比MD4稍微慢一些,但却更为安全。这个算法很明显的由四个和MD4设计有少许不同的步骤组成。在MD5算法中,信息-摘要的大小和填充的必要条件与MD4完全相同。Den Boer和Bosselaers曾发现MD5算法中的假冲突(Pseudo-Collisions),但除此之外就没有其他被发现的加密后结果了。

Van Oorschot和Wiener曾经考虑过一个在散列中暴力搜寻冲突的函数(Brute-Force Hash Function),而且他们猜测一个被设计专门用来搜索MD5冲突的机器(这台机器在1994年的制造成本大约是一百万美元)可以平均每24天就找到一个冲突。但单从1991年到2001年这10年间,竟没有出现替代MD5算法的MD6或被叫做其他什么名字的新算法这一点,我们就可以看出这个瑕疵并没有太多的影响MD5的安全性。上面所有这些都不足以成为MD5的在实际应用中的问题。并且,由于MD5算法的使用不需要支付任何版权费用的,所以在一般的情况下(非绝密应用领域。但即便是应用在绝密领域内,MD5也不失为一种非常优秀的中间技术),MD5怎么都应该算得上是非常安全的了。

算法的应用

MD5的典型应用是对一段信息(Message)产生信息摘要(Message-Digest),以防止被篡改。比如,在UNIX下有很多软件在下载的时候都有一个文件名相同,文件扩展名为.md5的文件,在这个文件中通常只有一行文本,大致结构如:

MD5 (tanajiya.tar.gz) = 0ca175b9c0f726a831d895e269332461

这就是tanajiya.tar.gz文件的数字签名。MD5将整个文件当作一个大文本信息,通过其不可逆的字符串变换算法,产生了这个唯一的MD5信息摘要。如果在以后传播这个文件的过程中,无论文件的内容发生了任何形式的改变(包括人为修改或者下载过程中线路不稳定引起的传输错误等),只要你对这个文件重新计算MD5时就会发现信息摘要不相同,由此可以确定你得到的只是一个不正确的文件。如果再有一个第三方的认证机构,用MD5还可以防止文件作者的”抵赖”,这就是所谓的数字签名应用。

MD5还广泛用于加密和解密技术上。比如在UNIX系统中用户的密码就是以MD5(或其它类似的算法)经加密后存储在文件系统中。当用户登录的时候,系统把用户输入的密码计算成MD5值,然后再去和保存在文件系统中的MD5值进行比较,进而确定输入的密码是否正确。通过这样的步骤,系统在并不知道用户密码的明码的情况下就可以确定用户登录系统的合法性。这不但可以避免用户的密码被具有系统管理员权限的用户知道,而且还在一定程度上增加了密码被破解的难度。

正是因为这个原因,现在被黑客使用最多的一种破译密码的方法就是一种被称为”跑字典”的方法。有两种方法得到字典,一种是日常搜集的用做密码的字符串表,另一种是用排列组合方法生成的,先用MD5程序计算出这些字典项的MD5值,然后再用目标的MD5值在这个字典中检索。我们假设密码的最大长度为8位字节(8 Bytes),同时密码只能是字母和数字,共26+26+10=62个字符,排列组合出的字典的项数则是P(62,1)+P(62,2)….+P(62,8),那也已经是一个很天文的数字了,存储这个字典就需要TB级的磁盘阵列,而且这种方法还有一个前提,就是能获得目标账户的密码MD5值的情况下才可以。这种加密技术被广泛的应用于UNIX系统中,这也是为什么UNIX系统比一般操作系统更为坚固一个重要原因。

算法描述

对MD5算法简要的叙述可以为:MD5以512位分组来处理输入的信息,且每一分组又被划分为16个32位子分组,经过了一系列的处理后,算法的输出由四个32位分组组成,将这四个32位分组级联后将生成一个128位散列值。

在MD5算法中,首先需要对信息进行填充,使其字节长度对512求余的结果等于448。因此,信息的字节长度(Bits Length)将被扩展至N*512+448,即N*64+56个字节(Bytes),N为一个正整数。填充的方法如下,在信息的后面填充一个1和无数个0,直到满足上面的条件时才停止用0对信息的填充。然后,在在这个结果后面附加一个以64位二进制表示的填充前信息长度。经过这两步的处理,现在的信息字节长度=N*512+448+64=(N+1)*512,即长度恰好是512的整数倍。这样做的原因是为满足后面处理中对信息长度的要求。

MD5中有四个32位被称作链接变量(Chaining Variable)的整数参数,他们分别为:A=0×01234567,B=0x89abcdef,C=0xfedcba98,D=0×76543210。

当设置好这四个链接变量后,就开始进入算法的四轮循环运算。循环的次数是信息中512位信息分组的数目。

将上面四个链接变量复制到另外四个变量中:A到a,B到b,C到c,D到d。

主循环有四轮(MD4只有三轮),每轮循环都很相似。第一轮进行16次操作。每次操作对a、b、c和d中的其中三个作一次非线性函数运算,然后将所得结果加上第四个变量,文本的一个子分组和一个常数。再将所得结果向右环移一个不定的数,并加上a、b、c或d中之一。最后用该结果取代a、b、c或d中之一。
以一下是每次操作中用到的四个非线性函数(每轮一个)。

F(X,Y,Z) =(X&Y)|((~X)&Z)
G(X,Y,Z) =(X&Z)|(Y&(~Z))
H(X,Y,Z) =X^Y^Z
I(X,Y,Z)=Y^(X|(~Z))
(&是与,|是或,~是非,^是异或)

这四个函数的说明:如果X、Y和Z的对应位是独立和均匀的,那么结果的每一位也应是独立和均匀的。
F是一个逐位运算的函数。即,如果X,那么Y,否则Z。函数H是逐位奇偶操作符。

假设Mj表示消息的第j个子分组(从0到15),<<
FF(a,b,c,d,Mj,s,ti)表示a=b+((a+(F(b,c,d)+Mj+ti)<<    GG(a,b,c,d,Mj,s,ti)表示a=b+((a+(G(b,c,d)+Mj+ti)<<    HH(a,b,c,d,Mj,s,ti)表示a=b+((a+(H(b,c,d)+Mj+ti)<<    II(a,b,c,d,Mj,s,ti)表示a=b+((a+(I(b,c,d)+Mj+ti)<<
这四轮(64步)是:

第一轮

FF(a,b,c,d,M0,7,0xd76aa478)
FF(d,a,b,c,M1,12,0xe8c7b756)
FF(c,d,a,b,M2,17,0x242070db)
FF(b,c,d,a,M3,22,0xc1bdceee)
FF(a,b,c,d,M4,7,0xf57c0faf)
FF(d,a,b,c,M5,12,0x4787c62a)
FF(c,d,a,b,M6,17,0xa8304613)
FF(b,c,d,a,M7,22,0xfd469501)
FF(a,b,c,d,M8,7,0x698098d8)
FF(d,a,b,c,M9,12,0x8b44f7af)
FF(c,d,a,b,M10,17,0xffff5bb1)
FF(b,c,d,a,M11,22,0x895cd7be)
FF(a,b,c,d,M12,7,0x6b901122)
FF(d,a,b,c,M13,12,0xfd987193)
FF(c,d,a,b,M14,17,0xa679438e)
FF(b,c,d,a,M15,22,0x49b40821)

第二轮

GG(a,b,c,d,M1,5,0xf61e2562)
GG(d,a,b,c,M6,9,0xc040b340)
GG(c,d,a,b,M11,14,0x265e5a51)
GG(b,c,d,a,M0,20,0xe9b6c7aa)
GG(a,b,c,d,M5,5,0xd62f105d)
GG(d,a,b,c,M10,9,0×02441453)
GG(c,d,a,b,M15,14,0xd8a1e681)
GG(b,c,d,a,M4,20,0xe7d3fbc8)
GG(a,b,c,d,M9,5,0x21e1cde6)
GG(d,a,b,c,M14,9,0xc33707d6)
GG(c,d,a,b,M3,14,0xf4d50d87)
GG(b,c,d,a,M8,20,0x455a14ed)
GG(a,b,c,d,M13,5,0xa9e3e905)
GG(d,a,b,c,M2,9,0xfcefa3f8)
GG(c,d,a,b,M7,14,0x676f02d9)
GG(b,c,d,a,M12,20,0x8d2a4c8a)

第三轮

HH(a,b,c,d,M5,4,0xfffa3942)
HH(d,a,b,c,M8,11,0x8771f681)
HH(c,d,a,b,M11,16,0x6d9d6122)
HH(b,c,d,a,M14,23,0xfde5380c)
HH(a,b,c,d,M1,4,0xa4beea44)
HH(d,a,b,c,M4,11,0x4bdecfa9)
HH(c,d,a,b,M7,16,0xf6bb4b60)
HH(b,c,d,a,M10,23,0xbebfbc70)
HH(a,b,c,d,M13,4,0x289b7ec6)
HH(d,a,b,c,M0,11,0xeaa127fa)
HH(c,d,a,b,M3,16,0xd4ef3085)
HH(b,c,d,a,M6,23,0x04881d05)
HH(a,b,c,d,M9,4,0xd9d4d039)
HH(d,a,b,c,M12,11,0xe6db99e5)
HH(c,d,a,b,M15,16,0x1fa27cf8)
HH(b,c,d,a,M2,23,0xc4ac5665)

第四轮

II(a,b,c,d,M0,6,0xf4292244)
II(d,a,b,c,M7,10,0x432aff97)
II(c,d,a,b,M14,15,0xab9423a7)
II(b,c,d,a,M5,21,0xfc93a039)
II(a,b,c,d,M12,6,0x655b59c3)
II(d,a,b,c,M3,10,0x8f0ccc92)
II(c,d,a,b,M10,15,0xffeff47d)
II(b,c,d,a,M1,21,0x85845dd1)
II(a,b,c,d,M8,6,0x6fa87e4f)
II(d,a,b,c,M15,10,0xfe2ce6e0)
II(c,d,a,b,M6,15,0xa3014314)
II(b,c,d,a,M13,21,0x4e0811a1)
II(a,b,c,d,M4,6,0xf7537e82)
II(d,a,b,c,M11,10,0xbd3af235)
II(c,d,a,b,M2,15,0x2ad7d2bb)
II(b,c,d,a,M9,21,0xeb86d391)

常数ti可以如下选择:

在第i步中,ti是4294967296*abs(sin(i))的整数部分,i的单位是弧度。(4294967296等于2的32次方)
所有这些完成之后,将A、B、C、D分别加上a、b、c、d。然后用下一分组数据继续运行算法,最后的输出是A、B、C和D的级联。

当你按照我上面所说的方法实现MD5算法以后,你可以用以下几个信息对你做出来的程序作一个简单的测试,看看程序有没有错误。

MD5 (“”) = d41d8cd98f00b204e9800998ecf8427e
MD5 (“a”) = 0cc175b9c0f1b6a831c399e269772661
MD5 (“abc”) = 900150983cd24fb0d6963f7d28e17f72
MD5 (“message digest”) = f96b697d7cb7938d525a2f31aaf161d0
MD5 (“abcdefghijklmnopqrstuvwxyz”) = c3fcd3d76192e4007dfb496cca67e13b
MD5 (“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789″) =
d174ab98d277d9f5a5611c2c9f419d9f
MD5 (“123456789012345678901234567890123456789012345678901234567890123456789
01234567890″) = 57edf4a22be3c955ac49da2e2107b67a

/************************************************

* MD5 算法

* @author 我行我素

* @Date 2007-07-01

*************************************************/

public class MD5 {

static final String hexs[]={"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"};

//标准的幻数

private static final long A=0x67452301L;

private static final long B=0xefcdab89L;

private static final long C=0x98badcfeL;

private static final long D=0x10325476L;

//下面这些S11-S44实际上是一个4*4的矩阵,在四轮循环运算中用到

static final int S11 = 7;

static final int S12 = 12;

static final int S13 = 17;

static final int S14 = 22;

static final int S21 = 5;

static final int S22 = 9;

static final int S23 = 14;

static final int S24 = 20;

static final int S31 = 4;

static final int S32 = 11;

static final int S33 = 16;

static final int S34 = 23;

static final int S41 = 6;

static final int S42 = 10;

static final int S43 = 15;

static final int S44 = 21;

//java不支持无符号的基本数据(unsigned)

private long [] result={A,B,C,D};//存储hash结果,共4×32=128位,初始化值为(幻数的级联)

public static void main(String []args){

MD5 md=new MD5();

System.out.println("md5(abc)="+md.digest("abc"));

}

private String digest(String inputStr){

byte [] inputBytes=inputStr.getBytes();

int byteLen=inputBytes.length;//长度(字节)

int groupCount=0;//完整分组的个数

groupCount=byteLen/64;//每组512位(64字节)

long []groups=null;//每个小组(64字节)再细分后的16个小组(4字节)

//处理每一个完整 分组

for(int step=0;step<groupCount;step++){

groups=divGroup(inputBytes,step*64);

trans(groups);//处理分组,核心算法

}

//处理完整分组后的尾巴

int rest=byteLen%64;//512位分组后的余数

byte [] tempBytes=new byte[64];

if(rest<=56){

for(int i=0;i<rest;i++)

tempBytes[i]=inputBytes[byteLen-rest+i];

if(rest<56){

tempBytes[rest]=(byte)(1<<7);

for(int i=1;i<56-rest;i++)

tempBytes[rest+i]=0;

}

long len=(long)(byteLen<<3);

for(int i=0;i<8;i++){

tempBytes[56+i]=(byte)(len&0xFFL);

len=len>>8;

}

groups=divGroup(tempBytes,0);

trans(groups);//处理分组

}else{

for(int i=0;i<rest;i++)

tempBytes[i]=inputBytes[byteLen-rest+i];

tempBytes[rest]=(byte)(1<<7);

for(int i=rest+1;i<64;i++)

tempBytes[i]=0;

groups=divGroup(tempBytes,0);

trans(groups);//处理分组

for(int i=0;i<56;i++)

tempBytes[i]=0;

long len=(long)(byteLen<<3);

for(int i=0;i<8;i++){

tempBytes[56+i]=(byte)(len&0xFFL);

len=len>>8;

}

groups=divGroup(tempBytes,0);

trans(groups);//处理分组

}

//将Hash值转换成十六进制的字符串

String resStr="";

long temp=0;

for(int i=0;i<4;i++){

for(int j=0;j<4;j++){

temp=result[i]&0x0FL;

String a=hexs[(int)(temp)];

result[i]=result[i]>>4;

temp=result[i]&0x0FL;

resStr+=hexs[(int)(temp)]+a;

result[i]=result[i]>>4;

}

}

return resStr;

}

/**

* 从inputBytes的index开始取512位,作为新的分组

* 将每一个512位的分组再细分成16个小组,每个小组64位(8个字节)

* @param inputBytes

* @param index

* @return

*/

private static long[] divGroup(byte[] inputBytes,int index){

long [] temp=new long[16];

for(int i=0;i<16;i++){

temp[i]=b2iu(inputBytes[4*i+index])|

(b2iu(inputBytes[4*i+1+index]))<<8|

(b2iu(inputBytes[4*i+2+index]))<<16|

(b2iu(inputBytes[4*i+3+index]))<<24;

}

return temp;

}

/**

* 这时不存在符号位(符号位存储不再是代表正负),所以需要处理一下

* @param b

* @return

*/

public static long b2iu(byte b){

return b < 0 ? b & 0x7F + 128 : b;

}

/**

* 主要的操作,四轮循环

* @param groups[]--每一个分组512位(64字节)

*/

private void trans(long[] groups) {

long a = result[0], b = result[1], c = result[2], d = result[3];

/*第一轮*/

a = FF(a, b, c, d, groups[0], S11, 0xd76aa478L); /* 1 */

d = FF(d, a, b, c, groups[1], S12, 0xe8c7b756L); /* 2 */

c = FF(c, d, a, b, groups[2], S13, 0x242070dbL); /* 3 */

b = FF(b, c, d, a, groups[3], S14, 0xc1bdceeeL); /* 4 */

a = FF(a, b, c, d, groups[4], S11, 0xf57c0fafL); /* 5 */

d = FF(d, a, b, c, groups[5], S12, 0x4787c62aL); /* 6 */

c = FF(c, d, a, b, groups[6], S13, 0xa8304613L); /* 7 */

b = FF(b, c, d, a, groups[7], S14, 0xfd469501L); /* 8 */

a = FF(a, b, c, d, groups[8], S11, 0x698098d8L); /* 9 */

d = FF(d, a, b, c, groups[9], S12, 0x8b44f7afL); /* 10 */

c = FF(c, d, a, b, groups[10], S13, 0xffff5bb1L); /* 11 */

b = FF(b, c, d, a, groups[11], S14, 0x895cd7beL); /* 12 */

a = FF(a, b, c, d, groups[12], S11, 0x6b901122L); /* 13 */

d = FF(d, a, b, c, groups[13], S12, 0xfd987193L); /* 14 */

c = FF(c, d, a, b, groups[14], S13, 0xa679438eL); /* 15 */

b = FF(b, c, d, a, groups[15], S14, 0x49b40821L); /* 16 */

/*第二轮*/

a = GG(a, b, c, d, groups[1], S21, 0xf61e2562L); /* 17 */

d = GG(d, a, b, c, groups[6], S22, 0xc040b340L); /* 18 */

c = GG(c, d, a, b, groups[11], S23, 0x265e5a51L); /* 19 */

b = GG(b, c, d, a, groups[0], S24, 0xe9b6c7aaL); /* 20 */

a = GG(a, b, c, d, groups[5], S21, 0xd62f105dL); /* 21 */

d = GG(d, a, b, c, groups[10], S22, 0x2441453L); /* 22 */

c = GG(c, d, a, b, groups[15], S23, 0xd8a1e681L); /* 23 */

b = GG(b, c, d, a, groups[4], S24, 0xe7d3fbc8L); /* 24 */

a = GG(a, b, c, d, groups[9], S21, 0x21e1cde6L); /* 25 */

d = GG(d, a, b, c, groups[14], S22, 0xc33707d6L); /* 26 */

c = GG(c, d, a, b, groups[3], S23, 0xf4d50d87L); /* 27 */

b = GG(b, c, d, a, groups[8], S24, 0x455a14edL); /* 28 */

a = GG(a, b, c, d, groups[13], S21, 0xa9e3e905L); /* 29 */

d = GG(d, a, b, c, groups[2], S22, 0xfcefa3f8L); /* 30 */

c = GG(c, d, a, b, groups[7], S23, 0x676f02d9L); /* 31 */

b = GG(b, c, d, a, groups[12], S24, 0x8d2a4c8aL); /* 32 */

/*第三轮*/

a = HH(a, b, c, d, groups[5], S31, 0xfffa3942L); /* 33 */

d = HH(d, a, b, c, groups[8], S32, 0x8771f681L); /* 34 */

c = HH(c, d, a, b, groups[11], S33, 0x6d9d6122L); /* 35 */

b = HH(b, c, d, a, groups[14], S34, 0xfde5380cL); /* 36 */

a = HH(a, b, c, d, groups[1], S31, 0xa4beea44L); /* 37 */

d = HH(d, a, b, c, groups[4], S32, 0x4bdecfa9L); /* 38 */

c = HH(c, d, a, b, groups[7], S33, 0xf6bb4b60L); /* 39 */

b = HH(b, c, d, a, groups[10], S34, 0xbebfbc70L); /* 40 */

a = HH(a, b, c, d, groups[13], S31, 0x289b7ec6L); /* 41 */

d = HH(d, a, b, c, groups[0], S32, 0xeaa127faL); /* 42 */

c = HH(c, d, a, b, groups[3], S33, 0xd4ef3085L); /* 43 */

b = HH(b, c, d, a, groups[6], S34, 0x4881d05L); /* 44 */

a = HH(a, b, c, d, groups[9], S31, 0xd9d4d039L); /* 45 */

d = HH(d, a, b, c, groups[12], S32, 0xe6db99e5L); /* 46 */

c = HH(c, d, a, b, groups[15], S33, 0x1fa27cf8L); /* 47 */

b = HH(b, c, d, a, groups[2], S34, 0xc4ac5665L); /* 48 */

/*第四轮*/

a = II(a, b, c, d, groups[0], S41, 0xf4292244L); /* 49 */

d = II(d, a, b, c, groups[7], S42, 0x432aff97L); /* 50 */

c = II(c, d, a, b, groups[14], S43, 0xab9423a7L); /* 51 */

b = II(b, c, d, a, groups[5], S44, 0xfc93a039L); /* 52 */

a = II(a, b, c, d, groups[12], S41, 0x655b59c3L); /* 53 */

d = II(d, a, b, c, groups[3], S42, 0x8f0ccc92L); /* 54 */

c = II(c, d, a, b, groups[10], S43, 0xffeff47dL); /* 55 */

b = II(b, c, d, a, groups[1], S44, 0x85845dd1L); /* 56 */

a = II(a, b, c, d, groups[8], S41, 0x6fa87e4fL); /* 57 */

d = II(d, a, b, c, groups[15], S42, 0xfe2ce6e0L); /* 58 */

c = II(c, d, a, b, groups[6], S43, 0xa3014314L); /* 59 */

b = II(b, c, d, a, groups[13], S44, 0x4e0811a1L); /* 60 */

a = II(a, b, c, d, groups[4], S41, 0xf7537e82L); /* 61 */

d = II(d, a, b, c, groups[11], S42, 0xbd3af235L); /* 62 */

c = II(c, d, a, b, groups[2], S43, 0x2ad7d2bbL); /* 63 */

b = II(b, c, d, a, groups[9], S44, 0xeb86d391L); /* 64 */

/*加入到之前计算的结果当中*/

result[0] += a;

result[1] += b;

result[2] += c;

result[3] += d;

result[0]=result[0]&0xFFFFFFFFL;

result[1]=result[1]&0xFFFFFFFFL;

result[2]=result[2]&0xFFFFFFFFL;

result[3]=result[3]&0xFFFFFFFFL;

}

/**

* 下面是处理要用到的线性函数

*/

private static long F(long x, long y, long z) {

return (x & y) | ((~x) & z);

}

private static long G(long x, long y, long z) {

return (x & z) | (y & (~z));

}

private static long H(long x, long y, long z) {

return x ^ y ^ z;

}

private static long I(long x, long y, long z) {

return y ^ (x | (~z));

}

private static long FF(long a, long b, long c, long d, long x, long s,

long ac) {

a += (F(b, c, d)&0xFFFFFFFFL) + x + ac;

a = ((a&0xFFFFFFFFL)<< s) | ((a&0xFFFFFFFFL) >>> (32 - s));

a += b;

return (a&0xFFFFFFFFL);

}

private static long GG(long a, long b, long c, long d, long x, long s,

long ac) {

a += (G(b, c, d)&0xFFFFFFFFL) + x + ac;

a = ((a&0xFFFFFFFFL) << s) | ((a&0xFFFFFFFFL) >>> (32 - s));

a += b;

return (a&0xFFFFFFFFL);

}

private static long HH(long a, long b, long c, long d, long x, long s,

long ac) {

a += (H(b, c, d)&0xFFFFFFFFL) + x + ac;

a = ((a&0xFFFFFFFFL) << s) | ((a&0xFFFFFFFFL) >>> (32 - s));

a += b;

return (a&0xFFFFFFFFL);

}

private static long II(long a, long b, long c, long d, long x, long s,

long ac) {

a += (I(b, c, d)&0xFFFFFFFFL) + x + ac;

a = ((a&0xFFFFFFFFL) << s) | ((a&0xFFFFFFFFL) >>> (32 - s));

a += b;

return (a&0xFFFFFFFFL);

}

}

MD5安全性:

普遍认为MD5是很安全,因为暴力破解的时间是一般人无法接受的。实际上如果把用户的密码MD5处理后再存储到数据库,其实是很不安全的。因为用户的密码是比较短的,而且很多用户的密码都使用生日,手机号码,身份证号码,电话号码等等。或者使用常用的一些吉利的数字,或者某个英文单词。如果我把常用的密码先MD5处理,把数据存储起来,然后再跟你的MD5结果匹配,这时我就有可能得到明文。

MD5 加密原理(转)的更多相关文章

  1. MD5加密和sha加密

    sha加密原理Algorithm)又叫安全哈希加密技术,是当今世界最先近的加密算法.主要用于文件身份识别.数字签名和口令加密等. 对于明文信息A,通过SHA1算法,生成一条160位长的识别码B.且明文 ...

  2. md5加密后不能解密

    MD5加密原理是散列算法,散列算法也称哈希算法.计算机专业学的数据结构就有哈希表这一知识点.比如10除以3余数为一,4除以3余数也为一,但余数为一的就不知道这个数是哪个了.所以md5不能解密.就算是设 ...

  3. md5 32位 加密原理 Java实现md5加密

    md5 32位 加密原理 简单概括起来,MD5 算法的过程分为四步:处理原文,设置初始值,循环加工,拼接结果. 第一步:处理原文 首先,我们计算出原文长度(bit)对 512 求余的结果,如果不等于 ...

  4. app逆向万能的md5加密hook破解入参方法(其他加密用通用方法原理差不多,小白推荐)

    一.原理 安卓开发调用md5加密时候都会调用到系统类java.security.MessageDigest 加密时候会会调用里面2个关键方法update以及digest 根据这个原理我们开始写代码吧 ...

  5. aip接口中对url参数md5加密防篡改的原理

    目前网上所有开放api的网站中,数据的调用都是采用同一种方式,即: http:www.xxx.com/aa=1&bb=2...,原后对这些参数按字典顺序排序后进行md5加密,将md5加密串与接 ...

  6. MD5加密的Java实现

    在各种应用系统中,如果需要设置账户,那么就会涉及到储存用户账户信息的问题,为了保证所储存账户信息的安全,通常会采用MD5加密的方式来,进行储存.首先,简单得介绍一下,什么是MD5加密. MD5的全称是 ...

  7. java中使用MD5加密技术

    在项目中经常会对一些信息进行加密,现在常用的信息加密技术有:MD5.RSA.DES等,今天主要说一下,md5加密,以及如何在java代码根据自己的业务需求使用md5. MD5简介: MD5即Messa ...

  8. iOS,一行代码进行RSA、DES 、AES、MD5加密、解密

    本文为投稿文章,作者:Flying_Einstein(简书) 加密的Demo,欢迎下载 JAVA端的加密解密,读者可以看我同事的这篇文章:http://www.jianshu.com/p/98569e ...

  9. MD5加密操作

    MD5加密操作:MD5加密算法原理MD5的全称是Message-Digest Algorithm 5(信息-摘要算法),它的作用是让大容量信息在用数字签名软件签署私人密匙前被"压缩" ...

随机推荐

  1. 51nod 1301 集合异或和(DP)

    因为当\(A<B\)时,会存在在二进制下的一位,满足这一位B的这一位是\(1\),\(A\)的这一位是\(0\). 我们枚举最大的这一位.设为\(x\)吧. 设计状态.\(dp[i][j][1/ ...

  2. 使用tf.ConfigProto()配置Session运行参数和GPU设备指定

    参考链接:https://blog.csdn.net/dcrmg/article/details/79091941 tf.ConfigProto()函数用在创建session的时候,用来对sessio ...

  3. ansible yum 模块 安装 vsftp

    [root@ftp:/root] > ansible ansible01 -u root -k -m yum -a 'name=vsftpd state=latest' SSH password ...

  4. 从YV12到NV12

    Media SDK的decoder,vpp,encoder对输入输出格式有着严格的限制,现在仅仅支持NV12.那么如何从其他格式转化为NV12是日常工作中经常遇到的事情.本篇文章以此为目的,讨论如何将 ...

  5. JS中Math函数基础

    Math 是数学函数,但又属于对象数据类型 typeof Math => ‘object’

  6. shell 测试命令

    一.使用 test 命令可以对文件.字符串等进行测试,一般配合控制语句使用. 1.字符串测试 test str1 = str2 //测试字符串是否相等 test str1 != str2 //测试字符 ...

  7. POJ 2230 Watchcow

    Watchcow Time Limit: 3000ms Memory Limit: 65536KB This problem will be judged on PKU. Original ID: 2 ...

  8. Qt之窗体透明

    简述 关于窗体透明,经常遇到,下面我们针对常用的透明效果进行讲解: 全透明(主窗体.子窗体均透明) 主窗体透明(子窗体不透明) 子窗体透明(主窗体不透明) 简述 正常状态 全透明 效果 源码 主窗体透 ...

  9. hdu Swipe Bo(bfs+状态压缩)错了多次的题

    Swipe Bo Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total S ...

  10. jmeter脚本编写之五类常见请求编写

    1.普通post请求 2.普通json请求 3.带query參数的json请求 4.xml请求 5.上传请求 starting (Windows系统 点击 F12 调出开发人员工具,选择Network ...