Bitcoin Core  0.20.99
P2P Digital Currency
script.cpp
Go to the documentation of this file.
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2019 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 
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 
153 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
171  }
172  lastOpcode = opcode;
173  }
174  return n;
175 }
176 
177 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 
197  CScript subscript(vData.begin(), vData.end());
198  return subscript.GetSigOpCount(true);
199 }
200 
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 
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.
220 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 
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 
254 {
255  return this->IsPushOnly(begin());
256 }
257 
258 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 
271 {
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 
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 
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 }
Definition: script.h:150
Definition: script.h:79
Definition: script.h:135
unsigned int GetSigOpCount(bool fAccurate) const
Pre-version-0.6, Bitcoin always counted CHECKMULTISIGs as 20 sigops.
Definition: script.cpp:153
static const int MAX_PUBKEYS_PER_MULTISIG
Definition: script.h:29
std::deque< CInv >::iterator it
Definition: script.h:118
static int DecodeOP_N(opcodetype opcode)
Encode/decode small integers:
Definition: script.h:497
Definition: script.h:171
static const unsigned int MAX_OPCODE
Definition: script.h:208
bool GetOp(const_iterator &pc, opcodetype &opcodeRet, std::vector< unsigned char > &vchRet) const
Definition: script.h:486
bool IsPayToScriptHash() const
Definition: script.cpp:201
Definition: script.h:96
Definition: script.h:89
Definition: script.h:85
Definition: script.h:149
Definition: script.h:77
Definition: script.h:156
Definition: script.h:83
Definition: script.h:78
bool IsPushOnly() const
Definition: script.cpp:253
bool HasValidOps() const
Check if the script contains valid OP_CODES.
Definition: script.cpp:270
bool IsWitnessProgram(int &version, std::vector< unsigned char > &program) const
Definition: script.cpp:220
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE
Definition: script.h:23
bool IsOpSuccess(const opcodetype &opcode)
Test for OP_SUCCESSx opcodes as defined by BIP342.
Definition: script.cpp:335
Definition: script.h:170
static uint16_t ReadLE16(const unsigned char *ptr)
Definition: common.h:17
Definition: script.h:91
Definition: script.h:87
Definition: script.h:136
Definition: script.h:80
iterator end()
Definition: prevector.h:292
Definition: script.h:157
opcodetype
Script opcodes.
Definition: script.h:65
Definition: script.h:127
Definition: script.h:82
Definition: script.h:75
Definition: script.h:94
bool GetScriptOp(CScriptBase::const_iterator &pc, CScriptBase::const_iterator end, opcodetype &opcodeRet, std::vector< unsigned char > *pvchRet)
Definition: script.cpp:283
Definition: script.h:154
Definition: script.h:122
Definition: script.h:155
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
static uint32_t ReadLE32(const unsigned char *ptr)
Definition: common.h:24
Definition: script.h:84
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:404
std::string GetOpName(opcodetype opcode)
Definition: script.cpp:12
Definition: script.h:81
iterator begin()
Definition: prevector.h:290
size_type size() const
Definition: prevector.h:282
Definition: script.h:88
Definition: script.h:137
Definition: script.h:86
Definition: script.h:95
Definition: script.h:68
std::string ToString() const
Definition: script.cpp:258
Definition: script.h:153
Definition: script.h:90
bool IsPayToWitnessScriptHash() const
Definition: script.cpp:210
Definition: script.h:117