区块链原理 / 系统课时
编写区块哈希和父块校验测试
编写区块哈希和父块校验测试
区块内容被修改后,旧哈希应立即失效;即使单个区块的哈希正确,也可能连接到错误的父块。本课用 Python 标准库构建三块测试链,通过四个单元测试验证正常区块、载荷篡改、父块引用错误与区块顺序颠倒,并定位到具体失败位置。
学习目标
- 使用稳定序列化规则重算 SHA-256 区块哈希。
- 校验创世块约定、父块哈希引用和相邻区块高度。
- 用独立负例区分内容篡改、链接错误与顺序错误。
定义区块与验收规则
本示例的区块含 height、prev_hash、payload、nonce、block_hash 五个字段。前四个字段参与 SHA-256 计算,最后一个字段保存结果。序列化固定为 UTF-8 编码的 JSON,并开启键排序、关闭多余空格,避免同一组数据因编码方式不同产生不同哈希。
按顺序检查以下条件:
- 重算每个区块的哈希,必须等于保存的
block_hash;否则报告HASH_MISMATCH。 - 首块约定高度为
0、父哈希为 64 个字符0;否则报告GENESIS_INVALID。 - 从第二块起,高度必须等于前块高度加
1,prev_hash必须等于前块的block_hash;分别报告HEIGHT_MISMATCH与PARENT_MISMATCH。
例如,创世块 G 的高度为 0,B1 为 1,B2 为 2。B2 需要引用 B1 的哈希,而不是 G 的哈希。这里的创世块约定只用于教学样例,不代表所有区块链的协议配置。与 Bitcoin 对 80 字节区块头做双重 SHA-256 不同,这里仅对四字段的 JSON 做单次 SHA-256。

实现校验器与四个单元测试
将以下完整代码保存为 test_chain.py,使用 Python 3.10 或更新版本运行,无需安装第三方包。make_block 创建自洽区块,validate_chain 返回是否通过及第一处失败原因;校验按“哈希、位置、父块引用”的顺序执行,因此一个区块存在多个问题时只报告首先命中的问题。
import hashlib
import json
import unittest
from dataclasses import dataclass, replace
ZERO_HASH = "0" * 64
@dataclass(frozen=True)
class Block:
height: int
prev_hash: str
payload: str
nonce: int
block_hash: str
def calculate_hash(height, prev_hash, payload, nonce):
# 固定字段顺序及 JSON 编码,避免同一数据被序列化成不同字节
raw = json.dumps(
{"height": height, "prev_hash": prev_hash,
"payload": payload, "nonce": nonce},
sort_keys=True, separators=(",", ":"), ensure_ascii=False
).encode("utf-8")
return hashlib.sha256(raw).hexdigest()
def make_block(height, prev_hash, payload, nonce=0):
digest = calculate_hash(height, prev_hash, payload, nonce)
return Block(height, prev_hash, payload, nonce, digest)
def validate_chain(blocks):
if not blocks:
return False, "EMPTY_CHAIN"
for index, block in enumerate(blocks):
# 每块先独立重算哈希,再检查它在链中的位置
digest = calculate_hash(
block.height, block.prev_hash, block.payload, block.nonce
)
if digest != block.block_hash:
return False, f"block[{index}]: HASH_MISMATCH"
if index == 0:
if block.height != 0 or block.prev_hash != ZERO_HASH:
return False, "block[0]: GENESIS_INVALID"
continue
parent = blocks[index - 1]
if block.height != parent.height + 1:
return False, f"block[{index}]: HEIGHT_MISMATCH"
if block.prev_hash != parent.block_hash:
return False, f"block[{index}]: PARENT_MISMATCH"
return True, "OK"
class ChainTests(unittest.TestCase):
def setUp(self):
self.genesis = make_block(0, ZERO_HASH, "genesis")
self.first = make_block(1, self.genesis.block_hash, "A pays B 5")
self.second = make_block(2, self.first.block_hash, "B pays C 2")
def test_valid_chain(self):
self.assertEqual(
validate_chain([self.genesis, self.first, self.second]),
(True, "OK")
)
def test_payload_tamper(self):
# 修改数据却保留旧哈希:应在区块 1 被识别
tampered = replace(self.first, payload="A pays B 50")
self.assertEqual(
validate_chain([self.genesis, tampered]),
(False, "block[1]: HASH_MISMATCH")
)
def test_wrong_parent(self):
# 重算正确的本块哈希,单独暴露父块引用错误
wrong = make_block(2, "f" * 64, "B pays C 2")
self.assertEqual(
validate_chain([self.genesis, self.first, wrong]),
(False, "block[2]: PARENT_MISMATCH")
)
def test_swapped_order(self):
self.assertEqual(
validate_chain([self.genesis, self.second, self.first]),
(False, "block[1]: HEIGHT_MISMATCH")
)
if __name__ == "__main__":
unittest.main(verbosity=2)预期输出(执行 python test_chain.py 后;<TIME> 表示每次不同的耗时):
test_payload_tamper (__main__.ChainTests.test_payload_tamper) ... ok
test_swapped_order (__main__.ChainTests.test_swapped_order) ... ok
test_valid_chain (__main__.ChainTests.test_valid_chain) ... ok
test_wrong_parent (__main__.ChainTests.test_wrong_parent) ... ok
----------------------------------------------------------------------
Ran 4 tests in <TIME>s
OK如何判断测试确实覆盖了错误
unittest 显示 ok,表示该测试中的断言成立,并不是坏区块通过了验证。四个用例实际断言的校验结果如下:
| 场景 | 校验结果 | 关键检查 |
|---|---|---|
| G、B1、B2 依次输入 | True, OK |
三块哈希、相邻高度和父引用都正确 |
B1 的载荷由 5 改为 50,保留旧哈希 |
False, block[1]: HASH_MISMATCH |
修改字段后哈希不再匹配 |
| B2 指向不存在的父哈希并重算自身哈希 | False, block[2]: PARENT_MISMATCH |
排除单块哈希错误的干扰 |
| 输入顺序改为 G、B2、B1 | False, block[1]: HEIGHT_MISMATCH |
索引 1 处出现高度跳跃 |
测试父块错误时,必须让错误区块的自身哈希正确,否则程序会先在哈希重算处拒绝,父引用分支实际上没有被测到。测试顺序时也不要改动块字段:仅交换列表中的位置,才能证明链内先后关系受到了检查。
这里校验的是给定区块列表的结构一致性,未实现交易有效性、工作量证明、权益投票或共识选链。如果攻击者把全部历史区块及后继哈希一起重算,结构检查仍可能通过。真实节点还需使用可信创世锚点及相应链的共识规则,不能仅凭这四个测试认定历史已被网络认可。