mirror of
https://github.com/dashpay/dash.git
synced 2024-12-25 12:02:48 +01:00
Merge #10192: Cache full script execution results in addition to signatures
e3f9c05Add CheckInputs() unit tests (Suhas Daftuar)a3543afBetter document CheckInputs parameter meanings (Matt Corallo)309ee1aUpdate -maxsigcachesize doc clarify init logprints for it (Matt Corallo)b014668Add CheckInputs wrapper CCoinsViewMemPool -> non-consensus-critical (Matt Corallo)eada04eDo not print soft-fork-script warning with -promiscuousmempool (Matt Corallo)b5fea8dCache full script execution results in addition to signatures (Matt Corallo)6d22b2bPull script verify flags calculation out of ConnectBlock (Matt Corallo) Tree-SHA512: 0c6c3c79c64fcb21e17ab60290c5c96d4fac11624c49f841a4201eec21cb480314c52a07d1e3abd4f9c764785cc57bfd178511f495aa0469addb204e96214fe4
This commit is contained in:
Wladimir J. van der Laan
commit
2935b469ae
@ -447,7 +447,7 @@ std::string HelpMessage(HelpMessageMode mode)
|
||||
{
|
||||
strUsage += HelpMessageOpt("-logtimemicros", strprintf("Add microsecond precision to debug timestamps (default: %u)", DEFAULT_LOGTIMEMICROS));
|
||||
strUsage += HelpMessageOpt("-mocktime=<n>", "Replace actual time with <n> seconds since epoch (default: 0)");
|
||||
strUsage += HelpMessageOpt("-maxsigcachesize=<n>", strprintf("Limit size of signature cache to <n> MiB (default: %u)", DEFAULT_MAX_SIG_CACHE_SIZE));
|
||||
strUsage += HelpMessageOpt("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_MAX_SIG_CACHE_SIZE));
|
||||
strUsage += HelpMessageOpt("-maxtipage=<n>", strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)", DEFAULT_MAX_TIP_AGE));
|
||||
}
|
||||
strUsage += HelpMessageOpt("-maxtxfee=<amt>", strprintf(_("Maximum total fees (in %s) to use in a single wallet transaction or raw transaction; setting this too low may abort large transactions (default: %s)"),
|
||||
@ -1191,6 +1191,7 @@ bool AppInitMain(boost::thread_group& threadGroup, CScheduler& scheduler)
|
||||
LogPrintf("Using at most %i automatic connections (%i file descriptors available)\n", nMaxConnections, nFD);
|
||||
|
||||
InitSignatureCache();
|
||||
InitScriptExecutionCache();
|
||||
|
||||
LogPrintf("Using %u threads for script verification\n", nScriptCheckThreads);
|
||||
if (nScriptCheckThreads) {
|
||||
|
||||
@ -74,10 +74,10 @@ void InitSignatureCache()
|
||||
{
|
||||
// nMaxCacheSize is unsigned. If -maxsigcachesize is set to zero,
|
||||
// setup_bytes creates the minimum possible cache (2 elements).
|
||||
size_t nMaxCacheSize = std::min(std::max((int64_t)0, GetArg("-maxsigcachesize", DEFAULT_MAX_SIG_CACHE_SIZE)), MAX_MAX_SIG_CACHE_SIZE) * ((size_t) 1 << 20);
|
||||
size_t nMaxCacheSize = std::min(std::max((int64_t)0, GetArg("-maxsigcachesize", DEFAULT_MAX_SIG_CACHE_SIZE) / 2), MAX_MAX_SIG_CACHE_SIZE) * ((size_t) 1 << 20);
|
||||
size_t nElems = signatureCache.setup_bytes(nMaxCacheSize);
|
||||
LogPrintf("Using %zu MiB out of %zu requested for signature cache, able to store %zu elements\n",
|
||||
(nElems*sizeof(uint256)) >>20, nMaxCacheSize>>20, nElems);
|
||||
LogPrintf("Using %zu MiB out of %zu/2 requested for signature cache, able to store %zu elements\n",
|
||||
(nElems*sizeof(uint256)) >>20, (nMaxCacheSize*2)>>20, nElems);
|
||||
}
|
||||
|
||||
bool CachingTransactionSignatureChecker::VerifySignature(const std::vector<unsigned char>& vchSig, const CPubKey& pubkey, const uint256& sighash) const
|
||||
|
||||
@ -38,6 +38,7 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName)
|
||||
SetupEnvironment();
|
||||
SetupNetworking();
|
||||
InitSignatureCache();
|
||||
InitScriptExecutionCache();
|
||||
fPrintToDebugLog = false; // don't want to write to debug.log file
|
||||
fCheckBlockIndex = true;
|
||||
SelectParams(chainName);
|
||||
|
||||
@ -10,11 +10,17 @@
|
||||
#include "txmempool.h"
|
||||
#include "random.h"
|
||||
#include "script/standard.h"
|
||||
#include "script/sign.h"
|
||||
#include "test/test_bitcoin.h"
|
||||
#include "utiltime.h"
|
||||
#include "core_io.h"
|
||||
#include "keystore.h"
|
||||
#include "policy/policy.h"
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks);
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(tx_validationcache_tests)
|
||||
|
||||
static bool
|
||||
@ -84,4 +90,282 @@ BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, TestChain100Setup)
|
||||
BOOST_CHECK_EQUAL(mempool.size(), 0);
|
||||
}
|
||||
|
||||
// Run CheckInputs (using pcoinsTip) on the given transaction, for all script
|
||||
// flags. Test that CheckInputs passes for all flags that don't overlap with
|
||||
// the failing_flags argument, but otherwise fails.
|
||||
// CHECKLOCKTIMEVERIFY and CHECKSEQUENCEVERIFY (and future NOP codes that may
|
||||
// get reassigned) have an interaction with DISCOURAGE_UPGRADABLE_NOPS: if
|
||||
// the script flags used contain DISCOURAGE_UPGRADABLE_NOPS but don't contain
|
||||
// CHECKLOCKTIMEVERIFY (or CHECKSEQUENCEVERIFY), but the script does contain
|
||||
// OP_CHECKLOCKTIMEVERIFY (or OP_CHECKSEQUENCEVERIFY), then script execution
|
||||
// should fail.
|
||||
// Capture this interaction with the upgraded_nop argument: set it when evaluating
|
||||
// any script flag that is implemented as an upgraded NOP code.
|
||||
void ValidateCheckInputsForAllFlags(CMutableTransaction &tx, uint32_t failing_flags, bool add_to_cache, bool upgraded_nop)
|
||||
{
|
||||
PrecomputedTransactionData txdata(tx);
|
||||
// If we add many more flags, this loop can get too expensive, but we can
|
||||
// rewrite in the future to randomly pick a set of flags to evaluate.
|
||||
for (uint32_t test_flags=0; test_flags < (1U << 16); test_flags += 1) {
|
||||
CValidationState state;
|
||||
// Filter out incompatible flag choices
|
||||
if ((test_flags & SCRIPT_VERIFY_CLEANSTACK)) {
|
||||
// CLEANSTACK requires P2SH and WITNESS, see VerifyScript() in
|
||||
// script/interpreter.cpp
|
||||
test_flags |= SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS;
|
||||
}
|
||||
if ((test_flags & SCRIPT_VERIFY_WITNESS)) {
|
||||
// WITNESS requires P2SH
|
||||
test_flags |= SCRIPT_VERIFY_P2SH;
|
||||
}
|
||||
bool ret = CheckInputs(tx, state, pcoinsTip, true, test_flags, true, add_to_cache, txdata, nullptr);
|
||||
// CheckInputs should succeed iff test_flags doesn't intersect with
|
||||
// failing_flags
|
||||
bool expected_return_value = !(test_flags & failing_flags);
|
||||
if (expected_return_value && upgraded_nop) {
|
||||
// If the script flag being tested corresponds to an upgraded NOP,
|
||||
// then script execution should fail if DISCOURAGE_UPGRADABLE_NOPS
|
||||
// is set.
|
||||
expected_return_value = !(test_flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS);
|
||||
}
|
||||
BOOST_CHECK_EQUAL(ret, expected_return_value);
|
||||
|
||||
// Test the caching
|
||||
if (ret && add_to_cache) {
|
||||
// Check that we get a cache hit if the tx was valid
|
||||
std::vector<CScriptCheck> scriptchecks;
|
||||
BOOST_CHECK(CheckInputs(tx, state, pcoinsTip, true, test_flags, true, add_to_cache, txdata, &scriptchecks));
|
||||
BOOST_CHECK(scriptchecks.empty());
|
||||
} else {
|
||||
// Check that we get script executions to check, if the transaction
|
||||
// was invalid, or we didn't add to cache.
|
||||
std::vector<CScriptCheck> scriptchecks;
|
||||
BOOST_CHECK(CheckInputs(tx, state, pcoinsTip, true, test_flags, true, add_to_cache, txdata, &scriptchecks));
|
||||
BOOST_CHECK_EQUAL(scriptchecks.size(), tx.vin.size());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)
|
||||
{
|
||||
// Test that passing CheckInputs with one set of script flags doesn't imply
|
||||
// that we would pass again with a different set of flags.
|
||||
InitScriptExecutionCache();
|
||||
|
||||
CScript p2pk_scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
|
||||
CScript p2sh_scriptPubKey = GetScriptForDestination(CScriptID(p2pk_scriptPubKey));
|
||||
CScript p2pkh_scriptPubKey = GetScriptForDestination(coinbaseKey.GetPubKey().GetID());
|
||||
CScript p2wpkh_scriptPubKey = GetScriptForWitness(p2pkh_scriptPubKey);
|
||||
|
||||
CBasicKeyStore keystore;
|
||||
keystore.AddKey(coinbaseKey);
|
||||
keystore.AddCScript(p2pk_scriptPubKey);
|
||||
|
||||
// flags to test: SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, SCRIPT_VERIFY_CHECKSEQUENCE_VERIFY, SCRIPT_VERIFY_NULLDUMMY, uncompressed pubkey thing
|
||||
|
||||
// Create 2 outputs that match the three scripts above, spending the first
|
||||
// coinbase tx.
|
||||
CMutableTransaction spend_tx;
|
||||
|
||||
spend_tx.nVersion = 1;
|
||||
spend_tx.vin.resize(1);
|
||||
spend_tx.vin[0].prevout.hash = coinbaseTxns[0].GetHash();
|
||||
spend_tx.vin[0].prevout.n = 0;
|
||||
spend_tx.vout.resize(4);
|
||||
spend_tx.vout[0].nValue = 11*CENT;
|
||||
spend_tx.vout[0].scriptPubKey = p2sh_scriptPubKey;
|
||||
spend_tx.vout[1].nValue = 11*CENT;
|
||||
spend_tx.vout[1].scriptPubKey = p2wpkh_scriptPubKey;
|
||||
spend_tx.vout[2].nValue = 11*CENT;
|
||||
spend_tx.vout[2].scriptPubKey = CScript() << OP_CHECKLOCKTIMEVERIFY << OP_DROP << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
|
||||
spend_tx.vout[3].nValue = 11*CENT;
|
||||
spend_tx.vout[3].scriptPubKey = CScript() << OP_CHECKSEQUENCEVERIFY << OP_DROP << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
|
||||
|
||||
// Sign, with a non-DER signature
|
||||
{
|
||||
std::vector<unsigned char> vchSig;
|
||||
uint256 hash = SignatureHash(p2pk_scriptPubKey, spend_tx, 0, SIGHASH_ALL, 0, SIGVERSION_BASE);
|
||||
BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
|
||||
vchSig.push_back((unsigned char) 0); // padding byte makes this non-DER
|
||||
vchSig.push_back((unsigned char)SIGHASH_ALL);
|
||||
spend_tx.vin[0].scriptSig << vchSig;
|
||||
}
|
||||
|
||||
LOCK(cs_main);
|
||||
|
||||
// Test that invalidity under a set of flags doesn't preclude validity
|
||||
// under other (eg consensus) flags.
|
||||
// spend_tx is invalid according to DERSIG
|
||||
CValidationState state;
|
||||
{
|
||||
PrecomputedTransactionData ptd_spend_tx(spend_tx);
|
||||
|
||||
BOOST_CHECK(!CheckInputs(spend_tx, state, pcoinsTip, true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, nullptr));
|
||||
|
||||
// If we call again asking for scriptchecks (as happens in
|
||||
// ConnectBlock), we should add a script check object for this -- we're
|
||||
// not caching invalidity (if that changes, delete this test case).
|
||||
std::vector<CScriptCheck> scriptchecks;
|
||||
BOOST_CHECK(CheckInputs(spend_tx, state, pcoinsTip, true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, &scriptchecks));
|
||||
BOOST_CHECK_EQUAL(scriptchecks.size(), 1);
|
||||
|
||||
// Test that CheckInputs returns true iff DERSIG-enforcing flags are
|
||||
// not present. Don't add these checks to the cache, so that we can
|
||||
// test later that block validation works fine in the absence of cached
|
||||
// successes.
|
||||
ValidateCheckInputsForAllFlags(spend_tx, SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC, false, false);
|
||||
|
||||
// And if we produce a block with this tx, it should be valid (DERSIG not
|
||||
// enabled yet), even though there's no cache entry.
|
||||
CBlock block;
|
||||
|
||||
block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);
|
||||
BOOST_CHECK(chainActive.Tip()->GetBlockHash() == block.GetHash());
|
||||
BOOST_CHECK(pcoinsTip->GetBestBlock() == block.GetHash());
|
||||
}
|
||||
|
||||
// Test P2SH: construct a transaction that is valid without P2SH, and
|
||||
// then test validity with P2SH.
|
||||
{
|
||||
CMutableTransaction invalid_under_p2sh_tx;
|
||||
invalid_under_p2sh_tx.nVersion = 1;
|
||||
invalid_under_p2sh_tx.vin.resize(1);
|
||||
invalid_under_p2sh_tx.vin[0].prevout.hash = spend_tx.GetHash();
|
||||
invalid_under_p2sh_tx.vin[0].prevout.n = 0;
|
||||
invalid_under_p2sh_tx.vout.resize(1);
|
||||
invalid_under_p2sh_tx.vout[0].nValue = 11*CENT;
|
||||
invalid_under_p2sh_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
|
||||
std::vector<unsigned char> vchSig2(p2pk_scriptPubKey.begin(), p2pk_scriptPubKey.end());
|
||||
invalid_under_p2sh_tx.vin[0].scriptSig << vchSig2;
|
||||
|
||||
ValidateCheckInputsForAllFlags(invalid_under_p2sh_tx, SCRIPT_VERIFY_P2SH, true, false);
|
||||
}
|
||||
|
||||
// Test CHECKLOCKTIMEVERIFY
|
||||
{
|
||||
CMutableTransaction invalid_with_cltv_tx;
|
||||
invalid_with_cltv_tx.nVersion = 1;
|
||||
invalid_with_cltv_tx.nLockTime = 100;
|
||||
invalid_with_cltv_tx.vin.resize(1);
|
||||
invalid_with_cltv_tx.vin[0].prevout.hash = spend_tx.GetHash();
|
||||
invalid_with_cltv_tx.vin[0].prevout.n = 2;
|
||||
invalid_with_cltv_tx.vin[0].nSequence = 0;
|
||||
invalid_with_cltv_tx.vout.resize(1);
|
||||
invalid_with_cltv_tx.vout[0].nValue = 11*CENT;
|
||||
invalid_with_cltv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
|
||||
|
||||
// Sign
|
||||
std::vector<unsigned char> vchSig;
|
||||
uint256 hash = SignatureHash(spend_tx.vout[2].scriptPubKey, invalid_with_cltv_tx, 0, SIGHASH_ALL, 0, SIGVERSION_BASE);
|
||||
BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
|
||||
vchSig.push_back((unsigned char)SIGHASH_ALL);
|
||||
invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
|
||||
|
||||
ValidateCheckInputsForAllFlags(invalid_with_cltv_tx, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, true);
|
||||
|
||||
// Make it valid, and check again
|
||||
invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
|
||||
CValidationState state;
|
||||
PrecomputedTransactionData txdata(invalid_with_cltv_tx);
|
||||
BOOST_CHECK(CheckInputs(invalid_with_cltv_tx, state, pcoinsTip, true, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, true, txdata, nullptr));
|
||||
}
|
||||
|
||||
// TEST CHECKSEQUENCEVERIFY
|
||||
{
|
||||
CMutableTransaction invalid_with_csv_tx;
|
||||
invalid_with_csv_tx.nVersion = 2;
|
||||
invalid_with_csv_tx.vin.resize(1);
|
||||
invalid_with_csv_tx.vin[0].prevout.hash = spend_tx.GetHash();
|
||||
invalid_with_csv_tx.vin[0].prevout.n = 3;
|
||||
invalid_with_csv_tx.vin[0].nSequence = 100;
|
||||
invalid_with_csv_tx.vout.resize(1);
|
||||
invalid_with_csv_tx.vout[0].nValue = 11*CENT;
|
||||
invalid_with_csv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
|
||||
|
||||
// Sign
|
||||
std::vector<unsigned char> vchSig;
|
||||
uint256 hash = SignatureHash(spend_tx.vout[3].scriptPubKey, invalid_with_csv_tx, 0, SIGHASH_ALL, 0, SIGVERSION_BASE);
|
||||
BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
|
||||
vchSig.push_back((unsigned char)SIGHASH_ALL);
|
||||
invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
|
||||
|
||||
ValidateCheckInputsForAllFlags(invalid_with_csv_tx, SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, true);
|
||||
|
||||
// Make it valid, and check again
|
||||
invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
|
||||
CValidationState state;
|
||||
PrecomputedTransactionData txdata(invalid_with_csv_tx);
|
||||
BOOST_CHECK(CheckInputs(invalid_with_csv_tx, state, pcoinsTip, true, SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, true, txdata, nullptr));
|
||||
}
|
||||
|
||||
// TODO: add tests for remaining script flags
|
||||
|
||||
// Test that passing CheckInputs with a valid witness doesn't imply success
|
||||
// for the same tx with a different witness.
|
||||
{
|
||||
CMutableTransaction valid_with_witness_tx;
|
||||
valid_with_witness_tx.nVersion = 1;
|
||||
valid_with_witness_tx.vin.resize(1);
|
||||
valid_with_witness_tx.vin[0].prevout.hash = spend_tx.GetHash();
|
||||
valid_with_witness_tx.vin[0].prevout.n = 1;
|
||||
valid_with_witness_tx.vout.resize(1);
|
||||
valid_with_witness_tx.vout[0].nValue = 11*CENT;
|
||||
valid_with_witness_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
|
||||
|
||||
// Sign
|
||||
SignatureData sigdata;
|
||||
ProduceSignature(MutableTransactionSignatureCreator(&keystore, &valid_with_witness_tx, 0, 11*CENT, SIGHASH_ALL), spend_tx.vout[1].scriptPubKey, sigdata);
|
||||
UpdateTransaction(valid_with_witness_tx, 0, sigdata);
|
||||
|
||||
// This should be valid under all script flags.
|
||||
ValidateCheckInputsForAllFlags(valid_with_witness_tx, 0, true, false);
|
||||
|
||||
// Remove the witness, and check that it is now invalid.
|
||||
valid_with_witness_tx.vin[0].scriptWitness.SetNull();
|
||||
ValidateCheckInputsForAllFlags(valid_with_witness_tx, SCRIPT_VERIFY_WITNESS, true, false);
|
||||
}
|
||||
|
||||
{
|
||||
// Test a transaction with multiple inputs.
|
||||
CMutableTransaction tx;
|
||||
|
||||
tx.nVersion = 1;
|
||||
tx.vin.resize(2);
|
||||
tx.vin[0].prevout.hash = spend_tx.GetHash();
|
||||
tx.vin[0].prevout.n = 0;
|
||||
tx.vin[1].prevout.hash = spend_tx.GetHash();
|
||||
tx.vin[1].prevout.n = 1;
|
||||
tx.vout.resize(1);
|
||||
tx.vout[0].nValue = 22*CENT;
|
||||
tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
|
||||
|
||||
// Sign
|
||||
for (int i=0; i<2; ++i) {
|
||||
SignatureData sigdata;
|
||||
ProduceSignature(MutableTransactionSignatureCreator(&keystore, &tx, i, 11*CENT, SIGHASH_ALL), spend_tx.vout[i].scriptPubKey, sigdata);
|
||||
UpdateTransaction(tx, i, sigdata);
|
||||
}
|
||||
|
||||
// This should be valid under all script flags
|
||||
ValidateCheckInputsForAllFlags(tx, 0, true, false);
|
||||
|
||||
// Check that if the second input is invalid, but the first input is
|
||||
// valid, the transaction is not cached.
|
||||
// Invalidate vin[1]
|
||||
tx.vin[1].scriptWitness.SetNull();
|
||||
|
||||
CValidationState state;
|
||||
PrecomputedTransactionData txdata(tx);
|
||||
// This transaction is now invalid under segwit, because of the second input.
|
||||
BOOST_CHECK(!CheckInputs(tx, state, pcoinsTip, true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, nullptr));
|
||||
|
||||
std::vector<CScriptCheck> scriptchecks;
|
||||
// Make sure this transaction was not cached (ie because the first
|
||||
// input was valid)
|
||||
BOOST_CHECK(CheckInputs(tx, state, pcoinsTip, true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, &scriptchecks));
|
||||
// Should get 2 script checks back -- caching is on a whole-transaction basis.
|
||||
BOOST_CHECK_EQUAL(scriptchecks.size(), 2);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#include "consensus/merkle.h"
|
||||
#include "consensus/tx_verify.h"
|
||||
#include "consensus/validation.h"
|
||||
#include "cuckoocache.h"
|
||||
#include "fs.h"
|
||||
#include "hash.h"
|
||||
#include "init.h"
|
||||
@ -189,7 +190,7 @@ enum FlushStateMode {
|
||||
static bool FlushStateToDisk(const CChainParams& chainParams, CValidationState &state, FlushStateMode mode, int nManualPruneHeight=0);
|
||||
static void FindFilesToPruneManual(std::set<int>& setFilesToPrune, int nManualPruneHeight);
|
||||
static void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfterHeight);
|
||||
static bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks = NULL);
|
||||
bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks = nullptr);
|
||||
static FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly = false);
|
||||
|
||||
bool CheckFinalTx(const CTransaction &tx, int flags)
|
||||
@ -312,6 +313,9 @@ bool CheckSequenceLocks(const CTransaction &tx, int flags, LockPoints* lp, bool
|
||||
return EvaluateSequenceLocks(index, lockPair);
|
||||
}
|
||||
|
||||
// Returns the script flags which should be checked for a given block
|
||||
static unsigned int GetBlockScriptFlags(const CBlockIndex* pindex, const Consensus::Params& chainparams);
|
||||
|
||||
static void LimitMempoolSize(CTxMemPool& pool, size_t limit, unsigned long age) {
|
||||
int expired = pool.Expire(GetTime() - age);
|
||||
if (expired != 0) {
|
||||
@ -395,6 +399,42 @@ void UpdateMempoolForReorg(DisconnectedBlockTransactions &disconnectpool, bool f
|
||||
LimitMempoolSize(mempool, GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000, GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60);
|
||||
}
|
||||
|
||||
// Used to avoid mempool polluting consensus critical paths if CCoinsViewMempool
|
||||
// were somehow broken and returning the wrong scriptPubKeys
|
||||
static bool CheckInputsFromMempoolAndCache(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &view, CTxMemPool& pool,
|
||||
unsigned int flags, bool cacheSigStore, PrecomputedTransactionData& txdata) {
|
||||
AssertLockHeld(cs_main);
|
||||
|
||||
// pool.cs should be locked already, but go ahead and re-take the lock here
|
||||
// to enforce that mempool doesn't change between when we check the view
|
||||
// and when we actually call through to CheckInputs
|
||||
LOCK(pool.cs);
|
||||
|
||||
assert(!tx.IsCoinBase());
|
||||
for (const CTxIn& txin : tx.vin) {
|
||||
const Coin& coin = view.AccessCoin(txin.prevout);
|
||||
|
||||
// At this point we haven't actually checked if the coins are all
|
||||
// available (or shouldn't assume we have, since CheckInputs does).
|
||||
// So we just return failure if the inputs are not available here,
|
||||
// and then only have to check equivalence for available inputs.
|
||||
if (coin.IsSpent()) return false;
|
||||
|
||||
const CTransactionRef& txFrom = pool.get(txin.prevout.hash);
|
||||
if (txFrom) {
|
||||
assert(txFrom->GetHash() == txin.prevout.hash);
|
||||
assert(txFrom->vout.size() > txin.prevout.n);
|
||||
assert(txFrom->vout[txin.prevout.n] == coin.out);
|
||||
} else {
|
||||
const Coin& coinFromDisk = pcoinsTip->AccessCoin(txin.prevout);
|
||||
assert(!coinFromDisk.IsSpent());
|
||||
assert(coinFromDisk.out == coin.out);
|
||||
}
|
||||
}
|
||||
|
||||
return CheckInputs(tx, state, view, true, flags, cacheSigStore, true, txdata);
|
||||
}
|
||||
|
||||
static bool AcceptToMemoryPoolWorker(const CChainParams& chainparams, CTxMemPool& pool, CValidationState& state, const CTransactionRef& ptx, bool fLimitFree,
|
||||
bool* pfMissingInputs, int64_t nAcceptTime, std::list<CTransactionRef>* plTxnReplaced,
|
||||
bool fOverrideMempoolLimit, const CAmount& nAbsurdFee, std::vector<COutPoint>& coins_to_uncache)
|
||||
@ -751,32 +791,51 @@ static bool AcceptToMemoryPoolWorker(const CChainParams& chainparams, CTxMemPool
|
||||
// Check against previous transactions
|
||||
// This is done last to help prevent CPU exhaustion denial-of-service attacks.
|
||||
PrecomputedTransactionData txdata(tx);
|
||||
if (!CheckInputs(tx, state, view, true, scriptVerifyFlags, true, txdata)) {
|
||||
if (!CheckInputs(tx, state, view, true, scriptVerifyFlags, true, false, txdata)) {
|
||||
// SCRIPT_VERIFY_CLEANSTACK requires SCRIPT_VERIFY_WITNESS, so we
|
||||
// need to turn both off, and compare against just turning off CLEANSTACK
|
||||
// to see if the failure is specifically due to witness validation.
|
||||
CValidationState stateDummy; // Want reported failures to be from first CheckInputs
|
||||
if (!tx.HasWitness() && CheckInputs(tx, stateDummy, view, true, scriptVerifyFlags & ~(SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_CLEANSTACK), true, txdata) &&
|
||||
!CheckInputs(tx, stateDummy, view, true, scriptVerifyFlags & ~SCRIPT_VERIFY_CLEANSTACK, true, txdata)) {
|
||||
if (!tx.HasWitness() && CheckInputs(tx, stateDummy, view, true, scriptVerifyFlags & ~(SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_CLEANSTACK), true, false, txdata) &&
|
||||
!CheckInputs(tx, stateDummy, view, true, scriptVerifyFlags & ~SCRIPT_VERIFY_CLEANSTACK, true, false, txdata)) {
|
||||
// Only the witness is missing, so the transaction itself may be fine.
|
||||
state.SetCorruptionPossible();
|
||||
}
|
||||
return false; // state filled in by CheckInputs
|
||||
}
|
||||
|
||||
// Check again against just the consensus-critical mandatory script
|
||||
// verification flags, in case of bugs in the standard flags that cause
|
||||
// Check again against the current block tip's script verification
|
||||
// flags to cache our script execution flags. This is, of course,
|
||||
// useless if the next block has different script flags from the
|
||||
// previous one, but because the cache tracks script flags for us it
|
||||
// will auto-invalidate and we'll just have a few blocks of extra
|
||||
// misses on soft-fork activation.
|
||||
//
|
||||
// This is also useful in case of bugs in the standard flags that cause
|
||||
// transactions to pass as valid when they're actually invalid. For
|
||||
// instance the STRICTENC flag was incorrectly allowing certain
|
||||
// CHECKSIG NOT scripts to pass, even though they were invalid.
|
||||
//
|
||||
// There is a similar check in CreateNewBlock() to prevent creating
|
||||
// invalid blocks, however allowing such transactions into the mempool
|
||||
// can be exploited as a DoS attack.
|
||||
if (!CheckInputs(tx, state, view, true, MANDATORY_SCRIPT_VERIFY_FLAGS, true, txdata))
|
||||
// invalid blocks (using TestBlockValidity), however allowing such
|
||||
// transactions into the mempool can be exploited as a DoS attack.
|
||||
unsigned int currentBlockScriptVerifyFlags = GetBlockScriptFlags(chainActive.Tip(), Params().GetConsensus());
|
||||
if (!CheckInputsFromMempoolAndCache(tx, state, view, pool, currentBlockScriptVerifyFlags, true, txdata))
|
||||
{
|
||||
return error("%s: BUG! PLEASE REPORT THIS! ConnectInputs failed against MANDATORY but not STANDARD flags %s, %s",
|
||||
__func__, hash.ToString(), FormatStateMessage(state));
|
||||
// If we're using promiscuousmempoolflags, we may hit this normally
|
||||
// Check if current block has some flags that scriptVerifyFlags
|
||||
// does not before printing an ominous warning
|
||||
if (!(~scriptVerifyFlags & currentBlockScriptVerifyFlags)) {
|
||||
return error("%s: BUG! PLEASE REPORT THIS! ConnectInputs failed against latest-block but not STANDARD flags %s, %s",
|
||||
__func__, hash.ToString(), FormatStateMessage(state));
|
||||
} else {
|
||||
if (!CheckInputs(tx, state, view, true, MANDATORY_SCRIPT_VERIFY_FLAGS, true, false, txdata)) {
|
||||
return error("%s: ConnectInputs failed against MANDATORY but not STANDARD flags due to promiscuous mempool %s, %s",
|
||||
__func__, hash.ToString(), FormatStateMessage(state));
|
||||
} else {
|
||||
LogPrintf("Warning: -promiscuousmempool flags set to not include currently enforced soft forks, this may break mining or otherwise cause instability!\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Remove conflicting transactions from the mempool
|
||||
@ -1152,12 +1211,34 @@ int GetSpendHeight(const CCoinsViewCache& inputs)
|
||||
return pindexPrev->nHeight + 1;
|
||||
}
|
||||
|
||||
|
||||
static CuckooCache::cache<uint256, SignatureCacheHasher> scriptExecutionCache;
|
||||
static uint256 scriptExecutionCacheNonce(GetRandHash());
|
||||
|
||||
void InitScriptExecutionCache() {
|
||||
// nMaxCacheSize is unsigned. If -maxsigcachesize is set to zero,
|
||||
// setup_bytes creates the minimum possible cache (2 elements).
|
||||
size_t nMaxCacheSize = std::min(std::max((int64_t)0, GetArg("-maxsigcachesize", DEFAULT_MAX_SIG_CACHE_SIZE) / 2), MAX_MAX_SIG_CACHE_SIZE) * ((size_t) 1 << 20);
|
||||
size_t nElems = scriptExecutionCache.setup_bytes(nMaxCacheSize);
|
||||
LogPrintf("Using %zu MiB out of %zu/2 requested for script execution cache, able to store %zu elements\n",
|
||||
(nElems*sizeof(uint256)) >>20, (nMaxCacheSize*2)>>20, nElems);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether all inputs of this transaction are valid (no double spends, scripts & sigs, amounts)
|
||||
* This does not modify the UTXO set. If pvChecks is not NULL, script checks are pushed onto it
|
||||
* instead of being performed inline.
|
||||
* This does not modify the UTXO set.
|
||||
*
|
||||
* If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline. Any
|
||||
* script checks which are not necessary (eg due to script execution cache hits) are, obviously,
|
||||
* not pushed onto pvChecks/run.
|
||||
*
|
||||
* Setting cacheSigStore/cacheFullScriptStore to false will remove elements from the corresponding cache
|
||||
* which are matched. This is useful for checking blocks where we will likely never need the cache
|
||||
* entry again.
|
||||
*
|
||||
* Non-static (and re-declared) in src/test/txvalidationcache_tests.cpp
|
||||
*/
|
||||
static bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks)
|
||||
bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks)
|
||||
{
|
||||
if (!tx.IsCoinBase())
|
||||
{
|
||||
@ -1177,6 +1258,21 @@ static bool CheckInputs(const CTransaction& tx, CValidationState &state, const C
|
||||
// Of course, if an assumed valid block is invalid due to false scriptSigs
|
||||
// this optimization would allow an invalid chain to be accepted.
|
||||
if (fScriptChecks) {
|
||||
// First check if script executions have been cached with the same
|
||||
// flags. Note that this assumes that the inputs provided are
|
||||
// correct (ie that the transaction hash which is in tx's prevouts
|
||||
// properly commits to the scriptPubKey in the inputs view of that
|
||||
// transaction).
|
||||
uint256 hashCacheEntry;
|
||||
// We only use the first 19 bytes of nonce to avoid a second SHA
|
||||
// round - giving us 19 + 32 + 4 = 55 bytes (+ 8 + 1 = 64)
|
||||
static_assert(55 - sizeof(flags) - 32 >= 128/8, "Want at least 128 bits of nonce for script execution cache");
|
||||
CSHA256().Write(scriptExecutionCacheNonce.begin(), 55 - sizeof(flags) - 32).Write(tx.GetWitnessHash().begin(), 32).Write((unsigned char*)&flags, sizeof(flags)).Finalize(hashCacheEntry.begin());
|
||||
AssertLockHeld(cs_main); //TODO: Remove this requirement by making CuckooCache not require external locks
|
||||
if (scriptExecutionCache.contains(hashCacheEntry, !cacheFullScriptStore)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
for (unsigned int i = 0; i < tx.vin.size(); i++) {
|
||||
const COutPoint &prevout = tx.vin[i].prevout;
|
||||
const Coin& coin = inputs.AccessCoin(prevout);
|
||||
@ -1191,7 +1287,7 @@ static bool CheckInputs(const CTransaction& tx, CValidationState &state, const C
|
||||
const CAmount amount = coin.out.nValue;
|
||||
|
||||
// Verify signature
|
||||
CScriptCheck check(scriptPubKey, amount, tx, i, flags, cacheStore, &txdata);
|
||||
CScriptCheck check(scriptPubKey, amount, tx, i, flags, cacheSigStore, &txdata);
|
||||
if (pvChecks) {
|
||||
pvChecks->push_back(CScriptCheck());
|
||||
check.swap(pvChecks->back());
|
||||
@ -1204,7 +1300,7 @@ static bool CheckInputs(const CTransaction& tx, CValidationState &state, const C
|
||||
// avoid splitting the network between upgraded and
|
||||
// non-upgraded nodes.
|
||||
CScriptCheck check2(scriptPubKey, amount, tx, i,
|
||||
flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS, cacheStore, &txdata);
|
||||
flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS, cacheSigStore, &txdata);
|
||||
if (check2())
|
||||
return state.Invalid(false, REJECT_NONSTANDARD, strprintf("non-mandatory-script-verify-flag (%s)", ScriptErrorString(check.GetScriptError())));
|
||||
}
|
||||
@ -1218,6 +1314,12 @@ static bool CheckInputs(const CTransaction& tx, CValidationState &state, const C
|
||||
return state.DoS(100,false, REJECT_INVALID, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError())));
|
||||
}
|
||||
}
|
||||
|
||||
if (cacheFullScriptStore && !pvChecks) {
|
||||
// We executed all of the provided scripts, and were told to
|
||||
// cache the result. Do so now.
|
||||
scriptExecutionCache.insert(hashCacheEntry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1481,6 +1583,41 @@ public:
|
||||
// Protected by cs_main
|
||||
static ThresholdConditionCache warningcache[VERSIONBITS_NUM_BITS];
|
||||
|
||||
static unsigned int GetBlockScriptFlags(const CBlockIndex* pindex, const Consensus::Params& consensusparams) {
|
||||
AssertLockHeld(cs_main);
|
||||
|
||||
// BIP16 didn't become active until Apr 1 2012
|
||||
int64_t nBIP16SwitchTime = 1333238400;
|
||||
bool fStrictPayToScriptHash = (pindex->GetBlockTime() >= nBIP16SwitchTime);
|
||||
|
||||
unsigned int flags = fStrictPayToScriptHash ? SCRIPT_VERIFY_P2SH : SCRIPT_VERIFY_NONE;
|
||||
|
||||
// Start enforcing the DERSIG (BIP66) rule
|
||||
if (pindex->nHeight >= consensusparams.BIP66Height) {
|
||||
flags |= SCRIPT_VERIFY_DERSIG;
|
||||
}
|
||||
|
||||
// Start enforcing CHECKLOCKTIMEVERIFY (BIP65) rule
|
||||
if (pindex->nHeight >= consensusparams.BIP65Height) {
|
||||
flags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
|
||||
}
|
||||
|
||||
// Start enforcing BIP68 (sequence locks) and BIP112 (CHECKSEQUENCEVERIFY) using versionbits logic.
|
||||
if (VersionBitsState(pindex->pprev, consensusparams, Consensus::DEPLOYMENT_CSV, versionbitscache) == THRESHOLD_ACTIVE) {
|
||||
flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
|
||||
}
|
||||
|
||||
// Start enforcing WITNESS rules using versionbits logic.
|
||||
if (IsWitnessEnabled(pindex->pprev, consensusparams)) {
|
||||
flags |= SCRIPT_VERIFY_WITNESS;
|
||||
flags |= SCRIPT_VERIFY_NULLDUMMY;
|
||||
}
|
||||
|
||||
return flags;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static int64_t nTimeCheck = 0;
|
||||
static int64_t nTimeForks = 0;
|
||||
static int64_t nTimeVerify = 0;
|
||||
@ -1584,34 +1721,14 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
|
||||
}
|
||||
}
|
||||
|
||||
// BIP16 didn't become active until Apr 1 2012
|
||||
int64_t nBIP16SwitchTime = 1333238400;
|
||||
bool fStrictPayToScriptHash = (pindex->GetBlockTime() >= nBIP16SwitchTime);
|
||||
|
||||
unsigned int flags = fStrictPayToScriptHash ? SCRIPT_VERIFY_P2SH : SCRIPT_VERIFY_NONE;
|
||||
|
||||
// Start enforcing the DERSIG (BIP66) rule
|
||||
if (pindex->nHeight >= chainparams.GetConsensus().BIP66Height) {
|
||||
flags |= SCRIPT_VERIFY_DERSIG;
|
||||
}
|
||||
|
||||
// Start enforcing CHECKLOCKTIMEVERIFY (BIP65) rule
|
||||
if (pindex->nHeight >= chainparams.GetConsensus().BIP65Height) {
|
||||
flags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
|
||||
}
|
||||
|
||||
// Start enforcing BIP68 (sequence locks) and BIP112 (CHECKSEQUENCEVERIFY) using versionbits logic.
|
||||
int nLockTimeFlags = 0;
|
||||
if (VersionBitsState(pindex->pprev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_CSV, versionbitscache) == THRESHOLD_ACTIVE) {
|
||||
flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
|
||||
nLockTimeFlags |= LOCKTIME_VERIFY_SEQUENCE;
|
||||
}
|
||||
|
||||
// Start enforcing WITNESS rules using versionbits logic.
|
||||
if (IsWitnessEnabled(pindex->pprev, chainparams.GetConsensus())) {
|
||||
flags |= SCRIPT_VERIFY_WITNESS;
|
||||
flags |= SCRIPT_VERIFY_NULLDUMMY;
|
||||
}
|
||||
// Get the script flags for this block
|
||||
unsigned int flags = GetBlockScriptFlags(pindex, chainparams.GetConsensus());
|
||||
|
||||
int64_t nTime2 = GetTimeMicros(); nTimeForks += nTime2 - nTime1;
|
||||
LogPrint(BCLog::BENCH, " - Fork checks: %.2fms [%.2fs]\n", 0.001 * (nTime2 - nTime1), nTimeForks * 0.000001);
|
||||
@ -1672,7 +1789,7 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
|
||||
|
||||
std::vector<CScriptCheck> vChecks;
|
||||
bool fCacheResults = fJustCheck; /* Don't cache results if we're actually connecting blocks (still consult the cache, though) */
|
||||
if (!CheckInputs(tx, state, view, fScriptChecks, flags, fCacheResults, txdata[i], nScriptCheckThreads ? &vChecks : NULL))
|
||||
if (!CheckInputs(tx, state, view, fScriptChecks, flags, fCacheResults, fCacheResults, txdata[i], nScriptCheckThreads ? &vChecks : NULL))
|
||||
return error("ConnectBlock(): CheckInputs on %s failed with %s",
|
||||
tx.GetHash().ToString(), FormatStateMessage(state));
|
||||
control.Add(vChecks);
|
||||
|
||||
@ -393,6 +393,9 @@ public:
|
||||
ScriptError GetScriptError() const { return error; }
|
||||
};
|
||||
|
||||
/** Initializes the script-execution cache */
|
||||
void InitScriptExecutionCache();
|
||||
|
||||
|
||||
/** Functions for disk access for blocks */
|
||||
bool ReadBlockFromDisk(CBlock& block, const CDiskBlockPos& pos, const Consensus::Params& consensusParams);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user