Differential D5126 Diff 15940 src/test/txvalidationcache_tests.cpp

Changeset View

Standalone View

src/test/txvalidationcache_tests.cpp

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
// script flags used contain DISCOURAGE_UPGRADABLE_NOPS but don't contain		// script flags used contain DISCOURAGE_UPGRADABLE_NOPS but don't contain
// CHECKLOCKTIMEVERIFY (or CHECKSEQUENCEVERIFY), but the script does contain		// CHECKLOCKTIMEVERIFY (or CHECKSEQUENCEVERIFY), but the script does contain
// OP_CHECKLOCKTIMEVERIFY (or OP_CHECKSEQUENCEVERIFY), then script execution		// OP_CHECKLOCKTIMEVERIFY (or OP_CHECKSEQUENCEVERIFY), then script execution
// should fail.		// should fail.
// Capture this interaction with the upgraded_nop argument: set it when		// Capture this interaction with the upgraded_nop argument: set it when
// evaluating any script flag that is implemented as an upgraded NOP code.		// evaluating any script flag that is implemented as an upgraded NOP code.
static void		static void
ValidateCheckInputsForAllFlags(const CTransaction &tx, uint32_t failing_flags,		ValidateCheckInputsForAllFlags(const CTransaction &tx, uint32_t failing_flags,
uint32_t required_flags, bool add_to_cache)		uint32_t required_flags, bool add_to_cache,
		int expected_sigchecks)
EXCLUSIVE_LOCKS_REQUIRED(cs_main) {		EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
PrecomputedTransactionData txdata(tx);		PrecomputedTransactionData txdata(tx);

MMIXLinearCongruentialGenerator lcg;		MMIXLinearCongruentialGenerator lcg;
for (int i = 0; i < 4096; i++) {		for (int i = 0; i < 4096; i++) {
uint32_t test_flags = lcg.next() \| required_flags;		uint32_t test_flags = lcg.next() \| required_flags;
CValidationState state;		CValidationState state;

// Filter out incompatible flag choices		// Filter out incompatible flag choices
if ((test_flags & SCRIPT_VERIFY_CLEANSTACK)) {		if ((test_flags & SCRIPT_VERIFY_CLEANSTACK)) {
// CLEANSTACK requires P2SH, see VerifyScript() in		// CLEANSTACK requires P2SH, see VerifyScript() in
// script/interpreter.cpp		// script/interpreter.cpp
test_flags \|= SCRIPT_VERIFY_P2SH;		test_flags \|= SCRIPT_VERIFY_P2SH;
}		}

		int nSigChecksDirect = 0xf00d;
bool ret = CheckInputs(tx, state, pcoinsTip.get(), true, test_flags,		bool ret = CheckInputs(tx, state, pcoinsTip.get(), true, test_flags,
true, add_to_cache, txdata, nullptr);		true, add_to_cache, txdata, nSigChecksDirect);

// CheckInputs should succeed iff test_flags doesn't intersect with		// CheckInputs should succeed iff test_flags doesn't intersect with
// failing_flags		// failing_flags
bool expected_return_value = !(test_flags & failing_flags);		bool expected_return_value = !(test_flags & failing_flags);
BOOST_CHECK_EQUAL(ret, expected_return_value);		BOOST_CHECK_EQUAL(ret, expected_return_value);

		if (ret) {
		if (test_flags & SCRIPT_REPORT_SIGCHECKS) {
		BOOST_CHECK(nSigChecksDirect == expected_sigchecks);
		} else {
		BOOST_CHECK(nSigChecksDirect == 0);
		}
		}

// Test the caching		// Test the caching
if (ret && add_to_cache) {		if (ret && add_to_cache) {
// Check that we get a cache hit if the tx was valid		// Check that we get a cache hit if the tx was valid
std::vector<CScriptCheck> scriptchecks;		std::vector<CScriptCheck> scriptchecks;
		int nSigChecksCached = 0xbeef;
BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true,		BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true,
test_flags, true, add_to_cache, txdata,		test_flags, true, add_to_cache, txdata,
&scriptchecks));		nSigChecksCached, &scriptchecks));
		BOOST_CHECK(nSigChecksCached == nSigChecksDirect);
BOOST_CHECK(scriptchecks.empty());		BOOST_CHECK(scriptchecks.empty());
} else {		} else {
// Check that we get script executions to check, if the transaction		// Check that we get script executions to check, if the transaction
// was invalid, or we didn't add to cache.		// was invalid, or we didn't add to cache.
std::vector<CScriptCheck> scriptchecks;		std::vector<CScriptCheck> scriptchecks;
		int nSigChecksUncached = 0xbabe;
BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true,		BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true,
test_flags, true, add_to_cache, txdata,		test_flags, true, add_to_cache, txdata,
&scriptchecks));		nSigChecksUncached, &scriptchecks));
		BOOST_CHECK(!ret \|\| nSigChecksUncached == 0);
BOOST_CHECK_EQUAL(scriptchecks.size(), tx.vin.size());		BOOST_CHECK_EQUAL(scriptchecks.size(), tx.vin.size());
}		}
}		}
}		}

BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup) {		BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup) {
// Test that passing CheckInputs with one set of script flags doesn't imply		// Test that passing CheckInputs with one set of script flags doesn't imply
// that we would pass again with a different set of flags.		// that we would pass again with a different set of flags.
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines	BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup) {
// spend_tx is invalid according to DISCOURAGE_UPGRADABLE_NOPS		// spend_tx is invalid according to DISCOURAGE_UPGRADABLE_NOPS
{		{
const CTransaction tx(spend_tx);		const CTransaction tx(spend_tx);

LOCK(cs_main);		LOCK(cs_main);

CValidationState state;		CValidationState state;
PrecomputedTransactionData ptd_spend_tx(tx);		PrecomputedTransactionData ptd_spend_tx(tx);
		int nSigChecksDummy;

BOOST_CHECK(!CheckInputs(tx, state, pcoinsTip.get(), true,		BOOST_CHECK(!CheckInputs(tx, state, pcoinsTip.get(), true,
STANDARD_SCRIPT_VERIFY_FLAGS, true, true,		STANDARD_SCRIPT_VERIFY_FLAGS, true, true,
ptd_spend_tx, nullptr));		ptd_spend_tx, nSigChecksDummy, nullptr));

// If we call again asking for scriptchecks (as happens in		// If we call again asking for scriptchecks (as happens in
// ConnectBlock), we should add a script check object for this -- we're		// ConnectBlock), we should add a script check object for this -- we're
// not caching invalidity (if that changes, delete this test case).		// not caching invalidity (if that changes, delete this test case).
std::vector<CScriptCheck> scriptchecks;		std::vector<CScriptCheck> scriptchecks;
BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true,		BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true,
STANDARD_SCRIPT_VERIFY_FLAGS, true, true,		STANDARD_SCRIPT_VERIFY_FLAGS, true, true,
ptd_spend_tx, &scriptchecks));		ptd_spend_tx, nSigChecksDummy, &scriptchecks));
BOOST_CHECK_EQUAL(scriptchecks.size(), 1U);		BOOST_CHECK_EQUAL(scriptchecks.size(), 1U);

// Test that CheckInputs returns true iff cleanstack-enforcing flags are		// Test that CheckInputs returns true iff cleanstack-enforcing flags are
// not present. Don't add these checks to the cache, so that we can test		// 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		// later that block validation works fine in the absence of cached
// successes.		// successes.
ValidateCheckInputsForAllFlags(		ValidateCheckInputsForAllFlags(
tx, SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS, 0, false);		tx, SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS, 0, false, 0);
}		}

// And if we produce a block with this tx, it should be valid, even though		// And if we produce a block with this tx, it should be valid, even though
// there's no cache entry.		// there's no cache entry.
CBlock block;		CBlock block;

block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);		block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);
LOCK(cs_main);		LOCK(cs_main);
Show All 10 Lines	// test validity with P2SH.
invalid_under_p2sh_tx.vout.resize(1);		invalid_under_p2sh_tx.vout.resize(1);
invalid_under_p2sh_tx.vout[0].nValue = 11 * CENT;		invalid_under_p2sh_tx.vout[0].nValue = 11 * CENT;
invalid_under_p2sh_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;		invalid_under_p2sh_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
std::vector<uint8_t> vchSig2(p2pk_scriptPubKey.begin(),		std::vector<uint8_t> vchSig2(p2pk_scriptPubKey.begin(),
p2pk_scriptPubKey.end());		p2pk_scriptPubKey.end());
invalid_under_p2sh_tx.vin[0].scriptSig << vchSig2;		invalid_under_p2sh_tx.vin[0].scriptSig << vchSig2;

ValidateCheckInputsForAllFlags(CTransaction(invalid_under_p2sh_tx),		ValidateCheckInputsForAllFlags(CTransaction(invalid_under_p2sh_tx),
SCRIPT_VERIFY_P2SH, 0, true);		SCRIPT_VERIFY_P2SH, 0, true, 0);
}		}

// Test CHECKLOCKTIMEVERIFY		// Test CHECKLOCKTIMEVERIFY
{		{
CMutableTransaction invalid_with_cltv_tx;		CMutableTransaction invalid_with_cltv_tx;
invalid_with_cltv_tx.nVersion = 1;		invalid_with_cltv_tx.nVersion = 1;
invalid_with_cltv_tx.nLockTime = 100;		invalid_with_cltv_tx.nLockTime = 100;
invalid_with_cltv_tx.vin.resize(1);		invalid_with_cltv_tx.vin.resize(1);
Show All 10 Lines	// Test CHECKLOCKTIMEVERIFY
0, SigHashType().withForkId(), spend_tx.vout[1].nValue);		0, SigHashType().withForkId(), spend_tx.vout[1].nValue);
BOOST_CHECK(coinbaseKey.SignECDSA(hash, vchSig));		BOOST_CHECK(coinbaseKey.SignECDSA(hash, vchSig));
vchSig.push_back(uint8_t(SIGHASH_ALL \| SIGHASH_FORKID));		vchSig.push_back(uint8_t(SIGHASH_ALL \| SIGHASH_FORKID));
invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 101;		invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 101;

ValidateCheckInputsForAllFlags(CTransaction(invalid_with_cltv_tx),		ValidateCheckInputsForAllFlags(CTransaction(invalid_with_cltv_tx),
SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY \|		SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY \|
SCRIPT_ENABLE_REPLAY_PROTECTION,		SCRIPT_ENABLE_REPLAY_PROTECTION,
SCRIPT_ENABLE_SIGHASH_FORKID, true);		SCRIPT_ENABLE_SIGHASH_FORKID, true, 1);

// Make it valid, and check again		// Make it valid, and check again
invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;		invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
CValidationState state;		CValidationState state;

CTransaction transaction(invalid_with_cltv_tx);		CTransaction transaction(invalid_with_cltv_tx);
PrecomputedTransactionData txdata(transaction);		PrecomputedTransactionData txdata(transaction);

BOOST_CHECK(CheckInputs(transaction, state, pcoinsTip.get(), true,		int nSigChecksRet;
STANDARD_SCRIPT_VERIFY_FLAGS, true, true,		BOOST_CHECK(
txdata, nullptr));		CheckInputs(transaction, state, pcoinsTip.get(), true,
		STANDARD_SCRIPT_VERIFY_FLAGS \| SCRIPT_REPORT_SIGCHECKS,
		true, true, txdata, nSigChecksRet, nullptr));
		BOOST_CHECK(nSigChecksRet == 1);
}		}

// TEST CHECKSEQUENCEVERIFY		// TEST CHECKSEQUENCEVERIFY
{		{
CMutableTransaction invalid_with_csv_tx;		CMutableTransaction invalid_with_csv_tx;
invalid_with_csv_tx.nVersion = 2;		invalid_with_csv_tx.nVersion = 2;
invalid_with_csv_tx.vin.resize(1);		invalid_with_csv_tx.vin.resize(1);
invalid_with_csv_tx.vin[0].prevout = COutPoint(spend_tx.GetId(), 2);		invalid_with_csv_tx.vin[0].prevout = COutPoint(spend_tx.GetId(), 2);
Show All 9 Lines	// TEST CHECKSEQUENCEVERIFY
SigHashType().withForkId(), spend_tx.vout[2].nValue);		SigHashType().withForkId(), spend_tx.vout[2].nValue);
BOOST_CHECK(coinbaseKey.SignECDSA(hash, vchSig));		BOOST_CHECK(coinbaseKey.SignECDSA(hash, vchSig));
vchSig.push_back(uint8_t(SIGHASH_ALL \| SIGHASH_FORKID));		vchSig.push_back(uint8_t(SIGHASH_ALL \| SIGHASH_FORKID));
invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 101;		invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 101;

ValidateCheckInputsForAllFlags(CTransaction(invalid_with_csv_tx),		ValidateCheckInputsForAllFlags(CTransaction(invalid_with_csv_tx),
SCRIPT_VERIFY_CHECKSEQUENCEVERIFY \|		SCRIPT_VERIFY_CHECKSEQUENCEVERIFY \|
SCRIPT_ENABLE_REPLAY_PROTECTION,		SCRIPT_ENABLE_REPLAY_PROTECTION,
SCRIPT_ENABLE_SIGHASH_FORKID, true);		SCRIPT_ENABLE_SIGHASH_FORKID, true, 1);

// Make it valid, and check again		// Make it valid, and check again
invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;		invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
CValidationState state;		CValidationState state;

CTransaction transaction(invalid_with_csv_tx);		CTransaction transaction(invalid_with_csv_tx);
PrecomputedTransactionData txdata(transaction);		PrecomputedTransactionData txdata(transaction);

BOOST_CHECK(CheckInputs(transaction, state, pcoinsTip.get(), true,		int nSigChecksRet;
STANDARD_SCRIPT_VERIFY_FLAGS, true, true,		BOOST_CHECK(
txdata, nullptr));		CheckInputs(transaction, state, pcoinsTip.get(), true,
		STANDARD_SCRIPT_VERIFY_FLAGS \| SCRIPT_REPORT_SIGCHECKS,
		true, true, txdata, nSigChecksRet, nullptr));
		BOOST_CHECK(nSigChecksRet == 1);
}		}

// TODO: add tests for remaining script flags		// TODO: add tests for remaining script flags

{		{
// Test a transaction with multiple inputs.		// Test a transaction with multiple inputs.
CMutableTransaction tx;		CMutableTransaction tx;

Show All 24 Lines	// TODO: add tests for remaining script flags
spend_tx.vout[3].scriptPubKey, sigdata));		spend_tx.vout[3].scriptPubKey, sigdata));
UpdateInput(tx.vin[1], sigdata);		UpdateInput(tx.vin[1], sigdata);
}		}

// This should be valid under all script flags that support our sighash		// This should be valid under all script flags that support our sighash
// convention.		// convention.
ValidateCheckInputsForAllFlags(		ValidateCheckInputsForAllFlags(
CTransaction(tx), SCRIPT_ENABLE_REPLAY_PROTECTION,		CTransaction(tx), SCRIPT_ENABLE_REPLAY_PROTECTION,
SCRIPT_ENABLE_SIGHASH_FORKID \| SCRIPT_VERIFY_P2SH, true);		SCRIPT_ENABLE_SIGHASH_FORKID \| SCRIPT_VERIFY_P2SH, true, 2);

// Check that if the second input is invalid, but the first input is		// Check that if the second input is invalid, but the first input is
// valid, the transaction is not cached.		// valid, the transaction is not cached.
// Invalidate vin[1]		// Invalidate vin[1]
tx.vin[1].scriptSig = CScript();		tx.vin[1].scriptSig = CScript();

CValidationState state;		CValidationState state;
CTransaction transaction(tx);		CTransaction transaction(tx);
PrecomputedTransactionData txdata(transaction);		PrecomputedTransactionData txdata(transaction);

// This transaction is now invalid because the second signature is		// This transaction is now invalid because the second signature is
// missing.		// missing.
		int nSigChecksDummy;
BOOST_CHECK(		BOOST_CHECK(
!CheckInputs(transaction, state, pcoinsTip.get(), true,		!CheckInputs(transaction, state, pcoinsTip.get(), true,
STANDARD_SCRIPT_VERIFY_FLAGS \| SCRIPT_REPORT_SIGCHECKS,		STANDARD_SCRIPT_VERIFY_FLAGS \| SCRIPT_REPORT_SIGCHECKS,
true, true, txdata, nullptr));		true, true, txdata, nSigChecksDummy, nullptr));

// Make sure this transaction was not cached (ie becausethe first input		// Make sure this transaction was not cached (ie becausethe first input
// was valid)		// was valid)
std::vector<CScriptCheck> scriptchecks;		std::vector<CScriptCheck> scriptchecks;
BOOST_CHECK(		BOOST_CHECK(
CheckInputs(transaction, state, pcoinsTip.get(), true,		CheckInputs(transaction, state, pcoinsTip.get(), true,
STANDARD_SCRIPT_VERIFY_FLAGS \| SCRIPT_REPORT_SIGCHECKS,		STANDARD_SCRIPT_VERIFY_FLAGS \| SCRIPT_REPORT_SIGCHECKS,
true, true, txdata, &scriptchecks));		true, true, txdata, nSigChecksDummy, &scriptchecks));
// Should get 2 script checks back -- caching is on a whole-transaction		// Should get 2 script checks back -- caching is on a whole-transaction
// basis.		// basis.
BOOST_CHECK_EQUAL(scriptchecks.size(), 2U);		BOOST_CHECK_EQUAL(scriptchecks.size(), 2U);

// Execute the first check, and check its result		// Execute the first check, and check its result
BOOST_CHECK(scriptchecks[0]());		BOOST_CHECK(scriptchecks[0]());
BOOST_CHECK_EQUAL(scriptchecks[0].GetScriptError(), ScriptError::OK);		BOOST_CHECK_EQUAL(scriptchecks[0].GetScriptError(), ScriptError::OK);
BOOST_CHECK_EQUAL(		BOOST_CHECK_EQUAL(
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines