672a38cc06
Use CAmount rather than unsigned int for amounts for consistency with other fee rate amounts. This does change the type from unsigned int to unsigned int64, and while it is unlikely anyone would need a dust limit higher than unsigned int, again this ensures the theoretical maximum is in line with other rates.
223 lines
8.1 KiB
C++
223 lines
8.1 KiB
C++
// 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 "validation.h"
|
|
#include "tinyformat.h"
|
|
#include "util.h"
|
|
#include "utilstrencodings.h"
|
|
|
|
#include <boost/foreach.hpp>
|
|
|
|
/**
|
|
* 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, const bool witnessEnabled)
|
|
{
|
|
std::vector<std::vector<unsigned char> > vSolutions;
|
|
if (!Solver(scriptPubKey, whichType, vSolutions))
|
|
return false;
|
|
|
|
if (whichType == TX_MULTISIG)
|
|
{
|
|
unsigned char m = vSolutions.front()[0];
|
|
unsigned char 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 &&
|
|
(!fAcceptDatacarrier || scriptPubKey.size() > nMaxDatacarrierBytes))
|
|
return false;
|
|
|
|
else if (!witnessEnabled && (whichType == TX_WITNESS_V0_KEYHASH || whichType == TX_WITNESS_V0_SCRIPTHASH))
|
|
return false;
|
|
|
|
return whichType != TX_NONSTANDARD;
|
|
}
|
|
|
|
bool IsStandardTx(const CTransaction& tx, std::string& reason, const bool witnessEnabled)
|
|
{
|
|
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_WEIGHT mitigates CPU exhaustion attacks.
|
|
unsigned int sz = GetTransactionWeight(tx);
|
|
if (sz >= MAX_STANDARD_TX_WEIGHT) {
|
|
reason = "tx-size";
|
|
return false;
|
|
}
|
|
|
|
BOOST_FOREACH(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;
|
|
BOOST_FOREACH(const CTxOut& txout, tx.vout) {
|
|
if (!::IsStandard(txout.scriptPubKey, whichType, witnessEnabled)) {
|
|
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())
|
|
return true; // Coinbases don't use vin normally
|
|
|
|
for (unsigned int i = 0; i < tx.vin.size(); i++)
|
|
{
|
|
const CTxOut& prev = mapInputs.GetOutputFor(tx.vin[i]);
|
|
|
|
std::vector<std::vector<unsigned char> > 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<std::vector<unsigned char> > stack;
|
|
// convert the scriptSig into a stack, so we can inspect the redeemScript
|
|
if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SIGVERSION_BASE))
|
|
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;
|
|
}
|
|
|
|
bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
|
|
{
|
|
if (tx.IsCoinBase())
|
|
return true; // Coinbases are skipped
|
|
|
|
for (unsigned int i = 0; i < tx.vin.size(); i++)
|
|
{
|
|
// We don't care if witness for this input is empty, since it must not be bloated.
|
|
// If the script is invalid without witness, it would be caught sooner or later during validation.
|
|
if (tx.vin[i].scriptWitness.IsNull())
|
|
continue;
|
|
|
|
const CTxOut &prev = mapInputs.GetOutputFor(tx.vin[i]);
|
|
|
|
// get the scriptPubKey corresponding to this input:
|
|
CScript prevScript = prev.scriptPubKey;
|
|
|
|
if (prevScript.IsPayToScriptHash()) {
|
|
std::vector <std::vector<unsigned char> > stack;
|
|
// If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
|
|
// into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
|
|
// If the check fails at this stage, we know that this txid must be a bad one.
|
|
if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SIGVERSION_BASE))
|
|
return false;
|
|
if (stack.empty())
|
|
return false;
|
|
prevScript = CScript(stack.back().begin(), stack.back().end());
|
|
}
|
|
|
|
int witnessversion = 0;
|
|
std::vector<unsigned char> witnessprogram;
|
|
|
|
// Non-witness program must not be associated with any witness
|
|
if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
|
|
return false;
|
|
|
|
// Check P2WSH standard limits
|
|
if (witnessversion == 0 && witnessprogram.size() == 32) {
|
|
if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
|
|
return false;
|
|
size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
|
|
if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
|
|
return false;
|
|
for (unsigned int j = 0; j < sizeWitnessStack; j++) {
|
|
if (tx.vin[i].scriptWitness.stack[j].size() > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
CFeeRate incrementalRelayFee = CFeeRate(DEFAULT_INCREMENTAL_RELAY_FEE);
|
|
CFeeRate dustRelayFee = CFeeRate(DUST_RELAY_TX_FEE);
|
|
unsigned int nBytesPerSigOp = DEFAULT_BYTES_PER_SIGOP;
|
|
CAmount nDustLimit = DEFAULT_DUST_LIMIT;
|
|
|
|
int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost)
|
|
{
|
|
return (std::max(nWeight, nSigOpCost * nBytesPerSigOp) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
|
|
}
|
|
|
|
int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost)
|
|
{
|
|
return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost);
|
|
}
|