src/policy/policy.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 // NOTE: This file is intended to be customised by the end user, and includes only local node policy logic
   7
   8 #include "policy/policy.h"
   9
  10 #include "consensus/validation.h"
  11 #include "validation.h"
  12 #include "coins.h"
  13 #include "tinyformat.h"
  14 #include "util.h"
  15 #include "utilstrencodings.h"
  16
  17
  18 CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
  19 {
  20     // "Dust" is defined in terms of dustRelayFee,
  21     // which has units satoshis-per-kilobyte.
  22     // If you'd pay more in fees than the value of the output
  23     // to spend something, then we consider it dust.
  24     // A typical spendable non-segwit txout is 34 bytes big, and will
  25     // need a CTxIn of at least 148 bytes to spend:
  26     // so dust is a spendable txout less than
  27     // 182*dustRelayFee/1000 (in satoshis).
  28     // 546 satoshis at the default rate of 3000 sat/kB.
  29     // A typical spendable segwit txout is 31 bytes big, and will
  30     // need a CTxIn of at least 67 bytes to spend:
  31     // so dust is a spendable txout less than
  32     // 98*dustRelayFee/1000 (in satoshis).
  33     // 294 satoshis at the default rate of 3000 sat/kB.
  34     if (txout.scriptPubKey.IsUnspendable())
  35         return 0;
  36
  37     size_t nSize = GetSerializeSize(txout, SER_DISK, 0);
  38     int witnessversion = 0;
  39     std::vector<unsigned char> witnessprogram;
  40
  41     if (txout.scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
  42         // sum the sizes of the parts of a transaction input
  43         // with 75% segwit discount applied to the script size.
  44         nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4);
  45     } else {
  46         nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above
  47     }
  48
  49     return dustRelayFeeIn.GetFee(nSize);
  50 }
  51
  52 bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
  53 {
  54     return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
  55 }
  56
  57     /**
  58      * Check transaction inputs to mitigate two
  59      * potential denial-of-service attacks:
  60      *
  61      * 1. scriptSigs with extra data stuffed into them,
  62      *    not consumed by scriptPubKey (or P2SH script)
  63      * 2. P2SH scripts with a crazy number of expensive
  64      *    CHECKSIG/CHECKMULTISIG operations
  65      *
  66      * Why bother? To avoid denial-of-service attacks; an attacker
  67      * can submit a standard HASH... OP_EQUAL transaction,
  68      * which will get accepted into blocks. The redemption
  69      * script can be anything; an attacker could use a very
  70      * expensive-to-check-upon-redemption script like:
  71      *   DUP CHECKSIG DROP ... repeated 100 times... OP_1
  72      */
  73
  74 bool IsStandard(const CScript& scriptPubKey, txnouttype& whichType, const bool witnessEnabled)
  75 {
  76     std::vector<std::vector<unsigned char> > vSolutions;
  77     if (!Solver(scriptPubKey, whichType, vSolutions))
  78         return false;
  79
  80     if (whichType == TX_MULTISIG)
  81     {
  82         unsigned char m = vSolutions.front()[0];
  83         unsigned char n = vSolutions.back()[0];
  84         // Support up to x-of-3 multisig txns as standard
  85         if (n < 1 || n > 3)
  86             return false;
  87         if (m < 1 || m > n)
  88             return false;
  89     } else if (whichType == TX_NULL_DATA &&
  90                (!fAcceptDatacarrier || scriptPubKey.size() > nMaxDatacarrierBytes))
  91           return false;
  92
  93     else if (!witnessEnabled && (whichType == TX_WITNESS_V0_KEYHASH || whichType == TX_WITNESS_V0_SCRIPTHASH))
  94         return false;
  95
  96     return whichType != TX_NONSTANDARD;
  97 }
  98
  99 bool IsStandardTx(const CTransaction& tx, std::string& reason, const bool witnessEnabled)
 100 {
 101     if (tx.nVersion > CTransaction::MAX_STANDARD_VERSION || tx.nVersion < 1) {
 102         reason = "version";
 103         return false;
 104     }
 105
 106     // Extremely large transactions with lots of inputs can cost the network
 107     // almost as much to process as they cost the sender in fees, because
 108     // computing signature hashes is O(ninputs*txsize). Limiting transactions
 109     // to MAX_STANDARD_TX_WEIGHT mitigates CPU exhaustion attacks.
 110     unsigned int sz = GetTransactionWeight(tx);
 111     if (sz >= MAX_STANDARD_TX_WEIGHT) {
 112         reason = "tx-size";
 113         return false;
 114     }
 115
 116     for (const CTxIn& txin : tx.vin)
 117     {
 118         // Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed
 119         // keys (remember the 520 byte limit on redeemScript size). That works
 120         // out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)+3=1627
 121         // bytes of scriptSig, which we round off to 1650 bytes for some minor
 122         // future-proofing. That's also enough to spend a 20-of-20
 123         // CHECKMULTISIG scriptPubKey, though such a scriptPubKey is not
 124         // considered standard.
 125         if (txin.scriptSig.size() > 1650) {
 126             reason = "scriptsig-size";
 127             return false;
 128         }
 129         if (!txin.scriptSig.IsPushOnly()) {
 130             reason = "scriptsig-not-pushonly";
 131             return false;
 132         }
 133     }
 134
 135     unsigned int nDataOut = 0;
 136     txnouttype whichType;
 137     for (const CTxOut& txout : tx.vout) {
 138         if (!::IsStandard(txout.scriptPubKey, whichType, witnessEnabled)) {
 139             reason = "scriptpubkey";
 140             return false;
 141         }
 142
 143         if (whichType == TX_NULL_DATA)
 144             nDataOut++;
 145         else if ((whichType == TX_MULTISIG) && (!fIsBareMultisigStd)) {
 146             reason = "bare-multisig";
 147             return false;
 148         } else if (IsDust(txout, ::dustRelayFee)) {
 149             reason = "dust";
 150             return false;
 151         }
 152     }
 153
 154     // only one OP_RETURN txout is permitted
 155     if (nDataOut > 1) {
 156         reason = "multi-op-return";
 157         return false;
 158     }
 159
 160     return true;
 161 }
 162
 163 bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
 164 {
 165     if (tx.IsCoinBase())
 166         return true; // Coinbases don't use vin normally
 167
 168     for (unsigned int i = 0; i < tx.vin.size(); i++)
 169     {
 170         const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
 171
 172         std::vector<std::vector<unsigned char> > vSolutions;
 173         txnouttype whichType;
 174         // get the scriptPubKey corresponding to this input:
 175         const CScript& prevScript = prev.scriptPubKey;
 176         if (!Solver(prevScript, whichType, vSolutions))
 177             return false;
 178
 179         if (whichType == TX_SCRIPTHASH)
 180         {
 181             std::vector<std::vector<unsigned char> > stack;
 182             // convert the scriptSig into a stack, so we can inspect the redeemScript
 183             if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SIGVERSION_BASE))
 184                 return false;
 185             if (stack.empty())
 186                 return false;
 187             CScript subscript(stack.back().begin(), stack.back().end());
 188             if (subscript.GetSigOpCount(true) > MAX_P2SH_SIGOPS) {
 189                 return false;
 190             }
 191         }
 192     }
 193
 194     return true;
 195 }
 196
 197 bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
 198 {
 199     if (tx.IsCoinBase())
 200         return true; // Coinbases are skipped
 201
 202     for (unsigned int i = 0; i < tx.vin.size(); i++)
 203     {
 204         // We don't care if witness for this input is empty, since it must not be bloated.
 205         // If the script is invalid without witness, it would be caught sooner or later during validation.
 206         if (tx.vin[i].scriptWitness.IsNull())
 207             continue;
 208
 209         const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
 210
 211         // get the scriptPubKey corresponding to this input:
 212         CScript prevScript = prev.scriptPubKey;
 213
 214         if (prevScript.IsPayToScriptHash()) {
 215             std::vector <std::vector<unsigned char> > stack;
 216             // If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
 217             // into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
 218             // If the check fails at this stage, we know that this txid must be a bad one.
 219             if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SIGVERSION_BASE))
 220                 return false;
 221             if (stack.empty())
 222                 return false;
 223             prevScript = CScript(stack.back().begin(), stack.back().end());
 224         }
 225
 226         int witnessversion = 0;
 227         std::vector<unsigned char> witnessprogram;
 228
 229         // Non-witness program must not be associated with any witness
 230         if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
 231             return false;
 232
 233         // Check P2WSH standard limits
 234         if (witnessversion == 0 && witnessprogram.size() == 32) {
 235             if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
 236                 return false;
 237             size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
 238             if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
 239                 return false;
 240             for (unsigned int j = 0; j < sizeWitnessStack; j++) {
 241                 if (tx.vin[i].scriptWitness.stack[j].size() > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
 242                     return false;
 243             }
 244         }
 245     }
 246     return true;
 247 }
 248
 249 CFeeRate incrementalRelayFee = CFeeRate(DEFAULT_INCREMENTAL_RELAY_FEE);
 250 CFeeRate dustRelayFee = CFeeRate(DUST_RELAY_TX_FEE);
 251 unsigned int nBytesPerSigOp = DEFAULT_BYTES_PER_SIGOP;
 252
 253 int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost)
 254 {
 255     return (std::max(nWeight, nSigOpCost * nBytesPerSigOp) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
 256 }
 257
 258 int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost)
 259 {
 260     return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost);
 261 }