维基百科

MD5消息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的 密码散列函数，可以产生出一个128位（16个字符(BYTES)）的散列值（hash value），用于确保信息传输完整一致。MD5由美国密码学家 罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代 MD4 算法。这套算法的程序在 RFC 1321 中被加以规范。

推荐阅读

• 文中代码参考 龙哥 csdn 文章

• 文中md5描述参考RFC 1321 链接

MD5 算法描述（RFC 1321）

假设我们有个 bit 位长度的输入，即：

m_0 m_1 ... m_{b-1}

• 1、补位

MD5 算法是对输入的数据进行补位，使得如果数据位长度LEN对512求余的结果是448。即数
据扩展至K512+448位。即K64+56个字节，K为整数。补位操作始终要执行，即使数据长度LEN
对512求余的结果已是448。
具体补位操作：补一个1，然后补0至满足上述要求。总共最少要补一位，最多补512位。

• 2、补数据长度

用一个64位的数字表示数据的原始长度b，把b用两个32位数表示。那么只取B的低64位。
当遇到b大于2^64这种极少遇到的情况时，这时，数据就被填补成长度为512位的倍数。也就是说，
此时的数据长度是16个字（32位）的整数倍数。用M[0 ... N-1]表示此时的数据，其中的N是16
的倍数。

• 3、初始化MD缓冲器

用一个四个字的缓冲器（A，B，C，D）来计算报文摘要，A,B,C,D分别是32位的寄存器，初
始化使用的是十六进制表示的数字
A=0X01234567
B=0X89abcdef
C=0Xfedcba98
D=0X76543210

• 4、处理位操作函数

首先定义4个辅助函数，每个函数的输入是三个32位的字，输出是一个32位的字。
X，Y，Z为32位整数。
F(X,Y,Z) = XY v not(X) Z
G(X,Y,Z) = XZ v Y not(Z)
H(X,Y,Z) = X xor Y xor Z
I(X,Y,Z) = Y xor (X v not(Z))
这一步中 使用一个64元素的常数组T[1 ... 64]，它由sine函数构成，T[i]表示数组中的第i个元
素，它的值等于经过4294967296次abs(sin(i))后的值的整数部分（其中i是弧度 ）。T[i]为32位
整数用16进制表示。

• 5、四轮运算
• / 第1轮 /

/* 以 [abcd k s i] 表示如下操作 a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) */
[ABCD 0 7 1] [DABC 1 12 2] [CDAB 2 17 3] [BCDA 3 22 4]
[ABCD 4 7 5] [DABC 5 12 6] [CDAB 6 17 7] [BCDA 7 22 8]
[ABCD 8 7 9] [DABC 9 12 10] [CDAB 10 17 11] [BCDA 11 22 12]
[ABCD 12 7 13] [DABC 13 12 14] [CDAB 14 17 15] [BCDA 15 22 16]

• / 第2轮 /

/* 以 [abcd k s i] 表示如下操作 a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s) */
[ABCD 1 5 17] [DABC 6 9 18] [CDAB 11 14 19] [BCDA 0 20 20]
[ABCD 5 5 21] [DABC 10 9 22] [CDAB 15 14 23] [BCDA 4 20 24]
[ABCD 9 5 25] [DABC 14 9 26] [CDAB 3 14 27] [BCDA 8 20 28]
[ABCD 13 5 29] [DABC 2 9 30] [CDAB 7 14 31] [BCDA 12 20 32]

• / 第3轮 /

/* 以 [abcd k s i] 表示如下操作 a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s) */
[ABCD 5 4 33] [DABC 8 11 34] [CDAB 11 16 35] [BCDA 14 23 36]
[ABCD 1 4 37] [DABC 4 11 38] [CDAB 7 16 39] [BCDA 10 23 40]
[ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43] [BCDA 6 23 44]
[ABCD 9 4 45] [DABC 12 11 46] [CDAB 15 16 47] [BCDA 2 23 48]

• / 第4轮 /

/* 以 [abcd k s i] 表示如下操作 a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s) */
[ABCD 0 6 49] [DABC 7 10 50] [CDAB 14 15 51] [BCDA 5 21 52]
[ABCD 12 6 53] [DABC 3 10 54] [CDAB 10 15 55] [BCDA 1 21 56]
[ABCD 8 6 57] [DABC 15 10 58] [CDAB 6 15 59] [BCDA 13 21 60]
[ABCD 4 6 61] [DABC 11 10 62] [CDAB 2 15 63] [BCDA 9 21 64]

• / 每轮运算结束 /

A = A + AA
B = B + BB
C = C + CC
D = D + DD

MD5 算法过程

0x1 初始化常量

• 1、md 缓冲器

A = 0x67452301
B = 0x0EFCDAB89
C = 0x98BADCFE
D = 0x10325476

• 2、常数组 T（正弦函数表）

T = [int(abs(math.sin(i)) * 4294967296) for i in range(1, 65)]

• 3、循环左移位数（我这里称之为 S，也可在下面计算时写死）

s1 = [7, 12, 17, 22] * 4
s2 = [5, 9, 14, 20] * 4
s3 = [4, 11, 16, 23] * 4
s4 = [6, 10, 15, 21] * 4
S = s1 + s2 + s3 + s4

0x2 数据填充

• 1、填充规则

在明文后面填充一个1，n个0，满足 input_len + pad_leg % 512 = 448 条件即可

最终的 bit 位长度需要等于 512 的整倍数，(input_len + pad_leg + 64bit 原始文明的长度) % 512 = 0

• 2、代码实现

msg = 'hello world!'.encode()
msg_bit_len = len(msg) * 8
msg_len = msg_bit_len % (2 ** 32)

# 现在明文后面填充一个字节，80 转成二进制等于 1000 0000
msg += b'\x80'

# 计算需要填充的位数
pad_leg = ((448 - (msg_len + 8) % 512) % 512) // 8

# 填充，拼接数据，这里直接填充 0 即可，因为前面已经填充 1 了
msg = msg + b'\x00' * pad_leg + msg_len.to_bytes(8, byteorder='little')

0x3 计算函数

• 1、其他函数

# 循环左移
def left_circular_shift(k, bits):
    bits = bits % 32
    k = k % (2 ** 32)
    upper = (k << bits) % (2 ** 32)
    result = upper | (k >> (32 - bits))
    return result

# 分块
def block_divide(block, chunks):
    result = []
    size = len(block) // chunks
    for i in range(0, chunks):
        result.append(int.from_bytes(block[i * size:(i + 1) * size], byteorder="little"))
    return result

# 数据转换
def fmt8(num):
    big_hex = '{0:08x}'.format(num)
    bin_ver = binascii.unhexlify(big_hex)
    result = '{0:08x}'.format(int.from_bytes(bin_ver, byteorder='little'))
    return result

• 2、定义四个线性辅助函数

F(X,Y,Z) = XY v not(X) Z
G(X,Y,Z) = XZ v Y not(Z)
H(X,Y,Z) = X xor Y xor Z
I(X,Y,Z) = Y xor (X v not(Z))

def F(x, y, z):
    return (x & y) | ((~x) & z)

def G(x, y, z):
    return (x & z) | (y & (~z))

def H(x, y, z):
    return x ^ y ^ z

def I(x, y, z):
    return y ^ (x | (~z))

• 3、四轮循环运算（将每 512 字节细分成 16 个小组，每个小组 64bit，8 个字节）

• / 定义四个 F 函数 /

def FF(a, b, c, d, m, s, t):
    result = b + left_circular_shift((a + F(b, c, d) + m + t), s)
    return result

def GG(a, b, c, d, m, s, t):
    result = b + left_circular_shift((a + G(b, c, d) + m + t), s)
    return result

def HH(a, b, c, d, m, s, t):
    result = b + left_circular_shift((a + H(b, c, d) + m + t), s)
    return result

def II(a, b, c, d, m, s, t):
    result = b + left_circular_shift((a + I(b, c, d) + m + t), s)
    return result

• 4、transform 函数

这里可以参考以上资料自行实现

---

运行代码，结果相同

全部代码

注意该订单不支持退款，如有问题可联系博主