LCOV - code coverage report
Current view: top level - src/script - script.cpp (source / functions) Hit Total Coverage
Test: coverage.lcov Lines: 241 269 89.6 %
Date: 2021-06-29 14:35:33 Functions: 12 12 100.0 %
Legend: Modified by patch:
Lines: hit not hit | Branches: + taken - not taken # not executed

Not modified by patch:
Lines: hit not hit | Branches: + taken - not taken # not executed
Branches: 325 354 91.8 %

           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 : }

Generated by: LCOV version 1.14