Android MD5校驗碼的生成與算法實現

時間 2019-11-24

原文原文鏈接

在Java中，java.security.MessageDigest （rt.jar中）已經定義了 MD5 的計算，因此咱們只須要簡單地調用便可獲得 MD5 的128 位整數。而後將此 128 位計 16 個字節轉換成 16 進製表示便可。 java

下面是一個可生成字符串或文件MD5校驗碼的例子，測試過，可當作工具類直接使用，其中最主要的是getMD5String(String s)和getFileMD5String(File file)兩個方法，分別用於生成字符串的md5校驗值和生成文件的md5校驗值，getFileMD5String_old(File file)方法可刪除，不建議使用：git

Java代碼

package com.why.md5;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class MD5Util {
/**
* 默認的密碼字符串組合，用來將字節轉換成 16 進製表示的字符,apache校驗下載的文件的正確性用的就是默認的這個組合
*/
protected static char hexDigits[] = { '0' , '1' , '2' , '3' , '4' , '5' , '6' ,
'7' , '8' , '9' , 'a' , 'b' , 'c' , 'd' , 'e' , 'f' };
protected static MessageDigest messagedigest = null ;
static {
try {
messagedigest = MessageDigest.getInstance("MD5" );
} catch (NoSuchAlgorithmException nsaex) {
System.err.println(MD5Util.class .getName()
+ "初始化失敗，MessageDigest不支持MD5Util。" );
nsaex.printStackTrace();
}
}
/**
* 生成字符串的md5校驗值
*
* @param s
* @return
*/
public static String getMD5String(String s) {
return getMD5String(s.getBytes());
}
/**
* 判斷字符串的md5校驗碼是否與一個已知的md5碼相匹配
*
* @param password 要校驗的字符串
* @param md5PwdStr 已知的md5校驗碼
* @return
*/
public static boolean checkPassword(String password, String md5PwdStr) {
String s = getMD5String(password);
return s.equals(md5PwdStr);
}
/**
* 生成文件的md5校驗值
*
* @param file
* @return
* @throws IOException
*/
public static String getFileMD5String(File file) throws IOException {
InputStream fis;
fis = new FileInputStream(file);
byte [] buffer = new byte [ 1024 ];
int numRead = 0 ;
while ((numRead = fis.read(buffer)) > 0 ) {
messagedigest.update(buffer, 0 , numRead);
}
fis.close();
return bufferToHex(messagedigest.digest());
}
/**
* JDK1.4中不支持以MappedByteBuffer類型爲參數update方法，而且網上有討論要慎用MappedByteBuffer，
* 緣由是當使用 FileChannel.map 方法時，MappedByteBuffer 已經在系統內佔用了一個句柄，
* 而使用 FileChannel.close 方法是沒法釋放這個句柄的，且FileChannel有沒有提供相似 unmap 的方法，
* 所以會出現沒法刪除文件的狀況。
*
* 不推薦使用
*
* @param file
* @return
* @throws IOException
*/
public static String getFileMD5String_old(File file) throws IOException {
FileInputStream in = new FileInputStream(file);
FileChannel ch = in.getChannel();
MappedByteBuffer byteBuffer = ch.map(FileChannel.MapMode.READ_ONLY, 0 ,
file.length());
messagedigest.update(byteBuffer);
return bufferToHex(messagedigest.digest());
}
public static String getMD5String( byte [] bytes) {
messagedigest.update(bytes);
return bufferToHex(messagedigest.digest());
}
private static String bufferToHex( byte bytes[]) {
return bufferToHex(bytes, 0 , bytes.length);
}
private static String bufferToHex( byte bytes[], int m, int n) {
StringBuffer stringbuffer = new StringBuffer( 2 * n);
int k = m + n;
for ( int l = m; l < k; l++) {
appendHexPair(bytes[l], stringbuffer);
}
return stringbuffer.toString();
}
private static void appendHexPair( byte bt, StringBuffer stringbuffer) {
char c0 = hexDigits[(bt & 0xf0 ) >> 4 ]; // 取字節中高 4 位的數字轉換, >>> 爲邏輯右移，將符號位一塊兒右移,此處未發現兩種符號有何不一樣
char c1 = hexDigits[bt & 0xf ]; // 取字節中低 4 位的數字轉換
stringbuffer.append(c0);
stringbuffer.append(c1);
}
public static void main(String[] args) throws IOException {
long begin = System.currentTimeMillis();
File file = new File( "C:/12345.txt" );
String md5 = getFileMD5String(file);
// String md5 = getMD5String("a");
long end = System.currentTimeMillis();
System.out.println("md5:" + md5 + " time:" + ((end - begin) / 1000 ) + "s" );
}
}

Java代碼

package com.why.md5;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class MD5Util {
/**
* 默認的密碼字符串組合，用來將字節轉換成 16 進製表示的字符,apache校驗下載的文件的正確性用的就是默認的這個組合
*/
protected static char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
protected static MessageDigest messagedigest = null;
static {
try {
messagedigest = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException nsaex) {
System.err.println(MD5Util.class.getName()
+ "初始化失敗，MessageDigest不支持MD5Util。");
nsaex.printStackTrace();
}
}
/**
* 生成字符串的md5校驗值
*
* @param s
* @return
*/
public static String getMD5String(String s) {
return getMD5String(s.getBytes());
}
/**
* 判斷字符串的md5校驗碼是否與一個已知的md5碼相匹配
*
* @param password 要校驗的字符串
* @param md5PwdStr 已知的md5校驗碼
* @return
*/
public static boolean checkPassword(String password, String md5PwdStr) {
String s = getMD5String(password);
return s.equals(md5PwdStr);
}
/**
* 生成文件的md5校驗值
*
* @param file
* @return
* @throws IOException
*/
public static String getFileMD5String(File file) throws IOException {
InputStream fis;
fis = new FileInputStream(file);
byte[] buffer = new byte[1024];
int numRead = 0;
while ((numRead = fis.read(buffer)) > 0) {
messagedigest.update(buffer, 0, numRead);
}
fis.close();
return bufferToHex(messagedigest.digest());
}
/**
* JDK1.4中不支持以MappedByteBuffer類型爲參數update方法，而且網上有討論要慎用MappedByteBuffer，
* 緣由是當使用 FileChannel.map 方法時，MappedByteBuffer 已經在系統內佔用了一個句柄，
* 而使用 FileChannel.close 方法是沒法釋放這個句柄的，且FileChannel有沒有提供相似 unmap 的方法，
* 所以會出現沒法刪除文件的狀況。
*
* 不推薦使用
*
* @param file
* @return
* @throws IOException
*/
public static String getFileMD5String_old(File file) throws IOException {
FileInputStream in = new FileInputStream(file);
FileChannel ch = in.getChannel();
MappedByteBuffer byteBuffer = ch.map(FileChannel.MapMode.READ_ONLY, 0,
file.length());
messagedigest.update(byteBuffer);
return bufferToHex(messagedigest.digest());
}
public static String getMD5String(byte[] bytes) {
messagedigest.update(bytes);
return bufferToHex(messagedigest.digest());
}
private static String bufferToHex(byte bytes[]) {
return bufferToHex(bytes, 0, bytes.length);
}
private static String bufferToHex(byte bytes[], int m, int n) {
StringBuffer stringbuffer = new StringBuffer(2 * n);
int k = m + n;
for (int l = m; l < k; l++) {
appendHexPair(bytes[l], stringbuffer);
}
return stringbuffer.toString();
}
private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
char c0 = hexDigits[(bt & 0xf0) >> 4];// 取字節中高 4 位的數字轉換, >>> 爲邏輯右移，將符號位一塊兒右移,此處未發現兩種符號有何不一樣
char c1 = hexDigits[bt & 0xf];// 取字節中低 4 位的數字轉換
stringbuffer.append(c0);
stringbuffer.append(c1);
}
public static void main(String[] args) throws IOException {
long begin = System.currentTimeMillis();
File file = new File("C:/12345.txt");
String md5 = getFileMD5String(file);
// String md5 = getMD5String("a");
long end = System.currentTimeMillis();
System.out.println("md5:" + md5 + " time:" + ((end - begin) / 1000) + "s");
}
}

MD5的全稱是Message-digest Algorithm 5（信息-摘要算法），用於確保信息傳輸完整一致。90年代初由MIT的計算機科學實驗室和RSA Data Security Inc的Ronald L. Rivest開發出來，經MD二、MD3和MD4發展而來。算法

任何一個字符串或文件，不管是可執行程序、圖像文件、臨時文件或者其餘任何類型的文件，也無論它體積多大，都有且只有一個獨一無二的MD5信息碼，而且若是這個文件被修改過，它的MD5碼也將隨之改變。apache

Message-Digest泛指字節串(Message)的Hash變換，就是把一個任意長度的字節串變換成必定長的大整數。注意這裏說的是「字節串」而不是「字符串」，由於這種變換隻與字節的值有關，與字符集或編碼方式無關。數組

MD5用的是哈希函數，在計算機網絡中應用較多的不可逆加密算法有RSA公司發明的MD5算法和由美國國家技術標準研究所建議的安全散列算法SHA。安全

MD5將任意長度的「字節串」變換成一個128bit的大整數，而且它是一個不可逆的字符串變換算法，換句話說就是，即便你看到源程序和算法描述，也沒法將一個MD5的值變換回原始的字符串，從數學原理上說，是由於原始的字符串有無窮多個，這有點象不存在反函數的數學函數。因此，要遇到了md5密碼的問題，比較好的辦法是：你能夠用這個系統中的md5()函數從新設一個密碼，如admin，把生成的一串密碼的Hash值覆蓋原來的Hash值就好了。網絡

MD5的典型應用是對一段Message(字節串)產生fingerprint(指紋)，以防止被「篡改」。舉個例子，你將一段話寫在一個叫 readme.txt文件中，並對這個readme.txt產生一個MD5的值並記錄在案，而後你能夠傳播這個文件給別人，別人若是修改了文件中的任何內容，你對這個文件從新計算MD5時就會發現（兩個MD5值不相同）。若是再有一個第三方的認證機構，用MD5還能夠防止文件做者的「抵賴」，這就是所謂的數字簽名應用。app

　　MD5還普遍用於操做系統的登錄認證上，如Unix、各種BSD系統登陸密碼、數字簽名等諸多方。如在UNIX系統中用戶的密碼是以 MD5（或其它相似的算法）經Hash運算後存儲在文件系統中。當用戶登陸的時候，系統把用戶輸入的密碼進行MD5 Hash運算，而後再去和保存在文件系統中的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算法定義在RFC 1321中，由Ron Rivest（RSA公司）在1992年提出。然而不少學者已經找出了構造md5衝突的方法。這些人中包括中國山東大學的王教授和Hans Dobbertin。因此，單純使用md5的信息認證模式變得不可靠了。但並非說md5不可以使用。

MD5以512位分組來處理輸入的信息，且每一分組又被劃分爲16個32位子分組，通過了一系列的處理後，算法的輸出由四個32位分組組成，將這四個32位分組級聯後將生成一個128位散列值。

MD5算法的計算步驟：

1.經過添加一個1和若干個0的方式，把輸入數據長度（按照字節算）變成64m+56
2.添加8個字節到輸入數據中去，這樣輸入數據長度變成了64的倍數
3.把數據劃分紅塊，每塊64個字節
4.初始狀況下，輸出爲：
m_state[0] = 0x67452301L;
m_state[1] = 0xefcdab89L;
m_state[2] = 0x98badcfeL;
m_state[3] = 0x10325476L;
5.分別對每塊進行計算。輸出最後結果。

MD5的算法在RFC1321中實際上已經提供了C的實現，須要注意的是，不少早期的C編譯器的int類型是16 bit的，MD5使用了unsigned long int，並認爲它是32bit的無符號整數。而在Java中int是32 bit的，long是64 bit的。在MD5的C實現中，使用了大量的位操做。這裏須要指出的一點是，儘管Java提供了位操做，因爲Java沒有unsigned類型，對於右移位操做多提供了一個無符號右移：>>>，等價於C中的 >> 對於unsigned 數的處理。

下面是一個MD5算法的Java實現：

Java代碼

package com.why.md5;
/*******************************************************************************
* MD5_SRC 類實現了RSA Data Security, Inc.在提交給IETF的RFC1321中的MD5_SRC message-digest
* 算法。
******************************************************************************/
public class MD5_SRC {
/*
* 下面這些S11-S44其實是一個4*4的矩陣，在原始的C實現中是用#define 實現的，這裏把它們實現成爲static
* final是表示了只讀，且能在同一個進程空間內的多個 Instance間共享
*/
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 ;
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 };
/*
* 下面的三個成員是keyBean計算過程當中用到的3個核心數據，在原始的C實現中被定義到keyBean_CTX結構中
*/
private long [] state = new long [ 4 ]; // state (ABCD)
private long [] count = new long [ 2 ]; // number of bits, modulo 2^64 (lsb first)
private byte [] buffer = new byte [ 64 ]; // input buffer
/*
* digestHexStr是keyBean的惟一一個公共成員，是最新一次計算結果的 16進制ASCII表示.
*/
public String digestHexStr;
/*
* digest,是最新一次計算結果的2進制內部表示，表示128bit的keyBean值.
*/
private byte [] digest = new byte [ 16 ];
/*
* getkeyBeanofStr是類keyBean最主要的公共方法，入口參數是你想要進行keyBean變換的字符串
* 返回的是變換完的結果，這個結果是從公共成員digestHexStr取得的．
*/
public String getkeyBeanofStr(String inbuf) {
keyBeanInit();
keyBeanUpdate(inbuf.getBytes(), inbuf.length());
keyBeanFinal();
digestHexStr = "" ;
for ( int i = 0 ; i < 16 ; i++) {
digestHexStr += byteHEX(digest[i]);
}
return digestHexStr;
}
// 這是keyBean這個類的標準構造函數，JavaBean要求有一個public的而且沒有參數的構造函數
public MD5_SRC() {
keyBeanInit();
return ;
}
/* keyBeanInit是一個初始化函數，初始化核心變量，裝入標準的幻數 */
private void keyBeanInit() {
count[0 ] = 0L;
count[1 ] = 0L;
// /* Load magic initialization constants.
state[0 ] = 0x67452301L;
state[1 ] = 0xefcdab89L;
state[2 ] = 0x98badcfeL;
state[3 ] = 0x10325476L;
return ;
}
/*
* F, G, H ,I 是4 個基本的keyBean函數，在原始的keyBean的C實現中，因爲它們是
* 簡單的位運算，可能出於效率的考慮把它們實現成了宏，在java中，咱們把它們實現成了private 方法，名字保持了原來C中的。
*/
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進行近一步變換 FF, GG, HH, and II transformations for
* rounds 1, 2, 3, and 4. Rotation is separate from addition to prevent
* recomputation.
*/
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));
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));
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));
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));
a += b;
return a;
}
/*
* keyBeanUpdate是keyBean的主計算過程，inbuf是要變換的字節串，inputlen是長度，這個
* 函數由getkeyBeanofStr調用，調用以前須要調用keyBeaninit，所以把它設計成private的
*/
private void keyBeanUpdate( byte [] inbuf, int inputLen) {
int i, index, partLen;
byte [] block = new byte [ 64 ];
index = (int ) (count[ 0 ] >>> 3 ) & 0x3F ;
// /* Update number of bits */
if ((count[ 0 ] += (inputLen << 3 )) < (inputLen << 3 ))
count[1 ]++;
count[1 ] += (inputLen >>> 29 );
partLen = 64 - index;
// Transform as many times as possible.
if (inputLen >= partLen) {
keyBeanMemcpy(buffer, inbuf, index, 0 , partLen);
keyBeanTransform(buffer);
for (i = partLen; i + 63 < inputLen; i += 64 ) {
keyBeanMemcpy(block, inbuf, 0 , i, 64 );
keyBeanTransform(block);
}
index = 0 ;
} else
i = 0 ;
// /* Buffer remaining input */
keyBeanMemcpy(buffer, inbuf, index, i, inputLen - i);
}
/*
* keyBeanFinal整理和填寫輸出結果
*/
private void keyBeanFinal() {
byte [] bits = new byte [ 8 ];
int index, padLen;
// /* Save number of bits */
Encode(bits, count, 8 );
// /* Pad out to 56 mod 64.
index = (int ) (count[ 0 ] >>> 3 ) & 0x3f ;
padLen = (index < 56 ) ? ( 56 - index) : ( 120 - index);
keyBeanUpdate(PADDING, padLen);
// /* Append length (before padding) */
keyBeanUpdate(bits, 8 );
// /* Store state in digest */
Encode(digest, state, 16 );
}
/*
* keyBeanMemcpy是一個內部使用的byte數組的塊拷貝函數，從input的inpos開始把len長度的
* 字節拷貝到output的outpos位置開始
*/
private void keyBeanMemcpy( byte [] output, byte [] input, int outpos,
int inpos, int len) {
int i;
for (i = 0 ; i < len; i++)
output[outpos + i] = input[inpos + i];
}
/*
* keyBeanTransform是keyBean核心變換程序，由keyBeanUpdate調用，block是分塊的原始字節
*/
private void keyBeanTransform( byte block[]) {
long a = state[ 0 ], b = state[ 1 ], c = state[ 2 ], d = state[ 3 ];
long [] x = new long [ 16 ];
Decode(x, block, 64 );
/* Round 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 */
/* Round 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 */
/* Round 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 */
/* Round 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 ] += a;
state[1 ] += b;
state[2 ] += c;
state[3 ] += d;
}
/*
* Encode把long數組按順序拆成byte數組，由於java的long類型是64bit的，只拆低32bit，以適應原始C實現的用途
*/
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] & 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);
}
}
/*
* Decode把byte數組按順序合成成long數組，由於java的long類型是64bit的，
* 只合成低32bit，高32bit清零，以適應原始C實現的用途
*/
private void Decode( long [] output, byte [] input, int len) {
int i, j;
for (i = 0 , j = 0 ; j < len; i++, j += 4 )
output[i] = b2iu(input[j]) | (b2iu(input[j + 1 ]) << 8 )
| (b2iu(input[j + 2 ]) << 16 ) | (b2iu(input[j + 3 ]) << 24 );
return ;
}
/*
* b2iu是我寫的一個把byte按照不考慮正負號的原則的」升位」程序，由於java沒有unsigned運算
*/
public static long b2iu( byte b) {
return b < 0 ? b & 0x7F + 128 : b;
}
/*
* byteHEX()，用來把一個byte類型的數轉換成十六進制的ASCII表示，
* 由於java中的byte的toString沒法實現這一點，咱們又沒有C語言中的 sprintf(outbuf,"%02X",ib)
*/
public static String byteHEX( byte ib) {
char [] Digit = { '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'A' ,
'B' , 'C' , 'D' , 'E' , 'F' };
char [] ob = new char [ 2 ];
ob[0 ] = Digit[(ib >>> 4 ) & 0X0F ];
ob[1 ] = Digit[ib & 0X0F ];
String s = new String(ob);
return s;
}
public static void main(String args[]) {
MD5_SRC m = new MD5_SRC();
System.out.println("keyBean Test suite:" );
System.out.println("keyBean(\"\"):" +m.getkeyBeanofStr( "" ));
System.out.println("keyBean(\"a\"):" +m.getkeyBeanofStr( "a" ));
System.out.println("keyBean(\"abc\"):" +m.getkeyBeanofStr( "abc" ));
System.out.println("keyBean(\"message digest\"):" +m.getkeyBeanofStr( "message digest" ));
System.out.println("keyBean(\"abcdefghijklmnopqrstuvwxyz\"):" +
m.getkeyBeanofStr("abcdefghijklmnopqrstuvwxyz" ));
System.out.println("keyBean(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\"):" +
m.getkeyBeanofStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" ));
}
}