diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp index f596e7f8a..4ae486cc9 100644 --- a/src/policy/policy.cpp +++ b/src/policy/policy.cpp @@ -1,160 +1,160 @@ // 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. unsigned int 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) { 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 (size_t i = 0; i < tx.vin.size(); i++) { - const CTxOut &prev = mapInputs.GetOutputFor(tx.vin[i]); + 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, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, + 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(true) > MAX_P2SH_SIGOPS) { return false; } } } return true; } CFeeRate dustRelayFee = CFeeRate(DUST_RELAY_TX_FEE); -unsigned int nBytesPerSigOp = DEFAULT_BYTES_PER_SIGOP; +uint32_t nBytesPerSigOp = DEFAULT_BYTES_PER_SIGOP; diff --git a/src/policy/policy.h b/src/policy/policy.h index 1070aee65..45dd07718 100644 --- a/src/policy/policy.h +++ b/src/policy/policy.h @@ -1,92 +1,113 @@ // 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 **/ +/** + * 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 **/ +/** + * 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 **/ +/** + * 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 */ +/** + * The maximum size for transactions we're willing to relay/mine. + */ static const unsigned int MAX_STANDARD_TX_SIZE = 100000; -/** Maximum number of signature check operations in an IsStandard() P2SH script +/** + * 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 */ +/** + * 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 */ +/** + * 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 **/ +/** + * 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 */ +/** + * 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 unsigned int STANDARD_SCRIPT_VERIFY_FLAGS = +static const uint32_t STANDARD_SCRIPT_VERIFY_FLAGS = MANDATORY_SCRIPT_VERIFY_FLAGS | SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_MINIMALDATA | SCRIPT_VERIFY_NULLDUMMY | SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS | SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_NULLFAIL | SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY | SCRIPT_VERIFY_CHECKSEQUENCEVERIFY | SCRIPT_VERIFY_LOW_S; -/** For convenience, standard but not mandatory verify flags. */ -static const unsigned int STANDARD_NOT_MANDATORY_VERIFY_FLAGS = +/** + * 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 unsigned int STANDARD_LOCKTIME_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; 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 unsigned int nBytesPerSigOp; +extern uint32_t nBytesPerSigOp; #endif // BITCOIN_POLICY_POLICY_H