policy.cpp
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 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 if (txout.scriptPubKey.IsUnspendable()) 43 return 0; 44 45 uint64_t nSize{GetSerializeSize(txout)}; 46 int witnessversion = 0; 47 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 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 nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4); 58 } else { 59 nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above 60 } 61 62 return dustRelayFeeIn.GetFee(nSize); 63 } 64 65 bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFeeIn) 66 { 67 return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn)); 68 } 69 70 std::vector<uint32_t> GetDust(const CTransaction& tx, CFeeRate dust_relay_rate) 71 { 72 std::vector<uint32_t> dust_outputs; 73 for (uint32_t i{0}; i < tx.vout.size(); ++i) { 74 if (IsDust(tx.vout[i], dust_relay_rate)) dust_outputs.push_back(i); 75 } 76 return dust_outputs; 77 } 78 79 bool IsStandard(const CScript& scriptPubKey, TxoutType& whichType) 80 { 81 std::vector<std::vector<unsigned char> > vSolutions; 82 whichType = Solver(scriptPubKey, vSolutions); 83 84 if (whichType == TxoutType::NONSTANDARD) { 85 return false; 86 } else if (whichType == TxoutType::MULTISIG) { 87 unsigned char m = vSolutions.front()[0]; 88 unsigned char n = vSolutions.back()[0]; 89 // Support up to x-of-3 multisig txns as standard 90 if (n < 1 || n > 3) 91 return false; 92 if (m < 1 || m > n) 93 return false; 94 } 95 96 return true; 97 } 98 99 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 if (tx.version > TX_MAX_STANDARD_VERSION || tx.version < TX_MIN_STANDARD_VERSION) { 102 reason = "version"; 103 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 unsigned int sz = GetTransactionWeight(tx); 111 if (sz > MAX_STANDARD_TX_WEIGHT) { 112 reason = "tx-size"; 113 return false; 114 } 115 116 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 if (txin.scriptSig.size() > MAX_STANDARD_SCRIPTSIG_SIZE) { 127 reason = "scriptsig-size"; 128 return false; 129 } 130 if (!txin.scriptSig.IsPushOnly()) { 131 reason = "scriptsig-not-pushonly"; 132 return false; 133 } 134 } 135 136 unsigned int datacarrier_bytes_left = max_datacarrier_bytes.value_or(0); 137 TxoutType whichType; 138 for (const CTxOut& txout : tx.vout) { 139 if (!::IsStandard(txout.scriptPubKey, whichType)) { 140 reason = "scriptpubkey"; 141 return false; 142 } 143 144 if (whichType == TxoutType::NULL_DATA) { 145 unsigned int size = txout.scriptPubKey.size(); 146 if (size > datacarrier_bytes_left) { 147 reason = "datacarrier"; 148 return false; 149 } 150 datacarrier_bytes_left -= size; 151 } else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) { 152 reason = "bare-multisig"; 153 return false; 154 } 155 } 156 157 // Only MAX_DUST_OUTPUTS_PER_TX dust is permitted(on otherwise valid ephemeral dust) 158 if (GetDust(tx, dust_relay_fee).size() > MAX_DUST_OUTPUTS_PER_TX) { 159 reason = "dust"; 160 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 static bool CheckSigopsBIP54(const CTransaction& tx, const CCoinsViewCache& inputs) 170 { 171 Assert(!tx.IsCoinBase()); 172 173 unsigned int sigops{0}; 174 for (const auto& txin: tx.vin) { 175 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 sigops += txin.scriptSig.GetSigOpCount(/*fAccurate=*/true); 185 sigops += prev_txo.scriptPubKey.GetSigOpCount(txin.scriptSig); 186 187 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 bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs) 214 { 215 if (tx.IsCoinBase()) { 216 return true; // Coinbases don't use vin normally 217 } 218 219 if (!CheckSigopsBIP54(tx, mapInputs)) { 220 return false; 221 } 222 223 for (unsigned int i = 0; i < tx.vin.size(); i++) { 224 const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out; 225 226 std::vector<std::vector<unsigned char> > vSolutions; 227 TxoutType whichType = Solver(prev.scriptPubKey, vSolutions); 228 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 } else if (whichType == TxoutType::SCRIPTHASH) { 235 std::vector<std::vector<unsigned char> > stack; 236 // convert the scriptSig into a stack, so we can inspect the redeemScript 237 if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE)) 238 return false; 239 if (stack.empty()) 240 return false; 241 CScript subscript(stack.back().begin(), stack.back().end()); 242 if (subscript.GetSigOpCount(true) > MAX_P2SH_SIGOPS) { 243 return false; 244 } 245 } 246 } 247 248 return true; 249 } 250 251 bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs) 252 { 253 if (tx.IsCoinBase()) 254 return true; // Coinbases are skipped 255 256 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 if (tx.vin[i].scriptWitness.IsNull()) 261 continue; 262 263 const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out; 264 265 // get the scriptPubKey corresponding to this input: 266 CScript prevScript = prev.scriptPubKey; 267 268 // witness stuffing detected 269 if (prevScript.IsPayToAnchor()) { 270 return false; 271 } 272 273 bool p2sh = false; 274 if (prevScript.IsPayToScriptHash()) { 275 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 if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE)) 280 return false; 281 if (stack.empty()) 282 return false; 283 prevScript = CScript(stack.back().begin(), stack.back().end()); 284 p2sh = true; 285 } 286 287 int witnessversion = 0; 288 std::vector<unsigned char> witnessprogram; 289 290 // Non-witness program must not be associated with any witness 291 if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram)) 292 return false; 293 294 // Check P2WSH standard limits 295 if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) { 296 if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE) 297 return false; 298 size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1; 299 if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS) 300 return false; 301 for (unsigned int j = 0; j < sizeWitnessStack; j++) { 302 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 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 std::span stack{tx.vin[i].scriptWitness.stack}; 313 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 if (stack.size() >= 2) { 318 // Script path spend (2 or more stack elements after removing optional annex) 319 const auto& control_block = SpanPopBack(stack); 320 SpanPopBack(stack); // Ignore script 321 if (control_block.empty()) return false; // Empty control block is invalid 322 if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) { 323 // Leaf version 0xc0 (aka Tapscript, see BIP 342) 324 for (const auto& item : stack) { 325 if (item.size() > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE) return false; 326 } 327 } 328 } 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 } 337 return true; 338 } 339 340 bool SpendsNonAnchorWitnessProg(const CTransaction& tx, const CCoinsViewCache& prevouts) 341 { 342 if (tx.IsCoinBase()) { 343 return false; 344 } 345 346 int version; 347 std::vector<uint8_t> program; 348 for (const auto& txin: tx.vin) { 349 const auto& prev_spk{prevouts.AccessCoin(txin.prevout).out.scriptPubKey}; 350 351 // Note this includes not-yet-defined witness programs. 352 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 if (prev_spk.IsPayToScriptHash()) { 360 // If EvalScript fails or results in an empty stack, the transaction is invalid by consensus. 361 std::vector <std::vector<uint8_t>> stack; 362 if (!EvalScript(stack, txin.scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker{}, SigVersion::BASE) 363 || stack.empty()) { 364 continue; 365 } 366 const CScript redeem_script{stack.back().begin(), stack.back().end()}; 367 if (redeem_script.IsWitnessProgram(version, program)) { 368 return true; 369 } 370 } 371 } 372 373 return false; 374 } 375 376 int64_t GetSigOpsAdjustedWeight(int64_t weight, int64_t sigop_cost, unsigned int bytes_per_sigop) 377 { 378 return std::max(weight, sigop_cost * bytes_per_sigop); 379 } 380 381 int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop) 382 { 383 return (GetSigOpsAdjustedWeight(nWeight, nSigOpCost, bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR; 384 } 385 386 int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop) 387 { 388 return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost, bytes_per_sigop); 389 } 390 391 int64_t GetVirtualTransactionInputSize(const CTxIn& txin, int64_t nSigOpCost, unsigned int bytes_per_sigop) 392 { 393 return GetVirtualTransactionSize(GetTransactionInputWeight(txin), nSigOpCost, bytes_per_sigop); 394 }