TermiNexus
3dd5bca28e
sha256/sha1/md5 的 digest 阶段把 32/64 位掩码结果写入 bytes 元素（i8），触发隐式窄化；统一加 uint8(...)（与 __sha512 一致）
129 lines
5.4 KiB
Plaintext
129 lines
5.4 KiB
Plaintext
import string
|
|
|
|
|
|
# ==============================================
|
|
# MD5 hash algorithm
|
|
# ==============================================
|
|
define MD5_BLOCK_LEN = 64 # Group block size
|
|
define MD5_DIGEST_LEN = 16 # Digest output length
|
|
|
|
# MD5 four-round nonlinear functions
|
|
define md5_F(x: uint32, y: uint32, z: uint32) -> uint32: return (x & y) | (~x & z)
|
|
define md5_G(x: uint32, y: uint32, z: uint32) -> uint32: return (x & z) | (y & ~z)
|
|
define md5_H(x: uint32, y: uint32, z: uint32) -> uint32: return x ^ y ^ z
|
|
define md5_I(x: uint32, y: uint32, z: uint32) -> uint32: return y ^ (x | ~z)
|
|
# Circular left shift
|
|
define md5_rotl(x: uint32, n: int) -> uint32: return (x << n) | (x >> (32 - n))
|
|
|
|
# MD5 constant table
|
|
md5_T: const [64]uint32 = [
|
|
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
|
|
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
|
|
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
|
|
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
|
|
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
|
|
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
|
|
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
|
|
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
|
|
]
|
|
|
|
md5_S: const [64]int = [
|
|
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
|
|
]
|
|
|
|
|
|
# MD5 Context
|
|
class md5:
|
|
state: [4]uint32 = [
|
|
0x67452301, 0xefcdab89,
|
|
0x98badcfe, 0x10325476
|
|
] # 4 32-bit state registers
|
|
count: uint64 = 0 # processed bits
|
|
buf: [MD5_BLOCK_LEN]uint8
|
|
# Initialize MD5 context
|
|
def __init__(self):
|
|
string.memset(self.buf, 0, MD5_BLOCK_LEN)
|
|
# MD5 single-group compression transform
|
|
def transform(self, block: uint8*):
|
|
a: uint32 = self.state[0]
|
|
b: uint32 = self.state[1]
|
|
c: uint32 = self.state[2]
|
|
d: uint32 = self.state[3]
|
|
w: [16]uint32
|
|
# Byte order 32-bit words
|
|
for i in range(16):
|
|
w[i] = ((uint32(block[i * 4 + 0]) << 0) |
|
|
(uint32(block[i * 4 + 1]) << 8) |
|
|
(uint32(block[i * 4 + 2]) << 16) |
|
|
(uint32(block[i * 4 + 3]) << 24))
|
|
# 4-round 51 iterations
|
|
for i in range(16):
|
|
tmp: uint32 = md5_F(b, c, d) + a + md5_T[i] + w[i]
|
|
a = d; d = c; c = b
|
|
b += md5_rotl(tmp, md5_S[i])
|
|
# 4-round 51 iterations
|
|
for i in range(16, 32):
|
|
tmp: uint32 = md5_G(b, c, d) + a + md5_T[i] + w[(5 * i + 1) % 16]
|
|
a = d; d = c; c = b
|
|
b += md5_rotl(tmp, md5_S[i])
|
|
for i in range(32, 48):
|
|
tmp: uint32 = md5_H(b, c, d) + a + md5_T[i] + w[(3 * i + 5) % 16]
|
|
a = d; d = c; c = b
|
|
b += md5_rotl(tmp, md5_S[i])
|
|
for i in range(48, 64):
|
|
tmp: uint32 = md5_I(b, c, d) + a + md5_T[i] + w[(7 * i + 0) % 16]
|
|
a = d; d = c; c = b
|
|
b += md5_rotl(tmp, md5_S[i])
|
|
# Accumulate to state registers
|
|
self.state[0] += a
|
|
self.state[1] += b
|
|
self.state[2] += c
|
|
self.state[3] += d
|
|
# Batch input data
|
|
def update(self, s: str):
|
|
data: uint8* = uint8*(s)
|
|
length: sizet = len(s)
|
|
idx: sizet = self.count % MD5_BLOCK_LEN
|
|
self.count += length
|
|
if idx > 0:
|
|
left: sizet = MD5_BLOCK_LEN - idx
|
|
if length >= left:
|
|
string.memcpy(self.buf + idx, data, left)
|
|
self.transform(self.buf)
|
|
data += left
|
|
length -= left
|
|
idx = 0
|
|
while length >= MD5_BLOCK_LEN:
|
|
self.transform(data)
|
|
data += MD5_BLOCK_LEN
|
|
length -= MD5_BLOCK_LEN
|
|
if length > 0:
|
|
string.memcpy(self.buf + idx, data, length)
|
|
# End calculation, output 16-byte digest
|
|
def final(self, out: [MD5_DIGEST_LEN]uint8):
|
|
idx: sizet = self.count % MD5_BLOCK_LEN
|
|
# Pad 0x80 end
|
|
self.buf[idx] = 0x80
|
|
idx += 1
|
|
# If space is not enough, compress once
|
|
if idx > MD5_BLOCK_LEN - 8:
|
|
string.memset(self.buf + idx, 0, MD5_BLOCK_LEN - idx)
|
|
self.transform(self.buf)
|
|
idx = 0
|
|
# Pad 0 to end 8 bytes
|
|
string.memset(self.buf + idx, 0, MD5_BLOCK_LEN - 8 - idx)
|
|
# Write total bit count
|
|
bits: uint64 = self.count << 3
|
|
for i in range(8):
|
|
self.buf[MD5_BLOCK_LEN - 8 + i] = uint8((bits >> (i * 8)) & 0xFF)
|
|
self.transform(self.buf)
|
|
# State registers to little-endian byte output output
|
|
for i in range(4):
|
|
out[i * 4 + 0] = uint8((self.state[i] >> 0) & 0xFF)
|
|
out[i * 4 + 1] = uint8((self.state[i] >> 8) & 0xFF)
|
|
out[i * 4 + 2] = uint8((self.state[i] >> 16) & 0xFF)
|
|
out[i * 4 + 3] = uint8((self.state[i] >> 24) & 0xFF)
|