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