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