MD5原理及Python實現

簡介

MD5消息摘要算法一種被廣泛使用的密碼散列函數，輸入長度小於2^{64比特的消息，我的代碼也是以小於2}64比特的消息爲例，輸出一個128位（16字節）的散列值（hash value），輸入信息以512比特的分組爲單位處理。

算法流程

1. 附加位填充
2. 初始化鏈接變量
3. 分組處理
4. 步函數的運算

這個流程描述下來非常符合hash函數的一般模型：

單個點拿出來仔細分析

附加位填充

填充一個1和若干個0使消息長度模512與448同餘，也就說剩餘消息(此處的消息長度已經不滿512位了)的最後512比特分組裏面加上這一對填充的東西長度應該是448，還剩下64位是消息的長度，滿足L mod 2^64,下圖就很清楚解釋了這一過程：

關鍵代碼：

 length = struct.pack('<Q', len(message)*8)  #原消息長度64位比特的添加格式，太騷額這種寫法
    while len(message) > 64:
        solve(message[:64])
        message = message[64:]
    #長度不足64位消息自行填充
    message += '\x80'
    message += '\x00' * (56 - len(message) % 64)
    #print type(length)
    message += length
    solve(message[:64])

初始化鏈接變量

使用4個32位的寄存器A， B，C， D存放4個固定的32位整型參數，用於第一輪迭代，這裏需要注意，書本上的值是直接給你的，但是沒有倒過來，也就是大端和小端的轉換問題。

#初始向量
A, B, C, D = (0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476)
# A, B, C, D = (0x01234567, 0x89ABCDEF, 0xFEDCBA98, 0x76543210)

分組處理

與分組密碼分組處理相似，有4輪步驟，將512比特的消息分組平均分爲16個子分組，每個子分組有32比特，參與每一輪的的16步運算，每步輸入是4個32比特的鏈接變量和一個32位的的消息子分組，經過這樣的64步之後得到4個寄存器的值分別與輸入的鏈接變量進行模加，關鍵代碼如下，爲了能夠保存一下一開始A，B，C，D這四個初始變量的值，所以就先找四個變量把他們的值暫存一下，爲最後一步的模加做準備。

def solve(chunk):
    global A
    global B
    global C
    global D
    w = list(struct.unpack('<' + 'I' * 16, chunk))  #分成16個組，I代表1組32位,tql,學到了
    a, b, c, d = A, B, C, D

    for i in range(64):  #64輪運算
        if i < 16:  #每一輪運算只用到了b,c,d三個
            f = ( b & c)|((~b) & d)
            flag  = i      #用於標識處於第幾組信息
        elif i < 32:
            f = (b & d)|(c & (~d))
            flag = (5 * i +1) %16
        elif i < 48:
            f = (b ^ c ^ d)
            flag  = (3 * i + 5)% 16
        else:
            f = c ^(b |(~d))
            flag  = (7 * i ) % 16
        tmp = b + lrot((a + f + k[i] + w[flag])& 0xffffffff,r[i]) #&0xffffffff爲了類型轉換
        a, b, c, d = d, tmp & 0xffffffff, b, c
        #print(hex(a).replace("0x","").replace("L",""), hex(b).replace("0x","").replace("L","") , hex(c).replace("0x","").replace("L",""), hex(d).replace("0x","").replace("L",""))
    A = (A + a) & 0xffffffff
    B = (B + b) & 0xffffffff
    C = (C + c) & 0xffffffff
    D = (D + d) & 0xffffffff

這上面的代碼也包含了第四步的步函數，可以單獨把他們提取出來，而不同輪使用的步函數使用的非線性函數是不一樣的。即四輪使用四個不同的非線性函數，其實可以發現每個非線性函數的輸入不需要A寄存器裏面的值，我們只需要B，C，D寄存器裏面的東西，這裏面得出來的結果分別放進A，C，D寄存器，所以一開始纔要找另外的寄存器去存儲本身的值，不然的話在轉化過程中本身的變量會丟失。

f = ( b & c)|((~b) & d)
f = (b & d)|(c & (~d))
f = (b ^ c ^ d)
f = c ^(b |(~d))

A寄存器裏面的值的運算有另外自己的一套模式，先用B，C，D向量裏面做一次非線性的運算，然後將得出來的結果依次加上第一個變量，32比特的消息和一個僞隨機數常數，再將結果循環左移指定的位數，並加上B的值，最後把得出來的結果放進B寄存器。

#循環左移的位移位數
r = [   7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
        5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20,
         4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
         6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21
        ]
lrot = lambda x,n: (x << n)|(x >> 32- n)
#使用正弦函數產生的位隨機數，也就是書本上的T[i]
k =  [int(math.floor(abs(math.sin(i + 1)) * (2 ** 32))) for i in range(64)]
tmp = b + lrot((a + f + k[i] + w[flag])& 0xffffffff,r[i]) 

正確性

以"helloworld"爲例，分別將其在代碼中運行，以及線上工具運行，檢查它們的一致性。

詳細代碼(放在github上了)：MD5實現