前言

這段時間剛好正在做軟件安全的實驗和課設，學習了各種加密算法，比如對稱加密算法的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^yz
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)進製爲4bit,故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值，由於不相同，所以返回了錯誤信息

$[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-roCDh3vj-1573630736919)(F:\md\算法\images\WanAndroid.png)]$

2.2 一致性驗證

一致性驗證就是文件MD5值的應用，MD5加密時，將整個文件當作一個大文本信息，通過字符串變換算法，產生了唯一的MD5值。在Android中最常用的莫過於文件下載，比如首先服務器會預先給一個完整的文件提供一個MD5值，用戶下載該文件後，重新計算文件的MD5值，如果相同，證明文件已經被成功的下載了。如果不相同，則證明文件下載出錯或者當前文件還在下載中。在Android中使用計算文件的MD5值需要注意要將該操作放在子線程中操作，因爲計算文件MD5值屬於耗時操作，不能在主線程運行，否則會出現OOM的情況。

1.百度網盤的秒傳

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

基本概念

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

原理

秒傳看上去很神奇，其實原理就是MD5的一致性驗證。當我們成功上傳資源到自己網盤時，服務器會計算這個完整文件的MD5值，然後保存在服務器上，當下一次要上傳文件時，網盤首先會檢測服務器是否有相同MD5值的文件，如果有的話，就直接從服務器複製到網盤上，這樣就省去了上傳的時間

過程

讓我們重新解釋下上面提到的例子：當分享人在分享軟件安全書籍的資源時，一定是通過自己的百度網盤上來進行分享，這就證明該資源已經保存在服務器中，接下來我們打開了這個鏈接，然後點擊保存時，網盤就檢測到這個資源的MD5值已經存在在服務器中，所以不需要佔用網絡帶寬，直接複製這個資源到我們的網盤上，從而實現了秒傳。總體過程下圖：

$[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-5hCXQGD3-1573630736920)(F:\md\算法\images\window.png)]$

2.應用程序更新

也許你又納悶了，應用程序更新爲什麼需要用到MD5?這是爲了友好的用戶體驗以及安全性考慮，MD5一致性驗證可以防止下載的更新APK被惡意篡改或者防止下載的APK不完整造成不良的用戶體驗。MD5在應用程序更新中的主要作用就是：

檢驗APK文件簽名是否一致，防止下載被攔截和篡改
檢驗下載文件的完整性

五、安全性

上面講了這麼多，你會發現從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 "";
    }

流程

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

$[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-hnpfLOYA-1573630736921)(F:\md\算法\images\salt.png)]$

總結

MD5看似是很簡單的加密算法，但是搞懂其底層實現原理並沒有想象中那麼容易。MD5加密算法不僅僅在安卓平臺上，在其它平臺上也是非常重要的一種加密算法。通過這次對MD5的學習，真的是收益匪淺，不僅僅讓我對MD5有了更深的理解，並且認識到了MD5和加密算法的重要性。

參考博客：

MD5算法原理及其實現

Android大文件上傳秒傳之MD5篇

jsyjst

發佈了39 篇原創文章 · 獲贊 41 · 訪問量 2萬+

私信關注

MD5算法全解析

前言