?? md5_encoding.java
字號:
package com.mvc.login;
import java.lang.*;
import java.math.*;
public class MD5_Encoding { //實現數據加密
static final int S11 = 7,S12 = 12,S13 = 17, S14 = 22; //RFC1321中定義的標準4*4矩陣的常量定義
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;
static final byte[] PADDING = { -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //按RFC1321標準定義不可變byte型數組PADDING
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 };
private long[] state = new long[4]; //計算狀態(分別對應a b c d)
private byte[] buffer = new byte[64]; //分配64個字節私有緩沖區
private long[] count = new long[2]; //位個數
public String resultStr; //最新一次計算結果的16進制ASCII字符串表示，代表了16個字符串形式的MD5值
public byte[] digest = new byte[16]; //最新一次計算結果的2進制數組表示，一共16個字節，代表了128bit形式的MD5值
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;
}
public MD5_Encoding() { //構造函數，調用md5Init函數進行初始化工作
md5Init();
return;
}
private void md5Init() { //初始化核心變量
state[0] = 0x67452301L; // 定義state為RFC1321中定義的標準幻數
state[1] = 0xefcdab89L; // 定義state為RFC1321中定義的標準幻數
state[2] = 0x98badcfeL; // 定義state為RFC1321中定義的標準幻數
state[3] = 0x10325476L; // 定義state為RFC1321中定義的標準幻數
count[0] = count[1] =0L; // 初始化為0
resultStr = "";// 初始化resultStr字符串為空
for(int i=0;i<16;i++) digest[i]=0;//初始化digest數組元素為0
return;
}
private long F(long x, long y, long z) { //定義F G H I 為4個基數 ，即為4個基本的MD5函數,進行簡單的位運算
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));
}
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;
}
private void md5Update(byte[] input, int inputLen) { //MD5的主計算過程
int i=0, index, partLen;
byte[] block = new byte[64]; // 分配64個字節緩沖區
//根據count計算index值。這里long型數據右移時使用無符號右移運算符>>>
index = (int) (count[0] >>> 3) & 0x3F;
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);
}
private void md5Final() { //整理和填寫輸出結果
byte[] bits = new byte[8];
int index, padLen;
Encode(bits, count, 8);
index = (int) (count[0] >>> 3) & 0x3f; //這里long型數據右移時使用無符號右移運算符>>>
padLen = (index < 56) ? (56 - index) : (120 - index);
md5Update(PADDING, padLen);
md5Update(bits, 8);
Encode(digest, state, 16);
}
private void md5Memcpy(byte[] output, byte[] input, int outpos, int inpos, int len) {//byte數組的塊拷貝函數
int i;
for (i = 0; i < len; i++)
output[outpos + i] = input[inpos + i];
}
private void md5Transform(byte block[]) { // MD5核心變換計算程序
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, 0xd76aa478L); /* 1 */
d = FF(d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */
c = FF(c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */
b = FF(b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */
a = FF(a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */
d = FF(d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */
c = FF(c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */
b = FF(b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */
a = FF(a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */
d = FF(d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */
c = FF(c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */
b = FF(b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */
a = FF(a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */
d = FF(d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */
c = FF(c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */
b = FF(b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */
// 第2級
a = GG(a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */
d = GG(d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */
c = GG(c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */
b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */
a = GG(a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */
d = GG(d, a, b, c, x[10], S22, 0x2441453L); /* 22 */
c = GG(c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */
b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */
a = GG(a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */
d = GG(d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */
c = GG(c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */
b = GG(b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */
a = GG(a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */
d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */
c = GG(c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */
b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */
// 第3級
a = HH(a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */
d = HH(d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */
c = HH(c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */
b = HH(b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */
a = HH(a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */
d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */
c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */
b = HH(b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */
a = HH(a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */
d = HH(d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */
c = HH(c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */
b = HH(b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */
a = HH(a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */
d = HH(d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */
c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */
b = HH(b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */
// 第4級
a = II(a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */
d = II(d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */
c = II(c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */
b = II(b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */
a = II(a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */
d = II(d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */
c = II(c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */
b = II(b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */
a = II(a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */
d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */
c = II(c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */
b = II(b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */
a = II(a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */
d = II(d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */
c = II(c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */
b = II(b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */
//分別累加到state[0],state[1],state[2],state[3]
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
}
private static long byteToul(byte b) { //把byte型數據轉換為無符號long型數據
return b >0 ?b : ( b & 0x7F + 128);
}
private static String byteToHEX(byte in) { //把byte類型的數據轉換成十六進制ASCII字符表示
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) & 0x0F]; //取高4位
out[1] = DigitStr[in & 0x0F]; //取低4位
String s = new String(out);
return s;
}
private void Encode(byte[] output, long[] input, int len) { //將long型數組按順序拆成byte型數組,長度為len
int i, j;
for (i = 0, j = 0; j < len; i++, j += 4) {
output[j] = (byte) (input[i] & 0xffL);
output[j + 1] = (byte) ((input[i] >>> 8) & 0xffL);
output[j + 2] = (byte) ((input[i] >>> 16) & 0xffL);
output[j + 3] = (byte) ((input[i] >>> 24) & 0xffL);
}
}
private void Decode(long[] output, byte[] input, int len) { //將byte型數組按順序合成long型數組，長度為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);
return;
}
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -