区块链基础原理与共识机制

导语：从密码学到信任机器

2008 年，中本聪发布《Bitcoin: A Peer-to-Peer Electronic Cash System》，提出了一个令人震惊的命题：不依赖任何中心化机构，陌生人之间可以直接交易电子现金。

这个问题的难点不在技术本身，而在社会学：如何让互不信任的节点就同一本账本达成一致？这就是共识机制要解决的问题。

区块链的本质是将密码学（哈希、签名）与博弈论（经济激励）结合，构造一个"不可伪造的历史"。任何人都可以验证这个历史，但没有人能单方面篡改。

一句话总结：区块链不是新技术的发明，而是已有密码学工具（哈希 + 数字签名 + Merkle Tree）的精妙组合，创造出"去信任化的公共账本"。

1. 区块结构：数据如何被"链"起来

区块链的"链"不是比喻，而是密码学意义上的链式结构。

1.1 单个区块的组成

┌─────────────────────────────────────────┐
│              Block Header                │
├─────────────────────────────────────────┤
│  Version          (4 bytes)              │
│  Previous Hash    (32 bytes)  ← 前一区块的哈希 │
│  Merkle Root      (32 bytes)  ← 本区块所有交易的摘要 │
│  Timestamp        (4 bytes)              │
│  Difficulty Bits  (4 bytes)              │
│  Nonce            (4 bytes)   ← PoW 中的随机数 │
└─────────────────────────────────────────┘
│              Block Body                  │
├─────────────────────────────────────────┤
│  Transaction Count  (varint)             │
│  Transactions[]     (列表)               │
│    ├── 输入 (引用之前的 UTXO)              │
│    ├── 输出 (金额 + 锁定脚本)              │
│    └── 签名 (证明所有权)                   │
└─────────────────────────────────────────┘

1.2 哈希链：不可篡改的数学保证

import hashlib

def sha256(data: bytes) -> bytes:
    return hashlib.sha256(data).digest()

# 简单的区块哈希计算
def block_hash(prev_hash: bytes, merkle_root: bytes, nonce: int) -> bytes:
    header = prev_hash + merkle_root + nonce.to_bytes(4, 'little')
    return sha256(sha256(header))  # Bitcoin 使用 double-SHA256

# 一旦前一区块的哈希被包含在当前区块中，
# 任何对历史区块的修改都会改变其哈希，从而破坏后续整条链

篡改历史区块的成本：需要重新计算被篡改区块以及其后所有区块的哈希。在 PoW 链上，这意味着重新完成所有累积的工作量。

一句话总结：每个区块都"盖章认证"了前一个区块的哈希，篡改历史交易必须重做之后所有区块的计算——在计算成本高昂时，这变得经济不可行。

2. Merkle Tree：交易的指纹

2.1 构建过程

如果有 4 笔交易 A、B、C、D，Merkle Root 的计算方式是：

                ┌─────────────────┐
                │   Merkle Root   │
                │  H(H_AB + H_CD) │
                └────────┬────────┘
                         │
           ┌─────────────┴─────────────┐
           ▼                           ▼
      ┌──────────┐               ┌──────────┐
      │   H_AB   │               │   H_CD   │
      │H(H_A+H_B)│               │H(H_C+H_D)│
      └────┬─────┘               └────┬─────┘
           │                          │
    ┌──────┴──────┐            ┌──────┴──────┐
    ▼             ▼            ▼             ▼
┌───────┐   ┌───────┐    ┌───────┐   ┌───────┐
│  H_A  │   │  H_B  │    │  H_C  │   │  H_D  │
│Hash(A)│   │Hash(B)│    │Hash(C)│   │Hash(D)│
└───────┘   └───────┘    └───────┘   └───────┘

2.2 SPV 轻节点验证

轻节点只需要保存区块头（80 字节/块），就可以验证某笔交易是否在链上：

def verify_tx_in_merkle(tx_hash: bytes, merkle_root: bytes, proof: list) -> bool:
    """
    proof: [(sibling_hash, is_left), ...]
    """
    current = tx_hash
    for sibling, is_left in proof:
        if is_left:
            current = sha256(current + sibling)
        else:
            current = sha256(sibling + current)
    return current == merkle_root

一笔交易的 Merkle 证明只需要 log2(N) 个兄弟哈希，在比特币的百万级交易区块中也只需要约 20 个 32 字节哈希。

一句话总结：Merkle Tree 让整个区块的所有交易被压缩成 32 字节的根哈希，轻节点只需区块头就能验证任意交易是否存在。

3. 共识机制：谁有记账权

3.1 问题定义：拜占庭将军问题

在分布式系统中，如果部分节点可能故障或作恶，如何让诚实节点达成一致？这就是拜占庭容错（BFT）问题。区块链在开放网络中面临更严峻的挑战：

• 节点可以任意加入和退出
• 没有身份认证机制（无许可链）
• 攻击者可以控制相当一部分算力或权益

3.2 工作量证明（Proof of Work）

import hashlib
import time

def mine_block(prev_hash: bytes, merkle_root: bytes, difficulty: int) -> tuple:
    """
    difficulty: 目标哈希前面需要有多少个 0
    """
    target = 1 << (256 - difficulty)
    nonce = 0
    
    while True:
        header = prev_hash + merkle_root + nonce.to_bytes(4, 'little')
        hash_result = int.from_bytes(
            hashlib.sha256(hashlib.sha256(header).digest()).digest(),
            'big'
        )
        
        if hash_result < target:
            return nonce, hash_result.to_bytes(32, 'big')
        
        nonce += 1
        # 实际挖矿中会每轮改变 coinbase extra nonce

PoW 的核心思想是"一 CPU 一票"——投入算力竞争记账权，算力占比决定出块概率。

3.3 权益证明（Proof of Stake）

PoS 用"经济权益"替代"算力"作为竞争记账权的资源：

出块概率 ∝ 质押的代币数量 × 质押时间

验证者集合：质押 32 ETH → 成为验证者
            ↓
Epoch (6.4 分钟)：将验证者分配到不同 Slot
            ↓
Committee (128 验证者)：每个 Slot 确定一个出块者
            ↓
分叉选择：LMD GHOST + Casper FFG 终局性

以太坊从 PoW 转向 PoS 的 The Merge 后：

3.4 其他共识机制

一句话总结：PoW 用算力买安全，PoS 用经济抵押买安全，二者都在开放网络中实现了拜占庭容错，只是资源成本和激励机制不同。

4. 分布式一致性

4.1 CAP 定理与区块链

CAP 定理指出分布式系统最多同时满足两项：

• Consistency（一致性）：所有节点看到相同数据
• Availability（可用性）：每个请求都得到响应
• Partition tolerance（分区容错性）：网络分区时仍能运行

区块链的选择：

• Bitcoin/Ethereum：CP 系统 — 网络分区时宁愿暂停交易确认也要保证所有节点最终一致
• 但请注意：这里的 C 是"最终一致性"，不是强一致性

4.2 最终一致性（Finality）

交易广播 → 纳入区块 → N 个确认 → 概率性终局 → 绝对终局
                                    ↓
                          等待更多区块确认，回滚概率指数下降

Bitcoin: 6 个确认 ≈ 不可回滚（概率 < 0.01%）
Ethereum PoS: 2 Epoch (64 slots ≈ 12.8分钟) = 绝对终局

一句话总结：区块链通过概率性终局（PoW）或确定性终局（PoS）在异步网络中达成了无需许可的一致性。

5. 总结

区块链的底层由三层组成：

1. 数据结构层：哈希链 + Merkle Tree = 不可篡改的交易历史
2. 密码学层：数字签名 = 所有权证明；哈希 = 完整性校验
3. 共识层：PoW/PoS/BFT = 无信任环境下的达成一致

这些技术都不是新发明的，但组合在一起创造了一个前所未有的系统：一个不需要中央权威的公共数据库。

后续专题将在此基础上展开：

• Solidity 智能合约开发入门 — 在以太坊上编写可编程的交易逻辑
• 智能合约安全审计与常见漏洞 — 理解区块链应用安全