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