Line data    Source code

       1             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2             : // Copyright (c) 2009-2019 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      144701 : std::string GetOpName(opcodetype opcode)
      13             : {
      14      144701 :     switch (opcode)
      15             :     {
      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          19 :     case OP_RESERVED               : return "OP_RESERVED";
      23          18 :     case OP_1                      : return "1";
      24         136 :     case OP_2                      : return "2";
      25           2 :     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          19 :     case OP_NOP                    : return "OP_NOP";
      42          19 :     case OP_VER                    : return "OP_VER";
      43          20 :     case OP_IF                     : return "OP_IF";
      44          19 :     case OP_NOTIF                  : return "OP_NOTIF";
      45          19 :     case OP_VERIF                  : return "OP_VERIF";
      46          19 :     case OP_VERNOTIF               : return "OP_VERNOTIF";
      47          20 :     case OP_ELSE                   : return "OP_ELSE";
      48          20 :     case OP_ENDIF                  : return "OP_ENDIF";
      49          19 :     case OP_VERIFY                 : return "OP_VERIFY";
      50          97 :     case OP_RETURN                 : return "OP_RETURN";
      51             : 
      52             :     // stack ops
      53          19 :     case OP_TOALTSTACK             : return "OP_TOALTSTACK";
      54          19 :     case OP_FROMALTSTACK           : return "OP_FROMALTSTACK";
      55          19 :     case OP_2DROP                  : return "OP_2DROP";
      56          19 :     case OP_2DUP                   : return "OP_2DUP";
      57          19 :     case OP_3DUP                   : return "OP_3DUP";
      58          19 :     case OP_2OVER                  : return "OP_2OVER";
      59          19 :     case OP_2ROT                   : return "OP_2ROT";
      60          19 :     case OP_2SWAP                  : return "OP_2SWAP";
      61          19 :     case OP_IFDUP                  : return "OP_IFDUP";
      62          19 :     case OP_DEPTH                  : return "OP_DEPTH";
      63          36 :     case OP_DROP                   : return "OP_DROP";
      64       31424 :     case OP_DUP                    : return "OP_DUP";
      65          19 :     case OP_NIP                    : return "OP_NIP";
      66          19 :     case OP_OVER                   : return "OP_OVER";
      67          19 :     case OP_PICK                   : return "OP_PICK";
      68          19 :     case OP_ROLL                   : return "OP_ROLL";
      69          19 :     case OP_ROT                    : return "OP_ROT";
      70          19 :     case OP_SWAP                   : return "OP_SWAP";
      71          19 :     case OP_TUCK                   : return "OP_TUCK";
      72             : 
      73             :     // splice ops
      74          19 :     case OP_CAT                    : return "OP_CAT";
      75          19 :     case OP_SUBSTR                 : return "OP_SUBSTR";
      76          19 :     case OP_LEFT                   : return "OP_LEFT";
      77          19 :     case OP_RIGHT                  : return "OP_RIGHT";
      78          19 :     case OP_SIZE                   : return "OP_SIZE";
      79             : 
      80             :     // bit logic
      81          19 :     case OP_INVERT                 : return "OP_INVERT";
      82          19 :     case OP_AND                    : return "OP_AND";
      83          19 :     case OP_OR                     : return "OP_OR";
      84          19 :     case OP_XOR                    : return "OP_XOR";
      85        8492 :     case OP_EQUAL                  : return "OP_EQUAL";
      86       31422 :     case OP_EQUALVERIFY            : return "OP_EQUALVERIFY";
      87          19 :     case OP_RESERVED1              : return "OP_RESERVED1";
      88          19 :     case OP_RESERVED2              : return "OP_RESERVED2";
      89             : 
      90             :     // numeric
      91          19 :     case OP_1ADD                   : return "OP_1ADD";
      92          19 :     case OP_1SUB                   : return "OP_1SUB";
      93          19 :     case OP_2MUL                   : return "OP_2MUL";
      94          19 :     case OP_2DIV                   : return "OP_2DIV";
      95          19 :     case OP_NEGATE                 : return "OP_NEGATE";
      96          19 :     case OP_ABS                    : return "OP_ABS";
      97          43 :     case OP_NOT                    : return "OP_NOT";
      98          19 :     case OP_0NOTEQUAL              : return "OP_0NOTEQUAL";
      99          19 :     case OP_ADD                    : return "OP_ADD";
     100          19 :     case OP_SUB                    : return "OP_SUB";
     101          19 :     case OP_MUL                    : return "OP_MUL";
     102          19 :     case OP_DIV                    : return "OP_DIV";
     103          19 :     case OP_MOD                    : return "OP_MOD";
     104          19 :     case OP_LSHIFT                 : return "OP_LSHIFT";
     105          19 :     case OP_RSHIFT                 : return "OP_RSHIFT";
     106          19 :     case OP_BOOLAND                : return "OP_BOOLAND";
     107          19 :     case OP_BOOLOR                 : return "OP_BOOLOR";
     108          19 :     case OP_NUMEQUAL               : return "OP_NUMEQUAL";
     109          19 :     case OP_NUMEQUALVERIFY         : return "OP_NUMEQUALVERIFY";
     110          19 :     case OP_NUMNOTEQUAL            : return "OP_NUMNOTEQUAL";
     111          19 :     case OP_LESSTHAN               : return "OP_LESSTHAN";
     112          19 :     case OP_GREATERTHAN            : return "OP_GREATERTHAN";
     113          19 :     case OP_LESSTHANOREQUAL        : return "OP_LESSTHANOREQUAL";
     114          19 :     case OP_GREATERTHANOREQUAL     : return "OP_GREATERTHANOREQUAL";
     115          19 :     case OP_MIN                    : return "OP_MIN";
     116          19 :     case OP_MAX                    : return "OP_MAX";
     117          19 :     case OP_WITHIN                 : return "OP_WITHIN";
     118             : 
     119             :     // crypto
     120          19 :     case OP_RIPEMD160              : return "OP_RIPEMD160";
     121          19 :     case OP_SHA1                   : return "OP_SHA1";
     122          19 :     case OP_SHA256                 : return "OP_SHA256";
     123       39895 :     case OP_HASH160                : return "OP_HASH160";
     124          19 :     case OP_HASH256                : return "OP_HASH256";
     125          19 :     case OP_CODESEPARATOR          : return "OP_CODESEPARATOR";
     126       31472 :     case OP_CHECKSIG               : return "OP_CHECKSIG";
     127          20 :     case OP_CHECKSIGVERIFY         : return "OP_CHECKSIGVERIFY";
     128         112 :     case OP_CHECKMULTISIG          : return "OP_CHECKMULTISIG";
     129          19 :     case OP_CHECKMULTISIGVERIFY    : return "OP_CHECKMULTISIGVERIFY";
     130             : 
     131             :     // expansion
     132          19 :     case OP_NOP1                   : return "OP_NOP1";
     133          24 :     case OP_CHECKLOCKTIMEVERIFY    : return "OP_CHECKLOCKTIMEVERIFY";
     134          19 :     case OP_CHECKSEQUENCEVERIFY    : return "OP_CHECKSEQUENCEVERIFY";
     135          19 :     case OP_NOP4                   : return "OP_NOP4";
     136          19 :     case OP_NOP5                   : return "OP_NOP5";
     137          19 :     case OP_NOP6                   : return "OP_NOP6";
     138          19 :     case OP_NOP7                   : return "OP_NOP7";
     139          23 :     case OP_NOP8                   : return "OP_NOP8";
     140          19 :     case OP_NOP9                   : return "OP_NOP9";
     141          19 :     case OP_NOP10                  : return "OP_NOP10";
     142             : 
     143           0 :     case OP_INVALIDOPCODE          : return "OP_INVALIDOPCODE";
     144             : 
     145             :     default:
     146           0 :         return "OP_UNKNOWN";
     147             :     }
     148      144701 : }
     149             : 
     150     1566577 : unsigned int CScript::GetSigOpCount(bool fAccurate) const
     151             : {
     152             :     unsigned int n = 0;
     153     1566577 :     const_iterator pc = begin();
     154             :     opcodetype lastOpcode = OP_INVALIDOPCODE;
     155    37484596 :     while (pc < end())
     156             :     {
     157    35918132 :         opcodetype opcode;
     158    35918132 :         if (!GetOp(pc, opcode))
     159         113 :             break;
     160    35918019 :         if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
     161     1217858 :             n++;
     162    34700161 :         else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
     163             :         {
     164       25903 :             if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
     165         724 :                 n += DecodeOP_N(lastOpcode);
     166             :             else
     167       25179 :                 n += MAX_PUBKEYS_PER_MULTISIG;
     168             :         }
     169    35918019 :         lastOpcode = opcode;
     170    35918132 :     }
     171     1566577 :     return n;
     172     1566577 : }
     173             : 
     174       57653 : unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
     175             : {
     176       57653 :     if (!IsPayToScriptHash())
     177           0 :         return GetSigOpCount(true);
     178             : 
     179             :     // This is a pay-to-script-hash scriptPubKey;
     180             :     // get the last item that the scriptSig
     181             :     // pushes onto the stack:
     182       57653 :     const_iterator pc = scriptSig.begin();
     183       57653 :     std::vector<unsigned char> vData;
     184      172749 :     while (pc < scriptSig.end())
     185             :     {
     186      115096 :         opcodetype opcode;
     187      115096 :         if (!scriptSig.GetOp(pc, opcode, vData))
     188           0 :             return 0;
     189      115096 :         if (opcode > OP_16)
     190           0 :             return 0;
     191      115096 :     }
     192             : 
     193             :     /// ... and return its opcount:
     194       57653 :     CScript subscript(vData.begin(), vData.end());
     195       57653 :     return subscript.GetSigOpCount(true);
     196       57653 : }
     197             : 
     198     4933635 : bool CScript::IsPayToScriptHash() const
     199             : {
     200             :     // Extra-fast test for pay-to-script-hash CScripts:
     201     5401453 :     return (this->size() == 23 &&
     202      467811 :             (*this)[0] == OP_HASH160 &&
     203      467746 :             (*this)[1] == 0x14 &&
     204      467741 :             (*this)[22] == OP_EQUAL);
     205             : }
     206             : 
     207       29160 : bool CScript::IsPayToWitnessScriptHash() const
     208             : {
     209             :     // Extra-fast test for pay-to-witness-script-hash CScripts:
     210       30052 :     return (this->size() == 34 &&
     211         892 :             (*this)[0] == OP_0 &&
     212         892 :             (*this)[1] == 0x20);
     213             : }
     214             : 
     215             : // A witness program is any valid CScript that consists of a 1-byte push opcode
     216             : // followed by a data push between 2 and 40 bytes.
     217     4738790 : bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program) const
     218             : {
     219     4738790 :     if (this->size() < 4 || this->size() > 42) {
     220      525554 :         return false;
     221             :     }
     222     4213307 :     if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
     223     2684000 :         return false;
     224             :     }
     225     1529295 :     if ((size_t)((*this)[1] + 2) == this->size()) {
     226     1526306 :         version = DecodeOP_N((opcodetype)(*this)[0]);
     227     1526306 :         program = std::vector<unsigned char>(this->begin() + 2, this->end());
     228     1526306 :         return true;
     229             :     }
     230        3099 :     return false;
     231     4738943 : }
     232             : 
     233      683995 : bool CScript::IsPushOnly(const_iterator pc) const
     234             : {
     235    28611645 :     while (pc < end())
     236             :     {
     237    27928510 :         opcodetype opcode;
     238    27928510 :         if (!GetOp(pc, opcode))
     239          17 :             return false;
     240             :         // Note that IsPushOnly() *does* consider OP_RESERVED to be a
     241             :         // push-type opcode, however execution of OP_RESERVED fails, so
     242             :         // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
     243             :         // the P2SH special validation code being executed.
     244    27928494 :         if (opcode > OP_16)
     245         845 :             return false;
     246    27928511 :     }
     247      683141 :     return true;
     248      684003 : }
     249             : 
     250      355987 : bool CScript::IsPushOnly() const
     251             : {
     252      355987 :     return this->IsPushOnly(begin());
     253             : }
     254             : 
     255        3499 : std::string CScriptWitness::ToString() const
     256             : {
     257        3499 :     std::string ret = "CScriptWitness(";
     258        9167 :     for (unsigned int i = 0; i < stack.size(); i++) {
     259        5668 :         if (i) {
     260        2856 :             ret += ", ";
     261             :         }
     262        5668 :         ret += HexStr(stack[i]);
     263             :     }
     264        3499 :     return ret + ")";
     265        3499 : }
     266             : 
     267       65212 : bool CScript::HasValidOps() const
     268             : {
     269       65212 :     CScript::const_iterator it = begin();
     270     6969242 :     while (it < end()) {
     271     6904033 :         opcodetype opcode;
     272     6904033 :         std::vector<unsigned char> item;
     273     6904033 :         if (!GetOp(it, opcode, item) || opcode > MAX_OPCODE || item.size() > MAX_SCRIPT_ELEMENT_SIZE) {
     274           3 :             return false;
     275             :         }
     276     6904033 :     }
     277       65209 :     return true;
     278       65212 : }
     279             : 
     280    85666429 : bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet)
     281             : {
     282    85666429 :     opcodeRet = OP_INVALIDOPCODE;
     283    85666429 :     if (pvchRet)
     284    15314338 :         pvchRet->clear();
     285    85680449 :     if (pc >= end)
     286     1051151 :         return false;
     287             : 
     288             :     // Read instruction
     289    84626530 :     if (end - pc < 1)
     290           0 :         return false;
     291    84616442 :     unsigned int opcode = *pc++;
     292             : 
     293             :     // Immediate operand
     294    84616442 :     if (opcode <= OP_PUSHDATA4)
     295             :     {
     296             :         unsigned int nSize = 0;
     297    72432330 :         if (opcode < OP_PUSHDATA1)
     298             :         {
     299             :             nSize = opcode;
     300    72143725 :         }
     301      289715 :         else if (opcode == OP_PUSHDATA1)
     302             :         {
     303       20450 :             if (end - pc < 1)
     304           0 :                 return false;
     305       20450 :             nSize = *pc++;
     306       20450 :         }
     307      269265 :         else if (opcode == OP_PUSHDATA2)
     308             :         {
     309      264820 :             if (end - pc < 2)
     310           0 :                 return false;
     311      264831 :             nSize = ReadLE16(&pc[0]);
     312      264831 :             pc += 2;
     313      264831 :         }
     314        4445 :         else if (opcode == OP_PUSHDATA4)
     315             :         {
     316        4445 :             if (end - pc < 4)
     317           0 :                 return false;
     318        4445 :             nSize = ReadLE32(&pc[0]);
     319        4445 :             pc += 4;
     320        4445 :         }
     321    72433618 :         if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
     322         152 :             return false;
     323    72397322 :         if (pvchRet)
     324    10531213 :             pvchRet->assign(pc, pc + nSize);
     325    72398660 :         pc += nSize;
     326    72398660 :     }
     327             : 
     328    84583321 :     opcodeRet = static_cast<opcodetype>(opcode);
     329    84583321 :     return true;
     330    85634949 : }