节省资源的MD5算法

public final class Md5
{
/** return BytesMd5 (bytes, 0, Integer.MAX_VALUE) */
public static int[] BytesMd5(byte[] bytes)
{
return BytesMd5(bytes, 0, Integer.MAX_VALUE);
}

/**
* give the bytes and get the md result
* null bytes means from and end1 is 0
* return value is locally allocated array
* return[0] is highest 32 bits, return[3] is lowest 32 bits
* (((long)return[0]) << 32) | (return[1] & 0xFFFFFFFFL) is high 64 bits
* (((long)return[2]) << 32) | (return[3] & 0xFFFFFFFFL) is low 64 bits
* thread-safe without synchronized
*/
public static int[] BytesMd5(byte[] bytes, int from, int end1)
{
// bytes = Util.MaskNull(bytes);
// from = Util.Bound(from, 0, bytes.length);
// end1 = Util.Bound(end1, from, bytes.length);
/** !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
add code for checking the arguments here
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/

int[] x = new int[20]; // x[16-19] means the md result in little-endian
x[16] = 0x67452301;
x[17] = 0xEFCDAB89;
x[18] = 0x98BADCFE;
x[19] = 0x10325476;
int n;
int d;
for (n = 0, d = from; d < end1 - 3; d += 4)
{
x[n++] = (bytes[d] & 0xFF) | ((bytes[d + 1] & 0xFF) << 8) //
| ((bytes[d + 2] & 0xFF) << 16) | ((bytes[d + 3] & 0xFF) << 24);
if (n == 16)
{
Transform(x);
n = 0;
}
}
if (d == end1)
x[n++] = 0x80;
else if (d == end1 - 1)
x[n++] = (bytes[d] & 0xFF) | 0x8000;
else if (d == end1 - 2)
x[n++] = (bytes[d] & 0xFF) | ((bytes[d + 1] & 0xFF) << 8) | 0x800000;
else /* d == len - 3 */
x[n++] = (bytes[d] & 0xFF) | ((bytes[d + 1] & 0xFF) << 8) //
| ((bytes[d + 2] & 0xFF) << 16) | 0x80000000;
if (n == 15)
x[n++] = 0;
if (n == 16)
{
Transform(x);
n = 0;
}
if (n < 14)
for ( ; n < 14; n++)
x[n] = 0;
x[14] = (end1 - from) << 3;
x[15] = (end1 - from) >> 29;
Transform(x);
x[0] = x[19];
x[1] = x[18];
x[2] = x[17];
x[3] = x[16];
return x;
}

/** return UnicodeMd5 (chars, 0, Integer.MAX_VALUE) */
public static int[] UnicodeMd5(char[] chars)
{
return UnicodeMd5(chars, 0, Integer.MAX_VALUE);
}

/**
* give the unicode chars and get the md result
* null chars means from and end1 is 0
* each unicode char is treated as two bytes in big-endian
* return value is locally allocated array
* return[0] is highest 32 bits, return[3] is lowest 32 bits
* (((long)return[0]) << 32) | (return[1] & 0xFFFFFFFFL) is high 64 bits
* (((long)return[2]) << 32) | (return[3] & 0xFFFFFFFFL) is low 64 bits
* thread-safe without synchronized
*/
public static int[] UnicodeMd5(char[] chars, int from, int end1)
{
// chars = Util.MaskNull(chars);
// from = Util.Bound(from, 0, chars.length);
// end1 = Util.Bound(end1, from, chars.length);
/** !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
add code for checking the arguments here
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
int[] x = new int[20]; // x[16-19] means the md result in little-endian
x[16] = 0x67452301;
x[17] = 0xEFCDAB89;
x[18] = 0x98BADCFE;
x[19] = 0x10325476;
int n;
int d;
for (n = 0, d = from; d < end1 - 1; d += 2)
{
x[n++] = (chars[d] >>> 8) | ((chars[d] & 0xFF) << 8) //
| ((chars[d + 1] >>> 8) << 16) | ((chars[d + 1] & 0xFF) << 24);
if (n == 16)
{
Transform(x);
n = 0;
}
}
if (d == end1)
x[n++] = 0x80;
else /* d == end1 - 1 */
x[n++] = (chars[d] >>> 8) | ((chars[d] & 0xFF) << 8) | 0x800000;
if (n == 15)
x[n++] = 0;
if (n == 16)
{
Transform(x);
n = 0;
}
if (n < 14)
for ( ; n < 14; n++)
x[n] = 0;
x[14] = (end1 - from) << 4;
x[15] = (end1 - from) >> 28;
Transform(x);
x[0] = x[19];
x[1] = x[18];
x[2] = x[17];
x[3] = x[16];
return x;
}

/** return UnicodeMd5(s, 0, Integer.MAX_VALUE) */
public static int[] UnicodeMd5(String s)
{
return UnicodeMd5(s, 0, Integer.MAX_VALUE);
}

/**
* give the unicode str and get the md result
* null str means from and end1 is 0
* each unicode char is treated as two bytes in big-endian
* return value is locally allocated array
* return[0] is highest 32 bits, return[3] is lowest 32 bits
* (((long)return[0]) << 32) | (return[1] & 0xFFFFFFFFL) is high 64 bits
* (((long)return[2]) << 32) | (return[3] & 0xFFFFFFFFL) is low 64 bits
* thread-safe without synchronized
*/
public static int[] UnicodeMd5(String str, int from, int end1)
{
// str = Util.MaskNull(str);
// from = Util.Bound(from, 0, str.length());
// end1 = Util.Bound(end1, from, str.length());
/** !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
add code for checking the arguments here
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
int[] x = new int[20]; // x[16-19] means the md result in little-endian
x[16] = 0x67452301;
x[17] = 0xEFCDAB89;
x[18] = 0x98BADCFE;
x[19] = 0x10325476;
int n;
int d;
for (n = 0, d = from; d < end1 - 1; d += 2)
{
x[n++] = (str.charAt(d) >>> 8) | ((str.charAt(d) & 0xFF) << 8) //
| ((str.charAt(d + 1) >>> 8) << 16) | ((str.charAt(d + 1) & 0xFF) << 24);
if (n == 16)
{
Transform(x);
n = 0;
}
}
if (d == end1)
x[n++] = 0x80;
else /* d == end1 - 1 */
x[n++] = (str.charAt(d) >>> 8) | ((str.charAt(d) & 0xFF) << 8) | 0x800000;
if (n == 15)
x[n++] = 0;
if (n == 16)
{
Transform(x);
n = 0;
}
if (n < 14)
for ( ; n < 14; n++)
x[n] = 0;
x[14] = (end1 - from) << 4;
x[15] = (end1 - from) >> 28;
Transform(x);
x[0] = x[19];
x[1] = x[18];
x[2] = x[17];
x[3] = x[16];
return x;
}

private static int F(int x, int y, int z)
{
return (x & y) | ((~x) & z);
}

private static int G(int x, int y, int z)
{
return (x & z) | (y & (~z));
}

private static int H(int x, int y, int z)
{
return x ^ y ^ z;
}

private static int I(int x, int y, int z)
{
return y ^ (x | (~z));
}

private static int FF(int a, int b, int c, int d, int x, int s, int ac)
{
a += F(b, c, d) + x + ac;
return ((a << s) | (a >>> (32 - s))) + b;
}

private static int GG(int a, int b, int c, int d, int x, int s, int ac)
{
a += G(b, c, d) + x + ac;
return ((a << s) | (a >>> (32 - s))) + b;
}

private static int HH(int a, int b, int c, int d, int x, int s, int ac)
{
a += H(b, c, d) + x + ac;
return ((a << s) | (a >>> (32 - s))) + b;
}

private static int II(int a, int b, int c, int d, int x, int s, int ac)
{
a += I(b, c, d) + x + ac;
return ((a << s) | (a >>> (32 - s))) + b;
}

private static void Transform(int[] x)
{
int a = x[16], b = x[17], c = x[18], d = x[19];
//
// Round 1
a = FF(a, b, c, d, x[0], 7, 0xD76AA478);
d = FF(d, a, b, c, x[1], 12, 0xE8C7B756);
c = FF(c, d, a, b, x[2], 17, 0x242070DB);
b = FF(b, c, d, a, x[3], 22, 0xC1BDCEEE);
//
a = FF(a, b, c, d, x[4], 7, 0xF57C0FAF);
d = FF(d, a, b, c, x[5], 12, 0x4787C62A);
c = FF(c, d, a, b, x[6], 17, 0xA8304613);
b = FF(b, c, d, a, x[7], 22, 0xFD469501);
//
a = FF(a, b, c, d, x[8], 7, 0x698098D8);
d = FF(d, a, b, c, x[9], 12, 0x8B44F7AF);
c = FF(c, d, a, b, x[10], 17, 0xFFFF5BB1);
b = FF(b, c, d, a, x[11], 22, 0x895CD7BE);
//
a = FF(a, b, c, d, x[12], 7, 0x6B901122);
d = FF(d, a, b, c, x[13], 12, 0xFD987193);
c = FF(c, d, a, b, x[14], 17, 0xA679438E);
b = FF(b, c, d, a, x[15], 22, 0x49B40821);
//
// Round 2
a = GG(a, b, c, d, x[1], 5, 0xF61E2562);
d = GG(d, a, b, c, x[6], 9, 0xC040B340);
c = GG(c, d, a, b, x[11], 14, 0x265E5A51);
b = GG(b, c, d, a, x[0], 20, 0xE9B6C7AA);
//
a = GG(a, b, c, d, x[5], 5, 0xD62F105D);
d = GG(d, a, b, c, x[10], 9, 0x2441453);
c = GG(c, d, a, b, x[15], 14, 0xD8A1E681);
b = GG(b, c, d, a, x[4], 20, 0xE7D3FBC8);
//
a = GG(a, b, c, d, x[9], 5, 0x21E1CDE6);
d = GG(d, a, b, c, x[14], 9, 0xC33707D6);
c = GG(c, d, a, b, x[3], 14, 0xF4D50D87);
b = GG(b, c, d, a, x[8], 20, 0x455A14ED);
//
a = GG(a, b, c, d, x[13], 5, 0xA9E3E905);
d = GG(d, a, b, c, x[2], 9, 0xFCEFA3F8);
c = GG(c, d, a, b, x[7], 14, 0x676F02D9);
b = GG(b, c, d, a, x[12], 20, 0x8D2A4C8A);
//
// Round 3
a = HH(a, b, c, d, x[5], 4, 0xFFFA3942);
d = HH(d, a, b, c, x[8], 11, 0x8771F681);
c = HH(c, d, a, b, x[11], 16, 0x6D9D6122);
b = HH(b, c, d, a, x[14], 23, 0xFDE5380C);
//
a = HH(a, b, c, d, x[1], 4, 0xA4BEEA44);
d = HH(d, a, b, c, x[4], 11, 0x4BDECFA9);
c = HH(c, d, a, b, x[7], 16, 0xF6BB4B60);
b = HH(b, c, d, a, x[10], 23, 0xBEBFBC70);
//
a = HH(a, b, c, d, x[13], 4, 0x289B7EC6);
d = HH(d, a, b, c, x[0], 11, 0xEAA127FA);
c = HH(c, d, a, b, x[3], 16, 0xD4EF3085);
b = HH(b, c, d, a, x[6], 23, 0x4881D05);
//
a = HH(a, b, c, d, x[9], 4, 0xD9D4D039);
d = HH(d, a, b, c, x[12], 11, 0xE6DB99E5);
c = HH(c, d, a, b, x[15], 16, 0x1FA27CF8);
b = HH(b, c, d, a, x[2], 23, 0xC4AC5665);
//
// Round 4
a = II(a, b, c, d, x[0], 6, 0xF4292244);
d = II(d, a, b, c, x[7], 10, 0x432AFF97);
c = II(c, d, a, b, x[14], 15, 0xAB9423A7);
b = II(b, c, d, a, x[5], 21, 0xFC93A039);
//
a = II(a, b, c, d, x[12], 6, 0x655B59C3);
d = II(d, a, b, c, x[3], 10, 0x8F0CCC92);
c = II(c, d, a, b, x[10], 15, 0xFFEFF47D);
b = II(b, c, d, a, x[1], 21, 0x85845DD1);
//
a = II(a, b, c, d, x[8], 6, 0x6FA87E4F);
d = II(d, a, b, c, x[15], 10, 0xFE2CE6E0);
c = II(c, d, a, b, x[6], 15, 0xA3014314);
b = II(b, c, d, a, x[13], 21, 0x4E0811A1);
//
a = II(a, b, c, d, x[4], 6, 0xF7537E82);
d = II(d, a, b, c, x[11], 10, 0xBD3AF235);
c = II(c, d, a, b, x[2], 15, 0x2AD7D2BB);
b = II(b, c, d, a, x[9], 21, 0xEB86D391);
//
//
x[16] += a;
x[17] += b;
x[18] += c;
x[19] += d;
}
}