Branch data Line data Source code
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 <string>
15 : :
16 : 174267 : CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
17 : :
18 : 9225907 : std::string GetOpName(opcodetype opcode)
19 : : {
20 [ + + + + : 9225907 : switch (opcode)
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + +
+ ]
21 : : {
22 : : // push value
23 : 1378 : case OP_0 : return "0";
24 : 2 : case OP_PUSHDATA1 : return "OP_PUSHDATA1";
25 : 3 : case OP_PUSHDATA2 : return "OP_PUSHDATA2";
26 : 3 : case OP_PUSHDATA4 : return "OP_PUSHDATA4";
27 : 8296 : case OP_1NEGATE : return "-1";
28 : 32757 : case OP_RESERVED : return "OP_RESERVED";
29 : 109055 : case OP_1 : return "1";
30 : 60945 : case OP_2 : return "2";
31 : 80742 : case OP_3 : return "3";
32 : 23586 : case OP_4 : return "4";
33 : 17513 : case OP_5 : return "5";
34 : 9481 : case OP_6 : return "6";
35 : 6898 : case OP_7 : return "7";
36 : 113258 : case OP_8 : return "8";
37 : 19815 : case OP_9 : return "9";
38 : 10138 : case OP_10 : return "10";
39 : 60668 : case OP_11 : return "11";
40 : 11873 : case OP_12 : return "12";
41 : 40027 : case OP_13 : return "13";
42 : 12226 : case OP_14 : return "14";
43 : 18551 : case OP_15 : return "15";
44 : 11923 : case OP_16 : return "16";
45 : :
46 : : // control
47 : 1398657 : case OP_NOP : return "OP_NOP";
48 : 13251 : case OP_VER : return "OP_VER";
49 : 16713 : case OP_IF : return "OP_IF";
50 : 15162 : case OP_NOTIF : return "OP_NOTIF";
51 : 16220 : case OP_VERIF : return "OP_VERIF";
52 : 26714 : case OP_VERNOTIF : return "OP_VERNOTIF";
53 : 138628 : case OP_ELSE : return "OP_ELSE";
54 : 25171 : case OP_ENDIF : return "OP_ENDIF";
55 : 40878 : case OP_VERIFY : return "OP_VERIFY";
56 : 81345 : case OP_RETURN : return "OP_RETURN";
57 : :
58 : : // stack ops
59 : 19707 : case OP_TOALTSTACK : return "OP_TOALTSTACK";
60 : 20267 : case OP_FROMALTSTACK : return "OP_FROMALTSTACK";
61 : 33877 : case OP_2DROP : return "OP_2DROP";
62 : 9778 : case OP_2DUP : return "OP_2DUP";
63 : 40485 : case OP_3DUP : return "OP_3DUP";
64 : 12961 : case OP_2OVER : return "OP_2OVER";
65 : 25116 : case OP_2ROT : return "OP_2ROT";
66 : 21650 : case OP_2SWAP : return "OP_2SWAP";
67 : 20941 : case OP_IFDUP : return "OP_IFDUP";
68 : 19277 : case OP_DEPTH : return "OP_DEPTH";
69 : 12294 : case OP_DROP : return "OP_DROP";
70 : 42224 : case OP_DUP : return "OP_DUP";
71 : 153807 : case OP_NIP : return "OP_NIP";
72 : 11745 : case OP_OVER : return "OP_OVER";
73 : 12500 : case OP_PICK : return "OP_PICK";
74 : 16304 : case OP_ROLL : return "OP_ROLL";
75 : 25430 : case OP_ROT : return "OP_ROT";
76 : 53914 : case OP_SWAP : return "OP_SWAP";
77 : 13941 : case OP_TUCK : return "OP_TUCK";
78 : :
79 : : // splice ops
80 : 11605 : case OP_CAT : return "OP_CAT";
81 : 227312 : case OP_SUBSTR : return "OP_SUBSTR";
82 : 48342 : case OP_LEFT : return "OP_LEFT";
83 : 90618 : case OP_RIGHT : return "OP_RIGHT";
84 : 10133 : case OP_SIZE : return "OP_SIZE";
85 : :
86 : : // bit logic
87 : 15897 : case OP_INVERT : return "OP_INVERT";
88 : 46731 : case OP_AND : return "OP_AND";
89 : 12747 : case OP_OR : return "OP_OR";
90 : 11285 : case OP_XOR : return "OP_XOR";
91 : 182797 : case OP_EQUAL : return "OP_EQUAL";
92 : 41806 : case OP_EQUALVERIFY : return "OP_EQUALVERIFY";
93 : 13360 : case OP_RESERVED1 : return "OP_RESERVED1";
94 : 11657 : case OP_RESERVED2 : return "OP_RESERVED2";
95 : :
96 : : // numeric
97 : 12185 : case OP_1ADD : return "OP_1ADD";
98 : 9037 : case OP_1SUB : return "OP_1SUB";
99 : 11699 : case OP_2MUL : return "OP_2MUL";
100 : 8163 : case OP_2DIV : return "OP_2DIV";
101 : 10870 : case OP_NEGATE : return "OP_NEGATE";
102 : 8814 : case OP_ABS : return "OP_ABS";
103 : 13554 : case OP_NOT : return "OP_NOT";
104 : 79662 : case OP_0NOTEQUAL : return "OP_0NOTEQUAL";
105 : 13343 : case OP_ADD : return "OP_ADD";
106 : 13342 : case OP_SUB : return "OP_SUB";
107 : 13078 : case OP_MUL : return "OP_MUL";
108 : 55930 : case OP_DIV : return "OP_DIV";
109 : 17156 : case OP_MOD : return "OP_MOD";
110 : 46712 : case OP_LSHIFT : return "OP_LSHIFT";
111 : 13793 : case OP_RSHIFT : return "OP_RSHIFT";
112 : 48149 : case OP_BOOLAND : return "OP_BOOLAND";
113 : 21707 : case OP_BOOLOR : return "OP_BOOLOR";
114 : 23247 : case OP_NUMEQUAL : return "OP_NUMEQUAL";
115 : 10931 : case OP_NUMEQUALVERIFY : return "OP_NUMEQUALVERIFY";
116 : 18283 : case OP_NUMNOTEQUAL : return "OP_NUMNOTEQUAL";
117 : 20138 : case OP_LESSTHAN : return "OP_LESSTHAN";
118 : 10180 : case OP_GREATERTHAN : return "OP_GREATERTHAN";
119 : 465533 : case OP_LESSTHANOREQUAL : return "OP_LESSTHANOREQUAL";
120 : 11036 : case OP_GREATERTHANOREQUAL : return "OP_GREATERTHANOREQUAL";
121 : 23954 : case OP_MIN : return "OP_MIN";
122 : 77891 : case OP_MAX : return "OP_MAX";
123 : 27310 : case OP_WITHIN : return "OP_WITHIN";
124 : :
125 : : // crypto
126 : 12087 : case OP_RIPEMD160 : return "OP_RIPEMD160";
127 : 18737 : case OP_SHA1 : return "OP_SHA1";
128 : 10857 : case OP_SHA256 : return "OP_SHA256";
129 : 197920 : case OP_HASH160 : return "OP_HASH160";
130 : 13895 : case OP_HASH256 : return "OP_HASH256";
131 : 13322 : case OP_CODESEPARATOR : return "OP_CODESEPARATOR";
132 : 123875 : case OP_CHECKSIG : return "OP_CHECKSIG";
133 : 33037 : case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY";
134 : 700113 : case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG";
135 : 182519 : case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY";
136 : :
137 : : // expansion
138 : 24891 : case OP_NOP1 : return "OP_NOP1";
139 : 108965 : case OP_CHECKLOCKTIMEVERIFY : return "OP_CHECKLOCKTIMEVERIFY";
140 : 16630 : case OP_CHECKSEQUENCEVERIFY : return "OP_CHECKSEQUENCEVERIFY";
141 : 13852 : case OP_NOP4 : return "OP_NOP4";
142 : 26073 : case OP_NOP5 : return "OP_NOP5";
143 : 12449 : case OP_NOP6 : return "OP_NOP6";
144 : 10909 : case OP_NOP7 : return "OP_NOP7";
145 : 15870 : case OP_NOP8 : return "OP_NOP8";
146 : 11106 : case OP_NOP9 : return "OP_NOP9";
147 : 17122 : case OP_NOP10 : return "OP_NOP10";
148 : :
149 : : // Opcode added by BIP 342 (Tapscript)
150 : 8844 : case OP_CHECKSIGADD : return "OP_CHECKSIGADD";
151 : :
152 : 108251 : case OP_INVALIDOPCODE : return "OP_INVALIDOPCODE";
153 : :
154 : 2746501 : default:
155 : 2746501 : return "OP_UNKNOWN";
156 : : }
157 : : }
158 : :
159 : 23330293 : unsigned int CScript::GetSigOpCount(bool fAccurate) const
160 : : {
161 : 23330293 : unsigned int n = 0;
162 [ + + ]: 23330293 : const_iterator pc = begin();
163 : 23330293 : opcodetype lastOpcode = OP_INVALIDOPCODE;
164 [ + + ]: 130136366 : while (pc < end())
165 : : {
166 : 107307863 : opcodetype opcode;
167 [ + + ]: 107307863 : if (!GetOp(pc, opcode))
168 : : break;
169 [ + + ]: 106806073 : if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
170 : 650934 : n++;
171 [ + + ]: 106155139 : else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
172 : : {
173 [ + + + + ]: 1278642 : if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
174 : 1436 : n += DecodeOP_N(lastOpcode);
175 : : else
176 : 1277206 : n += MAX_PUBKEYS_PER_MULTISIG;
177 : : }
178 : : lastOpcode = opcode;
179 : : }
180 : 23330293 : return n;
181 : : }
182 : :
183 : 2017 : unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
184 : : {
185 [ + + ]: 2017 : if (!IsPayToScriptHash())
186 : 297 : 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 [ + + ]: 1720 : const_iterator pc = scriptSig.begin();
192 : 1720 : std::vector<unsigned char> vData;
193 [ + + ]: 19414 : while (pc < scriptSig.end())
194 : : {
195 : 18842 : opcodetype opcode;
196 [ + - + + ]: 18842 : if (!scriptSig.GetOp(pc, opcode, vData))
197 : : return 0;
198 [ + + ]: 17752 : if (opcode > OP_16)
199 : : return 0;
200 : : }
201 : :
202 : : /// ... and return its opcount:
203 : 572 : CScript subscript(vData.begin(), vData.end());
204 [ + - ]: 572 : return subscript.GetSigOpCount(true);
205 : 2292 : }
206 : :
207 : 2517023 : bool CScript::IsPayToAnchor() const
208 : : {
209 [ + + ]: 2517023 : return (this->size() == 4 &&
210 [ + + + + ]: 117126 : (*this)[0] == OP_1 &&
211 [ + + + + ]: 7302 : (*this)[1] == 0x02 &&
212 [ + + + + : 2524319 : (*this)[2] == 0x4e &&
+ + ]
213 [ + - + + ]: 3398 : (*this)[3] == 0x73);
214 : : }
215 : :
216 : 3926 : bool CScript::IsPayToAnchor(int version, const std::vector<unsigned char>& program)
217 : : {
218 : 6868 : return version == 1 &&
219 [ + + ]: 2942 : program.size() == 2 &&
220 [ + + + + ]: 5841 : program[0] == 0x4e &&
221 [ + + ]: 1239 : program[1] == 0x73;
222 : : }
223 : :
224 : 24618161 : bool CScript::IsPayToScriptHash() const
225 : : {
226 : : // Extra-fast test for pay-to-script-hash CScripts:
227 [ + + ]: 24618161 : return (this->size() == 23 &&
228 [ + + + + ]: 2430368 : (*this)[0] == OP_HASH160 &&
229 [ + + + + : 27007517 : (*this)[1] == 0x14 &&
+ + ]
230 [ + + + + ]: 2378994 : (*this)[22] == OP_EQUAL);
231 : : }
232 : :
233 : 6449 : bool CScript::IsPayToWitnessScriptHash() const
234 : : {
235 : : // Extra-fast test for pay-to-witness-script-hash CScripts:
236 [ + + + + ]: 6527 : return (this->size() == 34 &&
237 [ + + + + : 5720 : (*this)[0] == OP_0 &&
+ + ]
238 [ + + ]: 31 : (*this)[1] == 0x20);
239 : : }
240 : :
241 : : // A witness program is any valid CScript that consists of a 1-byte push opcode
242 : : // followed by a data push between 2 and 40 bytes.
243 : 46514706 : bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program) const
244 : : {
245 [ + + + + : 88472954 : if (this->size() < 4 || this->size() > 42) {
+ + + + ]
246 : : return false;
247 : : }
248 [ + + + + : 85661306 : if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
+ + + + ]
249 : : return false;
250 : : }
251 [ + + + + ]: 83215638 : if ((size_t)((*this)[1] + 2) == this->size()) {
252 : 41534399 : version = DecodeOP_N((opcodetype)(*this)[0]);
253 [ + + ]: 124603197 : program = std::vector<unsigned char>(this->begin() + 2, this->end());
254 : 41534399 : return true;
255 : : }
256 : : return false;
257 : : }
258 : :
259 : 5048843 : bool CScript::IsPushOnly(const_iterator pc) const
260 : : {
261 [ + + ]: 10014336 : while (pc < end())
262 : : {
263 : 5016341 : opcodetype opcode;
264 [ + + ]: 5016341 : if (!GetOp(pc, opcode))
265 : : return false;
266 : : // Note that IsPushOnly() *does* consider OP_RESERVED to be a
267 : : // push-type opcode, however execution of OP_RESERVED fails, so
268 : : // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
269 : : // the P2SH special validation code being executed.
270 [ + + ]: 4993088 : if (opcode > OP_16)
271 : : return false;
272 : : }
273 : : return true;
274 : : }
275 : :
276 : 5000796 : bool CScript::IsPushOnly() const
277 : : {
278 [ + + ]: 10001592 : return this->IsPushOnly(begin());
279 : : }
280 : :
281 : 1420354 : std::string CScriptWitness::ToString() const
282 : : {
283 : 1420354 : std::string ret = "CScriptWitness(";
284 [ + + ]: 9690715 : for (unsigned int i = 0; i < stack.size(); i++) {
285 [ + + ]: 8270361 : if (i) {
286 [ + - ]: 8235214 : ret += ", ";
287 : : }
288 [ + - ]: 16540722 : ret += HexStr(stack[i]);
289 : : }
290 [ + - ]: 1420354 : return ret + ")";
291 : 1420354 : }
292 : :
293 : 493686 : bool CScript::HasValidOps() const
294 : : {
295 [ + + ]: 493686 : CScript::const_iterator it = begin();
296 [ + + ]: 10374928 : while (it < end()) {
297 : 9886755 : opcodetype opcode;
298 : 9886755 : std::vector<unsigned char> item;
299 [ + - + + : 9886755 : if (!GetOp(it, opcode, item) || opcode > MAX_OPCODE || item.size() > MAX_SCRIPT_ELEMENT_SIZE) {
+ + + + ]
300 : 5513 : return false;
301 : : }
302 : 9886755 : }
303 : : return true;
304 : : }
305 : :
306 : 442392614 : bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet)
307 : : {
308 : 442392614 : opcodeRet = OP_INVALIDOPCODE;
309 [ + + ]: 442392614 : if (pvchRet)
310 [ + + ]: 71440024 : pvchRet->clear();
311 [ + + ]: 442392614 : if (pc >= end)
312 : : return false;
313 : :
314 : : // Read instruction
315 [ + - ]: 441939086 : if (end - pc < 1)
316 : : return false;
317 [ + + ]: 441939086 : unsigned int opcode = *pc++;
318 : :
319 : : // Immediate operand
320 [ + + ]: 441939086 : if (opcode <= OP_PUSHDATA4)
321 : : {
322 : 139287706 : unsigned int nSize = 0;
323 [ + + ]: 139287706 : if (opcode < OP_PUSHDATA1)
324 : : {
325 : : nSize = opcode;
326 : : }
327 [ + + ]: 20364595 : else if (opcode == OP_PUSHDATA1)
328 : : {
329 [ + + ]: 19859218 : if (end - pc < 1)
330 : : return false;
331 : 19851455 : nSize = *pc++;
332 : : }
333 [ + + ]: 505377 : else if (opcode == OP_PUSHDATA2)
334 : : {
335 [ + + ]: 377130 : if (end - pc < 2)
336 : : return false;
337 : 363311 : nSize = ReadLE16(&pc[0]);
338 : 363311 : pc += 2;
339 : : }
340 [ + - ]: 128247 : else if (opcode == OP_PUSHDATA4)
341 : : {
342 [ + + ]: 128247 : if (end - pc < 4)
343 : : return false;
344 : 120048 : nSize = ReadLE32(&pc[0]);
345 : 120048 : pc += 4;
346 : : }
347 [ + - + + ]: 139257925 : if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
348 : 1479870 : return false;
349 [ + + ]: 137778055 : if (pvchRet)
350 : 31119576 : pvchRet->assign(pc, pc + nSize);
351 : 137778055 : pc += nSize;
352 : : }
353 : :
354 : 440429435 : opcodeRet = static_cast<opcodetype>(opcode);
355 : 440429435 : return true;
356 : : }
357 : :
358 : 903390 : bool IsOpSuccess(const opcodetype& opcode)
359 : : {
360 [ + + + + : 903390 : return opcode == 80 || opcode == 98 || (opcode >= 126 && opcode <= 129) ||
+ + + +
+ ]
361 : : (opcode >= 131 && opcode <= 134) || (opcode >= 137 && opcode <= 138) ||
362 : : (opcode >= 141 && opcode <= 142) || (opcode >= 149 && opcode <= 153) ||
363 : 903390 : (opcode >= 187 && opcode <= 254);
364 : : }
365 : :
366 : 11826438 : bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
367 : : // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
368 [ - + ]: 11826438 : assert(0 <= opcode && opcode <= OP_PUSHDATA4);
369 [ + + ]: 11826438 : if (data.size() == 0) {
370 : : // Should have used OP_0.
371 : 10039446 : return opcode == OP_0;
372 [ + + + + : 1786992 : } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
+ + ]
373 : : // Should have used OP_1 .. OP_16.
374 : : return false;
375 [ + + + + ]: 1780006 : } else if (data.size() == 1 && data[0] == 0x81) {
376 : : // Should have used OP_1NEGATE.
377 : : return false;
378 [ + + ]: 1778698 : } else if (data.size() <= 75) {
379 : : // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
380 : 1725576 : return opcode == data.size();
381 [ + + ]: 53122 : } else if (data.size() <= 255) {
382 : : // Must have used OP_PUSHDATA.
383 : 37168 : return opcode == OP_PUSHDATA1;
384 [ + + ]: 15954 : } else if (data.size() <= 65535) {
385 : : // Must have used OP_PUSHDATA2.
386 : 15934 : return opcode == OP_PUSHDATA2;
387 : : }
388 : : return true;
389 : : }
|
