Line data    Source code

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