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 <hash.h> 10 #include <uint256.h> 11 #include <util/hash_type.h> 12 #include <util/strencodings.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 default: 155 return "OP_UNKNOWN"; 156 } 157 } 158 159 unsigned int CScript::GetSigOpCount(bool fAccurate) const 160 { 161 unsigned int n = 0; 162 const_iterator pc = begin(); 163 opcodetype lastOpcode = OP_INVALIDOPCODE; 164 while (pc < end()) 165 { 166 opcodetype opcode; 167 if (!GetOp(pc, opcode)) 168 break; 169 if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY) 170 n++; 171 else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY) 172 { 173 if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16) 174 n += DecodeOP_N(lastOpcode); 175 else 176 n += MAX_PUBKEYS_PER_MULTISIG; 177 } 178 lastOpcode = opcode; 179 } 180 return n; 181 } 182 183 unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const 184 { 185 if (!IsPayToScriptHash()) 186 return GetSigOpCount(true); 187 188 // This is a pay-to-script-hash scriptPubKey; 189 // get the last item that the scriptSig 190 // pushes onto the stack: 191 const_iterator pc = scriptSig.begin(); 192 std::vector<unsigned char> vData; 193 while (pc < scriptSig.end()) 194 { 195 opcodetype opcode; 196 if (!scriptSig.GetOp(pc, opcode, vData)) 197 return 0; 198 if (opcode > OP_16) 199 return 0; 200 } 201 202 /// ... and return its opcount: 203 CScript subscript(vData.begin(), vData.end()); 204 return subscript.GetSigOpCount(true); 205 } 206 207 bool CScript::IsPayToScriptHash() const 208 { 209 // Extra-fast test for pay-to-script-hash CScripts: 210 return (this->size() == 23 && 211 (*this)[0] == OP_HASH160 && 212 (*this)[1] == 0x14 && 213 (*this)[22] == OP_EQUAL); 214 } 215 216 bool CScript::IsPayToWitnessScriptHash() const 217 { 218 // Extra-fast test for pay-to-witness-script-hash CScripts: 219 return (this->size() == 34 && 220 (*this)[0] == OP_0 && 221 (*this)[1] == 0x20); 222 } 223 224 // A witness program is any valid CScript that consists of a 1-byte push opcode 225 // followed by a data push between 2 and 40 bytes. 226 bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program) const 227 { 228 if (this->size() < 4 || this->size() > 42) { 229 return false; 230 } 231 if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) { 232 return false; 233 } 234 if ((size_t)((*this)[1] + 2) == this->size()) { 235 version = DecodeOP_N((opcodetype)(*this)[0]); 236 program = std::vector<unsigned char>(this->begin() + 2, this->end()); 237 return true; 238 } 239 return false; 240 } 241 242 bool CScript::IsPushOnly(const_iterator pc) const 243 { 244 while (pc < end()) 245 { 246 opcodetype opcode; 247 if (!GetOp(pc, opcode)) 248 return false; 249 // Note that IsPushOnly() *does* consider OP_RESERVED to be a 250 // push-type opcode, however execution of OP_RESERVED fails, so 251 // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to 252 // the P2SH special validation code being executed. 253 if (opcode > OP_16) 254 return false; 255 } 256 return true; 257 } 258 259 bool CScript::IsPushOnly() const 260 { 261 return this->IsPushOnly(begin()); 262 } 263 264 std::string CScriptWitness::ToString() const 265 { 266 std::string ret = "CScriptWitness("; 267 for (unsigned int i = 0; i < stack.size(); i++) { 268 if (i) { 269 ret += ", "; 270 } 271 ret += HexStr(stack[i]); 272 } 273 return ret + ")"; 274 } 275 276 bool CScript::HasValidOps() const 277 { 278 CScript::const_iterator it = begin(); 279 while (it < end()) { 280 opcodetype opcode; 281 std::vector<unsigned char> item; 282 if (!GetOp(it, opcode, item) || opcode > MAX_OPCODE || item.size() > MAX_SCRIPT_ELEMENT_SIZE) { 283 return false; 284 } 285 } 286 return true; 287 } 288 289 bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet) 290 { 291 opcodeRet = OP_INVALIDOPCODE; 292 if (pvchRet) 293 pvchRet->clear(); 294 if (pc >= end) 295 return false; 296 297 // Read instruction 298 if (end - pc < 1) 299 return false; 300 unsigned int opcode = *pc++; 301 302 // Immediate operand 303 if (opcode <= OP_PUSHDATA4) 304 { 305 unsigned int nSize = 0; 306 if (opcode < OP_PUSHDATA1) 307 { 308 nSize = opcode; 309 } 310 else if (opcode == OP_PUSHDATA1) 311 { 312 if (end - pc < 1) 313 return false; 314 nSize = *pc++; 315 } 316 else if (opcode == OP_PUSHDATA2) 317 { 318 if (end - pc < 2) 319 return false; 320 nSize = ReadLE16(&pc[0]); 321 pc += 2; 322 } 323 else if (opcode == OP_PUSHDATA4) 324 { 325 if (end - pc < 4) 326 return false; 327 nSize = ReadLE32(&pc[0]); 328 pc += 4; 329 } 330 if (end - pc < 0 || (unsigned int)(end - pc) < nSize) 331 return false; 332 if (pvchRet) 333 pvchRet->assign(pc, pc + nSize); 334 pc += nSize; 335 } 336 337 opcodeRet = static_cast<opcodetype>(opcode); 338 return true; 339 } 340 341 bool IsOpSuccess(const opcodetype& opcode) 342 { 343 return opcode == 80 || opcode == 98 || (opcode >= 126 && opcode <= 129) || 344 (opcode >= 131 && opcode <= 134) || (opcode >= 137 && opcode <= 138) || 345 (opcode >= 141 && opcode <= 142) || (opcode >= 149 && opcode <= 153) || 346 (opcode >= 187 && opcode <= 254); 347 } 348 349 bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) { 350 // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal 351 assert(0 <= opcode && opcode <= OP_PUSHDATA4); 352 if (data.size() == 0) { 353 // Should have used OP_0. 354 return opcode == OP_0; 355 } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) { 356 // Should have used OP_1 .. OP_16. 357 return false; 358 } else if (data.size() == 1 && data[0] == 0x81) { 359 // Should have used OP_1NEGATE. 360 return false; 361 } else if (data.size() <= 75) { 362 // Must have used a direct push (opcode indicating number of bytes pushed + those bytes). 363 return opcode == data.size(); 364 } else if (data.size() <= 255) { 365 // Must have used OP_PUSHDATA. 366 return opcode == OP_PUSHDATA1; 367 } else if (data.size() <= 65535) { 368 // Must have used OP_PUSHDATA2. 369 return opcode == OP_PUSHDATA2; 370 } 371 return true; 372 }