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 : : #include <tinyformat.h>
22 : :
23 : : #include <algorithm>
24 : : #include <cstddef>
25 : : #include <vector>
26 : :
27 : 41864487 : CAmount 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 [ + + ]: 41864487 : if (txout.scriptPubKey.IsUnspendable())
44 : : return 0;
45 : :
46 : 41857172 : uint64_t nSize{GetSerializeSize(txout)};
47 : 41857172 : int witnessversion = 0;
48 : 41857172 : 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 [ + - + + ]: 41857172 : 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 : 41745540 : nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4);
59 : : } else {
60 : 111632 : nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above
61 : : }
62 : :
63 [ + - ]: 41857172 : return dustRelayFeeIn.GetFee(nSize);
64 : 41857172 : }
65 : :
66 : 41862840 : bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
67 : : {
68 : 41862840 : return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
69 : : }
70 : :
71 : 14695324 : std::vector<uint32_t> GetDust(const CTransaction& tx, CFeeRate dust_relay_rate)
72 : : {
73 : 14695324 : std::vector<uint32_t> dust_outputs;
74 [ - + + + ]: 56068919 : for (uint32_t i{0}; i < tx.vout.size(); ++i) {
75 [ + - + + : 41373595 : if (IsDust(tx.vout[i], dust_relay_rate)) dust_outputs.push_back(i);
+ - ]
76 : : }
77 : 14695324 : return dust_outputs;
78 : 0 : }
79 : :
80 : 5702226 : bool IsStandard(const CScript& scriptPubKey, TxoutType& whichType)
81 : : {
82 : 5702226 : std::vector<std::vector<unsigned char> > vSolutions;
83 [ + - ]: 5702226 : whichType = Solver(scriptPubKey, vSolutions);
84 : :
85 [ + + ]: 5702226 : if (whichType == TxoutType::NONSTANDARD) {
86 : : return false;
87 [ + + ]: 5678595 : } else if (whichType == TxoutType::MULTISIG) {
88 [ + + ]: 3481 : unsigned char m = vSolutions.front()[0];
89 : 3481 : unsigned char n = vSolutions.back()[0];
90 : : // Support up to x-of-3 multisig txns as standard
91 [ + + ]: 3481 : if (n < 1 || n > 3)
92 : : return false;
93 [ - + ]: 2044 : if (m < 1 || m > n)
94 : 0 : return false;
95 : : }
96 : :
97 : : return true;
98 : 5702226 : }
99 : :
100 : 926441 : bool 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 [ + + ]: 926441 : if (tx.version > TX_MAX_STANDARD_VERSION || tx.version < TX_MIN_STANDARD_VERSION) {
103 : 19951 : reason = "version";
104 : 19951 : 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 : 906490 : unsigned int sz = GetTransactionWeight(tx);
112 [ + + ]: 906490 : if (sz > MAX_STANDARD_TX_WEIGHT) {
113 : 379 : reason = "tx-size";
114 : 379 : return false;
115 : : }
116 : :
117 [ + + ]: 5258014 : 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 [ + + + + ]: 4355672 : if (txin.scriptSig.size() > MAX_STANDARD_SCRIPTSIG_SIZE) {
128 : 47 : reason = "scriptsig-size";
129 : 47 : return false;
130 : : }
131 [ + + ]: 4355625 : if (!txin.scriptSig.IsPushOnly()) {
132 : 3722 : reason = "scriptsig-not-pushonly";
133 : 3722 : return false;
134 : : }
135 : : }
136 : :
137 [ + + ]: 902342 : unsigned int datacarrier_bytes_left = max_datacarrier_bytes.value_or(0);
138 : 902342 : TxoutType whichType;
139 [ + + ]: 6577069 : for (const CTxOut& txout : tx.vout) {
140 [ + + ]: 5697967 : if (!::IsStandard(txout.scriptPubKey, whichType)) {
141 : 23040 : reason = "scriptpubkey";
142 : 23040 : return false;
143 : : }
144 : :
145 [ + + ]: 5674927 : if (whichType == TxoutType::NULL_DATA) {
146 [ + + ]: 5096 : unsigned int size = txout.scriptPubKey.size();
147 [ + + ]: 5096 : if (size > datacarrier_bytes_left) {
148 : 13 : reason = "datacarrier";
149 : 13 : return false;
150 : : }
151 : 5083 : datacarrier_bytes_left -= size;
152 [ + + + + ]: 5669831 : } else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) {
153 : 187 : reason = "bare-multisig";
154 : 187 : return false;
155 : : }
156 : : }
157 : :
158 : : // Only MAX_DUST_OUTPUTS_PER_TX dust is permitted(on otherwise valid ephemeral dust)
159 [ - + + + ]: 879102 : if (GetDust(tx, dust_relay_fee).size() > MAX_DUST_OUTPUTS_PER_TX) {
160 : 2128 : reason = "dust";
161 : 2128 : 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 : : */
170 : 497541 : static bool CheckSigopsBIP54(const CTransaction& tx, const CCoinsViewCache& inputs)
171 : : {
172 [ - + ]: 497541 : Assert(!tx.IsCoinBase());
173 : :
174 : 497541 : unsigned int sigops{0};
175 [ + + ]: 1982850 : for (const auto& txin: tx.vin) {
176 : 1485362 : 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 : 1485362 : sigops += txin.scriptSig.GetSigOpCount(/*fAccurate=*/true);
186 : 1485362 : sigops += prev_txo.scriptPubKey.GetSigOpCount(txin.scriptSig);
187 : :
188 [ + + ]: 1485362 : 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 : : */
214 : 497554 : TxValidationState ValidateInputsStandardness(const CTransaction& tx, const CCoinsViewCache& mapInputs)
215 : : {
216 [ + + ]: 497554 : TxValidationState state;
217 [ + + ]: 497554 : if (tx.IsCoinBase()) {
218 : : return state; // Coinbases don't use vin normally
219 : : }
220 : :
221 [ + - + + ]: 497541 : if (!CheckSigopsBIP54(tx, mapInputs)) {
222 [ + - + - : 106 : state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", "non-witness sigops exceed bip54 limit");
+ - ]
223 : 53 : return state;
224 : : }
225 : :
226 [ - + + + ]: 1879390 : for (unsigned int i = 0; i < tx.vin.size(); i++) {
227 [ + - ]: 1384992 : const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
228 : :
229 : 1384992 : std::vector<std::vector<unsigned char> > vSolutions;
230 [ + - ]: 1384992 : TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
231 [ + + ]: 1384992 : if (whichType == TxoutType::NONSTANDARD) {
232 [ + - + - : 2830 : state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("input %u script unknown", i));
+ - ]
233 : 1415 : return state;
234 [ + + ]: 1383577 : } 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 [ + - + - : 250 : state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("input %u witness program is undefined", i));
+ - ]
240 : 125 : return state;
241 [ + + ]: 1383452 : } else if (whichType == TxoutType::SCRIPTHASH) {
242 : 2058 : std::vector<std::vector<unsigned char> > stack;
243 : 2058 : ScriptError serror;
244 : : // convert the scriptSig into a stack, so we can inspect the redeemScript
245 [ + - + + ]: 2058 : if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE, &serror)) {
246 [ + - + - : 3076 : state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("p2sh scriptsig malformed (input %u: %s)", i, ScriptErrorString(serror)));
+ - + - ]
247 : 1538 : return state;
248 : : }
249 [ + + ]: 520 : if (stack.empty()) {
250 [ + - + - : 12 : state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("input %u P2SH redeemscript missing", i));
+ - ]
251 : 6 : return state;
252 : : }
253 : 514 : CScript subscript(stack.back().begin(), stack.back().end());
254 [ + - ]: 514 : unsigned int sigop_count = subscript.GetSigOpCount(true);
255 [ + + ]: 514 : if (sigop_count > MAX_P2SH_SIGOPS) {
256 [ + - + - : 12 : state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("p2sh redeemscript sigops exceed limit (input %u: %u > %u)", i, sigop_count, MAX_P2SH_SIGOPS));
+ - ]
257 : 6 : return state;
258 : : }
259 : 2058 : }
260 : 1384992 : }
261 : :
262 : : return state;
263 : 0 : }
264 : :
265 : 492072 : bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
266 : : {
267 [ + + ]: 492072 : if (tx.IsCoinBase())
268 : : return true; // Coinbases are skipped
269 : :
270 [ - + + + ]: 1917383 : for (unsigned int i = 0; i < tx.vin.size(); i++)
271 : : {
272 : : // We don't care if witness for this input is empty, since it must not be bloated.
273 : : // If the script is invalid without witness, it would be caught sooner or later during validation.
274 [ + + ]: 1429444 : if (tx.vin[i].scriptWitness.IsNull())
275 : 79060 : continue;
276 : :
277 : 1350384 : const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
278 : :
279 : : // get the scriptPubKey corresponding to this input:
280 : 1350384 : CScript prevScript = prev.scriptPubKey;
281 : :
282 : : // witness stuffing detected
283 [ + - + - ]: 1350384 : if (prevScript.IsPayToAnchor()) {
284 : : return false;
285 : : }
286 : :
287 : 1350384 : bool p2sh = false;
288 [ + - + + ]: 1350384 : if (prevScript.IsPayToScriptHash()) {
289 : 51 : std::vector <std::vector<unsigned char> > stack;
290 : : // If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
291 : : // into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
292 : : // If the check fails at this stage, we know that this txid must be a bad one.
293 [ + - + + ]: 51 : if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
294 : : return false;
295 [ + + ]: 30 : if (stack.empty())
296 : : return false;
297 : 27 : prevScript = CScript(stack.back().begin(), stack.back().end());
298 : 27 : p2sh = true;
299 : 51 : }
300 : :
301 : 1350360 : int witnessversion = 0;
302 : 1350360 : std::vector<unsigned char> witnessprogram;
303 : :
304 : : // Non-witness program must not be associated with any witness
305 [ + - + + ]: 1350360 : if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
306 : : return false;
307 : :
308 : : // Check P2WSH standard limits
309 [ + + + + ]: 2692272 : if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
310 [ - + + + ]: 1345396 : if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
311 : : return false;
312 [ - + ]: 1345321 : size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
313 [ + + ]: 1345321 : if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
314 : : return false;
315 [ + + ]: 2267075 : for (unsigned int j = 0; j < sizeWitnessStack; j++) {
316 [ - + + + ]: 921878 : if (tx.vin[i].scriptWitness.stack[j].size() > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
317 : : return false;
318 : : }
319 : : }
320 : :
321 : : // Check policy limits for Taproot spends:
322 : : // - MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE limit for stack item size
323 : : // - No annexes
324 [ + + + + : 1347111 : if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE && !p2sh) {
+ - ]
325 : : // Taproot spend (non-P2SH-wrapped, version 1, witness program size 32; see BIP 341)
326 [ - + ]: 767 : std::span stack{tx.vin[i].scriptWitness.stack};
327 [ + + + + : 767 : if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
+ + ]
328 : : // Annexes are nonstandard as long as no semantics are defined for them.
329 : : return false;
330 : : }
331 [ + + ]: 765 : if (stack.size() >= 2) {
332 : : // Script path spend (2 or more stack elements after removing optional annex)
333 : 342 : const auto& control_block = SpanPopBack(stack);
334 : 342 : SpanPopBack(stack); // Ignore script
335 [ + + ]: 342 : if (control_block.empty()) return false; // Empty control block is invalid
336 [ + + ]: 288 : if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) {
337 : : // Leaf version 0xc0 (aka Tapscript, see BIP 342)
338 [ + + ]: 289 : for (const auto& item : stack) {
339 [ - + + + ]: 245 : if (item.size() > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE) return false;
340 : : }
341 : : }
342 [ + - ]: 423 : } else if (stack.size() == 1) {
343 : : // Key path spend (1 stack element after removing optional annex)
344 : : // (no policy rules apply)
345 : : } else {
346 : : // 0 stack elements; this is already invalid by consensus rules
347 : : return false;
348 : : }
349 : : }
350 : 1354479 : }
351 : : return true;
352 : : }
353 : :
354 : 13057 : bool SpendsNonAnchorWitnessProg(const CTransaction& tx, const CCoinsViewCache& prevouts)
355 : : {
356 [ + - ]: 13057 : if (tx.IsCoinBase()) {
357 : : return false;
358 : : }
359 : :
360 : 13057 : int version;
361 : 13057 : std::vector<uint8_t> program;
362 [ + + ]: 17580 : for (const auto& txin: tx.vin) {
363 [ + - ]: 13067 : const auto& prev_spk{prevouts.AccessCoin(txin.prevout).out.scriptPubKey};
364 : :
365 : : // Note this includes not-yet-defined witness programs.
366 [ + - + + : 13067 : if (prev_spk.IsWitnessProgram(version, program) && !prev_spk.IsPayToAnchor(version, program)) {
+ - - + ]
367 : : return true;
368 : : }
369 : :
370 : : // For P2SH extract the redeem script and check if it spends a non-Taproot witness program. Note
371 : : // this is fine to call EvalScript (as done in ValidateInputsStandardness/IsWitnessStandard) because this
372 : : // function is only ever called after IsStandardTx, which checks the scriptsig is pushonly.
373 [ + - - + ]: 4523 : if (prev_spk.IsPayToScriptHash()) {
374 : : // If EvalScript fails or results in an empty stack, the transaction is invalid by consensus.
375 : 0 : std::vector <std::vector<uint8_t>> stack;
376 [ # # ]: 0 : if (!EvalScript(stack, txin.scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker{}, SigVersion::BASE)
377 [ # # # # ]: 0 : || stack.empty()) {
378 : 0 : continue;
379 : : }
380 : 0 : const CScript redeem_script{stack.back().begin(), stack.back().end()};
381 [ # # # # ]: 0 : if (redeem_script.IsWitnessProgram(version, program)) {
382 : 0 : return true;
383 : : }
384 : 0 : }
385 : : }
386 : :
387 : : return false;
388 : 13057 : }
389 : :
390 : 26573526 : int64_t GetSigOpsAdjustedWeight(int64_t weight, int64_t sigop_cost, unsigned int bytes_per_sigop)
391 : : {
392 [ + + ]: 26573526 : return std::max(weight, sigop_cost * bytes_per_sigop);
393 : : }
394 : :
395 : 23727001 : int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
396 : : {
397 : 23727001 : return (GetSigOpsAdjustedWeight(nWeight, nSigOpCost, bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
398 : : }
399 : :
400 : 1476 : int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop)
401 : : {
402 : 1476 : return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost, bytes_per_sigop);
403 : : }
404 : :
405 : 45 : int64_t GetVirtualTransactionInputSize(const CTxIn& txin, int64_t nSigOpCost, unsigned int bytes_per_sigop)
406 : : {
407 : 45 : return GetVirtualTransactionSize(GetTransactionInputWeight(txin), nSigOpCost, bytes_per_sigop);
408 : : }
|
