1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present 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 <coins.h>
11#include <consensus/amount.h>
12#include <consensus/consensus.h>
13#include <consensus/validation.h>
14#include <policy/feerate.h>
15#include <primitives/transaction.h>
16#include <script/interpreter.h>
17#include <script/script.h>
18#include <script/solver.h>
19#include <serialize.h>
20#include <span.h>
21#include <tinyformat.h>
22
23#include <algorithm>
24#include <cstddef>
25#include <vector>
26
27CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
28{
29    // "Dust" is defined in terms of dustRelayFee,
30    // which has units satoshis-per-kilobyte.
31    // If you'd pay more in fees than the value of the output
32    // to spend something, then we consider it dust.
33    // A typical spendable non-segwit txout is 34 bytes big, and will
34    // need a CTxIn of at least 148 bytes to spend:
35    // so dust is a spendable txout less than
36    // 182*dustRelayFee/1000 (in satoshis).
37    // 546 satoshis at the default rate of 3000 sat/kvB.
38    // A typical spendable segwit P2WPKH txout is 31 bytes big, and will
39    // need a CTxIn of at least 67 bytes to spend:
40    // so dust is a spendable txout less than
41    // 98*dustRelayFee/1000 (in satoshis).
42    // 294 satoshis at the default rate of 3000 sat/kvB.
43    if (txout.scriptPubKey.IsUnspendable())
44        return 0;
45
46    uint64_t nSize{GetSerializeSize(txout)};
47    int witnessversion = 0;
48    std::vector<unsigned char> witnessprogram;
49
50    // Note this computation is for spending a Segwit v0 P2WPKH output (a 33 bytes
51    // public key + an ECDSA signature). For Segwit v1 Taproot outputs the minimum
52    // satisfaction is lower (a single BIP340 signature) but this computation was
53    // kept to not further reduce the dust level.
54    // See discussion in https://github.com/bitcoin/bitcoin/pull/22779 for details.
55    if (txout.scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
56        // sum the sizes of the parts of a transaction input
57        // with 75% segwit discount applied to the script size.
58        nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4);
59    } else {
60        nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above
61    }
62
63    return dustRelayFeeIn.GetFee(nSize);
64}
65
66bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
67{
68    return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
69}
70
71std::vector<uint32_t> GetDust(const CTransaction& tx, CFeeRate dust_relay_rate)
72{
73    std::vector<uint32_t> dust_outputs;
74    for (uint32_t i{0}; i < tx.vout.size(); ++i) {
75        if (IsDust(tx.vout[i], dust_relay_rate)) dust_outputs.push_back(i);
76    }
77    return dust_outputs;
78}
79
80bool IsStandard(const CScript& scriptPubKey, TxoutType& whichType)
81{
82    std::vector<std::vector<unsigned char> > vSolutions;
83    whichType = Solver(scriptPubKey, vSolutions);
84
85    if (whichType == TxoutType::NONSTANDARD) {
86        return false;
87    } else if (whichType == TxoutType::MULTISIG) {
88        unsigned char m = vSolutions.front()[0];
89        unsigned char n = vSolutions.back()[0];
90        // Support up to x-of-3 multisig txns as standard
91        if (n < 1 || n > 3)
92            return false;
93        if (m < 1 || m > n)
94            return false;
95    }
96
97    return true;
98}
99
100bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate& dust_relay_fee, std::string& reason)
101{
102    if (tx.version > TX_MAX_STANDARD_VERSION || tx.version < TX_MIN_STANDARD_VERSION) {
103        reason = "version";
104        return false;
105    }
106
107    // Extremely large transactions with lots of inputs can cost the network
108    // almost as much to process as they cost the sender in fees, because
109    // computing signature hashes is O(ninputs*txsize). Limiting transactions
110    // to MAX_STANDARD_TX_WEIGHT mitigates CPU exhaustion attacks.
111    unsigned int sz = GetTransactionWeight(tx);
112    if (sz > MAX_STANDARD_TX_WEIGHT) {
113        reason = "tx-size";
114        return false;
115    }
116
117    for (const CTxIn& txin : tx.vin)
118    {
119        // Biggest 'standard' txin involving only keys is a 15-of-15 P2SH
120        // multisig with compressed keys (remember the MAX_SCRIPT_ELEMENT_SIZE byte limit on
121        // redeemScript size). That works out to a (15*(33+1))+3=513 byte
122        // redeemScript, 513+1+15*(73+1)+3=1627 bytes of scriptSig, which
123        // we round off to 1650(MAX_STANDARD_SCRIPTSIG_SIZE) bytes for
124        // some minor future-proofing. That's also enough to spend a
125        // 20-of-20 CHECKMULTISIG scriptPubKey, though such a scriptPubKey
126        // is not considered standard.
127        if (txin.scriptSig.size() > MAX_STANDARD_SCRIPTSIG_SIZE) {
128            reason = "scriptsig-size";
129            return false;
130        }
131        if (!txin.scriptSig.IsPushOnly()) {
132            reason = "scriptsig-not-pushonly";
133            return false;
134        }
135    }
136
137    unsigned int datacarrier_bytes_left = max_datacarrier_bytes.value_or(0);
138    TxoutType whichType;
139    for (const CTxOut& txout : tx.vout) {
140        if (!::IsStandard(txout.scriptPubKey, whichType)) {
141            reason = "scriptpubkey";
142            return false;
143        }
144
145        if (whichType == TxoutType::NULL_DATA) {
146            unsigned int size = txout.scriptPubKey.size();
147            if (size > datacarrier_bytes_left) {
148                reason = "datacarrier";
149                return false;
150            }
151            datacarrier_bytes_left -= size;
152        } else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) {
153            reason = "bare-multisig";
154            return false;
155        }
156    }
157
158    // Only MAX_DUST_OUTPUTS_PER_TX dust is permitted(on otherwise valid ephemeral dust)
159    if (GetDust(tx, dust_relay_fee).size() > MAX_DUST_OUTPUTS_PER_TX) {
160        reason = "dust";
161        return false;
162    }
163
164    return true;
165}
166
167/**
168 * Check the total number of non-witness sigops across the whole transaction, as per BIP54.
169 */
170static bool CheckSigopsBIP54(const CTransaction& tx, const CCoinsViewCache& inputs)
171{
172    Assert(!tx.IsCoinBase());
173
174    unsigned int sigops{0};
175    for (const auto& txin: tx.vin) {
176        const auto& prev_txo{inputs.AccessCoin(txin.prevout).out};
177
178        // Unlike the existing block wide sigop limit which counts sigops present in the block
179        // itself (including the scriptPubKey which is not executed until spending later), BIP54
180        // counts sigops in the block where they are potentially executed (only).
181        // This means sigops in the spent scriptPubKey count toward the limit.
182        // `fAccurate` means correctly accounting sigops for CHECKMULTISIGs(VERIFY) with 16 pubkeys
183        // or fewer. This method of accounting was introduced by BIP16, and BIP54 reuses it.
184        // The GetSigOpCount call on the previous scriptPubKey counts both bare and P2SH sigops.
185        sigops += txin.scriptSig.GetSigOpCount(/*fAccurate=*/true);
186        sigops += prev_txo.scriptPubKey.GetSigOpCount(txin.scriptSig);
187
188        if (sigops > MAX_TX_LEGACY_SIGOPS) {
189            return false;
190        }
191    }
192
193    return true;
194}
195
196/**
197 * Check transaction inputs.
198 *
199 * This does three things:
200 *  * Prevents mempool acceptance of spends of future
201 *    segwit versions we don't know how to validate
202 *  * Mitigates a potential denial-of-service attack with
203 *    P2SH scripts with a crazy number of expensive
204 *    CHECKSIG/CHECKMULTISIG operations.
205 *  * Prevents spends of unknown/irregular scriptPubKeys,
206 *    which mitigates potential denial-of-service attacks
207 *    involving expensive scripts and helps reserve them
208 *    as potential new upgrade hooks.
209 *
210 * Note that only the non-witness portion of the transaction is checked here.
211 *
212 * We also check the total number of non-witness sigops across the whole transaction, as per BIP54.
213 */
214TxValidationState ValidateInputsStandardness(const CTransaction& tx, const CCoinsViewCache& mapInputs)
215{
216    TxValidationState state;
217    if (tx.IsCoinBase()) {
218        return state; // Coinbases don't use vin normally
219    }
220
221    if (!CheckSigopsBIP54(tx, mapInputs)) {
222        state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", "non-witness sigops exceed bip54 limit");
223        return state;
224    }
225
226    for (unsigned int i = 0; i < tx.vin.size(); i++) {
227        const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
228
229        std::vector<std::vector<unsigned char> > vSolutions;
230        TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
231        if (whichType == TxoutType::NONSTANDARD) {
232            state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("input %u script unknown", i));
233            return state;
234        } else if (whichType == TxoutType::WITNESS_UNKNOWN) {
235            // WITNESS_UNKNOWN failures are typically also caught with a policy
236            // flag in the script interpreter, but it can be helpful to catch
237            // this type of NONSTANDARD transaction earlier in transaction
238            // validation.
239            state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("input %u witness program is undefined", i));
240            return state;
241        } else if (whichType == TxoutType::SCRIPTHASH) {
242            std::vector<std::vector<unsigned char> > stack;
243            ScriptError serror;
244            // convert the scriptSig into a stack, so we can inspect the redeemScript
245            if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE, &serror)) {
246                state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("p2sh scriptsig malformed (input %u: %s)", i, ScriptErrorString(serror)));
247                return state;
248            }
249            if (stack.empty()) {
250                state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("input %u P2SH redeemscript missing", i));