diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp index 4eec6a507..0118e6484 100644 --- a/src/policy/policy.cpp +++ b/src/policy/policy.cpp @@ -1,161 +1,155 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2016 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. // NOTE: This file is intended to be customised by the end user, and includes // only local node policy logic #include "policy/policy.h" #include "script/interpreter.h" #include "tinyformat.h" #include "util.h" #include "utilstrencodings.h" #include "validation.h" /** * Check transaction inputs to mitigate two potential denial-of-service attacks: * * 1. scriptSigs with extra data stuffed into them, not consumed by scriptPubKey * (or P2SH script) * 2. P2SH scripts with a crazy number of expensive CHECKSIG/CHECKMULTISIG * operations * * Why bother? To avoid denial-of-service attacks; an attacker can submit a * standard HASH... OP_EQUAL transaction, which will get accepted into blocks. * The redemption script can be anything; an attacker could use a very * expensive-to-check-upon-redemption script like: * DUP CHECKSIG DROP ... repeated 100 times... OP_1 */ bool IsStandard(const CScript &scriptPubKey, txnouttype &whichType) { std::vector> vSolutions; if (!Solver(scriptPubKey, whichType, vSolutions)) { return false; } if (whichType == TX_MULTISIG) { uint8_t m = vSolutions.front()[0]; uint8_t n = vSolutions.back()[0]; // Support up to x-of-3 multisig txns as standard if (n < 1 || n > 3) return false; if (m < 1 || m > n) return false; } else if (whichType == TX_NULL_DATA) { if (!fAcceptDatacarrier) { return false; } unsigned nMaxDatacarrierBytes = gArgs.GetArg("-datacarriersize", MAX_OP_RETURN_RELAY); if (scriptPubKey.size() > nMaxDatacarrierBytes) { return false; } } return whichType != TX_NONSTANDARD; } bool IsStandardTx(const CTransaction &tx, std::string &reason) { if (tx.nVersion > CTransaction::MAX_STANDARD_VERSION || tx.nVersion < 1) { reason = "version"; return false; } // Extremely large transactions with lots of inputs can cost the network // almost as much to process as they cost the sender in fees, because // computing signature hashes is O(ninputs*txsize). Limiting transactions // to MAX_STANDARD_TX_SIZE mitigates CPU exhaustion attacks. uint32_t sz = tx.GetTotalSize(); if (sz >= MAX_STANDARD_TX_SIZE) { reason = "tx-size"; return false; } for (const CTxIn &txin : tx.vin) { - // Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed - // keys (remember the 520 byte limit on redeemScript size). That works - // out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)+3=1627 - // bytes of scriptSig, which we round off to 1650 bytes for some minor - // future-proofing. That's also enough to spend a 20-of-20 CHECKMULTISIG - // scriptPubKey, though such a scriptPubKey is not considered standard. - if (txin.scriptSig.size() > 1650) { + if (txin.scriptSig.size() > MAX_TX_IN_SCRIPT_SIG_SIZE) { reason = "scriptsig-size"; return false; } if (!txin.scriptSig.IsPushOnly()) { reason = "scriptsig-not-pushonly"; return false; } } unsigned int nDataOut = 0; txnouttype whichType; for (const CTxOut &txout : tx.vout) { if (!::IsStandard(txout.scriptPubKey, whichType)) { reason = "scriptpubkey"; return false; } if (whichType == TX_NULL_DATA) { nDataOut++; } else if ((whichType == TX_MULTISIG) && (!fIsBareMultisigStd)) { reason = "bare-multisig"; return false; } else if (txout.IsDust(dustRelayFee)) { reason = "dust"; return false; } } // only one OP_RETURN txout is permitted if (nDataOut > 1) { reason = "multi-op-return"; return false; } return true; } bool AreInputsStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs) { if (tx.IsCoinBase()) { // Coinbases don't use vin normally. return true; } for (const CTxIn &in : tx.vin) { const CTxOut &prev = mapInputs.GetOutputFor(in); std::vector> vSolutions; txnouttype whichType; // get the scriptPubKey corresponding to this input: const CScript &prevScript = prev.scriptPubKey; if (!Solver(prevScript, whichType, vSolutions)) { return false; } if (whichType == TX_SCRIPTHASH) { std::vector> stack; // convert the scriptSig into a stack, so we can inspect the // redeemScript if (!EvalScript(stack, in.scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker())) { return false; } if (stack.empty()) { return false; } CScript subscript(stack.back().begin(), stack.back().end()); if (subscript.GetSigOpCount(STANDARD_CHECKDATASIG_VERIFY_FLAGS, true) > MAX_P2SH_SIGOPS) { return false; } } } return true; } CFeeRate dustRelayFee = CFeeRate(DUST_RELAY_TX_FEE); uint32_t nBytesPerSigOp = DEFAULT_BYTES_PER_SIGOP; diff --git a/src/policy/policy.h b/src/policy/policy.h index 166356264..3eaebf747 100644 --- a/src/policy/policy.h +++ b/src/policy/policy.h @@ -1,121 +1,132 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2016 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #ifndef BITCOIN_POLICY_POLICY_H #define BITCOIN_POLICY_POLICY_H #include "consensus/consensus.h" #include "script/standard.h" #include class CCoinsViewCache; class CTransaction; /** * Default for -blockmaxsize, which controls the maximum size of block the * mining code will create. */ static const uint64_t DEFAULT_MAX_GENERATED_BLOCK_SIZE = 2 * ONE_MEGABYTE; /** * Default for -blockprioritypercentage, define the amount of block space * reserved to high priority transactions. */ static const uint64_t DEFAULT_BLOCK_PRIORITY_PERCENTAGE = 5; /** * Default for -blockmintxfee, which sets the minimum feerate for a transaction * in blocks created by mining code. */ static const Amount DEFAULT_BLOCK_MIN_TX_FEE(1000); /** * The maximum size for transactions we're willing to relay/mine. */ static const unsigned int MAX_STANDARD_TX_SIZE = 100000; + +/** + * Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed + * keys (remember the 520 byte limit on redeemScript size). That works + * out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)+3=1627 + * bytes of scriptSig, which we round off to 1650 bytes for some minor + * future-proofing. That's also enough to spend a 20-of-20 CHECKMULTISIG + * scriptPubKey, though such a scriptPubKey is not considered standard. + */ +static const unsigned int MAX_TX_IN_SCRIPT_SIG_SIZE = 1650; + /** * Maximum number of signature check operations in an IsStandard() P2SH script. */ static const unsigned int MAX_P2SH_SIGOPS = 15; /** * The maximum number of sigops we're willing to relay/mine in a single tx. */ static const unsigned int MAX_STANDARD_TX_SIGOPS = MAX_TX_SIGOPS_COUNT / 5; /** * Default for -maxmempool, maximum megabytes of mempool memory usage. */ static const unsigned int DEFAULT_MAX_MEMPOOL_SIZE = 300; /** * Default for -incrementalrelayfee, which sets the minimum feerate increase for * mempool limiting or BIP 125 replacement. */ static const CFeeRate MEMPOOL_FULL_FEE_INCREMENT(Amount(1000)); /** * Default for -bytespersigop . */ static const unsigned int DEFAULT_BYTES_PER_SIGOP = 20; /** * Min feerate for defining dust. Historically this has been the same as the * minRelayTxFee, however changing the dust limit changes which transactions are * standard and should be done with care and ideally rarely. It makes sense to * only increase the dust limit after prior releases were already not creating * outputs below the new threshold. */ static const Amount DUST_RELAY_TX_FEE(1000); /** * Standard script verification flags that standard transactions will comply * with. However scripts violating these flags may still be present in valid * blocks and we must accept those blocks. */ static const uint32_t STANDARD_SCRIPT_VERIFY_FLAGS = MANDATORY_SCRIPT_VERIFY_FLAGS | SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_NULLDUMMY | SCRIPT_VERIFY_SIGPUSHONLY | SCRIPT_VERIFY_MINIMALDATA | SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS | SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY | SCRIPT_VERIFY_CHECKSEQUENCEVERIFY | SCRIPT_VERIFY_NULLFAIL; /** * For convenience, standard but not mandatory verify flags. */ static const uint32_t STANDARD_NOT_MANDATORY_VERIFY_FLAGS = STANDARD_SCRIPT_VERIFY_FLAGS & ~MANDATORY_SCRIPT_VERIFY_FLAGS; /** * Used as the flags parameter to sequence and nLocktime checks in non-consensus * code. */ static const uint32_t STANDARD_LOCKTIME_VERIFY_FLAGS = LOCKTIME_VERIFY_SEQUENCE | LOCKTIME_MEDIAN_TIME_PAST; /** * Used as the flags parameters to check for sigops as if OP_CHECKDATASIG is * enabled. Can be removed after OP_CHECKDATASIG is activated as the flag is * made standard. */ static const uint32_t STANDARD_CHECKDATASIG_VERIFY_FLAGS = STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_CHECKDATASIG; bool IsStandard(const CScript &scriptPubKey, txnouttype &whichType); /** * Check for standard transaction types * @return True if all outputs (scriptPubKeys) use only standard transaction * forms */ bool IsStandardTx(const CTransaction &tx, std::string &reason); /** * Check for standard transaction types * @param[in] mapInputs Map of previous transactions that have outputs we're * spending * @return True if all inputs (scriptSigs) use only standard transaction forms */ bool AreInputsStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs); extern CFeeRate incrementalRelayFee; extern CFeeRate dustRelayFee; extern uint32_t nBytesPerSigOp; #endif // BITCOIN_POLICY_POLICY_H