Branch data Line data Source code
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 : :
22 : : #include <algorithm>
23 : : #include <cstddef>
24 : : #include <vector>
25 : :
26 : 554664 : CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
27 : : {
28 : : // "Dust" is defined in terms of dustRelayFee,
29 : : // which has units satoshis-per-kilobyte.
30 : : // If you'd pay more in fees than the value of the output
31 : : // to spend something, then we consider it dust.
32 : : // A typical spendable non-segwit txout is 34 bytes big, and will
33 : : // need a CTxIn of at least 148 bytes to spend:
34 : : // so dust is a spendable txout less than
35 : : // 182*dustRelayFee/1000 (in satoshis).
36 : : // 546 satoshis at the default rate of 3000 sat/kvB.
37 : : // A typical spendable segwit P2WPKH txout is 31 bytes big, and will
38 : : // need a CTxIn of at least 67 bytes to spend:
39 : : // so dust is a spendable txout less than
40 : : // 98*dustRelayFee/1000 (in satoshis).
41 : : // 294 satoshis at the default rate of 3000 sat/kvB.
42 [ + + ]: 554664 : if (txout.scriptPubKey.IsUnspendable())
43 : : return 0;
44 : :
45 : 546928 : size_t nSize = GetSerializeSize(txout);
46 : 546928 : int witnessversion = 0;
47 : 546928 : std::vector<unsigned char> witnessprogram;
48 : :
49 : : // Note this computation is for spending a Segwit v0 P2WPKH output (a 33 bytes
50 : : // public key + an ECDSA signature). For Segwit v1 Taproot outputs the minimum
51 : : // satisfaction is lower (a single BIP340 signature) but this computation was
52 : : // kept to not further reduce the dust level.
53 : : // See discussion in https://github.com/bitcoin/bitcoin/pull/22779 for details.
54 [ + - + + ]: 546928 : if (txout.scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
55 : : // sum the sizes of the parts of a transaction input
56 : : // with 75% segwit discount applied to the script size.
57 : 515911 : nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4);
58 : : } else {
59 : 31017 : nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above
60 : : }
61 : :
62 [ + - ]: 546928 : return dustRelayFeeIn.GetFee(nSize);
63 : 546928 : }
64 : :
65 : 551207 : bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
66 : : {
67 : 551207 : return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
68 : : }
69 : :
70 : 62980 : std::vector<uint32_t> GetDust(const CTransaction& tx, CFeeRate dust_relay_rate)
71 : : {
72 : 62980 : std::vector<uint32_t> dust_outputs;
73 [ - + + + ]: 276863 : for (uint32_t i{0}; i < tx.vout.size(); ++i) {
74 [ + - + + : 213883 : if (IsDust(tx.vout[i], dust_relay_rate)) dust_outputs.push_back(i);
+ - ]
75 : : }
76 : 62980 : return dust_outputs;
77 : 0 : }
78 : :
79 : 108395 : bool IsStandard(const CScript& scriptPubKey, TxoutType& whichType)
80 : : {
81 : 108395 : std::vector<std::vector<unsigned char> > vSolutions;
82 [ + - ]: 108395 : whichType = Solver(scriptPubKey, vSolutions);
83 : :
84 [ + + ]: 108395 : if (whichType == TxoutType::NONSTANDARD) {
85 : : return false;
86 [ + + ]: 108374 : } else if (whichType == TxoutType::MULTISIG) {
87 [ + + ]: 93 : unsigned char m = vSolutions.front()[0];
88 : 93 : unsigned char n = vSolutions.back()[0];
89 : : // Support up to x-of-3 multisig txns as standard
90 [ + + ]: 93 : if (n < 1 || n > 3)
91 : : return false;
92 [ - + ]: 92 : if (m < 1 || m > n)
93 : 0 : return false;
94 : : }
95 : :
96 : : return true;
97 : 108395 : }
98 : :
99 : 34503 : bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate& dust_relay_fee, std::string& reason)
100 : : {
101 [ + + ]: 34503 : if (tx.version > TX_MAX_STANDARD_VERSION || tx.version < TX_MIN_STANDARD_VERSION) {
102 : 1960 : reason = "version";
103 : 1960 : 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 : 32543 : unsigned int sz = GetTransactionWeight(tx);
111 [ + + ]: 32543 : if (sz > MAX_STANDARD_TX_WEIGHT) {
112 : 5 : reason = "tx-size";
113 : 5 : return false;
114 : : }
115 : :
116 [ + + ]: 92645 : for (const CTxIn& txin : tx.vin)
117 : : {
118 : : // Biggest 'standard' txin involving only keys is a 15-of-15 P2SH
119 : : // multisig with compressed keys (remember the MAX_SCRIPT_ELEMENT_SIZE byte limit on
120 : : // redeemScript size). That works out to a (15*(33+1))+3=513 byte
121 : : // redeemScript, 513+1+15*(73+1)+3=1627 bytes of scriptSig, which
122 : : // we round off to 1650(MAX_STANDARD_SCRIPTSIG_SIZE) bytes for
123 : : // some minor future-proofing. That's also enough to spend a
124 : : // 20-of-20 CHECKMULTISIG scriptPubKey, though such a scriptPubKey
125 : : // is not considered standard.
126 [ + + + + ]: 60347 : if (txin.scriptSig.size() > MAX_STANDARD_SCRIPTSIG_SIZE) {
127 : 2 : reason = "scriptsig-size";
128 : 2 : return false;
129 : : }
130 [ + + ]: 60345 : if (!txin.scriptSig.IsPushOnly()) {
131 : 238 : reason = "scriptsig-not-pushonly";
132 : 238 : return false;
133 : : }
134 : : }
135 : :
136 [ + + ]: 32298 : unsigned int datacarrier_bytes_left = max_datacarrier_bytes.value_or(0);
137 : 32298 : TxoutType whichType;
138 [ + + ]: 140655 : for (const CTxOut& txout : tx.vout) {
139 [ + + ]: 108385 : if (!::IsStandard(txout.scriptPubKey, whichType)) {
140 : 15 : reason = "scriptpubkey";
141 : 15 : return false;
142 : : }
143 : :
144 [ + + ]: 108370 : if (whichType == TxoutType::NULL_DATA) {
145 [ + + ]: 4063 : unsigned int size = txout.scriptPubKey.size();
146 [ + + ]: 4063 : if (size > datacarrier_bytes_left) {
147 : 8 : reason = "datacarrier";
148 : 8 : return false;
149 : : }
150 : 4055 : datacarrier_bytes_left -= size;
151 [ + + + + ]: 104307 : } else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) {
152 : 5 : reason = "bare-multisig";
153 : 5 : return false;
154 : : }
155 : : }
156 : :
157 : : // Only MAX_DUST_OUTPUTS_PER_TX dust is permitted(on otherwise valid ephemeral dust)
158 [ - + + + ]: 32270 : if (GetDust(tx, dust_relay_fee).size() > MAX_DUST_OUTPUTS_PER_TX) {
159 : 30 : reason = "dust";
160 : 30 : return false;
161 : : }
162 : :
163 : : return true;
164 : : }
165 : :
166 : : /**
167 : : * Check the total number of non-witness sigops across the whole transaction, as per BIP54.
168 : : */
169 : 30973 : static bool CheckSigopsBIP54(const CTransaction& tx, const CCoinsViewCache& inputs)
170 : : {
171 : 30973 : Assert(!tx.IsCoinBase());
172 : :
173 : 30973 : unsigned int sigops{0};
174 [ + + ]: 86076 : for (const auto& txin: tx.vin) {
175 : 55106 : const auto& prev_txo{inputs.AccessCoin(txin.prevout).out};
176 : :
177 : : // Unlike the existing block wide sigop limit which counts sigops present in the block
178 : : // itself (including the scriptPubKey which is not executed until spending later), BIP54
179 : : // counts sigops in the block where they are potentially executed (only).
180 : : // This means sigops in the spent scriptPubKey count toward the limit.
181 : : // `fAccurate` means correctly accounting sigops for CHECKMULTISIGs(VERIFY) with 16 pubkeys
182 : : // or fewer. This method of accounting was introduced by BIP16, and BIP54 reuses it.
183 : : // The GetSigOpCount call on the previous scriptPubKey counts both bare and P2SH sigops.
184 : 55106 : sigops += txin.scriptSig.GetSigOpCount(/*fAccurate=*/true);
185 : 55106 : sigops += prev_txo.scriptPubKey.GetSigOpCount(txin.scriptSig);
186 : :
187 [ + + ]: 55106 : if (sigops > MAX_TX_LEGACY_SIGOPS) {
188 : : return false;
189 : : }
190 : : }
191 : :
192 : : return true;
193 : : }
194 : :
195 : : /**
196 : : * Check transaction inputs.
197 : : *
198 : : * This does three things:
199 : : * * Prevents mempool acceptance of spends of future
200 : : * segwit versions we don't know how to validate
201 : : * * Mitigates a potential denial-of-service attack with
202 : : * P2SH scripts with a crazy number of expensive
203 : : * CHECKSIG/CHECKMULTISIG operations.
204 : : * * Prevents spends of unknown/irregular scriptPubKeys,
205 : : * which mitigates potential denial-of-service attacks
206 : : * involving expensive scripts and helps reserve them
207 : : * as potential new upgrade hooks.
208 : : *
209 : : * Note that only the non-witness portion of the transaction is checked here.
210 : : *
211 : : * We also check the total number of non-witness sigops across the whole transaction, as per BIP54.
212 : : */
213 : 30973 : bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
214 : : {
215 [ + - ]: 30973 : if (tx.IsCoinBase()) {
216 : : return true; // Coinbases don't use vin normally
217 : : }
218 : :
219 [ + + ]: 30973 : if (!CheckSigopsBIP54(tx, mapInputs)) {
220 : : return false;
221 : : }
222 : :
223 [ - + + + ]: 85213 : for (unsigned int i = 0; i < tx.vin.size(); i++) {
224 : 54461 : const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
225 : :
226 : 54461 : std::vector<std::vector<unsigned char> > vSolutions;
227 [ + - ]: 54461 : TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
228 [ + + ]: 54461 : if (whichType == TxoutType::NONSTANDARD || whichType == TxoutType::WITNESS_UNKNOWN) {
229 : : // WITNESS_UNKNOWN failures are typically also caught with a policy
230 : : // flag in the script interpreter, but it can be helpful to catch
231 : : // this type of NONSTANDARD transaction earlier in transaction
232 : : // validation.
233 : : return false;
234 [ + + ]: 54264 : } else if (whichType == TxoutType::SCRIPTHASH) {
235 : 2306 : std::vector<std::vector<unsigned char> > stack;
236 : : // convert the scriptSig into a stack, so we can inspect the redeemScript
237 [ + - + - ]: 2306 : if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
238 : : return false;
239 [ + - ]: 2306 : if (stack.empty())
240 : : return false;
241 : 2306 : CScript subscript(stack.back().begin(), stack.back().end());
242 [ + - + + ]: 2306 : if (subscript.GetSigOpCount(true) > MAX_P2SH_SIGOPS) {
243 : 21 : return false;
244 : : }
245 : 2306 : }
246 : 54461 : }
247 : :
248 : : return true;
249 : : }
250 : :
251 : 29739 : bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
252 : : {
253 [ + - ]: 29739 : if (tx.IsCoinBase())
254 : : return true; // Coinbases are skipped
255 : :
256 [ - + + + ]: 80604 : for (unsigned int i = 0; i < tx.vin.size(); i++)
257 : : {
258 : : // We don't care if witness for this input is empty, since it must not be bloated.
259 : : // If the script is invalid without witness, it would be caught sooner or later during validation.
260 [ + + ]: 51006 : if (tx.vin[i].scriptWitness.IsNull())
261 : 871 : continue;
262 : :
263 : 50135 : const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
264 : :
265 : : // get the scriptPubKey corresponding to this input:
266 : 50135 : CScript prevScript = prev.scriptPubKey;
267 : :
268 : : // witness stuffing detected
269 [ + - + + ]: 50135 : if (prevScript.IsPayToAnchor()) {
270 : : return false;
271 : : }
272 : :
273 : 50134 : bool p2sh = false;
274 [ + - + + ]: 50134 : if (prevScript.IsPayToScriptHash()) {
275 : 1357 : std::vector <std::vector<unsigned char> > stack;
276 : : // If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
277 : : // into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
278 : : // If the check fails at this stage, we know that this txid must be a bad one.
279 [ + - + - ]: 1357 : if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
280 : : return false;
281 [ + - ]: 1357 : if (stack.empty())
282 : : return false;
283 : 1357 : prevScript = CScript(stack.back().begin(), stack.back().end());
284 : 1357 : p2sh = true;
285 : 1357 : }
286 : :
287 : 50134 : int witnessversion = 0;
288 : 50134 : std::vector<unsigned char> witnessprogram;
289 : :
290 : : // Non-witness program must not be associated with any witness
291 [ + - + + ]: 50134 : if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
292 : : return false;
293 : :
294 : : // Check P2WSH standard limits
295 [ + + + + ]: 59181 : if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
296 [ - + + + ]: 467 : if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
297 : : return false;
298 [ - + ]: 465 : size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
299 [ + + ]: 465 : if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
300 : : return false;
301 [ + + ]: 1583 : for (unsigned int j = 0; j < sizeWitnessStack; j++) {
302 [ - + + + ]: 1122 : if (tx.vin[i].scriptWitness.stack[j].size() > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
303 : : return false;
304 : : }
305 : : }
306 : :
307 : : // Check policy limits for Taproot spends:
308 : : // - MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE limit for stack item size
309 : : // - No annexes
310 [ + + + + : 91089 : if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE && !p2sh) {
+ + ]
311 : : // Taproot spend (non-P2SH-wrapped, version 1, witness program size 32; see BIP 341)
312 [ - + ]: 40957 : std::span stack{tx.vin[i].scriptWitness.stack};
313 [ + + + + : 40957 : if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
+ + ]
314 : : // Annexes are nonstandard as long as no semantics are defined for them.
315 : : return false;
316 : : }
317 [ + + ]: 40859 : if (stack.size() >= 2) {
318 : : // Script path spend (2 or more stack elements after removing optional annex)
319 : 39806 : const auto& control_block = SpanPopBack(stack);
320 : 39806 : SpanPopBack(stack); // Ignore script
321 [ + + ]: 39806 : if (control_block.empty()) return false; // Empty control block is invalid
322 [ + + ]: 39805 : if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) {
323 : : // Leaf version 0xc0 (aka Tapscript, see BIP 342)
324 [ + + ]: 239012 : for (const auto& item : stack) {
325 [ - + + + ]: 199895 : if (item.size() > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE) return false;
326 : : }
327 : : }
328 [ + - ]: 1053 : } else if (stack.size() == 1) {
329 : : // Key path spend (1 stack element after removing optional annex)
330 : : // (no policy rules apply)
331 : : } else {
332 : : // 0 stack elements; this is already invalid by consensus rules
333 : : return false;
334 : : }
335 : : }
336 : 50275 : }
337 : : return true;
338 : : }
339 : :
340 : 143 : bool SpendsNonAnchorWitnessProg(const CTransaction& tx, const CCoinsViewCache& prevouts)
341 : : {
342 [ + - ]: 143 : if (tx.IsCoinBase()) {
343 : : return false;
344 : : }
345 : :
346 : 143 : int version;
347 : 143 : std::vector<uint8_t> program;
348 [ + + ]: 225 : for (const auto& txin: tx.vin) {
349 [ + - ]: 143 : const auto& prev_spk{prevouts.AccessCoin(txin.prevout).out.scriptPubKey};
350 : :
351 : : // Note this includes not-yet-defined witness programs.
352 [ + - + + : 143 : if (prev_spk.IsWitnessProgram(version, program) && !prev_spk.IsPayToAnchor(version, program)) {
+ - + + ]
353 : : return true;
354 : : }
355 : :
356 : : // For P2SH extract the redeem script and check if it spends a non-Taproot witness program. Note
357 : : // this is fine to call EvalScript (as done in AreInputsStandard/IsWitnessStandard) because this
358 : : // function is only ever called after IsStandardTx, which checks the scriptsig is pushonly.
359 [ + - + + ]: 113 : if (prev_spk.IsPayToScriptHash()) {
360 : : // If EvalScript fails or results in an empty stack, the transaction is invalid by consensus.
361 : 66 : std::vector <std::vector<uint8_t>> stack;
362 [ + - ]: 66 : if (!EvalScript(stack, txin.scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker{}, SigVersion::BASE)
363 [ + - + + ]: 66 : || stack.empty()) {
364 : 27 : continue;
365 : : }
366 : 39 : const CScript redeem_script{stack.back().begin(), stack.back().end()};
367 [ + - + + ]: 39 : if (redeem_script.IsWitnessProgram(version, program)) {
368 : 31 : return true;
369 : : }
370 : 66 : }
371 : : }
372 : :
373 : : return false;
374 : 143 : }
375 : :
376 : 278388325 : int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
377 : : {
378 [ + + ]: 278388325 : return (std::max(nWeight, nSigOpCost * bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
379 : : }
380 : :
381 : 46468 : int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop)
382 : : {
383 : 46468 : return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost, bytes_per_sigop);
384 : : }
385 : :
386 : 2 : int64_t GetVirtualTransactionInputSize(const CTxIn& txin, int64_t nSigOpCost, unsigned int bytes_per_sigop)
387 : : {
388 : 2 : return GetVirtualTransactionSize(GetTransactionInputWeight(txin), nSigOpCost, bytes_per_sigop);
389 : : }
|
