package lwp;
/
＠author 梁WP
/
public class MD5_Encoding
{
// RFC1321中定义的标准44矩阵的常量定义。
static final int S11 = 7， S12 = 12， S13 = 17， S14 = 22;
static final int S21 = 5， S22 = 9， S23 = 14， S24 = 20;
static final int S31 = 4， S32 = 11， S33 = 16， S34 = 23;
static final int S41 = 6， S42 = 10， S43 = 15， S44 = 21;
// 按RFC1321标准定义不成变byte型数组PADDING
static final byte[] PADDING =
{
-128， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0，
0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0，
0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0，
0， 0， 0， 0， 0， 0， 0
};
// MD5策画过程中的3组核心数据，采取数组情势存放
private long[] state = new long[4]; // 策画状况（分别对应a b c d）
private byte[] buffer = new byte[64]; // 分派64个字节私有缓冲区
private long[] count = new long[2]; // 位个数
// 新一次策画成果的16进制ASCII字符串默示，代表了16个字符串情势的MD5值
public String resultStr;
// 新一次策画成果的2进制数组默示，一共16个字节，代表了128bit情势的MD5值
public byte[] digest = new byte[16];
// MD5_Encoding类供给的首要的接口函数getMD5ofStr，用来进行数据加密变换。调用其可对随便率性字符串进行加密运算，并以字符串情势返回加密成果。
public String getMD5ofStr（String in）
{
md5Init（）; // 初始化
md5Update（in.getBytes（）， in.length（））;// 调用MD5的主策画过程
md5Final（）; // 输出成果到digest数组中
for （int i = 0; i < 16; i++）
{
resultStr += byteToHEX（digest[i]）; // 将digest数组中的每个byte型数据转为16进制情势的字符串
}
return resultStr;
}
// 标准的机关函数，调用md5Init函数进行初始化工作
public MD5_Encoding（）
{
md5Init（）;
}
// md5初始化函数.初始化核心变量.
private void md5Init（）
{
state[0] = 0 x67452301L; // 定义state为RFC1321中定义的标准幻数
state[1] = 0 xefcdab89L; // 定义state为RFC1321中定义的标准幻数
state[2] = 0 x98badcfeL; // 定义state为RFC1321中定义的标准幻数
state[3] = 0 x10325476L; // 定义state为RFC1321中定义的标准幻数
count[0] = count[1] = 0L; // 初始化为0
resultStr = ;// 初始化resultStr字符串为空
for （int i = 0; i < 16; i++）
{
digest[i] = 0;//初始化digest数组元素为0
}
}
//定义F G H I 为4个基数 ，即为4个根蒂根基的MD5函数，进行简单的位运算
private long F（long x， long y， long z）
{
return （x & y） | （（~x） & z）;
}
private long G（long x， long y， long z）
{
return （x & z） | （y & （~z））;
}
private long H（long x， long y， long z）
{
return x ^ y ^ z;
}
private long I（long x， long y， long z）
{
return y ^ （x | （~z））;
}
// FF，GG，HH和II调用F，G，H，I函数进行进一步变换
private long FF（long a， long b， long c， long d， long x， long s， long ac）
{
a += F（b， c， d） + x + ac;
a = （（int） a << s） | （（int） a >>> （32 - s））; //这里long型数据右移时应用无符号右移运算符>>>
a += b;
return a;
}
private long GG（long a， long b， long c， long d， long x， long s， long ac）
{
a += G（b， c， d） + x + ac;
a = （（int） a << s） | （（int） a >>> （32 - s））; //这里long型数据右移时应用无符号右移运算符>>>
a += b;
return a;
}
private long HH（long a， long b， long c， long d， long x， long s， long ac）
{
a += H（b， c， d） + x + ac;
a = （（int） a << s） | （（int） a >>> （32 - s））;//这里long型数据右移时应用无符号右移运算符>>>
a += b;
return a;
}
private long II（long a， long b， long c， long d， long x， long s， long ac）
{
a += I（b， c， d） + x + ac;
a = （（int） a << s） | （（int） a >>> （32 - s））;//这里long型数据右移时应用无符号右移运算符>>>
a += b;
return a;
}
// MD5的主策画过程，input是须要变换的二进制字节串，inputlen是长度
private void md5Update（byte[] input， int inputLen）
{
int i， index， partLen;
byte[] block = new byte[64]; // 分派64个字节缓冲区
//按照count策画index值。这里long型数据右移时应用无符号右移运算符>>>
index = （int） （count[0] >>> 3） & 0 x3F;
if （（count[0] += （inputLen << 3）） < （inputLen << 3））
{
count[1]++;
}
count[1] += （inputLen >>> 29）; //这里int型数据右移时应用无符号右移运算符>>>
partLen = 64 - index; //策画partLen值
if （inputLen >= partLen）
{
md5Memcpy（buffer， input， index， 0， partLen）;
md5Transform（buffer）;
for （i = partLen; i + 63 < inputLen; i += 64）
{
md5Memcpy（block， input， 0， i， 64）;
md5Transform（block）;
}
index = 0;
}
else
{
i = 0;
}
md5Memcpy（buffer， input， index， i， inputLen - i）;
}
// 收拾和填写输出成果，成果放到数组digest中。
private void md5Final（）
{
byte[] bits = new byte[8];
int index， padLen;
Encode（bits， count， 8）;
index = （int） （count[0] >>> 3） & 0 x3f; //这里long型数据右移时应用无符号右移运算符>>>
padLen = （index < 56） ？ （56 - index） : （120 - index）;
md5Update（PADDING， padLen）;
md5Update（bits， 8）;
Encode（digest， state， 16）;
}
// byte数组的块拷贝函数，将input数组中的肇端地位为inpos，长度len的数据拷贝到output数组肇端地位outpos处。
private void md5Memcpy（byte[] output， byte[] input， int outpos， int inpos，
int len）
{
int i;
for （i = 0; i < len; i++）
{
output[outpos + i] = input[inpos + i];
}
}
// MD5核心变换策画法度，由md5Update函数调用，block是分块的原始字节数组
private void md5Transform（byte block[]）
{
long a = state[0]， b = state[1]， c = state[2]， d = state[3];
long[] x = new long[16];
Decode（x， block， 64）;
// 进行4级级联运算
// 第1级
a = FF（a， b， c， d， x[0]， S11， 0 xd76aa478L）; / 1 /
d = FF（d， a， b， c， x[1]， S12， 0 xe8c7b756L）; / 2 /
c = FF（c， d， a， b， x[2]， S13， 0 x242070dbL）; / 3 /
b = FF（b， c， d， a， x[3]， S14， 0 xc1bdceeeL）; / 4 /
a = FF（a， b， c， d， x[4]， S11， 0 xf57c0fafL）; / 5 /
d = FF（d， a， b， c， x[5]， S12， 0 x4787c62aL）; / 6 /
c = FF（c， d， a， b， x[6]， S13， 0 xa8304613L）; / 7 /
b = FF（b， c， d， a， x[7]， S14， 0 xfd469501L）; / 8 /
a = FF（a， b， c， d， x[8]， S11， 0 x698098d8L）; / 9 /
d = FF（d， a， b， c， x[9]， S12， 0 x8b44f7afL）; / 10 /
c = FF（c， d， a， b， x[10]， S13， 0 xffff5bb1L）; / 11 /
b = FF（b， c， d， a， x[11]， S14， 0 x895cd7beL）; / 12 /
a = FF（a， b， c， d， x[12]， S11， 0 x6b901122L）; / 13 /
d = FF（d， a， b， c， x[13]， S12， 0 xfd987193L）; / 14 /
c = FF（c， d， a， b， x[14]， S13， 0 xa679438eL）; / 15 /
b = FF（b， c， d， a， x[15]， S14， 0 x49b40821L）; / 16 /
// 第2级
a = GG（a， b， c， d， x[1]， S21， 0 xf61e2562L）; / 17 /
d = GG（d， a， b， c， x[6]， S22， 0 xc040b340L）; / 18 /
c = GG（c， d， a， b， x[11]， S23， 0 x265e5a51L）; / 19 /
b = GG（b， c， d， a， x[0]， S24， 0 xe9b6c7aaL）; / 20 /
a = GG（a， b， c， d， x[5]， S21， 0 xd62f105dL）; / 21 /
d = GG（d， a， b， c， x[10]， S22， 0 x2441453L）; / 22 /
c = GG（c， d， a， b， x[15]， S23， 0 xd8a1e681L）; / 23 /
b = GG（b， c， d， a， x[4]， S24， 0 xe7d3fbc8L）; / 24 /
a = GG（a， b， c， d， x[9]， S21， 0 x21e1cde6L）; / 25 /
d = GG（d， a， b， c， x[14]， S22， 0 xc33707d6L）; / 26 /
c = GG（c， d， a， b， x[3]， S23， 0 xf4d50d87L）; / 27 /
b = GG（b， c， d， a， x[8]， S24， 0 x455a14edL）; / 28 /
a = GG（a， b， c， d， x[13]， S21， 0 xa9e3e905L）; / 29 /
d = GG（d， a， b， c， x[2]， S22， 0 xfcefa3f8L）; / 30 /
c = GG（c， d， a， b， x[7]， S23， 0 x676f02d9L）; / 31 /
b = GG（b， c， d， a， x[12]， S24， 0 x8d2a4c8aL）; / 32 /
// 第3级
a = HH（a， b， c， d， x[5]， S31， 0 xfffa3942L）; / 33 /
d = HH（d， a， b， c， x[8]， S32， 0 x8771f681L）; / 34 /
c = HH（c， d， a， b， x[11]， S33， 0 x6d9d6122L）; / 35 /
b = HH（b， c， d， a， x[14]， S34， 0 xfde5380cL）; / 36 /
a = HH（a， b， c， d， x[1]， S31， 0 xa4beea44L）; / 37 /
d = HH（d， a， b， c， x[4]， S32， 0 x4bdecfa9L）; / 38 /
c = HH（c， d， a， b， x[7]， S33， 0 xf6bb4b60L）; / 39 /
b = HH（b， c， d， a， x[10]， S34， 0 xbebfbc70L）; / 40 /
a = HH（a， b， c， d， x[13]， S31， 0 x289b7ec6L）; / 41 /
d = HH（d， a， b， c， x[0]， S32， 0 xeaa127faL）; / 42 /
c = HH（c， d， a， b， x[3]， S33， 0 xd4ef3085L）; / 43 /
b = HH（b， c， d， a， x[6]， S34， 0 x4881d05L）; / 44 /
a = HH（a， b， c， d， x[9]， S31， 0 xd9d4d039L）; / 45 /
d = HH（d， a， b， c， x[12]， S32， 0 xe6db99e5L）; / 46 /
c = HH（c， d， a， b， x[15]， S33， 0 x1fa27cf8L）; / 47 /
b = HH（b， c， d， a， x[2]， S34， 0 xc4ac5665L）; / 48 /
// 第4级
a = II（a， b， c， d， x[0]， S41， 0 xf4292244L）; / 49 /
d = II（d， a， b， c， x[7]， S42， 0 x432aff97L）; / 50 /
c = II（c， d， a， b， x[14]， S43， 0 xab9423a7L）; / 51 /
b = II（b， c， d， a， x[5]， S44， 0 xfc93a039L）; / 52 /
a = II（a， b， c， d， x[12]， S41， 0 x655b59c3L）; / 53 /
d = II（d， a， b， c， x[3]， S42， 0 x8f0ccc92L）; / 54 /
c = II（c， d， a， b， x[10]， S43， 0 xffeff47dL）; / 55 /
b = II（b， c， d， a， x[1]， S44， 0 x85845dd1L）; / 56 /
a = II（a， b， c， d， x[8]， S41， 0 x6fa87e4fL）; / 57 /
d = II（d， a， b， c， x[15]， S42， 0 xfe2ce6e0L）; / 58 /
c = II（c， d， a， b， x[6]， S43， 0 xa3014314L）; / 59 /
b = II（b， c， d， a， x[13]， S44， 0 x4e0811a1L）; / 60 /
a = II（a， b， c， d， x[4]， S41， 0 xf7537e82L）; / 61 /
d = II（d， a， b， c， x[11]， S42， 0 xbd3af235L）; / 62 /
c = II（c， d， a， b， x[2]， S43， 0 x2ad7d2bbL）; / 63 /
b = II（b， c， d， a， x[9]， S44， 0 xeb86d391L）; / 64 /
//分别累加到state[0]，state[1]，state[2]，state[3]
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
}
// 把byte型数据转换为无符号long型数据
private static long byteToul（byte b）
{
return b > 0 ？ b : （b & 0 x7F + 128）;
}
// 把byte类型的数据转换成十六进制ASCII字符默示
private static String byteToHEX（byte in）
{
char[] DigitStr =
{
0， 1， 2， 3， 4， 5， 6， 7， 8， 9，
A， B， C， D， E， F
};
char[] out = new char[2];
out[0] = DigitStr[（in >> 4） & 0 x0F]; //取高4位
out[1] = DigitStr[in & 0 x0F]; //取低4位
String s = new String（out）;
return s;
}
// 将long型数组按次序拆成byte型数组，长度为len
private void Encode（byte[] output， long[] input， int len）
{
int i， j;
for （i = 0， j = 0; j < len; i++， j += 4）
{
output[j] = （byte） （input[i] & 0 xffL）;
output[j + 1] = （byte） （（input[i] >>> 8） & 0 xffL）;
output[j + 2] = （byte） （（input[i] >>> 16） & 0 xffL）;
output[j + 3] = （byte） （（input[i] >>> 24） & 0 xffL）;
}
}
// 将byte型数组按次序合成long型数组，长度为len
private void Decode（long[] output， byte[] input， int len）
{
int i， j;
for （i = 0， j = 0; j < len; i++， j += 4）
{
output[i] = byteToul（input[j]）
| （byteToul（input[j + 1]） << 8）
| （byteToul（input[j + 2]） << 16）
| （byteToul（input[j + 3]） << 24）;
}
}
}
