MD5算法全解析-魔扣目錄

這段時間剛好正在做軟件安全的實驗和課設，學習了各種加密算法，比如對稱加密算法的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)<<<s)
GG(a,b,c,d,Mi,s,Kj) ：表示b+((a+G(b,c,d)+Mi+Kj)<<<s)
HH(a,b,c,d,Mi,s,Kj) ：表示b+((a+H(b,c,d)+Mi+Kj)<<<s)
II(a,b,c,d,Mi,s,Kj) ：表示b+((a+I(b,c,d)+Mi+Kj)<<<s)

四、算法實現

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的情況。

1.百度網盤的秒傳

看到這估計有人會有些疑問，什么是秒傳功能？不急，待我慢慢道來！

基本概念

假設現在有人分享了一個軟件安全書籍的百度云鏈接給我們，然后我們接下來的操作就是，打開這個鏈接，接著我們將其保存到我們自己的網盤上，然后你會發現不管這個資源有多大，都能在幾秒內保存到我們的網盤上，而這就是所謂的秒傳（個人理解有錯誤請指出）

原理

秒傳看上去很神奇，其實原理就是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 "";
 }

流程

上面核心算法的加鹽過程和驗證如下圖所示。