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 三个盘子,再拿走一个,看每一步栈里剩什么。
-
放入 A:栈里只有 A。
-
放入 B:B 压在 A 上面。
-
放入 C:C 在最上面,从上到下是 C、B、A。
-
拿走一个:走的是最上面的 C,剩下 B、A。
怎么判断
拿到一个容器,问一句:最后放进去的,是不是最先出来?是,就是栈。
反过来,最先放进去的最先出来,那是队列,像排队打饭。比特币脚本用的是栈。
常见误解
以为可以直接取栈中间的那个
基本操作只能碰栈顶。想用下面的东西,得先把上面的拿走,或者用专门的操作码复制、交换。
试一下
依次放入 P、Q,拿走一个,再放入 R,再拿走一个。两次拿走的分别是谁?最后栈里剩什么?
第一次拿走 Q,剩 P。放入 R 后从上到下是 R、P。第二次拿走 R,最后剩 P。
2. 锁和钥匙:挑战脚本与响应脚本
它解决什么问题
上两页把锁写成 PK_John,意思是「付给 John 的公钥」。可规则不只这一种,有时要两个人都签名,有时要等到某个时间以后才能花。比特币把锁写成一段脚本,就能表达各种花钱条件。
从哪来(补充)
比特币 wiki 的 Script 条目写道:Script 类似 Forth 语言,基于栈,从左往右执行。它刻意设计成不是图灵完备的,没有循环,这样每段脚本都一定能在有限步内跑完。
直觉
每个输出带一段挑战脚本,它是一道题。花这个输出的输入,要带一段响应脚本,它是答案。节点把答案和题拼起来执行,跑通了,钱就能转走。
关键在于这一对锁和钥匙分属两笔交易。一笔交易的输入里放的钥匙,开的是上一笔交易输出上的锁;这笔交易自己输出上挂的新锁,要等下一笔交易来开。
一步一步看
目标:沿 0xb6ff → 0xbf11 → 0x12df 这条链对锁和钥匙,看出每把钥匙开的是上一笔交易的锁。
课件把三笔交易里的 PK 换成了 Challenge_Script,签名换成了 Response_Script。下面沿着 0xb6ff → 0xbf11 → 0x12df 这条链看每把钥匙开哪把锁。
-
0xb6ff 是 coinbase,没有输入;它的输出 [0] 挂着锁 Challenge_A,金额 12.5。
-
0xbf11 的输入写 0xb6ff[0] 和钥匙 Response_1,开的是 Challenge_A。
-
0xbf11 自己的输出挂上新锁 Challenge_C,这把锁现在还没人开。
-
0x12df 的输入写 0xbf11[0] 和钥匙 Response_2,开的才是 Challenge_C。
怎么判断
看到一个响应脚本,想知道它开哪把锁,就顺着同一个输入里的 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。
钥匙是
-
第 0 步:把钥匙和锁首尾拼起来,栈是空的。
-
第 1 步:钥匙里的 sig 和 pubKey 依次压栈,pubKey 在上。
-
第 2 步:OP_DUP 把栈顶的 pubKey 复制一份。
-
第 3 步:OP_HASH160 把栈顶换成它的 20 字节哈希。
-
第 4 步:锁里写的 pubKeyHash 压栈。
-
第 5 步:OP_EQUALVERIFY 比较栈顶两项,相等就把它们拿走,继续。
-
第 6 步:OP_CHECKSIG 用 pubKey 验 sig,对得上就留下 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 是挑战脚本。
一步一步看
目标:把一笔真实交易的原始字段逐个对上课上的名字,看出指针、响应脚本、金额和锁分别是哪一段。
课件给出的这笔交易只有一个输入、一个输出,原始字段如下,逐个对上课上的名字。
-
Previous tx 是 f5d8ee39…0b9a6,Index 是 0:指向那笔交易的第 0 个输出。
-
scriptSig 是 304502206e21…6b241501,共 72 字节:这是响应脚本,里面只有签名。
-
Value 是 5000000000,单位是聪:5000000000 ÷ 10⁸ = 50 BTC。
-
scriptPubKey 是 OP_DUP OP_HASH160 4043…549d OP_EQUALVERIFY OP_CHECKSIG:这是一把 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 截图,逐个字段说出它对应的课上名字。最后做变式题,练「在哪一步失败」。
必背
- 输出里的挑战脚本(scriptPubKey)是锁,输入里的响应脚本(scriptSig)是钥匙
- 响应脚本开的是上一笔交易的输出锁;本笔交易的输出锁要等下一笔交易来开
- P2PKH 锁是 OP_DUP OP_HASH160 <20 字节哈希> OP_EQUALVERIFY OP_CHECKSIG,花它要给签名 + 公钥
- OP_HASH160 = SHA-256 再 RIPEMD-160,得 20 字节;先比哈希,再用公钥验签名
- p.17 的 Value 以聪为单位,5000000000 聪 = 50 BTC;scriptSig 72 字节是 DER 签名加 1 字节 SIGHASH_ALL
- 同一地址可以多次收款,但交易会被关联,首次花钱后公钥公开
课件例题
例 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 要花它。写出他的响应脚本,并写出每一步执行后的栈(栈顶写在最右)。
解法:
- 响应脚本:<sig_John> <pubKey_John>,sig_John 是 John 用私钥对新交易做的签名。
- 拼起来:<sig_John> <pubKey_John> OP_DUP OP_HASH160 <h_John> OP_EQUALVERIFY OP_CHECKSIG。
- 压入两个数据:栈 [sig_John, pubKey_John]。
- OP_DUP:栈 [sig_John, pubKey_John, pubKey_John]。
- OP_HASH160:栈顶换成 HASH160(pubKey_John),栈 [sig_John, pubKey_John, HASH160(pubKey_John)]。
- 压入 <h_John>:栈 [sig_John, pubKey_John, HASH160(pubKey_John), h_John]。
- OP_EQUALVERIFY:HASH160(pubKey_John) = h_John,相等,两项拿走,栈 [sig_John, pubKey_John]。
- 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 集合 把所有还没被打开的锁收在一起,一块一块看这个集合怎样变化,以及怎样从里面数出每个人有多少钱。
个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。