script.cpp raw
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-present The Bitcoin Core developers
3 // Distributed under the MIT software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6 #include <script/script.h>
7
8 #include <crypto/common.h>
9 #include <crypto/hex_base.h>
10 #include <hash.h>
11 #include <uint256.h>
12 #include <util/hash_type.h>
13
14 #include <compare>
15 #include <string>
16
17 CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
18
19 std::string GetOpName(opcodetype opcode)
20 {
21 switch (opcode)
22 {
23 // push value
24 case OP_0 : return "0";
25 case OP_PUSHDATA1 : return "OP_PUSHDATA1";
26 case OP_PUSHDATA2 : return "OP_PUSHDATA2";
27 case OP_PUSHDATA4 : return "OP_PUSHDATA4";
28 case OP_1NEGATE : return "-1";
29 case OP_RESERVED : return "OP_RESERVED";
30 case OP_1 : return "1";
31 case OP_2 : return "2";
32 case OP_3 : return "3";
33 case OP_4 : return "4";
34 case OP_5 : return "5";
35 case OP_6 : return "6";
36 case OP_7 : return "7";
37 case OP_8 : return "8";
38 case OP_9 : return "9";
39 case OP_10 : return "10";
40 case OP_11 : return "11";
41 case OP_12 : return "12";
42 case OP_13 : return "13";
43 case OP_14 : return "14";
44 case OP_15 : return "15";
45 case OP_16 : return "16";
46
47 // control
48 case OP_NOP : return "OP_NOP";
49 case OP_VER : return "OP_VER";
50 case OP_IF : return "OP_IF";
51 case OP_NOTIF : return "OP_NOTIF";
52 case OP_VERIF : return "OP_VERIF";
53 case OP_VERNOTIF : return "OP_VERNOTIF";
54 case OP_ELSE : return "OP_ELSE";
55 case OP_ENDIF : return "OP_ENDIF";
56 case OP_VERIFY : return "OP_VERIFY";
57 case OP_RETURN : return "OP_RETURN";
58
59 // stack ops
60 case OP_TOALTSTACK : return "OP_TOALTSTACK";
61 case OP_FROMALTSTACK : return "OP_FROMALTSTACK";
62 case OP_2DROP : return "OP_2DROP";
63 case OP_2DUP : return "OP_2DUP";
64 case OP_3DUP : return "OP_3DUP";
65 case OP_2OVER : return "OP_2OVER";
66 case OP_2ROT : return "OP_2ROT";
67 case OP_2SWAP : return "OP_2SWAP";
68 case OP_IFDUP : return "OP_IFDUP";
69 case OP_DEPTH : return "OP_DEPTH";
70 case OP_DROP : return "OP_DROP";
71 case OP_DUP : return "OP_DUP";
72 case OP_NIP : return "OP_NIP";
73 case OP_OVER : return "OP_OVER";
74 case OP_PICK : return "OP_PICK";
75 case OP_ROLL : return "OP_ROLL";
76 case OP_ROT : return "OP_ROT";
77 case OP_SWAP : return "OP_SWAP";
78 case OP_TUCK : return "OP_TUCK";
79
80 // splice ops
81 case OP_CAT : return "OP_CAT";
82 case OP_SUBSTR : return "OP_SUBSTR";
83 case OP_LEFT : return "OP_LEFT";
84 case OP_RIGHT : return "OP_RIGHT";
85 case OP_SIZE : return "OP_SIZE";
86
87 // bit logic
88 case OP_INVERT : return "OP_INVERT";
89 case OP_AND : return "OP_AND";
90 case OP_OR : return "OP_OR";
91 case OP_XOR : return "OP_XOR";
92 case OP_EQUAL : return "OP_EQUAL";
93 case OP_EQUALVERIFY : return "OP_EQUALVERIFY";
94 case OP_RESERVED1 : return "OP_RESERVED1";
95 case OP_RESERVED2 : return "OP_RESERVED2";
96
97 // numeric
98 case OP_1ADD : return "OP_1ADD";
99 case OP_1SUB : return "OP_1SUB";
100 case OP_2MUL : return "OP_2MUL";
101 case OP_2DIV : return "OP_2DIV";
102 case OP_NEGATE : return "OP_NEGATE";
103 case OP_ABS : return "OP_ABS";
104 case OP_NOT : return "OP_NOT";
105 case OP_0NOTEQUAL : return "OP_0NOTEQUAL";
106 case OP_ADD : return "OP_ADD";
107 case OP_SUB : return "OP_SUB";
108 case OP_MUL : return "OP_MUL";
109 case OP_DIV : return "OP_DIV";
110 case OP_MOD : return "OP_MOD";
111 case OP_LSHIFT : return "OP_LSHIFT";
112 case OP_RSHIFT : return "OP_RSHIFT";
113 case OP_BOOLAND : return "OP_BOOLAND";
114 case OP_BOOLOR : return "OP_BOOLOR";
115 case OP_NUMEQUAL : return "OP_NUMEQUAL";
116 case OP_NUMEQUALVERIFY : return "OP_NUMEQUALVERIFY";
117 case OP_NUMNOTEQUAL : return "OP_NUMNOTEQUAL";
118 case OP_LESSTHAN : return "OP_LESSTHAN";
119 case OP_GREATERTHAN : return "OP_GREATERTHAN";
120 case OP_LESSTHANOREQUAL : return "OP_LESSTHANOREQUAL";
121 case OP_GREATERTHANOREQUAL : return "OP_GREATERTHANOREQUAL";
122 case OP_MIN : return "OP_MIN";
123 case OP_MAX : return "OP_MAX";
124 case OP_WITHIN : return "OP_WITHIN";
125
126 // crypto
127 case OP_RIPEMD160 : return "OP_RIPEMD160";
128 case OP_SHA1 : return "OP_SHA1";
129 case OP_SHA256 : return "OP_SHA256";
130 case OP_HASH160 : return "OP_HASH160";
131 case OP_HASH256 : return "OP_HASH256";
132 case OP_CODESEPARATOR : return "OP_CODESEPARATOR";
133 case OP_CHECKSIG : return "OP_CHECKSIG";
134 case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY";
135 case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG";
136 case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY";
137
138 // expansion
139 case OP_NOP1 : return "OP_NOP1";
140 case OP_CHECKLOCKTIMEVERIFY : return "OP_CHECKLOCKTIMEVERIFY";
141 case OP_CHECKSEQUENCEVERIFY : return "OP_CHECKSEQUENCEVERIFY";
142 case OP_NOP4 : return "OP_NOP4";
143 case OP_NOP5 : return "OP_NOP5";
144 case OP_NOP6 : return "OP_NOP6";
145 case OP_NOP7 : return "OP_NOP7";
146 case OP_NOP8 : return "OP_NOP8";
147 case OP_NOP9 : return "OP_NOP9";
148 case OP_NOP10 : return "OP_NOP10";
149
150 // Opcode added by BIP 342 (Tapscript)
151 case OP_CHECKSIGADD : return "OP_CHECKSIGADD";
152
153 case OP_INVALIDOPCODE : return "OP_INVALIDOPCODE";
154
155 } // no default case, so the compiler can warn about missing cases
156 return "OP_UNKNOWN";
157 }
158
159 unsigned int CScript::GetSigOpCount(bool fAccurate) const
160 {
161 unsigned int n = 0;
162 const_iterator pc = begin();
163 opcodetype lastOpcode = OP_INVALIDOPCODE;
164 while (pc < end())
165 {
166 opcodetype opcode;
167 if (!GetOp(pc, opcode))
168 break;
169 if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
170 n++;
171 else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
172 {
173 if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
174 n += DecodeOP_N(lastOpcode);
175 else
176 n += MAX_PUBKEYS_PER_MULTISIG;
177 }
178 lastOpcode = opcode;
179 }
180 return n;
181 }
182
183 unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
184 {
185 if (!IsPayToScriptHash())
186 return GetSigOpCount(true);
187
188 // This is a pay-to-script-hash scriptPubKey;
189 // get the last item that the scriptSig
190 // pushes onto the stack:
191 const_iterator pc = scriptSig.begin();
192 std::vector<unsigned char> vData;
193 while (pc < scriptSig.end())
194 {
195 opcodetype opcode;
196 if (!scriptSig.GetOp(pc, opcode, vData))
197 return 0;
198 if (opcode > OP_16)
199 return 0;
200 }
201
202 /// ... and return its opcount:
203 CScript subscript(vData.begin(), vData.end());
204 return subscript.GetSigOpCount(true);
205 }
206
207 bool CScript::IsPayToAnchor() const
208 {
209 return (this->size() == 4 &&
210 (*this)[0] == OP_1 &&
211 (*this)[1] == 0x02 &&
212 (*this)[2] == 0x4e &&
213 (*this)[3] == 0x73);
214 }
215
216 bool CScript::IsPayToAnchor(int version, const std::vector<unsigned char>& program)
217 {
218 return version == 1 &&
219 program.size() == 2 &&
220 program[0] == 0x4e &&
221 program[1] == 0x73;
222 }
223
224 bool CScript::IsPayToScriptHash() const
225 {
226 // Extra-fast test for pay-to-script-hash CScripts:
227 return (this->size() == 23 &&
228 (*this)[0] == OP_HASH160 &&
229 (*this)[1] == 0x14 &&
230 (*this)[22] == OP_EQUAL);
231 }
232
233 bool CScript::IsPayToWitnessScriptHash() const
234 {
235 // Extra-fast test for pay-to-witness-script-hash CScripts:
236 return (this->size() == 34 &&
237 (*this)[0] == OP_0 &&
238 (*this)[1] == 0x20);
239 }
240
241 bool CScript::IsPayToTaproot() const
242 {
243 return (this->size() == 34 &&
244 (*this)[0] == OP_1 &&
245 (*this)[1] == 0x20);
246 }
247
248 // A witness program is any valid CScript that consists of a 1-byte push opcode
249 // followed by a data push between 2 and 40 bytes.
250 bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program) const
251 {
252 if (this->size() < 4 || this->size() > 42) {
253 return false;
254 }
255 if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
256 return false;
257 }
258 if ((size_t)((*this)[1] + 2) == this->size()) {
259 version = DecodeOP_N((opcodetype)(*this)[0]);
260 program = std::vector<unsigned char>(this->begin() + 2, this->end());
261 return true;
262 }
263 return false;
264 }
265
266 bool CScript::IsPushOnly(const_iterator pc) const
267 {
268 while (pc < end())
269 {
270 opcodetype opcode;
271 if (!GetOp(pc, opcode))
272 return false;
273 // Note that IsPushOnly() *does* consider OP_RESERVED to be a
274 // push-type opcode, however execution of OP_RESERVED fails, so
275 // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
276 // the P2SH special validation code being executed.
277 if (opcode > OP_16)
278 return false;
279 }
280 return true;
281 }
282
283 bool CScript::IsPushOnly() const
284 {
285 return this->IsPushOnly(begin());
286 }
287
288 std::string CScriptWitness::ToString() const
289 {
290 std::string ret = "CScriptWitness(";
291 for (unsigned int i = 0; i < stack.size(); i++) {
292 if (i) {
293 ret += ", ";
294 }
295 ret += HexStr(stack[i]);
296 }
297 return ret + ")";
298 }
299
300 bool CScript::HasValidOps() const
301 {
302 CScript::const_iterator it = begin();
303 while (it < end()) {
304 opcodetype opcode;
305 std::vector<unsigned char> item;
306 if (!GetOp(it, opcode, item) || opcode > MAX_OPCODE || item.size() > MAX_SCRIPT_ELEMENT_SIZE) {
307 return false;
308 }
309 }
310 return true;
311 }
312
313 bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet)
314 {
315 opcodeRet = OP_INVALIDOPCODE;
316 if (pvchRet)
317 pvchRet->clear();
318 if (pc >= end)
319 return false;
320
321 // Read instruction
322 if (end - pc < 1)
323 return false;
324 unsigned int opcode = *pc++;
325
326 // Immediate operand
327 if (opcode <= OP_PUSHDATA4)
328 {
329 unsigned int nSize = 0;
330 if (opcode < OP_PUSHDATA1)
331 {
332 nSize = opcode;
333 }
334 else if (opcode == OP_PUSHDATA1)
335 {
336 if (end - pc < 1)
337 return false;
338 nSize = *pc++;
339 }
340 else if (opcode == OP_PUSHDATA2)
341 {
342 if (end - pc < 2)
343 return false;
344 nSize = ReadLE16(&pc[0]);
345 pc += 2;
346 }
347 else if (opcode == OP_PUSHDATA4)
348 {
349 if (end - pc < 4)
350 return false;
351 nSize = ReadLE32(&pc[0]);
352 pc += 4;
353 }
354 if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
355 return false;
356 if (pvchRet)
357 pvchRet->assign(pc, pc + nSize);
358 pc += nSize;
359 }
360
361 opcodeRet = static_cast<opcodetype>(opcode);
362 return true;
363 }
364
365 bool IsOpSuccess(const opcodetype& opcode)
366 {
367 return opcode == 80 || opcode == 98 || (opcode >= 126 && opcode <= 129) ||
368 (opcode >= 131 && opcode <= 134) || (opcode >= 137 && opcode <= 138) ||
369 (opcode >= 141 && opcode <= 142) || (opcode >= 149 && opcode <= 153) ||
370 (opcode >= 187 && opcode <= 254);
371 }
372
373 bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
374 // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
375 assert(0 <= opcode && opcode <= OP_PUSHDATA4);
376 if (data.size() == 0) {
377 // Should have used OP_0.
378 return opcode == OP_0;
379 } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
380 // Should have used OP_1 .. OP_16.
381 return false;
382 } else if (data.size() == 1 && data[0] == 0x81) {
383 // Should have used OP_1NEGATE.
384 return false;
385 } else if (data.size() <= 75) {
386 // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
387 return opcode == data.size();
388 } else if (data.size() <= 255) {
389 // Must have used OP_PUSHDATA.
390 return opcode == OP_PUSHDATA1;
391 } else if (data.size() <= 65535) {
392 // Must have used OP_PUSHDATA2.
393 return opcode == OP_PUSHDATA2;
394 }
395 return true;
396 }
397