← COMP5521 全部讲次
L09c · 第 9 周

L09c 比特币脚本:输出上挂锁,输入里带钥匙

从栈讲起,看挑战脚本和响应脚本怎样跨两笔交易配成一对,一帧一帧跑一遍最常见的 P2PKH 锁,再对照一笔真实交易的原始字段。

一句话版

比特币的每个输出都挂着一段小程序当锁,叫挑战脚本;想花它的人在输入里给一段小程序当钥匙,叫响应脚本。节点把钥匙和锁首尾拼起来,在一个栈上从左往右执行,最后栈顶是「真」,钱就能转走。

前两页讲了交易的骨架(L09a)和手续费(L09b),那里把锁简写成 PK_John。这一页把这把锁拆开看。

先认识这几个词

词 全称 / 读法 一句人话
栈 stack,LIFO 一摞盘子,只能从顶上放、从顶上拿
挑战脚本 challenge script / scriptPubKey 挂在输出上的锁,规定谁能花
响应脚本 response script / scriptSig 放在输入里的钥匙,通常是签名,常常还带公钥
操作码 opcode,如 OP_DUP 脚本里的一条指令,名字都以 OP_ 开头
P2PKH Pay to Public Key Hash 付给公钥哈希:最常见的一种锁
公钥哈希 public key hash 公钥先 SHA-256 再 RIPEMD-160 得到的 20 字节

一个类比:保险箱上的密码锁

每个输出是一只保险箱,箱子上装着一把锁。 装锁的人在锁上刻了一道题:「拿出一把公钥,它的指纹要等于这一串;再拿出这把公钥认得出的签名。」

想打开箱子的人,在输入里递上一张答题卡。 答题卡上写两样东西:签名和公钥。

守门人把答题卡和锁上的题拼在一起,一行一行照着做。 有一步对不上,箱子就不开;全部做完最后亮绿灯,箱子打开,钱可以转走。

类比在哪里失效:

  • 保险箱的锁和钥匙是同时造的。比特币的锁是收款那笔交易挂上的,钥匙要等到花钱那笔交易才出现,两者隔着一笔交易。
  • 守门人不需要信任谁。任何节点都能自己把脚本跑一遍,得到同样的结果。

从零讲起

1. 先补一块:栈(补充)

它解决什么问题

比特币脚本要在一块草稿纸上一步步算:放进签名、放进公钥、复制、算哈希、比较。它用的草稿纸是一个栈。不懂栈,就看不懂脚本每一步在干什么。

直觉

栈像一摞盘子。新盘子只能放在最上面,拿也只能从最上面拿。最后放上去的最先被拿走,英文叫 LIFO,Last In First Out,后进先出。

脚本里的数据(签名、公钥、哈希)就是一个个盘子。操作码要用数据时,从栈顶拿;算出结果,再放回栈顶。

一步一步看

目标:依次放入三个盘子再拿走一个,看出栈只能从顶上进出,最后放的最先拿走。

依次放入 A、B、C 三个盘子,再拿走一个,看每一步栈里剩什么。

  1. 放入 A:栈里只有 A。

  2. 放入 B:B 压在 A 上面。

  3. 放入 C:C 在最上面,从上到下是 C、B、A。

  4. 拿走一个:走的是最上面的 C,剩下 B、A。

    四个竖直的栈并排:放入 A;放入 B 压在 A 上;放入 C 压在最上;拿走一个,走的是 C,旁边青绿方块标出被拿走的 C,栈里剩 B 和 A;底部说明最后放进去的最先出来,比特币脚本就在这样一个栈上执行

怎么判断

拿到一个容器,问一句:最后放进去的,是不是最先出来?是,就是栈。

反过来,最先放进去的最先出来,那是队列,像排队打饭。比特币脚本用的是栈。

常见误解

以为可以直接取栈中间的那个

基本操作只能碰栈顶。想用下面的东西,得先把上面的拿走,或者用专门的操作码复制、交换。

试一下

依次放入 P、Q,拿走一个,再放入 R,再拿走一个。两次拿走的分别是谁?最后栈里剩什么?

第一次拿走 Q,剩 P。放入 R 后从上到下是 R、P。第二次拿走 R,最后剩 P。

2. 锁和钥匙:挑战脚本与响应脚本

它解决什么问题

上两页把锁写成 PK_John,意思是「付给 John 的公钥」。可规则不只这一种,有时要两个人都签名,有时要等到某个时间以后才能花。比特币把锁写成一段脚本,就能表达各种花钱条件。

从哪来(补充)

比特币 wiki 的 Script 条目写道:Script 类似 Forth 语言,基于栈,从左往右执行。它刻意设计成不是图灵完备的,没有循环,这样每段脚本都一定能在有限步内跑完。

出处:Bitcoin Wiki: Script

直觉

每个输出带一段挑战脚本,它是一道题。花这个输出的输入,要带一段响应脚本,它是答案。节点把答案和题拼起来执行,跑通了,钱就能转走。

关键在于这一对锁和钥匙分属两笔交易。一笔交易的输入里放的钥匙,开的是上一笔交易输出上的锁;这笔交易自己输出上挂的新锁,要等下一笔交易来开。

一步一步看

目标:沿 0xb6ff → 0xbf11 → 0x12df 这条链对锁和钥匙,看出每把钥匙开的是上一笔交易的锁。

课件把三笔交易里的 PK 换成了 Challenge_Script,签名换成了 Response_Script。下面沿着 0xb6ff → 0xbf11 → 0x12df 这条链看每把钥匙开哪把锁。

  1. 0xb6ff 是 coinbase,没有输入;它的输出 [0] 挂着锁 Challenge_A,金额 12.5。

  2. 0xbf11 的输入写 0xb6ff[0] 和钥匙 Response_1,开的是 Challenge_A。

  3. 0xbf11 自己的输出挂上新锁 Challenge_C,这把锁现在还没人开。

  4. 0x12df 的输入写 0xbf11[0] 和钥匙 Response_2,开的才是 Challenge_C。

    三笔交易从左到右排开:0xb6ff 没有输入,输出 [0] Challenge_A 12.5;0xbf11 的输入是 0xb6ff[0] 加 Response_1,输出 [0] Challenge_C 12;0x12df 的输入是 0xbf11[0] 加 Response_2,输出 Challenge_E 10 和 Challenge_F 2;青绿箭头连起 Response_1 和 Challenge_A,说明钥匙开的是上一笔交易的锁

怎么判断

看到一个响应脚本,想知道它开哪把锁,就顺着同一个输入里的 TXID[序号] 往回找,那个旧输出上的挑战脚本就是它的锁。

同一笔交易里的输入脚本和输出脚本不是一对,不要横着配。

常见误解

以为同一笔交易里的 scriptSig 和 scriptPubKey 是一对锁和钥匙

这是读真实交易时最容易犯的错。scriptSig 开的是上一笔交易的锁;这笔交易的 scriptPubKey 是新挂上的锁,要等下一笔交易来开。

试一下

课件里 0xb2cd 的输入写 0x12df[1] 和 Response_3。Response_3 开的是哪把锁?

顺着 0x12df[1] 往回找,那个输出挂的是 Challenge_F,金额 2。Response_3 开的就是 Challenge_F。

3. P2PKH:一帧一帧开一把锁

它解决什么问题

最常见的锁是「付给某个公钥」。如果锁里直接写整个公钥,收款前公钥就全部公开了。P2PKH 只在锁里写公钥的哈希,等到花钱时才拿出公钥,并且证明它和锁里的哈希对得上。

直觉

P2PKH 的锁是五个记号:OP_DUP OP_HASH160 <公钥哈希> OP_EQUALVERIFY OP_CHECKSIG。

花它的钥匙是两个记号:<签名> <公钥>。

执行时把钥匙放在前、锁放在后,拼成一行从左往右跑。数据记号直接压栈;操作码从栈顶取东西来用,结果再压回去。整段先确认「这个公钥就是锁指定的那个」,再确认「签名确实是这个公钥对应的私钥签的」。

一步一步看

目标:分七帧跟着栈执行 P2PKH,看出公钥先要哈希后对上锁里的值,签名验过才留下 true。

钥匙是 ,锁是 OP_DUP OP_HASH160 OP_EQUALVERIFY OP_CHECKSIG。假设花钱的人给的公钥正确、签名也正确,下面七帧跟着栈一起走。

  1. 第 0 步:把钥匙和锁首尾拼起来,栈是空的。

    第 0 步:上方一排七个记号,sig pubKey 是钥匙 scriptSig,后面 OP_DUP、OP_HASH160、pubKeyHash、OP_EQUALVERIFY、OP_CHECKSIG 是锁 scriptPubKey;左下的栈是空的,右边说明从左往右一个记号一个记号地跑

  2. 第 1 步:钥匙里的 sig 和 pubKey 依次压栈,pubKey 在上。

    第 1 步:钥匙记号青绿高亮;栈里从下到上是 sig、pubKey,栈顶 pubKey 青绿描边;右边说明 sig 是花钱人的签名,pubKey 是他的公钥

  3. 第 2 步:OP_DUP 把栈顶的 pubKey 复制一份。

    第 2 步:OP_DUP 青绿高亮;栈里从下到上是 sig、pubKey、pubKey,新复制的那份在栈顶;右边说明复制是为了留一份给最后一步验签用

  4. 第 3 步:OP_HASH160 把栈顶换成它的 20 字节哈希。

    第 3 步:OP_HASH160 青绿高亮;栈顶从 pubKey 换成了 哈希(pubKey),下面还有 pubKey 和 sig;右边说明先 SHA-256 再 RIPEMD-160,得到 20 字节

  5. 第 4 步:锁里写的 pubKeyHash 压栈。

    第 4 步:pubKeyHash 记号青绿高亮;栈里从下到上是 sig、pubKey、哈希(pubKey)、pubKeyHash;右边说明这是收款时写进锁里的公钥哈希

  6. 第 5 步:OP_EQUALVERIFY 比较栈顶两项,相等就把它们拿走,继续。

    第 5 步:OP_EQUALVERIFY 青绿高亮;栈顶两个哈希被拿走,栈里只剩 sig 和 pubKey;右边说明两个哈希相等,说明给的公钥就是锁指定的那个,不等就立刻失败

  7. 第 6 步:OP_CHECKSIG 用 pubKey 验 sig,对得上就留下 true。

    第 6 步:OP_CHECKSIG 青绿高亮;sig 和 pubKey 都被取走,栈里只剩一个 true;右边说明签名对得上公钥,结果是 true,钱可以花

怎么算

OP_HASH160(x) = RIPEMD-160(SHA-256(x))。

意思是:先把公钥做一次 SHA-256,再把结果做一次 RIPEMD-160,最后得到 20 字节,这就是锁里写的公钥哈希。

整段脚本的判定可以写成两个条件同时成立:HASH160(pubKey) = pubKeyHash,并且 CHECKSIG(sig, pubKey) = true。

意思是:第一个条件证明「你拿出的公钥就是收款人当初给的那个」;第二个条件证明「你手里有这个公钥对应的私钥」,因为只有私钥能签出这个公钥验得过的签名。签名和验签就是上一讲的 ECDSA。

常见误解

以为节点要知道私钥才能验证

不需要。OP_CHECKSIG 只用公钥和签名,按 ECDSA 的验签公式算一遍。私钥始终只在花钱的人手里。

以为 OP_EQUALVERIFY 不等时会留下 false 继续往下跑

带 VERIFY 的操作码不相等就立刻让整段脚本失败,后面的 OP_CHECKSIG 根本不会执行。

试一下

Alice 想花一个锁给 John 公钥哈希的输出,她给了自己的签名和自己的公钥。脚本在哪一步失败?

第 5 步。OP_HASH160 算出的是 Alice 公钥的哈希,和锁里 John 的公钥哈希不相等,OP_EQUALVERIFY 立刻失败。

4. 读一笔真实交易的原始字段

它解决什么问题

课件把锁和钥匙写成 PK_John、Response_1 这种简写。真实交易里它们是一串串十六进制和操作码。能把原始字段和课上的名字对上,才算真正看懂一笔交易。

直觉

一笔交易的原始数据分两块:Input 和 Output。

Input 这一块就是 L09a 的「指针加钥匙」:Previous tx 是被花的那笔交易的 TXID,Index 是输出序号,scriptSig 是响应脚本。

Output 这一块就是「金额加锁」:Value 是金额,单位是聪;scriptPubKey 是挑战脚本。

一步一步看

目标:把一笔真实交易的原始字段逐个对上课上的名字,看出指针、响应脚本、金额和锁分别是哪一段。

课件给出的这笔交易只有一个输入、一个输出,原始字段如下,逐个对上课上的名字。

  1. Previous tx 是 f5d8ee39…0b9a6,Index 是 0:指向那笔交易的第 0 个输出。

  2. scriptSig 是 304502206e21…6b241501,共 72 字节:这是响应脚本,里面只有签名。

  3. Value 是 5000000000,单位是聪:5000000000 ÷ 10⁸ = 50 BTC。

  4. scriptPubKey 是 OP_DUP OP_HASH160 4043…549d OP_EQUALVERIFY OP_CHECKSIG:这是一把 P2PKH 锁。

    一笔真实交易的原始字段两个框:Input 框列出 Previous tx f5d8ee39…0b9a6 即被花交易的 TXID,Index 0 即第 0 个输出,scriptSig 304502206e21…6b241501 即响应脚本签名;Output 框青绿描边,Value 5000000000 即 50 BTC,scriptPubKey 是 P2PKH 挑战脚本;底部说明上面的钥匙开的是上一笔交易的锁

怎么算

scriptSig 的 72 字节拆开是:开头 30 45,表示后面跟着 69 字节的 DER 编码 ECDSA 签名(r 32 字节、s 33 字节);最后一个字节 01 是签名类型 SIGHASH_ALL。

意思是:这一段只有签名,没有公钥。所以它开的那把旧锁是直接付给公钥的格式,公钥已经写在旧锁里了。

金额换算:BTC = 聪 ÷ 10⁸。

意思是:原始数据里的金额都以聪为单位写成整数,要除以一亿才是比特币个数。

常见误解

以为这笔交易的 scriptSig 是用来开它自己的 scriptPubKey 的

两者不是一对。scriptSig 开的是 Previous tx 那笔交易的输出锁;下面的 scriptPubKey 是这笔交易新挂的 P2PKH 锁,将来要用签名加公钥去开。

试一下

一个输出的 Value 写着 1250000000。它是多少 BTC?

1250000000 ÷ 10⁸ = 12.5 BTC,正好是课件例子里一个 coinbase 的金额。

把它们串起来

比特币里「谁能花这笔钱」由一段脚本说了算。

收款时,付款人在新输出上挂一把锁。最常见的是 P2PKH,锁里只写收款人公钥的 20 字节哈希。

花钱时,收款人在新交易的输入里递上钥匙:签名加公钥。节点把钥匙和旧锁拼起来,在栈上从左往右执行。先比哈希,确认公钥对;再验签名,确认手里有私钥。两关都过,栈顶留下 true。

锁和钥匙永远隔着一笔交易。读真实交易时,钥匙往回配上一笔的锁,这笔的锁往后等下一笔的钥匙。

每加一个区块,就有一批旧锁被打开、一批新锁挂上去。还没被打开的那些锁连着的钱,就是下一页的 UTXO 集合。

课件里的坑

  • [读图提醒] p.17 的 scriptSig 只有签名、没有公钥,它开的是上一笔交易的锁;下面的 scriptPubKey 是这笔交易新上的 P2PKH 锁,将来要用签名加公钥开。两者不是一对。
  • [记法] p.15 把 PK 换成 Challenge_Script_A 到 H,字母只是编号,和人名无关;p.20 的 UTXO 表沿用同一套字母。
  • [补充] P2PKH 的逐步执行课件没有展开,本页的七帧按比特币 wiki 的 Script 条目整理,考试以课件为准,能说出「先比哈希、再验签名」就够。

课后 10 分钟:考点复习

这 10 分钟怎么用:先默写必背,再合上页面,在纸上画一个空栈,把 P2PKH 七步自己跑一遍。然后拿课件的 p.17 截图,逐个字段说出它对应的课上名字。最后做变式题,练「在哪一步失败」。

必背

  1. 输出里的挑战脚本(scriptPubKey)是锁,输入里的响应脚本(scriptSig)是钥匙
  2. 响应脚本开的是上一笔交易的输出锁;本笔交易的输出锁要等下一笔交易来开
  3. P2PKH 锁是 OP_DUP OP_HASH160 <20 字节哈希> OP_EQUALVERIFY OP_CHECKSIG,花它要给签名 + 公钥
  4. OP_HASH160 = SHA-256 再 RIPEMD-160,得 20 字节;先比哈希,再用公钥验签名
  5. p.17 的 Value 以聪为单位,5000000000 聪 = 50 BTC;scriptSig 72 字节是 DER 签名加 1 字节 SIGHASH_ALL
  6. 同一地址可以多次收款,但交易会被关联,首次花钱后公钥公开

课件例题

例 1(课件 p.17):读一笔真实交易

题面:Input 有 Previous tx、Index 0、scriptSig;Output 有 Value 5000000000 和以 OP_DUP OP_HASH160 开头的 scriptPubKey。说出各字段的意思。

提示

Input 对应「指针加钥匙」,Output 对应「金额加锁」。Value 的单位不是 BTC。

解答

Previous tx 加 Index 是被花掉的那个输出;scriptSig 是响应脚本,这里是 72 字节,里面是 ECDSA 签名加 1 字节签名类型。Value 单位是聪,5000000000 聪是 50 BTC。scriptPubKey 是 P2PKH 锁,花它要给签名和公钥。

例 2(课件 p.24):一个比特币地址能不能多次用作收款方?会不会带来安全问题?

提示

先答能不能(课件 p.14 里 John 的找零付给了谁);再从隐私和公钥暴露两方面答问题。

解答

能,协议不禁止,p.14 里 John 就把找零付回了同一个 PK_John。问题有两个。隐私:同一地址的收付款在链上都能被关联,别人能统计这个地址的余额和交易对手。公钥暴露:P2PKH 地址第一次花钱前,链上只有公钥哈希;第一次花钱时公钥随签名公开,之后再收到这个地址的钱就少了哈希这层保护,只靠椭圆曲线离散对数难题。课件没给标准答案,以上是补充思路。

完整例题

题面(改编自课件 p.14、p.17):B56 之后,0xbf11[0] 的锁是 P2PKH,锁里写的是 John 公钥的哈希 h_John。John 要花它。写出他的响应脚本,并写出每一步执行后的栈(栈顶写在最右)。

解法:

  1. 响应脚本:<sig_John> <pubKey_John>,sig_John 是 John 用私钥对新交易做的签名。
  2. 拼起来:<sig_John> <pubKey_John> OP_DUP OP_HASH160 <h_John> OP_EQUALVERIFY OP_CHECKSIG。
  3. 压入两个数据:栈 [sig_John, pubKey_John]。
  4. OP_DUP:栈 [sig_John, pubKey_John, pubKey_John]。
  5. OP_HASH160:栈顶换成 HASH160(pubKey_John),栈 [sig_John, pubKey_John, HASH160(pubKey_John)]。
  6. 压入 <h_John>:栈 [sig_John, pubKey_John, HASH160(pubKey_John), h_John]。
  7. OP_EQUALVERIFY:HASH160(pubKey_John) = h_John,相等,两项拿走,栈 [sig_John, pubKey_John]。
  8. OP_CHECKSIG:用 pubKey_John 验 sig_John,通过,栈 [true]。脚本成功,John 可以花这 12。

要点:钥匙在前、锁在后;先比哈希再验签;带 VERIFY 的一步不相等会立刻失败。

答题格式:一行一步,每行写「执行了哪个记号 → 栈现在是什么」。

变式题(先自己做)

(1) 自编情境:John 给了正确的公钥,但签名是用别人的私钥签的。脚本在哪一步失败?栈里最后是什么? (2) 改编自课件 p.17:一个输出的 Value 是 1300000000,它是多少 BTC?这个数在课件四个区块的例子里是谁的 coinbase 金额? (3) 改编自课件 p.15:0x12df 输出 [0] 挂的锁是 Challenge_E。后来要花它的交易,输入里应该写什么?

提示

(1) 哈希那一关能过吗?(2) 除以 10⁸。(3) 输入 = TXID[序号] + 响应脚本。

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

判分点:① 指出失败在哪个操作码,并说出原因;② 金额换算写出除法;③ 输入写 TXID[序号] 和响应脚本,不写金额。

(1) 第 5 步 OP_EQUALVERIFY 能过,因为公钥是对的。第 6 步 OP_CHECKSIG 验签失败,栈里留下 false,脚本不通过。

(2) 1300000000 ÷ 10⁸ = 13 BTC,是 B56 的 coinbase 0x5fac 付给 Bob 的金额。

(3) 输入写 0x12df[0],加一段能通过 Challenge_E 的响应脚本,比如 Alice 的签名和公钥。不写金额 10。

闪卡自测

1. scriptSig 和 scriptPubKey 哪个是锁、哪个是钥匙?

scriptPubKey 是挑战脚本,是锁;scriptSig 是响应脚本,是钥匙(p.15、p.17)。

2. 一个输入里的响应脚本开的是哪把锁?

它所引用的那个旧输出上的挑战脚本,也就是上一笔交易的锁(p.15、p.17)。

3. P2PKH 的锁由哪几个记号组成?花它要给什么?

OP_DUP OP_HASH160 <20 字节哈希> OP_EQUALVERIFY OP_CHECKSIG;花它要给签名和公钥(p.17)。

4. 5000000000 聪是多少 BTC?

50 BTC,1 BTC = 10⁸ 聪(p.17)。

5. 地址复用有哪两个问题?

隐私上交易可被关联;首次花钱后公钥公开,之后的钱少了哈希这层保护(p.24)。

下一讲

下一页 L09d UTXO 集合 把所有还没被打开的锁收在一起,一块一块看这个集合怎样变化,以及怎样从里面数出每个人有多少钱。

下一讲 →
L09d L09d UTXO 集合:全网的零钱袋,一块一块地变

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