這段時間剛好正在做軟件安全的實驗和課設，學習了各種加密算法，比如對稱加密算法的DES,AES；非對稱加密算法的RSA；再如今天要講的主角-單向加密算法的MD5。為什麼這麼多算法，MD5成為了今天的豬腳呢？，這是因為個人感覺在目前Android開發中MD5算是比較常用的，所以很值得一講。所以今天讓我帶你們來全面認識我們的主角MD5。
一、基本概念
1. 單向加密算法
在介紹MD5算法前，很有必要解釋一下單向加密算法。單向加密，人如其名，就是隻能單向對明文進行加密，而不能逆向通過密文得到明文。該算法在加密過程中，在得到明文後，經過加密算法得到密文，不需要使用密鑰。因為沒有密鑰，所以就無法通過密文得到明文。
2. MD5算法
MD5,全稱Message Digest Algorithm 5，翻譯過來就是消息摘要算法第5版，是計算機安全領域廣泛使用的一種散列函數，用於確保信息傳輸的完整性。MD5算法是由MD2、MD3、MD4演變而來，是一種單向加密算法，一種不可逆的加密方式。
二、特點
1.長度固定
不過多長的數據，經過MD5加密後其MD5值長度都是固定的。MD5值長度固定為128位，而最後的值一般都用16進制數字表示，一個16進制數字佔4位，所以最後的MD5值都是用32個16進制數字表示。
2.計算簡單
MD5算法說到底還是散列算法，或者叫做哈希算法，所以計算一個數據的MD5值是比較容易的，同時加密速度也是很快的。
3.抗修改性
對原數據進行任何改動，哪怕只是修改1個字節，所得到的MD5值都有很大的區別。
4.強抗碰撞性
已知原數據和其MD5值，很難找到具有相同MD5值的數據，即很難偽造數據。這裡的碰撞在後面的安全性中會提到，在這裡我們簡單理解為一種破解手段。
三、原理
1.填充數據
首先計算數據長度（bit）對512求餘的結果，如果不等於448，就需要填充數據使得數據長度對512求餘的結果為448，其填充方式為第一位填充1，其餘位填充0.填充後數據長度為512*N+448。
2.記錄數據長度
用64位來存儲填充前數據的長度，這64位將加在填充後數據的後面，這樣最終的數據長度為512*N+448+64=(N+1)*512
3.裝入標準幻數
標準幻數其實就是4個整數，我們知道最終的MD5值長度為128位，按32位分成一組的話可以分成4組，而這4組結果就是由這4個標準幻數A,B,C,D經過不斷演變得到。在MD5官方的實現中，四個幻數為（16進制）：
A=01234567
B=89ABCDEF
C=FEDCBA98
D=76543210
其實上面是大端字節序的幻數，而在正常程序中，我們實現的是小端字節序，所以在程序中我們定義的幻數應該是：
A=0X67452301
B=0XEFCDAB89
C=0X98BADCFE
D=0X10325476
4.四輪循環運算
在上面對數據處理後，數據長度將是（N+1）/512,我們將每512位（64字節）作為一塊，總共要循環N+1次，並將塊細分為16個小組，每組的長度為32位（4字節），這16個小組即為一輪，總共得循環4輪，即64次循環。總的來說我們需要（N+1）個主循環，每個主循環包含了64次子循環，來不斷的改變幻數A,B,C,D才能最終得到數據的MD5值。
4.1 相關係數說明
1）4個非線性函數
- 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))
在4輪循環中，F,G,H,I會交替使用，第一輪使用F,第二輪使用G,第三輪使用H，第四輪使用I。即每隔16次循環會換一個函數。
2）Mi
將每一塊512位分成16等分，命名為M0~M15,每一等份長度為32位16次循環中，交替使用
3) Kj
常量數組，在64子循環中用到的常量都是不同的
4) s
左移量，每輪循環用的S各不相同，每輪總共有4個左移量，每4次循環為一週期
4.2 核心公式
總共有四個核心公式，與4個非線性函數一一對應，即每輪使用的核心公式裡的公式有差異。
- FF(a,b,c,d,Mi,s,Kj) ：表示b+((a+F(b,c,d)+Mi+Kj)<<
- GG(a,b,c,d,Mi,s,Kj) ：表示b+((a+G(b,c,d)+Mi+Kj)<<
- HH(a,b,c,d,Mi,s,Kj) ：表示b+((a+H(b,c,d)+Mi+Kj)<<
- II(a,b,c,d,Mi,s,Kj) ：表示b+((a+I(b,c,d)+Mi+Kj)<<
- GG(a,b,c,d,Mi,s,Kj) ：表示b+((a+G(b,c,d)+Mi+Kj)<<
四、算法實現
public class MD5 {
//16進制數字
private static final String[] hexes = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};
//標準的幻數
private static final long A = 0X67452301;
private static final long B = 0XEFCDAB89;
private static final long C = 0X98BADCFE;
private static final long D = 0X10325476;
//位移量s,行為輪，總共有4輪，列為每輪中的一次循環，總共16次
//下面這些S11-S44實際上是一個4*4的矩陣，在四輪循環運算中用到
private static final int S11 = 7;
private static final int S12 = 12;
private static final int S13 = 17;
private static final int S14 = 22;
private static final int S21 = 5;
private static final int S22 = 9;
private static final int S23 = 14;
private static final int S24 = 20;
private static final int S31 = 4;
private static final int S32 = 11;
private static final int S33 = 16;
private static final int S34 = 23;
private static final int S41 = 6;
private static final int S42 = 10;
private static final int S43 = 15;
private static final int S44 = 21;
//結果,共4*32=128位，初始值為幻數
private long[] result = {A, B, C, D};
/**
* 計算字符串數據的MD5值並返回
*
* @param src 數據
* @return 返回數據的MD5值
*/
public String digest(String src) {
byte[] inputBytes = src.getBytes();
int byteLen = inputBytes.length;//長度（字節）
//完整分組的個數
int groupCount = byteLen / 64;//每組512位（64字節）
long[] group;//每個小組(64字節)再細分後的16個小組(4字節)
//處理每一個完整分組
for (int step = 0; step < groupCount; step++) {
group = divGroup(inputBytes, step * 64);
trans(group);//處理分組，核心算法
}
//處理完整分組後的尾巴
int rest = byteLen % 64;//512位分組後的餘數
byte[] tempBytes = new byte[64];
//56個字節即488
if (rest <= 56) {
for (int i = 0; i < rest; i++) tempBytes[i] = inputBytes[byteLen - rest + i];
//不斷填充
if (rest < 56) {
//最高位填充1
tempBytes[rest] = (byte) (1 << 7);
//其餘位填充0
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;
}
group = divGroup(tempBytes, 0);
trans(group);//處理分組
} 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;
group = divGroup(tempBytes, 0);
trans(group);//處理分組
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;
}
group = divGroup(tempBytes, 0);
trans(group);//處理分組
}
//將Hash值轉換成十六進制的字符串
String resStr = "";
long temp;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
temp = result[i] & 0x0FL;
String a = hexes[(int) (temp)];
result[i] = result[i] >> 4;
temp = result[i] & 0x0FL;
resStr += hexes[(int) (temp)] + a;
result[i] = result[i] >> 4;
}
}
return resStr;
}
/**
* 從inputBytes的index開始取512位，作為新的分組
* 將每一個512位的分組再細分成16個小組，每個小組32位（8個字節）
*
* @param inputBytes
* @param index
* @return M
*/
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;
}
/**
* 這時不存在符號位（符號位存儲不再是代表正負），所以需要處理一下
*/
private 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 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));
}
private long FF(long a, long b, long c, long d, long M, long s, long K) {
a += (F(b, c, d) & 0xFFFFFFFFL) + M + K;
a = ((a & 0xFFFFFFFFL) << s) | ((a & 0xFFFFFFFFL) >>> (32 - s));
a += b;
return (a & 0xFFFFFFFFL);
}
private long GG(long a, long b, long c, long d, long M, long s, long K) {
a += (G(b, c, d) & 0xFFFFFFFFL) + M + K;
a = ((a & 0xFFFFFFFFL) << s) | ((a & 0xFFFFFFFFL) >>> (32 - s));
a += b;
return (a & 0xFFFFFFFFL);
}
private long HH(long a, long b, long c, long d, long M, long s, long K) {
a += (H(b, c, d) & 0xFFFFFFFFL) + M + K;
a = ((a & 0xFFFFFFFFL) << s) | ((a & 0xFFFFFFFFL) >>> (32 - s));
a += b;
return (a & 0xFFFFFFFFL);
}
private long II(long a, long b, long c, long d, long M, long s, long K) {
a += (I(b, c, d) & 0xFFFFFFFFL) + M + K;
a = ((a & 0xFFFFFFFFL) << s) | ((a & 0xFFFFFFFFL) >>> (32 - s));
a += b;
return (a & 0xFFFFFFFFL);
}
}五、Android中的實現
1.核心算法
1.1 計算字符串的MD5值
public static String encrypt(String src) throws Exception{
MessageDigest md5 = MessageDigest.getInstance("MD5");
//得到加密後的字節數組
byte[] bytes = md5.digest(src.getBytes());
StringBuilder result = new StringBuilder();
//將字節數組轉換成16進制式的字符串
for (byte b : bytes) {
//1個byte為8個bit,一個hex(16)進製為16bit,故1個byte可以用2個hex表示
String temp = Integer.toHexString(b & 0xff);
//不足2長度的用0來補充
if (temp.length() == 1) {
temp = "0" + temp;
}
result.append(temp);
}
//返回最終的字符串
return result.toString();
}1.2 計算文件的MD5值
public static String getFileMD5(File file){
if(file == null||!file.exists()) return "";
FileInputStream in = null;
byte[] buffer = new byte[1024];
StringBuilder res = new StringBuilder();
int len;
try {
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
in = new FileInputStream(file);
while ((len=in.read(buffer))!=-1){
//計算文件時需要通過分段讀取多次調用update來將數據更新給MessageDigest對象
messageDigest.update(buffer,0,len);
}
//真正計算文件的MD5值
byte[] bytes = messageDigest.digest();
//將字節數組轉換成16進制的字符串
for(byte b:bytes){
String temp = Integer.toHexString(b&0xff);
if(temp.length()!=2){
temp = "0"+temp;
}
res.append(temp);
}
//返回最終的字符串
return res.toString();
} catch (Exception e) {
e.printStackTrace();
} finally {
if(null!=in){
try {
in.close();
}catch (Exception e){
e.printStackTrace();
}
}
}
return res.toString();
}2.實際應用
2.1 密碼認證
密碼認證估計是MD5在Android中運用最廣泛的地方了。如今，正常的App都少不了註冊登錄的功能，而註冊登錄必不可少的就是密碼，密碼是用戶在Android設備註冊時需要向服務器發送密碼，然後服務器將密碼保存。這樣就存在一種問題，如果密碼以明文發送的的話，很可能在中途被惡意截取。又或者保存在服務器的密碼被洩漏，也會造成很大的危害，於是為了用戶的安全，一般會採用MD5對密碼進行加密，然後將加密後的密碼，其實就是密碼的MD5值發送給服務器，這樣即使MD5值洩漏，不法分子也很難得出正確的密碼。而登錄判定時，只需判斷輸入的密碼的MD5值與服務器中的MD5值是否相同即可。口說無憑！我們先來看看下面微信公眾平臺，來證明很多平臺的密碼是經過MD5加密的。
首先我們在微信公眾平臺網頁端輸入賬號和密碼
然後我們通過fiddler4爬取請求的接口，通過請求頭我們可以找到username和pwd的字段，可以斷定是賬號和密碼，接著核對賬號，確認是我們剛剛輸入的請求，然後核對pwd字段，結果發現是32位的字符串，我們可以斷定這個32位字符串應該是MD5值，因為我們知道MD5值長度固定為128位，然後用16進製表示的話，就是32個16進制數字（128/4）
接著我們使用 Wan Android中的MD5加密工具 來驗證此字符串是否為123456的MD5值。可以對比上下兩張圖，可以發現兩者的字符串是一樣的，所以我們可以斷定當我們登錄微信公眾平臺時，其密碼是經過MD5加密後發送給服務器，然後服務器對比數據庫中賬號所對應的密碼MD5值，由於不相同，所以返回了錯誤信息
2.2 一致性驗證
一致性驗證就是文件MD5值的應用，MD5加密時，將整個文件當作一個大文本信息，通過字符串變換算法，產生了唯一的MD5值。在Android中最常用的莫過於文件下載，比如首先服務器會預先給一個完整的文件提供一個MD5值，用戶下載該文件後，重新計算文件的MD5值，如果相同，證明文件已經被成功的下載了。如果不相同，則證明文件下載出錯或者當前文件還在下載中。在Android中使用計算文件的MD5值需要注意要將該操作放在子線程中操作，因為計算文件MD5值屬於耗時操作，不能在主線程運行，否則會出現OOM的情況。
看到這估計有人會有些疑問，什麼是秒傳功能？不急，待我慢慢道來！
基本概念
假設現在有人分享了一個軟件安全書籍的百度雲鏈接給我們，然後我們接下來的操作就是，打開這個鏈接，接著我們將其保存到我們自己的網盤上，然後你會發現不管這個資源有多大，都能在幾秒內保存到我們的網盤上，而這就是所謂的秒傳（個人理解有錯誤請指出）
原理
秒傳看上去很神奇，其實原理就是MD5的一致性驗證。當我們成功上傳資源到自己網盤時，服務器會計算這個完整文件的MD5值，然後保存在服務器上，當下一次要上傳文件時，網盤首先會檢測服務器是否有相同MD5值的文件，如果有的話，就直接從服務器複製到網盤上，這樣就省去了上傳的時間
過程
讓我們重新解釋下上面提到的例子：當分享人在分享軟件安全書籍的資源時，一定是通過自己的百度網盤上來進行分享，這就證明該資源已經保存在服務器中，接下來我們打開了這個鏈接，然後點擊保存時，網盤就檢測到這個資源的MD5值已經存在在服務器中，所以不需要佔用網絡帶寬，直接複製這個資源到我們的網盤上，從而實現了秒傳。總體過程下圖：
2.應用程序更新
也許你又納悶了，應用程序更新為什麼需要用到MD5?這是為了友好的用戶體驗以及安全性考慮，MD5一致性驗證可以防止下載的更新APK被惡意篡改或者防止下載的APK不完整造成不良的用戶體驗。MD5在應用程序更新中的主要作用就是：
- 檢驗APK文件簽名是否一致，防止下載被攔截和篡改
- 檢驗下載文件的完整性
五、安全性
上面講了這麼多，你會發現從MD5加密本身來講這個過程是不可逆的，但並不意味著MD5算法不可破解，破解對於MD5一致性認證沒多大影響，但是對於MD5的密碼認證來說是致命的。
1. 撞庫破解
如果讓我們猜密碼，肯定會猜“123456”,生日，手機號等，而撞庫的原理也就是這麼簡單。首先建立一個大型的數據庫，然後把最常見的，有可能出現的密碼，通過MD5加密成密文，並且以這些MD5值為主鍵加索引，將常見的密碼為單列存入數據庫中，並通過不斷的積累，形成一個巨大的密碼MD5數據庫，這樣當你截取到網絡上密碼的MD5值時，通過查詢這個巨大的數據庫來直接匹配MD5值，這就是所謂的撞庫。這麼一看撞庫有點類似窮舉法，所以撞庫破解的概率是很低的，但也不是說不可能破解。通過下面兩個網站就很容易獲得原文：
- www.cmd5.com/
- pmd5.com/}
2. MD5加鹽
2.1 原理
MD5加密可以通過撞庫來破解，因此為了防止內部人員和外部入侵者通過密碼的MD5來反查密碼明文，需要對密碼摻入其它信息，然後算出加工後的密碼的MD5值稱之為MD5加鹽。
2.2 加鹽算法
1.賬號+密碼
這個加鹽算法很簡單，就是將當註冊時將用戶名和密碼組合起來，然後計算其組合的MD5值作為密碼發送到服務器上，這樣就能增加反查的難度。但是這個加鹽算法也存在問題，當應用程序提供修改用戶名這一功能時，當用戶名發生變化時，密碼就不可用了（如果要用，就必須重新計算新的用戶名和密碼的MD5值然後發送給服務器，這樣修改用戶名，等於修改密碼的功能）
2.隨機數
原理
我們知道MD5加密有個特性，一個數據的MD5值永遠都是一樣的，也正是因為這個特性才有了MD5一致性的驗證，但是也是撞庫破解的一個入口。正是因為密碼的MD5值永遠都是一樣的，所以可以根據MD5值直接從數據庫中查詢出密碼。因此隨機數算法就是給密碼加入隨機數然後生成新的MD5值，這樣破壞這個特性，讓密碼的MD5值每次都是不一樣的。
核心算法
/**
* MD5加鹽
* @param password 密碼
* @return 密碼加鹽後的MD5值
*/
public static String salting(String password){
Random random = new Random();
//隨機數字符串最大容量為16位
StringBuilder sb = new StringBuilder(16);
//生成最多為16位的隨機字符串
sb.append(random.nextInt(99999999)).append(random.nextInt(99999999));
int len = sb.length();
//由於隨機字符串的長度不一定都是16位，做統一16位長度處理
if(len<16){
for (int i = 0; i < 16-len; i++) {
//在後面補0
sb.append("0");
}
}
//鹽
String salt = sb.toString();
//得到加鹽後密碼的16進制字符串,此時password的長度為32
password = md5toHex(password+salt);
//最終的結果長度為48位
char[] res = new char[48];
//48位中，按一定的規則將加鹽後的password存入res中
//總共循環16次
for (int i = 0; i < 48; i+=3) {
res[i] = password.charAt(i/3*2);
res[i+1] = salt.charAt(i/3);
res[i+2] = password.charAt(i/3*2+1);
}
//最終的md5值為48位，由16位隨機字符串和密碼加鹽後的md5值組成
return new String(res);
}
/**
* 驗證服務器中的密碼是否與輸入的密碼一致
* @param password 輸入的密碼
* @param md5 保存在服務器加鹽後的md5值
* @return 密碼是否正確
*/
public static boolean decode(String password,String md5){
//鹽，即隨機數
char[] salt = new char[16];
//真正加鹽後密碼的MD5值
char[] realMd5 = new char[32];
//按照加鹽規則提取出鹽和真正的MD5值
for (int i = 0; i < 48; i+=3) {
realMd5[i/3*2] = md5.charAt(i);
salt[i/3] = md5.charAt(i+1);
realMd5[i/3*2+1] = md5.charAt(i+2);
}
//得出密碼加鹽後的MD5值
String tempMd5 = md5toHex(password+new String(salt));
//與從服務器提取出來的真正MD5值進行對比
return new String(realMd5).equals(tempMd5);
}
/**
* 獲取16進制字符串形式的MD5值
* @param passwordAndSalt 密碼加入隨機數後的字符串
*/
private static String md5toHex(String passwordAndSalt){
try {
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
byte[] bytes = messageDigest.digest(passwordAndSalt.getBytes());
StringBuilder result = new StringBuilder();
//將字節數組轉換成16進制式的字符串
for (byte b : bytes) {
//1個byte為8個bit,一個hex(16)進製為16bit,故1個byte可以用2個hex表示
String temp = Integer.toHexString(b & 0xff);
//不足2長度的用0來補充
if (temp.length() == 1) {
temp = "0" + temp;
}
result.append(temp);
}
//返回最終的字符串
return result.toString();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return "";
}
流程
上面核心算法的加鹽過程和驗證如下圖所示。
總結
MD5看似是很簡單的加密算法，但是搞懂其底層實現原理並沒有想象中那麼容易。MD5加密算法不僅僅在安卓平臺上，在其它平臺上也是非常重要的一種加密算法。通過這次對MD5的學習，真的是收益匪淺，不僅僅讓我對MD5有了更深的理解，並且認識到了MD5和加密算法的重要性。
閱讀更多 sandag 的文章
