MD5算法全解析
前言
這段時間恰好正在作軟件安全的實驗和課設，學習了各類加密算法，好比對稱加密算法的DES,AES；非對稱加密算法的RSA；再現在天要講的主角-單向加密算法的MD5。爲何這麼多算法，MD5成爲了今天的豬腳呢？，這是由於我的感受在目前Android開發中MD5算是比較經常使用的，因此很值得一講。因此今天讓我帶大家來全面認識咱們的主角MD5。java
1、基本概念
1. 單向加密算法
在介紹MD5算法前，頗有必要解釋一下單向加密算法。單向加密，人如其名，就是隻能單向對明文進行加密，而不能逆向經過密文獲得明文。該算法在加密過程當中，在獲得明文後，通過加密算法獲得密文，不須要使用密鑰。由於沒有密鑰，因此就沒法經過密文獲得明文。android
2. MD5算法
MD5,全稱Message Digest Algorithm 5，翻譯過來就是消息摘要算法第5版，是計算機安全領域普遍使用的一種散列函數，用於確保信息傳輸的完整性。MD5算法是由MD二、MD三、MD4演變而來，是一種單向加密算法，一種不可逆的加密方式。git
2、特色
1.長度固定
不過多長的數據，通過MD5加密後其MD5值長度都是固定的。MD5值長度固定爲128位，而最後的值通常都用16進制數字表示，一個16進制數字佔4位，因此最後的MD5值都是用32個16進制數字表示。算法
2.計算簡單
MD5算法說到底仍是散列算法，或者叫作哈希算法，因此計算一個數據的MD5值是比較容易的，同時加密速度也是很快的。數據庫
3.抗修改性
對原數據進行任何改動，哪怕只是修改1個字節，所獲得的MD5值都有很大的區別。數組
4.強抗碰撞性
已知原數據和其MD5值，很難找到具備相同MD5值的數據，即很難僞造數據。這裏的碰撞在後面的安全性中會提到，在這裏咱們簡單理解爲一種破解手段。安全
3、原理
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)
4、算法實現
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);
}
}
複製代碼
5、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)進製爲4個bit,故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文件簽名是否一致，防止下載被攔截和篡改
-
檢驗下載文件的完整性
5、安全性
上面講了這麼多，你會發現從MD5加密自己來說這個過程是不可逆的，但並不意味着MD5算法不可破解，破解對於MD5一致性認證沒多大影響，可是對於MD5的密碼認證來講是致命的。
1. 撞庫破解
若是讓咱們猜密碼，確定會猜「123456」,生日，手機號等，而撞庫的原理也就是這麼簡單。首先創建一個大型的數據庫，而後把最多見的，有可能出現的密碼，經過MD5加密成密文，而且以這些MD5值爲主鍵加索引，將常見的密碼爲單列存入數據庫中，並經過不斷的積累，造成一個巨大的密碼MD5數據庫，這樣當你截取到網絡上密碼的MD5值時，經過查詢這個巨大的數據庫來直接匹配MD5值，這就是所謂的撞庫。這麼一看撞庫有點相似窮舉法，因此撞庫破解的機率是很低的，但也不是說不可能破解。經過下面兩個網站就很容易得到原文：
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和加密算法的重要性。
參考博客：
- 1. MD5算法全解析
- 2. MD5算法解析
- 3. 解析MD5算法
- 4. "MD5"加密算法全解析
- 5. MD5 算法分析
- 6. MD5算法詳解
- 7. MD5信息摘要算法解析
- 8. 網絡安全(7)——加密算法(3)——MD5(2)——MD5算法
- 9. MD5解密算法-JAVA算法實現
- 10. MD5 加密算法詳解
- 更多相關文章...
- • XML DOM 解析器 - XML DOM 教程
- • TCP報文格式解析 - TCP/IP教程
- • 算法總結-廣度優先算法
- • 算法總結-深度優先算法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 跳槽面試的幾個實用小技巧，不妨看看！
- 2. Mac實用技巧 |如何使用Mac系統中自帶的預覽工具將圖片變成黑白色?
- 3. Mac實用技巧 |如何使用Mac系統中自帶的預覽工具將圖片變成黑白色?
- 4. 如何使用Mac系統中自帶的預覽工具將圖片變成黑白色?
- 5. Mac OS非兼容Windows軟件運行解決方案——「以VMware & Microsoft Access爲例「
- 6. 封裝 pyinstaller -F -i b.ico excel.py
- 7. 數據庫作業三ER圖待完善
- 8. nvm安裝使用低版本node.js(非命令安裝)
- 9. 如何快速轉換圖片格式
- 10. 將表格內容分條轉換爲若干文檔
- 1. MD5算法全解析
- 2. MD5算法解析
- 3. 解析MD5算法
- 4. "MD5"加密算法全解析
- 5. MD5 算法分析
- 6. MD5算法詳解
- 7. MD5信息摘要算法解析
- 8. 網絡安全(7)——加密算法(3)——MD5(2)——MD5算法
- 9. MD5解密算法-JAVA算法實現
- 10. MD5 加密算法詳解