本文详解 Python 手动实现 SHA-1 算法时因消息填充逻辑错误（特别是长度计算未包含已添加的 0x80 字节）导致哈希值与 hashlib.sha1 不一致的问题，并提供可验证的修正代码与关键注意事项。
本文详解 python 手动实现 sha-1 算法时因消息填充逻辑错误（特别是长度计算未包含已添加的 `0x80` 字节）导致哈希值与 `hashlib.sha1` 不一致的问题，并提供可验证的修正代码与关键注意事项。
在实现 SHA-1 算法时，即使核心轮函数、逻辑运算和循环移位（rotl32）完全正确，消息预处理阶段的填充（padding）错误仍会导致最终哈希值与标准库 hashlib.sha1 严重偏离。本教程聚焦一个典型且隐蔽的错误：在计算零填充字节数时，忽略了已追加的 0x80 字节对当前消息长度的影响。
? 问题定位：填充长度计算偏差
SHA-1 要求输入消息按如下规则填充至 64 字节（512 位）块的整数倍：
- 追加单字节 0x80；
- 追加若干 0x00 字节，使填充后总长度（含 0x80）模 64 等于 56（即预留最后 8 字节存放原始消息比特长度）；
- 追加原始消息长度（单位：bit）的 64 位大端表示。
关键陷阱在于：步骤 2 中的“当前长度”必须是 len(data) + 1（即已含 0x80 的长度），而非原始 msg_len。原代码中：
data += b"\x80" data += b"\x00" * ((56 - msg_len % 64) % 64) # ❌ 错误：未考虑刚添加的 1 字节
这会导致零填充数量少算或多算，进而使后续的长度字段位置偏移、数据分块错乱，最终轮函数输入错误。
✅ 正确填充逻辑（修复版）
将填充计算修正为：
# 正确：msg_len 是原始长度，+1 表示已添加 0x80 后的当前长度 pad_len = (56 - (msg_len + 1) % 64) % 64 data += b"\x00" * pad_len
完整修复后的 sha1() 函数如下（仅展示关键修正部分，其余逻辑保持不变）：
def sha1(data: bytes) -> bytes:
h0 = 0x67452301
h1 = 0xefcdab89
h2 = 0x98badcfe
h3 = 0x10325476
h4 = 0xc3d2e1f0
msg_len = len(data) # 原始字节长度
# Step 1: append 0x80
data += b"\x80"
# Step 2: append 0x00 until (len + 1) % 64 == 56
pad_len = (56 - (msg_len + 1) % 64) % 64
data += b"\x00" * pad_len
# Step 3: append bit length as 64-bit big-endian
bit_length = msg_len * 8
data += bit_length.to_bytes(8, "big")
# Now process blocks...
msg_len = len(data) # 更新为填充后总长度
for i in range(0, msg_len, 64):
words = [int.from_bytes(data[i + j:i + j + 4], "big") for j in range(0, 64, 4)]
for j in range(16, 80):
words.append(rotl32(words[j-3] ^ words[j-8] ^ words[j-14] ^ words[j-16], 1))
a, b, c, d, e = h0, h1, h2, h3, h4
for j in range(80):
if 0 <= j <= 19:
f = (b & c) | ((~b) & d)
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 <= j <= 79
f = b ^ c ^ d
k = 0xca62c1d6
temp = (rotl32(a, 5) + f + e + k + words[j]) & 0xffffffff
e, d, c, b, a = d, c, rotl32(b, 30), a, temp
h0 = (h0 + a) & 0xffffffff
h1 = (h1 + b) & 0xffffffff
h2 = (h2 + c) & 0xffffffff
h3 = (h3 + d) & 0xffffffff
h4 = (h4 + e) & 0xffffffff
return ((h0 << 128) | (h1 << 96) | (h2 << 64) | (h3 << 32) | h4).to_bytes(20, "big")✅ 验证与使用
from hashlib import sha1 as builtin_sha1
if __name__ == "__main__":
test_data = b"hello"
assert sha1(test_data) == builtin_sha1(test_data).digest()
print("✅ SHA-1 implementation matches hashlib!")
print(f"Hash of 'hello': {sha1(test_data).hex()}")⚠️ 关键注意事项
- 字节序一致性：所有 int.from_bytes(..., "big") 和 .to_bytes(..., "big") 必须统一为大端，SHA-1 规范严格依赖此约定；
- 32 位截断：每轮运算后需用 & 0xffffffff 强制 32 位无符号整数行为（Python int 无限精度，不截断会导致高位溢出干扰）；
- 负数取反：~b 在 Python 中产生负数，应先转为 32 位无符号（如 ~b & 0xffffffff），但本例中 f = (b & c) | ((~b) & d) 在 b 为 32 位非负时 ~b 等价于 0xffffffff ^ b，实际可安全使用；若追求绝对严谨，建议显式写为 (b & c) | ((~b & 0xffffffff) & d)；
- 长度字段单位：务必使用比特长度（msg_len * 8），而非字节长度——这是初学者高频错误点。
通过精准修正填充逻辑，你的手写 SHA-1 实现即可与 hashlib 完全兼容，成为理解密码学哈希底层机制的可靠实践范例。
