src/script/ismine.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 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 "ismine.h"
   7
   8 #include "key.h"
   9 #include "keystore.h"
  10 #include "script/script.h"
  11 #include "script/standard.h"
  12 #include "script/sign.h"
  13
  14
  15 typedef std::vector<unsigned char> valtype;
  16
  17 unsigned int HaveKeys(const std::vector<valtype>& pubkeys, const CKeyStore& keystore)
  18 {
  19     unsigned int nResult = 0;
  20     for (const valtype& pubkey : pubkeys)
  21     {
  22         CKeyID keyID = CPubKey(pubkey).GetID();
  23         if (keystore.HaveKey(keyID))
  24             ++nResult;
  25     }
  26     return nResult;
  27 }
  28
  29 isminetype IsMine(const CKeyStore& keystore, const CScript& scriptPubKey, SigVersion sigversion)
  30 {
  31     bool isInvalid = false;
  32     return IsMine(keystore, scriptPubKey, isInvalid, sigversion);
  33 }
  34
  35 isminetype IsMine(const CKeyStore& keystore, const CTxDestination& dest, SigVersion sigversion)
  36 {
  37     bool isInvalid = false;
  38     return IsMine(keystore, dest, isInvalid, sigversion);
  39 }
  40
  41 isminetype IsMine(const CKeyStore &keystore, const CTxDestination& dest, bool& isInvalid, SigVersion sigversion)
  42 {
  43     CScript script = GetScriptForDestination(dest);
  44     return IsMine(keystore, script, isInvalid, sigversion);
  45 }
  46
  47 isminetype IsMine(const CKeyStore &keystore, const CScript& scriptPubKey, bool& isInvalid, SigVersion sigversion)
  48 {
  49     isInvalid = false;
  50
  51     std::vector<valtype> vSolutions;
  52     txnouttype whichType;
  53     if (!Solver(scriptPubKey, whichType, vSolutions)) {
  54         if (keystore.HaveWatchOnly(scriptPubKey))
  55             return ISMINE_WATCH_UNSOLVABLE;
  56         return ISMINE_NO;
  57     }
  58
  59     CKeyID keyID;
  60     switch (whichType)
  61     {
  62     case TX_NONSTANDARD:
  63     case TX_NULL_DATA:
  64     case TX_WITNESS_UNKNOWN:
  65         break;
  66     case TX_PUBKEY:
  67         keyID = CPubKey(vSolutions[0]).GetID();
  68         if (sigversion != SIGVERSION_BASE && vSolutions[0].size() != 33) {
  69             isInvalid = true;
  70             return ISMINE_NO;
  71         }
  72         if (keystore.HaveKey(keyID))
  73             return ISMINE_SPENDABLE;
  74         break;
  75     case TX_WITNESS_V0_KEYHASH:
  76     {
  77         if (!keystore.HaveCScript(CScriptID(CScript() << OP_0 << vSolutions[0]))) {
  78             // We do not support bare witness outputs unless the P2SH version of it would be
  79             // acceptable as well. This protects against matching before segwit activates.
  80             // This also applies to the P2WSH case.
  81             break;
  82         }
  83         isminetype ret = ::IsMine(keystore, GetScriptForDestination(CKeyID(uint160(vSolutions[0]))), isInvalid, SIGVERSION_WITNESS_V0);
  84         if (ret == ISMINE_SPENDABLE || ret == ISMINE_WATCH_SOLVABLE || (ret == ISMINE_NO && isInvalid))
  85             return ret;
  86         break;
  87     }
  88     case TX_PUBKEYHASH:
  89         keyID = CKeyID(uint160(vSolutions[0]));
  90         if (sigversion != SIGVERSION_BASE) {
  91             CPubKey pubkey;
  92             if (keystore.GetPubKey(keyID, pubkey) && !pubkey.IsCompressed()) {
  93                 isInvalid = true;
  94                 return ISMINE_NO;
  95             }
  96         }
  97         if (keystore.HaveKey(keyID))
  98             return ISMINE_SPENDABLE;
  99         break;
 100     case TX_SCRIPTHASH:
 101     {
 102         CScriptID scriptID = CScriptID(uint160(vSolutions[0]));
 103         CScript subscript;
 104         if (keystore.GetCScript(scriptID, subscript)) {
 105             isminetype ret = IsMine(keystore, subscript, isInvalid);
 106             if (ret == ISMINE_SPENDABLE || ret == ISMINE_WATCH_SOLVABLE || (ret == ISMINE_NO && isInvalid))
 107                 return ret;
 108         }
 109         break;
 110     }
 111     case TX_WITNESS_V0_SCRIPTHASH:
 112     {
 113         if (!keystore.HaveCScript(CScriptID(CScript() << OP_0 << vSolutions[0]))) {
 114             break;
 115         }
 116         uint160 hash;
 117         CRIPEMD160().Write(&vSolutions[0][0], vSolutions[0].size()).Finalize(hash.begin());
 118         CScriptID scriptID = CScriptID(hash);
 119         CScript subscript;
 120         if (keystore.GetCScript(scriptID, subscript)) {
 121             isminetype ret = IsMine(keystore, subscript, isInvalid, SIGVERSION_WITNESS_V0);
 122             if (ret == ISMINE_SPENDABLE || ret == ISMINE_WATCH_SOLVABLE || (ret == ISMINE_NO && isInvalid))
 123                 return ret;
 124         }
 125         break;
 126     }
 127
 128     case TX_MULTISIG:
 129     {
 130         // Only consider transactions "mine" if we own ALL the
 131         // keys involved. Multi-signature transactions that are
 132         // partially owned (somebody else has a key that can spend
 133         // them) enable spend-out-from-under-you attacks, especially
 134         // in shared-wallet situations.
 135         std::vector<valtype> keys(vSolutions.begin()+1, vSolutions.begin()+vSolutions.size()-1);
 136         if (sigversion != SIGVERSION_BASE) {
 137             for (size_t i = 0; i < keys.size(); i++) {
 138                 if (keys[i].size() != 33) {
 139                     isInvalid = true;
 140                     return ISMINE_NO;
 141                 }
 142             }
 143         }
 144         if (HaveKeys(keys, keystore) == keys.size())
 145             return ISMINE_SPENDABLE;
 146         break;
 147     }
 148     }
 149
 150     if (keystore.HaveWatchOnly(scriptPubKey)) {
 151         // TODO: This could be optimized some by doing some work after the above solver
 152         SignatureData sigs;
 153         return ProduceSignature(DummySignatureCreator(&keystore), scriptPubKey, sigs) ? ISMINE_WATCH_SOLVABLE : ISMINE_WATCH_UNSOLVABLE;
 154     }
 155     return ISMINE_NO;
 156 }