← COMP5567 全部讲次
L01a-2 · 第 1 周

L01a-2 区块头与挖矿:80 字节的页眉,和一个个试出来的 nonce

区块头五类字段各管什么、为什么加起来正好 80 字节,矿工怎样反复改 nonce 算哈希,以及难度 H(·) < 2¹⁸⁶ 和前导零的关系。

一句话版

区块链上的每一块分成头和体:体里装交易,头里装一小段固定格式的元信息。矿工要做的事,就是不停改头里的一个计数器 nonce,把头哈希一遍又一遍,直到碰出一个足够小的结果,谁先碰出来谁就有权写下一块。

哈希和账本的背景见上一页 L01a。这一页讲区块头、出块三步和难度。

先认识这几个词

词 全称 / 读法 一句人话
区块头 / 区块体 block header / block body 头是一小段元信息,体里装交易
Prev Hash previous block hash 前一块区块头的哈希,用来把块串成链
Merkle Root 默克尔树根 块里所有交易两两哈希、逐层合并出的一个总指纹
nonce number used once 区块头里矿工反复改动的计数器
target / nBits 难度目标 哈希结果必须小于的那个阈值
PoW Proof of Work,工作量证明 靠大量算哈希碰运气,抢写下一块的权利
前导零 leading zeros 一串数字最前面连续的 0,越多说明这个数越小

一个类比:抽奖箱里摸号码

设想公告栏旁边放着一个抽奖箱,里面的号码从 0 排到一个很大的数。规则是:谁先摸出一个小于某个门槛的号码,谁就能贴下一页账。

摸号码没有技巧,只能一次一次摸。每摸一次中奖的机会都一样,和你之前摸过多少次无关。所以手快的人、一秒能摸很多次的人,中奖的机会就大。门槛定得越低,能中奖的号码越少,大家平均要摸的次数越多。

类比在哪里失效:

  • 抽奖箱里的号码是随机的。区块头的哈希是确定的,同一个头算出来永远是同一个数,所以矿工每次都要改 nonce,让头变一下再算。
  • 摸到的号码自己看不出来对不对,要别人核对。哈希的好处是任何人拿到这个头重算一次就能验证,验证很快,找到却很慢。

从零讲起

1. 区块头的五类字段与 80 字节

它解决什么问题

一个区块里可能有成千上万笔交易。别的节点收到它,要能很快确认两件事:它接在哪一块后面,块里的交易有没有被动过。如果每次都把所有交易翻一遍,太慢。区块头把这些信息压在一小段固定长度的数据里,只看头就够了。

从哪来(补充)

头里的 Merkle Root 来自 Merkle 树。这种结构以 Ralph Merkle 命名,他在 1979 年为它申请了专利。比特币和以太坊的点对点网络都用到了它。

出处:Wikipedia: Merkle tree

直觉

把区块想成一个快递箱。箱子里装着货(交易),箱子外面贴着一张面单(区块头)。

面单上写着几样东西:上一个箱子的编号,这样箱子能排成一串;箱子里所有货的总指纹,货被调包了一对就知道;还有版本号、时间,以及挖矿要用的两项。看面单不用开箱。

一步一步看

目标:弄清区块头里有哪几类字段、各管什么,以及头为什么只有 80 字节。

  1. 先看整体:一个区块分成左边的头和右边的体,体里是 Transaction 1 到 Transaction N。

    一个区块分成左右两部分:左边 Block header 列出 Version、Prev Hash、Merkle Root、Time、Target + Nonce 五行并写出各自用途,右边 Block body 列出 Transaction 1、2、省略号、N,全部交易汇成一个根,用青绿箭头指向左边的 Merkle Root

  2. 再看头里的五类字段各管什么:Version 是版本号;Prev Hash 指向前一块,用来成链;Merkle Root 是全部交易压出来的根,保证块内交易完整;Time 是时间戳;Target 和 Nonce 给 PoW 用。

  3. 最后把头里每个字段的真实宽度排开。两个哈希字段各占 32 字节,其余四个各占 4 字节。

    区块头六个字段按真实字节数排成一条:Version 4、Prev Hash 32、Merkle Root 32、Time 4、nBits 4、Nonce 4,合计 80 字节;Magic no、Block size、Transaction counter 和 Transactions 都不算在这 80 字节里

  4. 头外面还有几项:Magic no(固定值 0xD9B4BEF9)、Block size、Transaction counter 和交易本身。它们和头写在同一张表里,但不属于头。

怎么算

把六个字段的字节数加起来:

4 + 32 + 32 + 4 + 4 + 4 = 80

两个 32 是这么来的:SHA-256 输出 256 位,256 ÷ 8 = 32 字节。Prev Hash 是前一块头的 SHA-256,Merkle Root 也是 SHA-256 算出来的,所以各占 32 字节。

意思是:区块头的长度是固定的 80 字节,和块里装了多少笔交易无关。挖矿时被反复哈希的,就是这 80 字节。

常见误解

把 Magic no 和 Block size 也算进区块头

这两项各 4 字节,和区块头写在同一张表里,但不在那 80 字节里。加进去就得到 4 + 4 + 80 = 88,答错。

以为改了一笔交易,只要不碰 Merkle Root 就没人发现

Merkle Root 是根据块内全部交易算出来的。交易一改,别人重算出来的根就和头里存的对不上,一眼就能发现。

试一下

Prev Hash 和 Merkle Root 都占 32 字节。如果有一天改用输出 512 位的哈希算法,其余字段不动,区块头变成多少字节?

512 ÷ 8 = 64 字节,两个哈希字段各 64 字节。总长 4 + 64 + 64 + 4 + 4 + 4 = 144 字节。

2. 出块三步与 nonce 穷举

它解决什么问题

上一页留下一个问题:共享账本的下一块由谁写?PoW 的回答是:谁先完成一件很费力、但别人很容易核对的事,谁就有权写。出块三步就是这件事的具体做法。

从哪来(补充)

用「先付出计算量」来换取资格,这个想法比比特币早。1993 年,Cynthia Dwork 和 Moni Naor 提出用它来防垃圾邮件:发一封邮件要先算一会儿,群发的人就发不起。1997 年 Adam Back 做的 Hashcash 也是这个思路,比特币的挖矿沿用了这类做法。

出处:Wikipedia: Proof of work

直觉

区块头里的其他字段一旦定下,就不能乱改:前一块是谁、装了哪些交易、难度多少,都是事实。能自由改的只有 nonce 这个计数器。

所以矿工的做法很笨:nonce 从 0 开始,算一次头的哈希,不够小就加 1 再算,一直算到够小为止。因为哈希改一点就整串变,没有任何办法提前知道哪个 nonce 能成。

一步一步看

目标:看矿工怎样只改 nonce、反复算哈希,直到碰上一个够小的结果。

下面用一个缩小版演示。真实规则要求哈希小于 target,这里换成一个好看的简化规则:哈希的第一个十六进制位要小于 4。

  1. 第一步先收集有效交易,算出 Merkle Root。然后 Version、Prev Hash、Merkle Root、Time、Target 全部固定,nonce 从 0 开始,算一次哈希,开头是 f,不小于 4,不过关。

    第 1 步:左上灰框写着固定的字段 Version、Prev Hash、Merkle Root、Time、Target,下面一框写着在变的 nonce = 0;右边表格一行,nonce 0 对应哈希 f2528035cf59,结果 f 不小于 4

  2. nonce 加 1 再算,再加 1 再算。1、2、3 的哈希开头分别是 9、7、7,都不小于 4,继续。

    第 2 步:在变的 nonce = 3;右边表格列出 nonce 0 到 3 的哈希前 12 位,开头分别是 f、9、7、7,结果都是不小于 4

  3. nonce = 4 时,哈希开头是 2,小于 4,过关。矿工停下,把这个区块广播到全网。

    第 3 步:在变的 nonce = 4;右边表格最后一行用青绿色标出,nonce 4 的哈希是 2a7898c5f18b,结果小于 4、过关

  4. 课件的出块流程图画的是同一个循环,只是对头连做两次 SHA-256,判断条件是「结果小于 target」。

    出块流程图:区块头六个字段作为输入,连过两次 SHA-256,结果带足够多前导零就算有效并广播,否则把 nonce 加 1 回到上一步重算
    图片来源:COMP5567 Lecture_1-Blockchain-introduction.pdf, p.23

怎么判断

拿到一次出块过程,按三步对:

  1. 有没有先收集有效交易、算出 Merkle Root?
  2. 是不是只改 nonce,反复对区块头做两次 SHA-256,直到结果小于 target?
  3. 找到之后有没有广播全网?

意思是:三步缺一步都不算完成出块。第 2 步里只有 nonce 在变,其余字段这一轮都固定。每次尝试成功的机会一样大,一秒能试多少次,就决定了抢到出块权的机会有多大。

常见误解

把 PoW 想成「解一道数学难题」

它是碰运气式的穷举,没有解题思路可言。每次尝试成功的概率固定且独立,除了一个个试没有别的办法。所以算力可以直接换算成出块概率。

以为试了很多次没中,下一次中的机会就更大

每次尝试互相独立,前面失败多少次都不影响下一次。上面演示里 nonce 0 到 3 都没中,nonce 4 中的机会和 nonce 0 一样。

试一下

沿用上面的简化规则,如果改成更严的「第一个十六进制位必须是 0」,从 nonce 0 开始往上试,第一个过关的是几?

是 12,它的哈希以 0701b97f 开头。规则越严,要试的次数通常越多:宽松规则在 nonce 4 就过了,严格规则要试到 12。

3. 难度:H(·) < 2¹⁸⁶ 和前导零

它解决什么问题

上一节说哈希要「足够小」。到底多小?这个门槛决定了挖一块平均要试多少次,也就决定了出块有多难。课件把门槛写成一个不等式,这一节把它翻成「前多少位必须是 0」。

直觉

一个 256 位的数,最高位都是 0,它就小;前面连续的 0 越多,它越小。

所以「哈希小于某个数」和「哈希前面有多少个 0」是同一件事的两种说法。门槛越低,要求的前导零越多,能过关的哈希越少,平均要试的次数越多。

一步一步看

目标:看「哈希小于 2 的某次方」怎样换算成「前面多少位必须是 0」。

先用 8 位的小哈希把关系看清,再换回真实的 256 位。

  1. 一个 8 位的数,从高到低每一位分别代表 2⁷、2⁶ 一直到 2⁰,能表示 0 到 255 共 256 个值。

  2. 要求它小于 2⁵ = 32。合法的数是 0 到 31,这些数的最高 3 位一定都是 0,后 5 位随便。

  3. 3 是怎么来的:8 − 5 = 3。

  4. 256 个值里只有 32 个合法,随便算一次命中的机会是 32 / 256 = 1/8。

    缩小版:8 个二进制位,前 3 位用青绿色标为 0,后 5 位是问号,旁边写着前 8 − 5 = 3 位必须是 0;下方数轴从 0 到 255,只有 0 到 32 一段用青绿粗线标为合法区间,注明命中机会 32 / 256 = 1/8,真实比特币是前 256 − 186 = 70 位要是 0

  5. 换回真实情况:SHA-256 输出 256 位,课件的谜题是 H(·) < 2¹⁸⁶,所以前 256 − 186 = 70 位必须全为 0。

怎么算

前导零位数 = 哈希位数 − 指数 = 256 − 186 = 70

难度倍数:两个门槛 2ᵃ 和 2ᵇ(a > b),合法哈希的个数从 2ᵃ 缩到 2ᵇ,命中概率变成原来的 2ᵇ ÷ 2ᵃ = 2^(b − a),平均要试的次数放大 2^(a − b) 倍。

意思是:指数每少 1,前导零多 1 位,难度翻一倍。看到不等式,先用 256 减指数得到前导零位数,再用两个指数相减得到难度差了 2 的几次方。

常见误解

以为 target 越大越难

方向反了。target 是哈希必须小于的那个数,它越大,能过关的哈希越多,越容易。指数越小、target 越小、前导零越多,才越难。

算前导零时用 186 去减别的数

前导零位数 = 256 − 指数。256 是 SHA-256 的输出位数,186 是不等式里的指数,两者相减才是必须为 0 的高位数。

试一下

门槛从 H(·) < 2¹⁸⁶ 改成 H(·) < 2¹⁸⁴,前导零要多少位?难度变成原来的几倍?

256 − 184 = 72 位,比原来多 2 位。难度倍数 2^(186 − 184) = 2² = 4 倍。

把它们串起来

上一页问「共享账本的下一块由谁写」,这一页给出 PoW 的做法。

先把区块拆开:体里装交易,头里装 80 字节的元信息。Prev Hash 把块串起来,Merkle Root 把块内交易锁住,Target 和 Nonce 留给挖矿。

挖矿就是对这 80 字节反复做两次 SHA-256,每次把 nonce 加 1,直到结果小于 target。门槛写成 H(·) < 2¹⁸⁶,翻译过来是前 70 位全为 0。每次尝试的成功机会固定,所以算力越大,越容易抢到写下一块的权利。

下一页接着问:块写上去之后,旧账能不能改?两个矿工同时挖到时听谁的?

课件里的坑

  • 本讲课件未发现错误。p.20 那张字段表把 Magic no 和 Block size 和区块头列在一起,容易被误算进 80 字节。

课后 10 分钟:考点复习

这 10 分钟怎么用:合上页面,先默写区块头 80 字节的那道加法和出块三步;再用 256 减指数算一遍 H(·) < 2¹⁸⁶ 的前导零;然后做课件例题、完整例题和变式题;最后回查两个最容易错的地方:把 Magic no 和 Block size 算进区块头、把 PoW 想成解一道数学难题。

必背

  1. 区块头五要素的用途:Prev Hash 成链、Merkle Root 保证块内交易完整性、Target 与 Nonce 做 PoW,另有 Version 和 Time。
  2. 区块头固定 80 字节 = 4 + 32 + 32 + 4 + 4 + 4;Magic no 与 Block size 各 4 字节,不算在区块头内。
  3. 出块三步:收集有效交易算 Merkle Root → 改 nonce 反复做双 SHA-256 直到哈希小于 target → 广播全网。
  4. PoW 是穷举碰运气,每次尝试概率固定且独立,算力直接等价于出块概率。
  5. 谜题 H(·) < 2¹⁸⁶ 等价于 256 位哈希的前 70 位全为 0;指数越小,前导零越多,难度越高。

课件例题

例 1(课件 p.23):PoW 流程图上走一遍,判断何时停

题面:区块头输入为 Version(4 字节)、Target(4 字节)、Prev Hash、Merkle Root 06c056519733、Timestamp 1507292970、Nonce 1559164。这六项连做两次 SHA-256,得到一个哈希。图上有两个出口:「A Valid Hash」,以及「Invalid Hash; Increment the Nonce, Repeat SHA 256」。问:哈希无效时改哪个字段?什么时候停?

提示

六个输入里,哪些是这一块的事实、不能乱改?哪一个是专门留给矿工改的?

解答

无效时只把 Nonce 加 1,其余五项这一轮都不动,然后重新做两次 SHA-256。

结果小于 target,就是有效哈希,表现为足够多的前导零,像图上的 0000008bb8…。这时停下并广播区块。target 越小,要求的前导零越多,平均要试的次数越多。

完整例题

这一页能动笔的地方集中在字节数和阈值上。两问的数据都来自课件:字段表(p.20)和谜题 H( ) < 2¹⁸⁶(p.26)。做法相同,把表和不等式直接代进去。

(1) 把区块头的字节数加一遍,为什么是 80?

  1. 按 p.20 的表逐项取值:Version 4、Previous Block Hash 32、Merkle Root 32、Timestamp 4、Target/nBits 4、Nonce 4。
  2. 相加:4 + 32 + 32 + 4 + 4 + 4 = 80 字节。
  3. 两个 32 的来历:SHA-256 输出 256 位,256 ÷ 8 = 32 字节,所以 Prev Hash 和 Merkle Root 各占 32。
  4. 容易多加的两项:Magic no 4 字节和 Block size 4 字节。它们在 p.20 的同一张表里,但不属于区块头,加上就变成 88,答错。
  5. 另外两项 Transaction counter(1–9 字节)和 Transactions(不定长)属于区块体,长度不固定,更不可能进那 80 字节。

(2) H( ) < 2¹⁸⁶ 要求哈希的前多少位是 0?改成 < 2¹⁷⁰ 难度变多少倍?

  1. SHA-256 的输出是 256 位。一个 256 位整数小于 2¹⁸⁶,等价于它的最高 256 − 186 = 70 位全为 0(p.26)。
  2. 同一算法代到 2¹⁷⁰:256 − 170 = 86 位全为 0,要求前导零多了 16 位。
  3. 合法哈希的个数从 2¹⁸⁶ 个缩到 2¹⁷⁰ 个,命中概率降为原来的 2¹⁷⁰ / 2¹⁸⁶ = 2⁻¹⁶,期望尝试次数放大 2¹⁶ = 65,536 倍(补充)。
  4. 答题时把「指数越小、阈值越小、前导零越多、难度越高」这条单调关系写出来,比只写数字稳。

变式题(先自己做)

改编自课件 p.20、p.26:

(1) 阈值改成 H( ) < 2¹⁶⁰,要求哈希的前多少位是 0?比 < 2¹⁸⁶ 难多少倍? (2) 假设有人把区块头里的 Timestamp 和 Nonce 各扩到 8 字节,其余字段不动,区块头变成多少字节?

提示

第一问两步:先算前导零位数,再比两个阈值的个数之比。第二问回到那张字段表,先确认哪六项才算区块头。

判分点与答案(非官方评分标准)

判分点:① 前导零位数 = 256 − 指数;② 难度倍数写成 2 的指数差,能给出数量级更好;③ 第二问不能把 Magic no 和 Block size 算进去。

(1) 256 − 160 = 96 位全为 0。合法哈希个数从 2¹⁸⁶ 缩到 2¹⁶⁰,命中概率降为 2⁻²⁶,期望尝试次数放大 2²⁶ ≈ 6.7 × 10⁷ 倍。单调关系照旧:指数越小 → 阈值越小 → 前导零越多 → 越难。

(2) 区块头六项:Version 4 + Prev Hash 32 + Merkle Root 32 + Timestamp 8 + nBits 4 + Nonce 8 = 88 字节。两个 32 不受影响,因为它们由 SHA-256 的 256 位输出定死。Magic no 和 Block size 各 4 字节仍然在头外,加进去得到 96 就错了。

闪卡自测

1. 区块分成哪两部分?交易放在哪?

分成区块头和区块体。交易放在区块体里,头里只放元信息(p.19)。

2. Prev Hash 和 Merkle Root 各保护什么?只改一笔交易但不改 Merkle Root,会被发现吗?

Prev Hash 把区块串成链并让篡改历史必须重算其后所有区块;Merkle Root 保证块内交易的完整性(p.19)。会被发现:Merkle Root 是基于块内全部交易算出的 256 位哈希,交易一改,重算出的根就和头里存的对不上(p.20)。

3. 把区块头的八个候选字段筛一遍,哪些进那 80 字节、哪些不进?

进:Version 4、Prev Hash 32、Merkle Root 32、Timestamp 4、Target/nBits 4、Nonce 4,合计 80。不进:Magic no 4、Block size 4,以及区块体里的 Transaction counter(1–9 字节)和 Transactions(不定长)(p.20)。

4. 为什么 Prev Hash 和 Merkle Root 正好各占 32 字节?

它们都是 SHA-256 的输出,256 位除以 8 就是 32 字节。

5. 出块的三步分别是什么?第 2 步里哪些字段在变、哪些不变?

收集有效交易并算出 Merkle Root → 反复计算区块头哈希、每次 nonce 加 1 直到小于目标值 → 广播全网(p.22)。第 2 步里只有 nonce 在变,前块哈希、Merkle Root、时间戳、target 这一轮都固定。

6. 为什么说算力可以直接换算成出块概率?

PoW 是穷举,每次尝试成功的概率固定且独立,所以单位时间能做多少次尝试,就按比例决定抢到出块权的概率(p.23)。

7. 比特币的 PoW 对区块头做几次 SHA-256?前导零的个数代表什么?

两次,图上标的是 2 times SHA 256,即 double SHA-256。前导零的个数就是难度:target 越小,要求的前导零越多,找到合法 nonce 要试的次数越多(p.23)。

8. H(·) < 2¹⁸⁶ 要求前多少位为 0?怎么算出来的?

前 70 位。SHA-256 输出 256 位,用 256 减去指数 186 得到 70(p.26)。

下一讲

L01b 接着讲块写上去以后的事:改一块旧账为什么要重挖后面所有块,两个矿工同时挖到时听谁的。

下一讲 →
L01b L01b 改不动的旧账:篡改的代价、最长链和分叉

个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。