区块链原理 / 系统课时

编写区块哈希和父块校验测试

编写区块哈希和父块校验测试

区块内容被修改后,旧哈希应立即失效;即使单个区块的哈希正确,也可能连接到错误的父块。本课用 Python 标准库构建三块测试链,通过四个单元测试验证正常区块、载荷篡改、父块引用错误与区块顺序颠倒,并定位到具体失败位置。

学习目标

  • 使用稳定序列化规则重算 SHA-256 区块哈希。
  • 校验创世块约定、父块哈希引用和相邻区块高度。
  • 用独立负例区分内容篡改、链接错误与顺序错误。

定义区块与验收规则

本示例的区块含 height、prev_hash、payload、nonce、block_hash 五个字段。前四个字段参与 SHA-256 计算,最后一个字段保存结果。序列化固定为 UTF-8 编码的 JSON,并开启键排序、关闭多余空格,避免同一组数据因编码方式不同产生不同哈希。

按顺序检查以下条件:

  1. 重算每个区块的哈希,必须等于保存的 block_hash;否则报告 HASH_MISMATCH。
  2. 首块约定高度为 0、父哈希为 64 个字符 0;否则报告 GENESIS_INVALID。
  3. 从第二块起,高度必须等于前块高度加 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 返回是否通过及第一处失败原因;校验按“哈希、位置、父块引用”的顺序执行,因此一个区块存在多个问题时只报告首先命中的问题。

python
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> 表示每次不同的耗时):

text
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 处出现高度跳跃

测试父块错误时,必须让错误区块的自身哈希正确,否则程序会先在哈希重算处拒绝,父引用分支实际上没有被测到。测试顺序时也不要改动块字段:仅交换列表中的位置,才能证明链内先后关系受到了检查。

这里校验的是给定区块列表的结构一致性,未实现交易有效性、工作量证明、权益投票或共识选链。如果攻击者把全部历史区块及后继哈希一起重算,结构检查仍可能通过。真实节点还需使用可信创世锚点及相应链的共识规则,不能仅凭这四个测试认定历史已被网络认可。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

编写区块哈希和父块校验测试

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通