本文详解 python 手动实现 sha-1 算法时常见的填充逻辑错误，重点指出消息长度计算与字节填充偏移的关联性，并提供可验证的修正代码及关键注意事项。
本文详解 python 手动实现 sha-1 算法时常见的填充逻辑错误，重点指出消息长度计算与字节填充偏移的关联性，并提供可验证的修正代码及关键注意事项。
SHA-1 是一种广泛使用的密码学哈希算法，其标准流程包括消息预处理（填充）、分块处理（64 字节/块）、80 轮消息扩展与压缩函数迭代。当手动实现时，即使核心逻辑（如逻辑函数、常量、循环左移）完全正确，预处理阶段的填充错误仍会导致最终哈希值与 hashlib.sha1 严重偏差——这正是本例的根本问题。
? 根本原因：填充长度计算未考虑已添加的 0x80 字节
在 SHA-1 规范中，填充步骤严格定义为：
- 追加单字节 0x80；
- 追加若干 0x00 字节，使当前消息长度（含 0x80）模 64 等于 56（即预留最后 8 字节存放原始消息的比特长度）；
- 追加 8 字节的大端序无符号整数，表示原始消息的总比特数（= len(data) * 8）。
关键陷阱在于：计算 0x00 填充数量时，必须基于“已添加 0x80 后的新长度”，而非原始 msg_len。原代码中：
data += b"\x80" data += b"\x00" * ((56 - msg_len % 64) % 64) # ❌ 错误：未计入刚添加的 1 字节
此处 msg_len 是追加 0x80 前的长度，因此 (56 - msg_len % 64) % 64 忽略了 0x80 占用的 1 字节位置，导致填充不足或溢出，破坏了后续 64 字节分块对齐，进而使消息扩展（words 数组）和压缩轮次输入完全错位。
✅ 正确做法是将 msg_len + 1（即含 0x80 的临时长度）代入模运算：
data += b"\x80" # 正确填充：确保 (原始长度 + 1 + 填充长度) % 64 == 56 padding_len = (56 - (msg_len + 1) % 64) % 64 data += b"\x00" * padding_len
? 提示：(x % 64) 在 x < 0 时可能为负，因此外层 % 64 不可省略，确保结果为非负整数。
✅ 完整修正版代码（含验证）
以下是修复后的完整实现，已通过 b"hello"、空字节、多长度输入等测试用例验证，与 hashlib.sha1 输出完全一致：
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:
# 初始化哈希状态
h0 = 0x67452301
h1 = 0xefcdab89
h2 = 0x98badcfe
h3 = 0x10325476
h4 = 0xc3d2e1f0
msg_len = len(data) # 原始字节长度
# 步骤1：追加 0x80
data = data + b"\x80"
# 步骤2：追加 0x00，使 (len(data) % 64) == 56
# 注意：此时 data 长度已是 msg_len + 1
padding_len = (56 - (msg_len + 1) % 64) % 64
data = data + b"\x00" * padding_len
# 步骤3：追加原始消息的比特长度（8 字节，大端序）
bit_length = msg_len * 8
data = data + bit_length.to_bytes(8, "big")
# 现在 data 长度必为 64 的倍数
assert len(data) % 64 == 0
# 处理每个 64 字节块
for i in range(0, len(data), 64):
# 将块拆分为 16 个 32 位大端整数
words = [
int.from_bytes(data[i + j : i + j + 4], "big")
for j in range(0, 64, 4)
]
# 消息扩展：生成 80 个字
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)
# 初始化工作变量
a, b, c, d, e = h0, h1, h2, h3, h4
# 80 轮主循环
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
d = c
c = rotl32(b, 30)
b = a
a = temp
# 累加到哈希状态
h0 = (h0 + a) & 0xffffffff
h1 = (h1 + b) & 0xffffffff
h2 = (h2 + c) & 0xffffffff
h3 = (h3 + d) & 0xffffffff
h4 = (h4 + e) & 0xffffffff
# 组合最终哈希值（20 字节大端序）
return (
(h0 << 128) | (h1 << 96) | (h2 << 64) | (h3 << 32) | h4
).to_bytes(20, "big")
# ✅ 验证
if __name__ == "__main__":
test_cases = [b"", b"hello", b"abc", b"message digest"]
for msg in test_cases:
assert sha1(msg) == builtin_sha1(msg).digest(), f"Failed on {msg!r}"
print("✅ All tests passed.")⚠️ 关键注意事项总结
- 比特长度 ≠ 字节长度：末尾追加的是 len(data) * 8（比特数），不是 len(data)（字节数），此点虽已在原代码中修正，但仍需强调；
- 大端序一致性：所有 int.from_bytes(..., "big") 和 .to_bytes(..., "big") 必须统一，不可混用小端；
- 32 位截断：每次算术运算后应用 & 0xffffffff，防止 Python 整数溢出导致高位干扰（尤其在 rotl32 和累加步骤）；
- 边界条件验证：务必测试 len(data) == 0、len(data) == 55（加 0x80 后为 56，无需填充）、len(data) == 56（加 0x80 后为 57，需填充 63 字节）等临界情况；
- 调试建议：可打印中间 words[0:16] 与 hashlib 实现的对应块前 16 字进行比对，快速定位填充或解析错误。
遵循以上规范，即可实现与标准库行为严格一致的 SHA-1 算法，为理解密码学哈希底层机制打下坚实基础。
