本文详解 python 手动实现 sha-1 算法时因消息填充长度计算偏差导致哈希结果与标准库不一致的根本原因，并提供可验证的修正方案与完整实现。
本文详解 python 手动实现 sha-1 算法时因消息填充长度计算偏差导致哈希结果与标准库不一致的根本原因，并提供可验证的修正方案与完整实现。
SHA-1 是一种广泛应用的密码学哈希函数，其规范要求对输入消息进行严格的消息填充（padding），以确保输入长度满足 len ≡ 448 (mod 512) 比特（即 len ≡ 56 (mod 64) 字节），随后追加 64 位原始消息长度（以比特为单位）。许多手动实现失败的关键，并非逻辑或轮函数错误，而是在计算零填充字节数时忽略了已添加的 0x80 字节对当前长度的影响。
在原始代码中，填充零字节的计算为：
data += b"\x80" data += b"\x00" * ((56 - msg_len % 64) % 64) # ❌ 错误：未计入刚添加的 0x80
此时 msg_len 是原始数据长度，但 b"\x80" 已使实际长度变为 msg_len + 1。因此，后续模运算应基于 msg_len + 1 计算剩余空间。正确公式为：
data += b"\x80" # 正确：考虑 0x80 占用 1 字节后，距离 56 字节边界还需补多少 0x00 pad_len = (56 - (msg_len + 1) % 64) % 64 data += b"\x00" * pad_len
✅ 关键理解：SHA-1 填充规则是 —— 在消息末尾追加单个 0x80 字节，再追加若干 0x00 字节，使得 len(original_msg) + 1 + pad_len ≡ 56 (mod 64)，即 (msg_len + 1 + pad_len) % 64 == 56。解得 pad_len = (56 - (msg_len + 1) % 64) % 64。
此外，还需确认另一处易错点：长度字段必须是原始消息的比特长度（而非字节长度），且以 64 位大端序（big-endian）编码。原始代码中 (msg_len * 8).to_bytes(8, "big") 是正确的，无需修改。
以下是修复后的完整、可运行 SHA-1 实现（已通过 b"hello"、空字符串、长文本等多组测试用例验证，与 hashlib.sha1().digest() 完全一致）：
from hashlib import sha1 as builtin_sha1
def rotl32(value: int, count: int) -> int:
return ((value << count) | (value >> (32 - count))) & 0xffffffff
def sha1(data: bytes) -> bytes:
# 初始化哈希值（RFC 3174）
h0, h1, h2, h3, h4 = 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
msg_len = len(data)
# Step 1: Append '1' bit (0x80 byte)
data = data + b"\x80"
# Step 2: Append '0' bits until length ≡ 56 (mod 64)
# Note: we've already added 1 byte → use (msg_len + 1) in modulo
pad_len = (56 - (msg_len + 1) % 64) % 64
data = data + b"\x00" * pad_len
# Step 3: Append original message length in BITS, as 64-bit big-endian integer
bit_length = msg_len * 8
data = data + bit_length.to_bytes(8, "big")
# Process each 64-byte chunk
for i in range(0, len(data), 64):
# Parse 16 words (32-bit each, big-endian)
words = [
int.from_bytes(data[i + j:i + j + 4], "big")
for j in range(0, 64, 4)
]
# Extend to 80 words
for j in range(16, 80):
w = rotl32(
words[j - 3] ^ words[j - 8] ^ words[j - 14] ^ words[j - 16],
1
)
words.append(w & 0xffffffff)
# Initialize working variables
a, b, c, d, e = h0, h1, h2, h3, h4
# Main loop (80 rounds)
for j in range(80):
if 0 <= j <= 19:
f = (b & c) | (~b & d) & 0xffffffff
k = 0x5a827999
elif 20 <= j <= 39:
f = b ^ c ^ d
k = 0x6ed9eba1
elif 40 <= j <= 59:
f = (b & c) | (b & d) | (c & d)
k = 0x8f1bbcdc
else: # 60–79
f = b ^ c ^ d
k = 0xca62c1d6
temp = (rotl32(a, 5) + f + e + k + words[j]) & 0xffffffff
e = d
d = c
c = rotl32(b, 30)
b = a
a = temp
# Update hash state
h0 = (h0 + a) & 0xffffffff
h1 = (h1 + b) & 0xffffffff
h2 = (h2 + c) & 0xffffffff
h3 = (h3 + d) & 0xffffffff
h4 = (h4 + e) & 0xffffffff
# Output: 20-byte big-endian digest
return (
(h0 << 128) | (h1 << 96) | (h2 << 64) | (h3 << 32) | h4
).to_bytes(20, "big")
# ✅ 验证示例
if __name__ == "__main__":
test_data = b"hello"
assert sha1(test_data) == builtin_sha1(test_data).digest()
print("✅ SHA-1 implementation matches hashlib.sha1")注意事项与最佳实践：
- 始终使用 & 0xffffffff 截断中间结果：Python 整数无符号溢出，需显式模拟 32 位整数行为；
- ~b 在 Python 中是带符号取反，应配合 & 0xffffffff 使用（如 (~b & 0xffffffff)），原代码中 (~b) & d 写法在 b 为正时虽暂可工作，但语义不严谨；推荐统一改写为 (b & c) | ((~b) & d & 0xffffffff) 或更清晰的 (b & c) | ((0xffffffff ^ b) & d)；
- 避免复用变量名 msg_len：填充前/后长度不同，建议分别命名为 orig_len 和 padded_len 提升可读性；
- 单元测试不可省略：除 "hello" 外，务必覆盖边界用例：空字节串 b""、64 字节消息（触发一次完整块）、55/56 字节消息（测试 padding 长度临界值）。
掌握这一填充细节，不仅解决 SHA-1 实现一致性问题，更是深入理解所有 Merkle–Damgård 结构哈希算法（如 MD5、SHA-256）填充机制的基石。
