Branch data Line data Source code
# 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 : : # 12 : : std::string GetOpName(opcodetype opcode) # 13 : 6097 : { # 14 : 6097 : switch (opcode) # 15 : 6097 : { # 16 : : // push value # 17 [ - + ]: 0 : case OP_0 : return "0"; # 18 [ - + ]: 0 : case OP_PUSHDATA1 : return "OP_PUSHDATA1"; # 19 [ - + ]: 0 : case OP_PUSHDATA2 : return "OP_PUSHDATA2"; # 20 [ - + ]: 0 : case OP_PUSHDATA4 : return "OP_PUSHDATA4"; # 21 [ - + ]: 0 : case OP_1NEGATE : return "-1"; # 22 [ + + ]: 2 : case OP_RESERVED : return "OP_RESERVED"; # 23 [ + + ]: 28 : case OP_1 : return "1"; # 24 [ + + ]: 141 : case OP_2 : return "2"; # 25 [ + + ]: 7 : case OP_3 : return "3"; # 26 [ - + ]: 0 : case OP_4 : return "4"; # 27 [ - + ]: 0 : case OP_5 : return "5"; # 28 [ - + ]: 0 : case OP_6 : return "6"; # 29 [ - + ]: 0 : case OP_7 : return "7"; # 30 [ - + ]: 0 : case OP_8 : return "8"; # 31 [ - + ]: 0 : case OP_9 : return "9"; # 32 [ - + ]: 0 : case OP_10 : return "10"; # 33 [ - + ]: 0 : case OP_11 : return "11"; # 34 [ - + ]: 0 : case OP_12 : return "12"; # 35 [ - + ]: 0 : case OP_13 : return "13"; # 36 [ - + ]: 0 : case OP_14 : return "14"; # 37 [ - + ]: 0 : case OP_15 : return "15"; # 38 [ - + ]: 0 : case OP_16 : return "16"; # 39 : : # 40 : : // control # 41 [ + + ]: 2 : case OP_NOP : return "OP_NOP"; # 42 [ + + ]: 2 : case OP_VER : return "OP_VER"; # 43 [ + + ]: 3 : case OP_IF : return "OP_IF"; # 44 [ + + ]: 2 : case OP_NOTIF : return "OP_NOTIF"; # 45 [ + + ]: 2 : case OP_VERIF : return "OP_VERIF"; # 46 [ + + ]: 2 : case OP_VERNOTIF : return "OP_VERNOTIF"; # 47 [ + + ]: 3 : case OP_ELSE : return "OP_ELSE"; # 48 [ + + ]: 3 : case OP_ENDIF : return "OP_ENDIF"; # 49 [ + + ]: 2 : case OP_VERIFY : return "OP_VERIFY"; # 50 [ + + ]: 1625 : case OP_RETURN : return "OP_RETURN"; # 51 : : # 52 : : // stack ops # 53 [ + + ]: 2 : case OP_TOALTSTACK : return "OP_TOALTSTACK"; # 54 [ + + ]: 2 : case OP_FROMALTSTACK : return "OP_FROMALTSTACK"; # 55 [ + + ]: 2 : case OP_2DROP : return "OP_2DROP"; # 56 [ + + ]: 2 : case OP_2DUP : return "OP_2DUP"; # 57 [ + + ]: 2 : case OP_3DUP : return "OP_3DUP"; # 58 [ + + ]: 2 : case OP_2OVER : return "OP_2OVER"; # 59 [ + + ]: 2 : case OP_2ROT : return "OP_2ROT"; # 60 [ + + ]: 2 : case OP_2SWAP : return "OP_2SWAP"; # 61 [ + + ]: 2 : case OP_IFDUP : return "OP_IFDUP"; # 62 [ + + ]: 2 : case OP_DEPTH : return "OP_DEPTH"; # 63 [ + + ]: 18 : case OP_DROP : return "OP_DROP"; # 64 [ + + ]: 338 : case OP_DUP : return "OP_DUP"; # 65 [ + + ]: 2 : case OP_NIP : return "OP_NIP"; # 66 [ + + ]: 2 : case OP_OVER : return "OP_OVER"; # 67 [ + + ]: 2 : case OP_PICK : return "OP_PICK"; # 68 [ + + ]: 2 : case OP_ROLL : return "OP_ROLL"; # 69 [ + + ]: 2 : case OP_ROT : return "OP_ROT"; # 70 [ + + ]: 2 : case OP_SWAP : return "OP_SWAP"; # 71 [ + + ]: 2 : case OP_TUCK : return "OP_TUCK"; # 72 : : # 73 : : // splice ops # 74 [ + + ]: 2 : case OP_CAT : return "OP_CAT"; # 75 [ + + ]: 2 : case OP_SUBSTR : return "OP_SUBSTR"; # 76 [ + + ]: 2 : case OP_LEFT : return "OP_LEFT"; # 77 [ + + ]: 2 : case OP_RIGHT : return "OP_RIGHT"; # 78 [ + + ]: 2 : case OP_SIZE : return "OP_SIZE"; # 79 : : # 80 : : // bit logic # 81 [ + + ]: 2 : case OP_INVERT : return "OP_INVERT"; # 82 [ + + ]: 2 : case OP_AND : return "OP_AND"; # 83 [ + + ]: 2 : case OP_OR : return "OP_OR"; # 84 [ + + ]: 2 : case OP_XOR : return "OP_XOR"; # 85 [ + + ]: 498 : case OP_EQUAL : return "OP_EQUAL"; # 86 [ + + ]: 334 : case OP_EQUALVERIFY : return "OP_EQUALVERIFY"; # 87 [ + + ]: 2 : case OP_RESERVED1 : return "OP_RESERVED1"; # 88 [ + + ]: 2 : case OP_RESERVED2 : return "OP_RESERVED2"; # 89 : : # 90 : : // numeric # 91 [ + + ]: 2 : case OP_1ADD : return "OP_1ADD"; # 92 [ + + ]: 2 : case OP_1SUB : return "OP_1SUB"; # 93 [ + + ]: 2 : case OP_2MUL : return "OP_2MUL"; # 94 [ + + ]: 2 : case OP_2DIV : return "OP_2DIV"; # 95 [ + + ]: 2 : case OP_NEGATE : return "OP_NEGATE"; # 96 [ + + ]: 2 : case OP_ABS : return "OP_ABS"; # 97 [ + + ]: 50 : case OP_NOT : return "OP_NOT"; # 98 [ + + ]: 2 : case OP_0NOTEQUAL : return "OP_0NOTEQUAL"; # 99 [ + + ]: 2 : case OP_ADD : return "OP_ADD"; # 100 [ + + ]: 2 : case OP_SUB : return "OP_SUB"; # 101 [ + + ]: 2 : case OP_MUL : return "OP_MUL"; # 102 [ + + ]: 2 : case OP_DIV : return "OP_DIV"; # 103 [ + + ]: 2 : case OP_MOD : return "OP_MOD"; # 104 [ + + ]: 2 : case OP_LSHIFT : return "OP_LSHIFT"; # 105 [ + + ]: 2 : case OP_RSHIFT : return "OP_RSHIFT"; # 106 [ + + ]: 2 : case OP_BOOLAND : return "OP_BOOLAND"; # 107 [ + + ]: 2 : case OP_BOOLOR : return "OP_BOOLOR"; # 108 [ + + ]: 2 : case OP_NUMEQUAL : return "OP_NUMEQUAL"; # 109 [ + + ]: 2 : case OP_NUMEQUALVERIFY : return "OP_NUMEQUALVERIFY"; # 110 [ + + ]: 2 : case OP_NUMNOTEQUAL : return "OP_NUMNOTEQUAL"; # 111 [ + + ]: 2 : case OP_LESSTHAN : return "OP_LESSTHAN"; # 112 [ + + ]: 2 : case OP_GREATERTHAN : return "OP_GREATERTHAN"; # 113 [ + + ]: 2 : case OP_LESSTHANOREQUAL : return "OP_LESSTHANOREQUAL"; # 114 [ + + ]: 2 : case OP_GREATERTHANOREQUAL : return "OP_GREATERTHANOREQUAL"; # 115 [ + + ]: 2 : case OP_MIN : return "OP_MIN"; # 116 [ + + ]: 2 : case OP_MAX : return "OP_MAX"; # 117 [ + + ]: 2 : case OP_WITHIN : return "OP_WITHIN"; # 118 : : # 119 : : // crypto # 120 [ + + ]: 2 : case OP_RIPEMD160 : return "OP_RIPEMD160"; # 121 [ + + ]: 2 : case OP_SHA1 : return "OP_SHA1"; # 122 [ + + ]: 2 : case OP_SHA256 : return "OP_SHA256"; # 123 [ + + ]: 830 : case OP_HASH160 : return "OP_HASH160"; # 124 [ + + ]: 2 : case OP_HASH256 : return "OP_HASH256"; # 125 [ + + ]: 2 : case OP_CODESEPARATOR : return "OP_CODESEPARATOR"; # 126 [ + + ]: 1925 : case OP_CHECKSIG : return "OP_CHECKSIG"; # 127 [ + + ]: 3 : case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY"; # 128 [ + + ]: 120 : case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG"; # 129 [ + + ]: 2 : case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY"; # 130 : : # 131 : : // expansion # 132 [ + + ]: 2 : case OP_NOP1 : return "OP_NOP1"; # 133 [ + + ]: 11 : case OP_CHECKLOCKTIMEVERIFY : return "OP_CHECKLOCKTIMEVERIFY"; # 134 [ + + ]: 2 : case OP_CHECKSEQUENCEVERIFY : return "OP_CHECKSEQUENCEVERIFY"; # 135 [ + + ]: 2 : case OP_NOP4 : return "OP_NOP4"; # 136 [ + + ]: 2 : case OP_NOP5 : return "OP_NOP5"; # 137 [ + + ]: 2 : case OP_NOP6 : return "OP_NOP6"; # 138 [ + + ]: 2 : case OP_NOP7 : return "OP_NOP7"; # 139 [ + + ]: 10 : case OP_NOP8 : return "OP_NOP8"; # 140 [ + + ]: 2 : case OP_NOP9 : return "OP_NOP9"; # 141 [ + + ]: 2 : case OP_NOP10 : return "OP_NOP10"; # 142 : : # 143 : : // Opcode added by BIP 342 (Tapscript) # 144 [ - + ]: 0 : case OP_CHECKSIGADD : return "OP_CHECKSIGADD"; # 145 : : # 146 [ - + ]: 0 : case OP_INVALIDOPCODE : return "OP_INVALIDOPCODE"; # 147 : : # 148 [ - + ]: 0 : default: # 149 : 0 : return "OP_UNKNOWN"; # 150 : 6097 : } # 151 : 6097 : } # 152 : : # 153 : : unsigned int CScript::GetSigOpCount(bool fAccurate) const # 154 : 2103627 : { # 155 : 2103627 : unsigned int n = 0; # 156 : 2103627 : const_iterator pc = begin(); # 157 : 2103627 : opcodetype lastOpcode = OP_INVALIDOPCODE; # 158 [ + + ]: 330727839 : while (pc < end()) # 159 : 328624431 : { # 160 : 328624431 : opcodetype opcode; # 161 [ + + ]: 328624431 : if (!GetOp(pc, opcode)) # 162 : 219 : break; # 163 [ + + ][ + + ]: 328624212 : if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY) # 164 : 294919054 : n++; # 165 [ + + ][ + + ]: 33705158 : else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY) # 166 : 30012 : { # 167 [ + + ][ + + ]: 30012 : if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16) # [ + + ] # 168 : 834 : n += DecodeOP_N(lastOpcode); # 169 : 29178 : else # 170 : 29178 : n += MAX_PUBKEYS_PER_MULTISIG; # 171 : 30012 : } # 172 : 328624212 : lastOpcode = opcode; # 173 : 328624212 : } # 174 : 2103627 : return n; # 175 : 2103627 : } # 176 : : # 177 : : unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const # 178 : 57375 : { # 179 [ - + ]: 57375 : if (!IsPayToScriptHash()) # 180 : 0 : 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 : 57375 : const_iterator pc = scriptSig.begin(); # 186 : 57375 : std::vector<unsigned char> vData; # 187 [ + + ]: 170957 : while (pc < scriptSig.end()) # 188 : 113582 : { # 189 : 113582 : opcodetype opcode; # 190 [ - + ]: 113582 : if (!scriptSig.GetOp(pc, opcode, vData)) # 191 : 0 : return 0; # 192 [ - + ]: 113582 : if (opcode > OP_16) # 193 : 0 : return 0; # 194 : 113582 : } # 195 : : # 196 : : /// ... and return its opcount: # 197 : 57375 : CScript subscript(vData.begin(), vData.end()); # 198 : 57375 : return subscript.GetSigOpCount(true); # 199 : 57375 : } # 200 : : # 201 : : bool CScript::IsPayToScriptHash() const # 202 : 7474676 : { # 203 : : // Extra-fast test for pay-to-script-hash CScripts: # 204 [ + + ]: 7474676 : return (this->size() == 23 && # 205 [ + + ]: 7474676 : (*this)[0] == OP_HASH160 && # 206 [ + + ]: 7474676 : (*this)[1] == 0x14 && # 207 [ + + ]: 7474676 : (*this)[22] == OP_EQUAL); # 208 : 7474676 : } # 209 : : # 210 : : bool CScript::IsPayToWitnessScriptHash() const # 211 : 43146 : { # 212 : : // Extra-fast test for pay-to-witness-script-hash CScripts: # 213 [ + + ]: 43146 : return (this->size() == 34 && # 214 [ + - ]: 43146 : (*this)[0] == OP_0 && # 215 [ + - ]: 43146 : (*this)[1] == 0x20); # 216 : 43146 : } # 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 : 7297991 : { # 222 [ + + ][ + + ]: 7297991 : if (this->size() < 4 || this->size() > 42) { # 223 : 499460 : return false; # 224 : 499460 : } # 225 [ + + ][ + + ]: 6798531 : if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) { # [ + + ] # 226 : 3592969 : return false; # 227 : 3592969 : } # 228 [ + + ]: 3205562 : if ((size_t)((*this)[1] + 2) == this->size()) { # 229 : 3202509 : version = DecodeOP_N((opcodetype)(*this)[0]); # 230 : 3202509 : program = std::vector<unsigned char>(this->begin() + 2, this->end()); # 231 : 3202509 : return true; # 232 : 3202509 : } # 233 : 3053 : return false; # 234 : 3053 : } # 235 : : # 236 : : bool CScript::IsPushOnly(const_iterator pc) const # 237 : 992713 : { # 238 [ + + ]: 27310746 : while (pc < end()) # 239 : 26319832 : { # 240 : 26319832 : opcodetype opcode; # 241 [ + + ]: 26319832 : if (!GetOp(pc, opcode)) # 242 : 24 : 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 [ + + ]: 26319808 : if (opcode > OP_16) # 248 : 1775 : return false; # 249 : 26319808 : } # 250 : 992713 : return true; # 251 : 992713 : } # 252 : : # 253 : : bool CScript::IsPushOnly() const # 254 : 624700 : { # 255 : 624700 : return this->IsPushOnly(begin()); # 256 : 624700 : } # 257 : : # 258 : : std::string CScriptWitness::ToString() const # 259 : 6092 : { # 260 : 6092 : std::string ret = "CScriptWitness("; # 261 [ + + ]: 16284 : for (unsigned int i = 0; i < stack.size(); i++) { # 262 [ + + ]: 10192 : if (i) { # 263 : 5126 : ret += ", "; # 264 : 5126 : } # 265 : 10192 : ret += HexStr(stack[i]); # 266 : 10192 : } # 267 : 6092 : return ret + ")"; # 268 : 6092 : } # 269 : : # 270 : : bool CScript::HasValidOps() const # 271 : 221492 : { # 272 : 221492 : CScript::const_iterator it = begin(); # 273 [ + + ]: 14170071 : while (it < end()) { # 274 : 13948594 : opcodetype opcode; # 275 : 13948594 : std::vector<unsigned char> item; # 276 [ + + ][ + + ]: 13948594 : if (!GetOp(it, opcode, item) || opcode > MAX_OPCODE || item.size() > MAX_SCRIPT_ELEMENT_SIZE) { # [ + + ] # 277 : 15 : return false; # 278 : 15 : } # 279 : 13948594 : } # 280 : 221492 : return true; # 281 : 221492 : } # 282 : : # 283 : : bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet) # 284 : 392623338 : { # 285 : 392623338 : opcodeRet = OP_INVALIDOPCODE; # 286 [ + + ]: 392623338 : if (pvchRet) # 287 : 28348390 : pvchRet->clear(); # 288 [ + + ]: 392623338 : if (pc >= end) # 289 : 1658520 : return false; # 290 : : # 291 : : // Read instruction # 292 [ - + ]: 390964818 : if (end - pc < 1) # 293 : 0 : return false; # 294 : 390964818 : unsigned int opcode = *pc++; # 295 : : # 296 : : // Immediate operand # 297 [ + + ]: 390964818 : if (opcode <= OP_PUSHDATA4) # 298 : 79790487 : { # 299 : 79790487 : unsigned int nSize = 0; # 300 [ + + ]: 79790487 : if (opcode < OP_PUSHDATA1) # 301 : 79496616 : { # 302 : 79496616 : nSize = opcode; # 303 : 79496616 : } # 304 [ + + ]: 293871 : else if (opcode == OP_PUSHDATA1) # 305 : 6257 : { # 306 [ + + ]: 6257 : if (end - pc < 1) # 307 : 298 : return false; # 308 : 5959 : nSize = *pc++; # 309 : 5959 : } # 310 [ + + ]: 287614 : else if (opcode == OP_PUSHDATA2) # 311 : 286132 : { # 312 [ - + ]: 286132 : if (end - pc < 2) # 313 : 0 : return false; # 314 : 286132 : nSize = ReadLE16(&pc[0]); # 315 : 286132 : pc += 2; # 316 : 286132 : } # 317 [ + + ]: 1482 : else if (opcode == OP_PUSHDATA4) # 318 : 4516 : { # 319 [ - + ]: 4516 : if (end - pc < 4) # 320 : 0 : return false; # 321 : 4516 : nSize = ReadLE32(&pc[0]); # 322 : 4516 : pc += 4; # 323 : 4516 : } # 324 [ + + ][ + + ]: 79790487 : if (end - pc < 0 || (unsigned int)(end - pc) < nSize) # 325 : 447 : return false; # 326 [ + + ]: 79789742 : if (pvchRet) # 327 : 20366966 : pvchRet->assign(pc, pc + nSize); # 328 : 79789742 : pc += nSize; # 329 : 79789742 : } # 330 : : # 331 : 390964818 : opcodeRet = static_cast<opcodetype>(opcode); # 332 : 390964073 : return true; # 333 : 390964818 : } # 334 : : # 335 : : bool IsOpSuccess(const opcodetype& opcode) # 336 : 609441 : { # 337 [ + + ][ + + ]: 609441 : return opcode == 80 || opcode == 98 || (opcode >= 126 && opcode <= 129) || # [ + + ][ + + ] # 338 [ + + ][ + + ]: 609441 : (opcode >= 131 && opcode <= 134) || (opcode >= 137 && opcode <= 138) || # [ + + ][ + + ] # 339 [ + + ][ + + ]: 609441 : (opcode >= 141 && opcode <= 142) || (opcode >= 149 && opcode <= 153) || # [ + + ][ + + ] # 340 [ + + ][ + + ]: 609441 : (opcode >= 187 && opcode <= 254); # 341 : 609441 : }