Page MenuHomePhabricator
Differential D3731 Diff 10456 src/test/script_tests.cpp

Changeset View

Standalone View

View Options

src/test/script_tests.cpp

Show All 35 Lines
#include <vector> #include <vector>
// Uncomment if you want to output updated JSON tests. // Uncomment if you want to output updated JSON tests.
// #define UPDATE_JSON_TESTS // #define UPDATE_JSON_TESTS
static const uint32_t gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC; static const uint32_t gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
struct ScriptErrorDesc { struct ScriptErrorDesc {
ScriptError_t err; ScriptError err;
const char *name; const char *name;
}; };
static ScriptErrorDesc script_errors[] = { static ScriptErrorDesc script_errors[] = {
{SCRIPT_ERR_OK, "OK"}, {ScriptError::OK, "OK"},
{SCRIPT_ERR_UNKNOWN_ERROR, "UNKNOWN_ERROR"}, {ScriptError::UNKNOWN, "UNKNOWN_ERROR"},
{SCRIPT_ERR_EVAL_FALSE, "EVAL_FALSE"}, {ScriptError::EVAL_FALSE, "EVAL_FALSE"},
{SCRIPT_ERR_OP_RETURN, "OP_RETURN"}, {ScriptError::OP_RETURN, "OP_RETURN"},
{SCRIPT_ERR_SCRIPT_SIZE, "SCRIPT_SIZE"}, {ScriptError::SCRIPT_SIZE, "SCRIPT_SIZE"},
{SCRIPT_ERR_PUSH_SIZE, "PUSH_SIZE"}, {ScriptError::PUSH_SIZE, "PUSH_SIZE"},
{SCRIPT_ERR_OP_COUNT, "OP_COUNT"}, {ScriptError::OP_COUNT, "OP_COUNT"},
{SCRIPT_ERR_STACK_SIZE, "STACK_SIZE"}, {ScriptError::STACK_SIZE, "STACK_SIZE"},
{SCRIPT_ERR_SIG_COUNT, "SIG_COUNT"}, {ScriptError::SIG_COUNT, "SIG_COUNT"},
{SCRIPT_ERR_PUBKEY_COUNT, "PUBKEY_COUNT"}, {ScriptError::PUBKEY_COUNT, "PUBKEY_COUNT"},
{SCRIPT_ERR_INVALID_OPERAND_SIZE, "OPERAND_SIZE"}, {ScriptError::INVALID_OPERAND_SIZE, "OPERAND_SIZE"},
{SCRIPT_ERR_INVALID_NUMBER_RANGE, "INVALID_NUMBER_RANGE"}, {ScriptError::INVALID_NUMBER_RANGE, "INVALID_NUMBER_RANGE"},
{SCRIPT_ERR_IMPOSSIBLE_ENCODING, "IMPOSSIBLE_ENCODING"}, {ScriptError::IMPOSSIBLE_ENCODING, "IMPOSSIBLE_ENCODING"},
{SCRIPT_ERR_INVALID_SPLIT_RANGE, "SPLIT_RANGE"}, {ScriptError::INVALID_SPLIT_RANGE, "SPLIT_RANGE"},
{SCRIPT_ERR_VERIFY, "VERIFY"}, {ScriptError::VERIFY, "VERIFY"},
{SCRIPT_ERR_EQUALVERIFY, "EQUALVERIFY"}, {ScriptError::EQUALVERIFY, "EQUALVERIFY"},
{SCRIPT_ERR_CHECKMULTISIGVERIFY, "CHECKMULTISIGVERIFY"}, {ScriptError::CHECKMULTISIGVERIFY, "CHECKMULTISIGVERIFY"},
{SCRIPT_ERR_CHECKSIGVERIFY, "CHECKSIGVERIFY"}, {ScriptError::CHECKSIGVERIFY, "CHECKSIGVERIFY"},
{SCRIPT_ERR_CHECKDATASIGVERIFY, "CHECKDATASIGVERIFY"}, {ScriptError::CHECKDATASIGVERIFY, "CHECKDATASIGVERIFY"},
{SCRIPT_ERR_NUMEQUALVERIFY, "NUMEQUALVERIFY"}, {ScriptError::NUMEQUALVERIFY, "NUMEQUALVERIFY"},
{SCRIPT_ERR_BAD_OPCODE, "BAD_OPCODE"}, {ScriptError::BAD_OPCODE, "BAD_OPCODE"},
{SCRIPT_ERR_DISABLED_OPCODE, "DISABLED_OPCODE"}, {ScriptError::DISABLED_OPCODE, "DISABLED_OPCODE"},
{SCRIPT_ERR_INVALID_STACK_OPERATION, "INVALID_STACK_OPERATION"}, {ScriptError::INVALID_STACK_OPERATION, "INVALID_STACK_OPERATION"},
{SCRIPT_ERR_INVALID_ALTSTACK_OPERATION, "INVALID_ALTSTACK_OPERATION"}, {ScriptError::INVALID_ALTSTACK_OPERATION, "INVALID_ALTSTACK_OPERATION"},
{SCRIPT_ERR_UNBALANCED_CONDITIONAL, "UNBALANCED_CONDITIONAL"}, {ScriptError::UNBALANCED_CONDITIONAL, "UNBALANCED_CONDITIONAL"},
{SCRIPT_ERR_NEGATIVE_LOCKTIME, "NEGATIVE_LOCKTIME"}, {ScriptError::NEGATIVE_LOCKTIME, "NEGATIVE_LOCKTIME"},
{SCRIPT_ERR_UNSATISFIED_LOCKTIME, "UNSATISFIED_LOCKTIME"}, {ScriptError::UNSATISFIED_LOCKTIME, "UNSATISFIED_LOCKTIME"},
{SCRIPT_ERR_SIG_HASHTYPE, "SIG_HASHTYPE"}, {ScriptError::SIG_HASHTYPE, "SIG_HASHTYPE"},
{SCRIPT_ERR_SIG_DER, "SIG_DER"}, {ScriptError::SIG_DER, "SIG_DER"},
{SCRIPT_ERR_MINIMALDATA, "MINIMALDATA"}, {ScriptError::MINIMALDATA, "MINIMALDATA"},
{SCRIPT_ERR_SIG_PUSHONLY, "SIG_PUSHONLY"}, {ScriptError::SIG_PUSHONLY, "SIG_PUSHONLY"},
{SCRIPT_ERR_SIG_HIGH_S, "SIG_HIGH_S"}, {ScriptError::SIG_HIGH_S, "SIG_HIGH_S"},
{SCRIPT_ERR_SIG_NULLDUMMY, "SIG_NULLDUMMY"}, {ScriptError::SIG_NULLDUMMY, "SIG_NULLDUMMY"},
{SCRIPT_ERR_PUBKEYTYPE, "PUBKEYTYPE"}, {ScriptError::PUBKEYTYPE, "PUBKEYTYPE"},
{SCRIPT_ERR_CLEANSTACK, "CLEANSTACK"}, {ScriptError::CLEANSTACK, "CLEANSTACK"},
{SCRIPT_ERR_MINIMALIF, "MINIMALIF"}, {ScriptError::MINIMALIF, "MINIMALIF"},
{SCRIPT_ERR_SIG_NULLFAIL, "NULLFAIL"}, {ScriptError::SIG_NULLFAIL, "NULLFAIL"},
{SCRIPT_ERR_SIG_BADLENGTH, "SIG_BADLENGTH"}, {ScriptError::SIG_BADLENGTH, "SIG_BADLENGTH"},
{SCRIPT_ERR_SIG_NONSCHNORR, "SIG_NONSCHNORR"}, {ScriptError::SIG_NONSCHNORR, "SIG_NONSCHNORR"},
{SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS, "DISCOURAGE_UPGRADABLE_NOPS"}, {ScriptError::DISCOURAGE_UPGRADABLE_NOPS, "DISCOURAGE_UPGRADABLE_NOPS"},
{SCRIPT_ERR_NONCOMPRESSED_PUBKEY, "NONCOMPRESSED_PUBKEY"}, {ScriptError::NONCOMPRESSED_PUBKEY, "NONCOMPRESSED_PUBKEY"},
{SCRIPT_ERR_ILLEGAL_FORKID, "ILLEGAL_FORKID"}, {ScriptError::ILLEGAL_FORKID, "ILLEGAL_FORKID"},
{SCRIPT_ERR_MUST_USE_FORKID, "MISSING_FORKID"}, {ScriptError::MUST_USE_FORKID, "MISSING_FORKID"},
{SCRIPT_ERR_DIV_BY_ZERO, "DIV_BY_ZERO"}, {ScriptError::DIV_BY_ZERO, "DIV_BY_ZERO"},
{SCRIPT_ERR_MOD_BY_ZERO, "MOD_BY_ZERO"}, {ScriptError::MOD_BY_ZERO, "MOD_BY_ZERO"},
}; };
static const char *FormatScriptError(ScriptError_t err) { static const char *FormatScriptError(ScriptError err) {
for (size_t i = 0; i < ARRAYLEN(script_errors); ++i) { for (size_t i = 0; i < ARRAYLEN(script_errors); ++i) {
if (script_errors[i].err == err) { if (script_errors[i].err == err) {
return script_errors[i].name; return script_errors[i].name;
} }
} }
BOOST_ERROR("Unknown scripterror enumeration value, update script_errors " BOOST_ERROR("Unknown scripterror enumeration value, update script_errors "
"in script_tests.cpp."); "in script_tests.cpp.");
return ""; return "";
} }
static ScriptError_t ParseScriptError(const std::string &name) { static ScriptError ParseScriptError(const std::string &name) {
for (size_t i = 0; i < ARRAYLEN(script_errors); ++i) { for (size_t i = 0; i < ARRAYLEN(script_errors); ++i) {
if (script_errors[i].name == name) { if (script_errors[i].name == name) {
return script_errors[i].err; return script_errors[i].err;
} }
} }
BOOST_ERROR("Unknown scripterror \"" << name << "\" in test description"); BOOST_ERROR("Unknown scripterror \"" << name << "\" in test description");
return SCRIPT_ERR_UNKNOWN_ERROR; return ScriptError::UNKNOWN;
} }
BOOST_FIXTURE_TEST_SUITE(script_tests, BasicTestingSetup) BOOST_FIXTURE_TEST_SUITE(script_tests, BasicTestingSetup)
static CMutableTransaction static CMutableTransaction
BuildCreditingTransaction(const CScript &scriptPubKey, const Amount nValue) { BuildCreditingTransaction(const CScript &scriptPubKey, const Amount nValue) {
CMutableTransaction txCredit; CMutableTransaction txCredit;
txCredit.nVersion = 1; txCredit.nVersion = 1;
Show All 22 LinesBuildSpendingTransaction(const CScript &scriptSig,
txSpend.vin[0].nSequence = CTxIn::SEQUENCE_FINAL; txSpend.vin[0].nSequence = CTxIn::SEQUENCE_FINAL;
txSpend.vout[0].scriptPubKey = CScript(); txSpend.vout[0].scriptPubKey = CScript();
txSpend.vout[0].nValue = txCredit.vout[0].nValue; txSpend.vout[0].nValue = txCredit.vout[0].nValue;
return txSpend; return txSpend;
} }
static void DoTest(const CScript &scriptPubKey, const CScript &scriptSig, static void DoTest(const CScript &scriptPubKey, const CScript &scriptSig,
uint32_t flags, const std::string &message, int scriptError, uint32_t flags, const std::string &message,
const Amount nValue) { ScriptError scriptError, const Amount nValue) {
bool expect = (scriptError == SCRIPT_ERR_OK); bool expect = (scriptError == ScriptError::OK);
if (flags & SCRIPT_VERIFY_CLEANSTACK) { if (flags & SCRIPT_VERIFY_CLEANSTACK) {
flags |= SCRIPT_VERIFY_P2SH; flags |= SCRIPT_VERIFY_P2SH;
} }
ScriptError err; ScriptError err;
const CTransaction txCredit{ const CTransaction txCredit{
BuildCreditingTransaction(scriptPubKey, nValue)}; BuildCreditingTransaction(scriptPubKey, nValue)};
CMutableTransaction tx = BuildSpendingTransaction(scriptSig, txCredit); CMutableTransaction tx = BuildSpendingTransaction(scriptSig, txCredit);
CMutableTransaction tx2 = tx; CMutableTransaction tx2 = tx;
BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, flags, BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, flags,
MutableTransactionSignatureChecker( MutableTransactionSignatureChecker(
&tx, 0, txCredit.vout[0].nValue), &tx, 0, txCredit.vout[0].nValue),
&err) == expect, &err) == expect,
message); message);
BOOST_CHECK_MESSAGE( BOOST_CHECK_MESSAGE(err == scriptError,
err == scriptError,
std::string(FormatScriptError(err)) + " where " + std::string(FormatScriptError(err)) + " where " +
std::string(FormatScriptError((ScriptError_t)scriptError)) + std::string(FormatScriptError(scriptError)) +
" expected: " + message); " expected: " + message);
#if defined(HAVE_CONSENSUS_LIB) #if defined(HAVE_CONSENSUS_LIB)
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
stream << tx2; stream << tx2;
uint32_t libconsensus_flags = uint32_t libconsensus_flags =
flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_ALL; flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_ALL;
if (libconsensus_flags == flags) { if (libconsensus_flags == flags) {
if (flags & bitcoinconsensus_SCRIPT_ENABLE_SIGHASH_FORKID) { if (flags & bitcoinconsensus_SCRIPT_ENABLE_SIGHASH_FORKID) {
BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount( BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesprivate:
//! The P2SH redeemscript //! The P2SH redeemscript
CScript redeemscript; CScript redeemscript;
CTransactionRef creditTx; CTransactionRef creditTx;
CMutableTransaction spendTx; CMutableTransaction spendTx;
bool havePush; bool havePush;
std::vector<uint8_t> push; std::vector<uint8_t> push;
std::string comment; std::string comment;
uint32_t flags; uint32_t flags;
int scriptError; ScriptError scriptError;
Amount nValue; Amount nValue;
void DoPush() { void DoPush() {
if (havePush) { if (havePush) {
spendTx.vin[0].scriptSig << push; spendTx.vin[0].scriptSig << push;
havePush = false; havePush = false;
} }
} }
Show All 35 Lines std::vector<uint8_t> DoSignSchnorr(const CKey &key,
return vchSig; return vchSig;
} }
public: public:
TestBuilder(const CScript &script_, const std::string &comment_, TestBuilder(const CScript &script_, const std::string &comment_,
uint32_t flags_, bool P2SH = false, uint32_t flags_, bool P2SH = false,
Amount nValue_ = Amount::zero()) Amount nValue_ = Amount::zero())
: script(script_), havePush(false), comment(comment_), flags(flags_), : script(script_), havePush(false), comment(comment_), flags(flags_),
scriptError(SCRIPT_ERR_OK), nValue(nValue_) { scriptError(ScriptError::OK), nValue(nValue_) {
CScript scriptPubKey = script; CScript scriptPubKey = script;
if (P2SH) { if (P2SH) {
redeemscript = scriptPubKey; redeemscript = scriptPubKey;
scriptPubKey = CScript() scriptPubKey = CScript()
<< OP_HASH160 << OP_HASH160
<< ToByteVector(CScriptID(redeemscript)) << OP_EQUAL; << ToByteVector(CScriptID(redeemscript)) << OP_EQUAL;
} }
creditTx = creditTx =
MakeTransactionRef(BuildCreditingTransaction(scriptPubKey, nValue)); MakeTransactionRef(BuildCreditingTransaction(scriptPubKey, nValue));
spendTx = BuildSpendingTransaction(CScript(), *creditTx); spendTx = BuildSpendingTransaction(CScript(), *creditTx);
} }
TestBuilder &ScriptError(ScriptError_t err) { TestBuilder &SetScriptError(ScriptError err) {
scriptError = err; scriptError = err;
return *this; return *this;
} }
TestBuilder &Add(const CScript &_script) { TestBuilder &Add(const CScript &_script) {
DoPush(); DoPush();
spendTx.vin[0].scriptSig += _script; spendTx.vin[0].scriptSig += _script;
return *this; return *this;
▲ Show 20 Lines • Show All 190 Lines • ▼ Show 20 Lines UniValue GetJSON() {
UniValue amount(UniValue::VARR); UniValue amount(UniValue::VARR);
amount.push_back(ValueFromAmount(nValue)); amount.push_back(ValueFromAmount(nValue));
array.push_back(amount); array.push_back(amount);
} }
array.push_back(FormatScript(spendTx.vin[0].scriptSig)); array.push_back(FormatScript(spendTx.vin[0].scriptSig));
array.push_back(FormatScript(creditTx->vout[0].scriptPubKey)); array.push_back(FormatScript(creditTx->vout[0].scriptPubKey));
array.push_back(FormatScriptFlags(flags)); array.push_back(FormatScriptFlags(flags));
array.push_back(FormatScriptError((ScriptError_t)scriptError)); array.push_back(FormatScriptError(scriptError));
array.push_back(comment); array.push_back(comment);
return array; return array;
} }
std::string GetComment() const { return comment; } std::string GetComment() const { return comment; }
}; };
std::string JSONPrettyPrint(const UniValue &univalue) { std::string JSONPrettyPrint(const UniValue &univalue) {
Show All 19 Lines tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK", 0) "P2PK", 0)
.PushSigECDSA(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK, bad sig", 0) "P2PK, bad sig", 0)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey1C.GetID()) << ToByteVector(keys.pubkey1C.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2PKH", 0) "P2PKH", 0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.Push(keys.pubkey1C)); .Push(keys.pubkey1C));
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey2C.GetID()) << ToByteVector(keys.pubkey2C.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2PKH, bad pubkey", 0) "P2PKH, bad pubkey", 0)
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.Push(keys.pubkey2C) .Push(keys.pubkey2C)
.DamagePush(5) .DamagePush(5)
.ScriptError(SCRIPT_ERR_EQUALVERIFY)); .SetScriptError(ScriptError::EQUALVERIFY));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2PK anyonecanpay", 0) "P2PK anyonecanpay", 0)
.PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay())); .PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay()));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2PK anyonecanpay marked with normal hashtype", 0) "P2PK anyonecanpay marked with normal hashtype", 0)
.PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay()) .PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay())
.EditPush(70, "81", "01") .EditPush(70, "81", "01")
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
"P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true) "P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushRedeem()); .PushRedeem());
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
"P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true) "P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushRedeem() .PushRedeem()
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey0.GetID()) << ToByteVector(keys.pubkey0.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true) "P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.Push(keys.pubkey0) .Push(keys.pubkey0)
.PushRedeem()); .PushRedeem());
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey1.GetID()) << ToByteVector(keys.pubkey1.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0, "P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0,
true) true)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10) .DamagePush(10)
.PushRedeem()); .PushRedeem());
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey1.GetID()) << ToByteVector(keys.pubkey1.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH, "P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH,
true) true)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10) .DamagePush(10)
.PushRedeem() .PushRedeem()
.ScriptError(SCRIPT_ERR_EQUALVERIFY)); .SetScriptError(ScriptError::EQUALVERIFY));
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"3-of-3", 0) "3-of-3", 0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.PushSigECDSA(keys.key2)); .PushSigECDSA(keys.key2));
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"3-of-3, 2 sigs", 0) "3-of-3, 2 sigs", 0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true) "P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.PushRedeem()); .PushRedeem());
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"P2SH(2-of-3), 1 sig", SCRIPT_VERIFY_P2SH, true) "P2SH(2-of-3), 1 sig", SCRIPT_VERIFY_P2SH, true)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.Num(0) .Num(0)
.PushRedeem() .PushRedeem()
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too much R padding but no DERSIG", 0) "P2PK with too much R padding but no DERSIG", 0)
.PushSigECDSA(keys.key1, SigHashType(), 31, 32) .PushSigECDSA(keys.key1, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000")); .EditPush(1, "43021F", "44022000"));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too much R padding", SCRIPT_VERIFY_DERSIG) "P2PK with too much R padding", SCRIPT_VERIFY_DERSIG)
.PushSigECDSA(keys.key1, SigHashType(), 31, 32) .PushSigECDSA(keys.key1, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000") .EditPush(1, "43021F", "44022000")
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too much S padding but no DERSIG", 0) "P2PK with too much S padding but no DERSIG", 0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.EditPush(1, "44", "45") .EditPush(1, "44", "45")
.EditPush(37, "20", "2100")); .EditPush(37, "20", "2100"));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too much S padding", SCRIPT_VERIFY_DERSIG) "P2PK with too much S padding", SCRIPT_VERIFY_DERSIG)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.EditPush(1, "44", "45") .EditPush(1, "44", "45")
.EditPush(37, "20", "2100") .EditPush(37, "20", "2100")
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too little R padding but no DERSIG", 0) "P2PK with too little R padding but no DERSIG", 0)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220")); .EditPush(1, "45022100", "440220"));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too little R padding", SCRIPT_VERIFY_DERSIG) "P2PK with too little R padding", SCRIPT_VERIFY_DERSIG)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT, CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
"P2PK NOT with bad sig with too much R padding but no DERSIG", 0) "P2PK NOT with bad sig with too much R padding but no DERSIG", 0)
.PushSigECDSA(keys.key2, SigHashType(), 31, 32) .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000") .EditPush(1, "43021F", "44022000")
.DamagePush(10)); .DamagePush(10));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"P2PK NOT with bad sig with too much R padding", "P2PK NOT with bad sig with too much R padding",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.PushSigECDSA(keys.key2, SigHashType(), 31, 32) .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000") .EditPush(1, "43021F", "44022000")
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() TestBuilder(CScript()
<< ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT, << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
"P2PK NOT with too much R padding but no DERSIG", 0) "P2PK NOT with too much R padding but no DERSIG", 0)
.PushSigECDSA(keys.key2, SigHashType(), 31, 32) .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000") .EditPush(1, "43021F", "44022000")
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"P2PK NOT with too much R padding", "P2PK NOT with too much R padding",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.PushSigECDSA(keys.key2, SigHashType(), 31, 32) .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000") .EditPush(1, "43021F", "44022000")
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"BIP66 example 1, without DERSIG", 0) "BIP66 example 1, without DERSIG", 0)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220")); .EditPush(1, "45022100", "440220"));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG) "BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"BIP66 example 2, without DERSIG", 0) "BIP66 example 2, without DERSIG", 0)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"BIP66 example 2, with DERSIG", "BIP66 example 2, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"BIP66 example 3, without DERSIG", 0) "BIP66 example 3, without DERSIG", 0)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"BIP66 example 3, with DERSIG", SCRIPT_VERIFY_DERSIG) "BIP66 example 3, with DERSIG", SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"BIP66 example 4, without DERSIG", 0) "BIP66 example 4, without DERSIG", 0)
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"BIP66 example 4, with DERSIG", "BIP66 example 4, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
Show All 10 Lines tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_NULLFAIL) SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_NULLFAIL)
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"BIP66 example 4, with DERSIG and NULLFAIL, " "BIP66 example 4, with DERSIG and NULLFAIL, "
"non-null DER-compliant signature", "non-null DER-compliant signature",
SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_NULLFAIL) SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_NULLFAIL)
.Push("300602010102010101") .Push("300602010102010101")
.ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); .SetScriptError(ScriptError::SIG_NULLFAIL));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"BIP66 example 5, without DERSIG", 0) "BIP66 example 5, without DERSIG", 0)
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"BIP66 example 5, with DERSIG", SCRIPT_VERIFY_DERSIG) "BIP66 example 5, with DERSIG", SCRIPT_VERIFY_DERSIG)
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"BIP66 example 6, without DERSIG", 0) "BIP66 example 6, without DERSIG", 0)
.Num(1)); .Num(1));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"BIP66 example 6, with DERSIG", "BIP66 example 6, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 7, without DERSIG", 0) "BIP66 example 7, without DERSIG", 0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.PushSigECDSA(keys.key2)); .PushSigECDSA(keys.key2));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 7, with DERSIG", "BIP66 example 7, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 8, without DERSIG", 0) "BIP66 example 8, without DERSIG", 0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 8, with DERSIG", "BIP66 example 8, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 9, without DERSIG", 0) "BIP66 example 9, without DERSIG", 0)
.Num(0) .Num(0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key2, SigHashType(), 33, 32) .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 9, with DERSIG", "BIP66 example 9, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key2, SigHashType(), 33, 32) .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 10, without DERSIG", 0) "BIP66 example 10, without DERSIG", 0)
.Num(0) .Num(0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key2, SigHashType(), 33, 32) .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220")); .EditPush(1, "45022100", "440220"));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 10, with DERSIG", "BIP66 example 10, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key2, SigHashType(), 33, 32) .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 11, without DERSIG", 0) "BIP66 example 11, without DERSIG", 0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 11, with DERSIG", "BIP66 example 11, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 12, without DERSIG", 0) "BIP66 example 12, without DERSIG", 0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0)); .Num(0));
Show All 12 Lines tests.push_back(
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.EditPush(70, "01", "0101")); .EditPush(70, "01", "0101"));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2PK with multi-byte hashtype, with DERSIG", "P2PK with multi-byte hashtype, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.EditPush(70, "01", "0101") .EditPush(70, "01", "0101")
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2PK with high S but no LOW_S", 0) "P2PK with high S but no LOW_S", 0)
.PushSigECDSA(keys.key2, SigHashType(), 32, 33)); .PushSigECDSA(keys.key2, SigHashType(), 32, 33));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2PK with high S", SCRIPT_VERIFY_LOW_S) "P2PK with high S", SCRIPT_VERIFY_LOW_S)
.PushSigECDSA(keys.key2, SigHashType(), 32, 33) .PushSigECDSA(keys.key2, SigHashType(), 32, 33)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .SetScriptError(ScriptError::SIG_HIGH_S));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
"P2PK with hybrid pubkey but no STRICTENC", 0) "P2PK with hybrid pubkey but no STRICTENC", 0)
.PushSigECDSA(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
"P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC) "P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC)
.PushSigECDSA(keys.key0, SigHashType()) .PushSigECDSA(keys.key0, SigHashType())
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .SetScriptError(ScriptError::PUBKEYTYPE));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"P2PK NOT with hybrid pubkey but no STRICTENC", "P2PK NOT with hybrid pubkey but no STRICTENC",
0) 0)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"P2PK NOT with hybrid pubkey", "P2PK NOT with hybrid pubkey",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .SetScriptError(ScriptError::PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() TestBuilder(CScript()
<< ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT, << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
"P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0) "P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10)); .DamagePush(10));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"P2PK NOT with invalid hybrid pubkey", "P2PK NOT with invalid hybrid pubkey",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .SetScriptError(ScriptError::PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H)
<< ToByteVector(keys.pubkey1C) << OP_2 << ToByteVector(keys.pubkey1C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"1-of-2 with the second 1 hybrid pubkey and no STRICTENC", "1-of-2 with the second 1 hybrid pubkey and no STRICTENC",
0) 0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1)); .PushSigECDSA(keys.key1));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H)
<< ToByteVector(keys.pubkey1C) << OP_2 << ToByteVector(keys.pubkey1C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"1-of-2 with the second 1 hybrid pubkey", "1-of-2 with the second 1 hybrid pubkey",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1)); .PushSigECDSA(keys.key1));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey0H) << OP_2 << ToByteVector(keys.pubkey0H) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"1-of-2 with the first 1 hybrid pubkey", "1-of-2 with the first 1 hybrid pubkey",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .SetScriptError(ScriptError::PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2PK with undefined hashtype but no STRICTENC", 0) "P2PK with undefined hashtype but no STRICTENC", 0)
.PushSigECDSA(keys.key1, SigHashType(5))); .PushSigECDSA(keys.key1, SigHashType(5)));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC) "P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC)
.PushSigECDSA(keys.key1, SigHashType(5)) .PushSigECDSA(keys.key1, SigHashType(5))
.ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); .SetScriptError(ScriptError::SIG_HASHTYPE));
// Generate P2PKH tests for invalid SigHashType // Generate P2PKH tests for invalid SigHashType
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey0.GetID()) << ToByteVector(keys.pubkey0.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2PKH with invalid sighashtype", 0) "P2PKH with invalid sighashtype", 0)
.PushSigECDSA(keys.key0, SigHashType(0x21), 32, 32, .PushSigECDSA(keys.key0, SigHashType(0x21), 32, 32,
Amount::zero(), 0) Amount::zero(), 0)
.Push(keys.pubkey0)); .Push(keys.pubkey0));
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey0.GetID()) << ToByteVector(keys.pubkey0.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2PKH with invalid sighashtype and STRICTENC", "P2PKH with invalid sighashtype and STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSigECDSA(keys.key0, SigHashType(0x21), 32, 32, .PushSigECDSA(keys.key0, SigHashType(0x21), 32, 32,
Amount::zero(), SCRIPT_VERIFY_STRICTENC) Amount::zero(), SCRIPT_VERIFY_STRICTENC)
.Push(keys.pubkey0) .Push(keys.pubkey0)
// Should fail for STRICTENC // Should fail for STRICTENC
.ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); .SetScriptError(ScriptError::SIG_HASHTYPE));
// Generate P2SH tests for invalid SigHashType // Generate P2SH tests for invalid SigHashType
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2SH(P2PK) with invalid sighashtype", SCRIPT_VERIFY_P2SH, "P2SH(P2PK) with invalid sighashtype", SCRIPT_VERIFY_P2SH,
true) true)
.PushSigECDSA(keys.key1, SigHashType(0x21)) .PushSigECDSA(keys.key1, SigHashType(0x21))
.PushRedeem()); .PushRedeem());
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2SH(P2PK) with invalid sighashtype and STRICTENC", "P2SH(P2PK) with invalid sighashtype and STRICTENC",
SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, true) SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, true)
.PushSigECDSA(keys.key1, SigHashType(0x21)) .PushSigECDSA(keys.key1, SigHashType(0x21))
.PushRedeem() .PushRedeem()
// Should fail for STRICTENC // Should fail for STRICTENC
.ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); .SetScriptError(ScriptError::SIG_HASHTYPE));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT, CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
"P2PK NOT with invalid sig and undefined hashtype but no STRICTENC", "P2PK NOT with invalid sig and undefined hashtype but no STRICTENC",
0) 0)
.PushSigECDSA(keys.key1, SigHashType(5)) .PushSigECDSA(keys.key1, SigHashType(5))
.DamagePush(10)); .DamagePush(10));
tests.push_back( tests.push_back(
TestBuilder(CScript() TestBuilder(CScript()
<< ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT, << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
"P2PK NOT with invalid sig and undefined hashtype", "P2PK NOT with invalid sig and undefined hashtype",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSigECDSA(keys.key1, SigHashType(5)) .PushSigECDSA(keys.key1, SigHashType(5))
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); .SetScriptError(ScriptError::SIG_HASHTYPE));
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"3-of-3 with nonzero dummy but no NULLDUMMY", 0) "3-of-3 with nonzero dummy but no NULLDUMMY", 0)
.Num(1) .Num(1)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.PushSigECDSA(keys.key2)); .PushSigECDSA(keys.key2));
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"3-of-3 with nonzero dummy", "3-of-3 with nonzero dummy",
SCRIPT_VERIFY_NULLDUMMY) SCRIPT_VERIFY_NULLDUMMY)
.Num(1) .Num(1)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_NULLDUMMY)); .SetScriptError(ScriptError::SIG_NULLDUMMY));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << OP_3 << ToByteVector(keys.pubkey0C) CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG
<< OP_NOT, << OP_NOT,
"3-of-3 NOT with invalid sig and nonzero dummy but no NULLDUMMY", 0) "3-of-3 NOT with invalid sig and nonzero dummy but no NULLDUMMY", 0)
.Num(1) .Num(1)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.DamagePush(10)); .DamagePush(10));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"3-of-3 NOT with invalid sig with nonzero dummy", "3-of-3 NOT with invalid sig with nonzero dummy",
SCRIPT_VERIFY_NULLDUMMY) SCRIPT_VERIFY_NULLDUMMY)
.Num(1) .Num(1)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_SIG_NULLDUMMY)); .SetScriptError(ScriptError::SIG_NULLDUMMY));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey1C) << OP_2 << ToByteVector(keys.pubkey1C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"2-of-2 with two identical keys and sigs " "2-of-2 with two identical keys and sigs "
"pushed using OP_DUP but no SIGPUSHONLY", "pushed using OP_DUP but no SIGPUSHONLY",
0) 0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.Add(CScript() << OP_DUP)); .Add(CScript() << OP_DUP));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << OP_2 << ToByteVector(keys.pubkey1C) CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey1C) << OP_2 << ToByteVector(keys.pubkey1C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"2-of-2 with two identical keys and sigs pushed using OP_DUP", "2-of-2 with two identical keys and sigs pushed using OP_DUP",
SCRIPT_VERIFY_SIGPUSHONLY) SCRIPT_VERIFY_SIGPUSHONLY)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.Add(CScript() << OP_DUP) .Add(CScript() << OP_DUP)
.ScriptError(SCRIPT_ERR_SIG_PUSHONLY)); .SetScriptError(ScriptError::SIG_PUSHONLY));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0, "P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0,
true) true)
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.Add(CScript() << OP_NOP8) .Add(CScript() << OP_NOP8)
.PushRedeem()); .PushRedeem());
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2PK with non-push scriptSig but with P2SH validation", 0) "P2PK with non-push scriptSig but with P2SH validation", 0)
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.Add(CScript() << OP_NOP8)); .Add(CScript() << OP_NOP8));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY", "P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY",
SCRIPT_VERIFY_P2SH, true) SCRIPT_VERIFY_P2SH, true)
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.Add(CScript() << OP_NOP8) .Add(CScript() << OP_NOP8)
.PushRedeem() .PushRedeem()
.ScriptError(SCRIPT_ERR_SIG_PUSHONLY)); .SetScriptError(ScriptError::SIG_PUSHONLY));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2SH(P2PK) with non-push scriptSig but not P2SH", "P2SH(P2PK) with non-push scriptSig but not P2SH",
SCRIPT_VERIFY_SIGPUSHONLY, true) SCRIPT_VERIFY_SIGPUSHONLY, true)
.PushSigECDSA(keys.key2) .PushSigECDSA(keys.key2)
.Add(CScript() << OP_NOP8) .Add(CScript() << OP_NOP8)
.PushRedeem() .PushRedeem()
.ScriptError(SCRIPT_ERR_SIG_PUSHONLY)); .SetScriptError(ScriptError::SIG_PUSHONLY));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey1C) << OP_2 << ToByteVector(keys.pubkey1C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"2-of-2 with two identical keys and sigs pushed", "2-of-2 with two identical keys and sigs pushed",
SCRIPT_VERIFY_SIGPUSHONLY) SCRIPT_VERIFY_SIGPUSHONLY)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.PushSigECDSA(keys.key1)); .PushSigECDSA(keys.key1));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK with unnecessary input but no CLEANSTACK", "P2PK with unnecessary input but no CLEANSTACK",
SCRIPT_VERIFY_P2SH) SCRIPT_VERIFY_P2SH)
.Num(11) .Num(11)
.PushSigECDSA(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK with unnecessary input", "P2PK with unnecessary input",
SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH) SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH)
.Num(11) .Num(11)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.ScriptError(SCRIPT_ERR_CLEANSTACK)); .SetScriptError(ScriptError::CLEANSTACK));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2SH with unnecessary input but no CLEANSTACK", "P2SH with unnecessary input but no CLEANSTACK",
SCRIPT_VERIFY_P2SH, true) SCRIPT_VERIFY_P2SH, true)
.Num(11) .Num(11)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushRedeem()); .PushRedeem());
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2SH with unnecessary input", "P2SH with unnecessary input",
SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true) SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true)
.Num(11) .Num(11)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushRedeem() .PushRedeem()
.ScriptError(SCRIPT_ERR_CLEANSTACK)); .SetScriptError(ScriptError::CLEANSTACK));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2SH with CLEANSTACK", "P2SH with CLEANSTACK",
SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true) SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushRedeem()); .PushRedeem());
static const Amount TEST_AMOUNT(int64_t(12345000000000) * SATOSHI); static const Amount TEST_AMOUNT(int64_t(12345000000000) * SATOSHI);
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK FORKID", SCRIPT_ENABLE_SIGHASH_FORKID, false, "P2PK FORKID", SCRIPT_ENABLE_SIGHASH_FORKID, false,
TEST_AMOUNT) TEST_AMOUNT)
.PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32, .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
TEST_AMOUNT)); TEST_AMOUNT));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK INVALID AMOUNT", SCRIPT_ENABLE_SIGHASH_FORKID, false, "P2PK INVALID AMOUNT", SCRIPT_ENABLE_SIGHASH_FORKID, false,
TEST_AMOUNT) TEST_AMOUNT)
.PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32, .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
TEST_AMOUNT + SATOSHI) TEST_AMOUNT + SATOSHI)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK INVALID FORKID", SCRIPT_VERIFY_STRICTENC, false, "P2PK INVALID FORKID", SCRIPT_VERIFY_STRICTENC, false,
TEST_AMOUNT) TEST_AMOUNT)
.PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32, .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
TEST_AMOUNT) TEST_AMOUNT)
.ScriptError(SCRIPT_ERR_ILLEGAL_FORKID)); .SetScriptError(ScriptError::ILLEGAL_FORKID));
// Test replay protection // Test replay protection
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK REPLAY PROTECTED", "P2PK REPLAY PROTECTED",
SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_ENABLE_SIGHASH_FORKID |
SCRIPT_ENABLE_REPLAY_PROTECTION, SCRIPT_ENABLE_REPLAY_PROTECTION,
false, TEST_AMOUNT) false, TEST_AMOUNT)
.PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32, .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
TEST_AMOUNT, TEST_AMOUNT,
SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_ENABLE_SIGHASH_FORKID |
SCRIPT_ENABLE_REPLAY_PROTECTION)); SCRIPT_ENABLE_REPLAY_PROTECTION));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK REPLAY PROTECTED", "P2PK REPLAY PROTECTED",
SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_ENABLE_SIGHASH_FORKID |
SCRIPT_ENABLE_REPLAY_PROTECTION, SCRIPT_ENABLE_REPLAY_PROTECTION,
false, TEST_AMOUNT) false, TEST_AMOUNT)
.PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32, .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
TEST_AMOUNT, SCRIPT_ENABLE_SIGHASH_FORKID) TEST_AMOUNT, SCRIPT_ENABLE_SIGHASH_FORKID)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
// Test OP_CHECKDATASIG // Test OP_CHECKDATASIG
const uint32_t checkdatasigflags = const uint32_t checkdatasigflags =
SCRIPT_VERIFY_STRICTENC | SCRIPT_VERIFY_NULLFAIL; SCRIPT_VERIFY_STRICTENC | SCRIPT_VERIFY_NULLFAIL;
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"Standard CHECKDATASIG", checkdatasigflags) "Standard CHECKDATASIG", checkdatasigflags)
.PushDataSigECDSA(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIG << OP_NOT, << OP_CHECKDATASIG << OP_NOT,
"CHECKDATASIG with NULLFAIL flags", "CHECKDATASIG with NULLFAIL flags",
checkdatasigflags) checkdatasigflags)
.PushDataSigECDSA(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); .SetScriptError(ScriptError::SIG_NULLFAIL));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIG << OP_NOT, << OP_CHECKDATASIG << OP_NOT,
"CHECKDATASIG without NULLFAIL flags", "CHECKDATASIG without NULLFAIL flags",
checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL) checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL)
.PushDataSigECDSA(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1)); .Num(1));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIG << OP_NOT, << OP_CHECKDATASIG << OP_NOT,
"CHECKDATASIG empty signature", "CHECKDATASIG empty signature",
checkdatasigflags) checkdatasigflags)
.Num(0) .Num(0)
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with High S but no Low S", checkdatasigflags) "CHECKDATASIG with High S but no Low S", checkdatasigflags)
.PushDataSigECDSA(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with High S", "CHECKDATASIG with High S",
checkdatasigflags | SCRIPT_VERIFY_LOW_S) checkdatasigflags | SCRIPT_VERIFY_LOW_S)
.PushDataSigECDSA(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .SetScriptError(ScriptError::SIG_HIGH_S));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with too little R padding but no DERSIG", "CHECKDATASIG with too little R padding but no DERSIG",
checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSigECDSA(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with too little R padding", checkdatasigflags) "CHECKDATASIG with too little R padding", checkdatasigflags)
.PushDataSigECDSA(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
"CHECKDATASIG with hybrid pubkey but no STRICTENC", "CHECKDATASIG with hybrid pubkey but no STRICTENC",
checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSigECDSA(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
"CHECKDATASIG with hybrid pubkey", checkdatasigflags) "CHECKDATASIG with hybrid pubkey", checkdatasigflags)
.PushDataSigECDSA(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .SetScriptError(ScriptError::PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG
<< OP_NOT, << OP_NOT,
"CHECKDATASIG with invalid hybrid pubkey but no STRICTENC", "CHECKDATASIG with invalid hybrid pubkey but no STRICTENC",
0) 0)
.PushDataSigECDSA(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
"CHECKDATASIG with invalid hybrid pubkey", "CHECKDATASIG with invalid hybrid pubkey",
checkdatasigflags) checkdatasigflags)
.PushDataSigECDSA(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .SetScriptError(ScriptError::PUBKEYTYPE));
// Test OP_CHECKDATASIGVERIFY // Test OP_CHECKDATASIGVERIFY
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"Standard CHECKDATASIGVERIFY", "Standard CHECKDATASIGVERIFY",
checkdatasigflags) checkdatasigflags)
.PushDataSigECDSA(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with NULLFAIL flags", "CHECKDATASIGVERIFY with NULLFAIL flags",
checkdatasigflags) checkdatasigflags)
.PushDataSigECDSA(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); .SetScriptError(ScriptError::SIG_NULLFAIL));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY without NULLFAIL flags", "CHECKDATASIGVERIFY without NULLFAIL flags",
checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL) checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL)
.PushDataSigECDSA(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY empty signature", "CHECKDATASIGVERIFY empty signature",
checkdatasigflags) checkdatasigflags)
.Num(0) .Num(0)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIG with High S but no Low S", "CHECKDATASIG with High S but no Low S",
checkdatasigflags) checkdatasigflags)
.PushDataSigECDSA(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIG with High S", "CHECKDATASIG with High S",
checkdatasigflags | SCRIPT_VERIFY_LOW_S) checkdatasigflags | SCRIPT_VERIFY_LOW_S)
.PushDataSigECDSA(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .SetScriptError(ScriptError::SIG_HIGH_S));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY
<< OP_TRUE, << OP_TRUE,
"CHECKDATASIGVERIFY with too little R padding but no DERSIG", "CHECKDATASIGVERIFY with too little R padding but no DERSIG",
checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSigECDSA(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with too little R padding", "CHECKDATASIGVERIFY with too little R padding",
checkdatasigflags) checkdatasigflags)
.PushDataSigECDSA(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .SetScriptError(ScriptError::SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with hybrid pubkey but no STRICTENC", "CHECKDATASIGVERIFY with hybrid pubkey but no STRICTENC",
checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSigECDSA(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with hybrid pubkey", "CHECKDATASIGVERIFY with hybrid pubkey",
checkdatasigflags) checkdatasigflags)
.PushDataSigECDSA(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .SetScriptError(ScriptError::PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY
<< OP_TRUE, << OP_TRUE,
"CHECKDATASIGVERIFY with invalid hybrid pubkey but no STRICTENC", 0) "CHECKDATASIGVERIFY with invalid hybrid pubkey but no STRICTENC", 0)
.PushDataSigECDSA(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with invalid hybrid pubkey", "CHECKDATASIGVERIFY with invalid hybrid pubkey",
checkdatasigflags) checkdatasigflags)
.PushDataSigECDSA(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .SetScriptError(ScriptError::PUBKEYTYPE));
// Test all six CHECK*SIG* opcodes with Schnorr signatures. // Test all six CHECK*SIG* opcodes with Schnorr signatures.
// - STRICTENC flag on/off. // - STRICTENC flag on/off.
// - test with different key / mismatching key // - test with different key / mismatching key
// CHECKSIG and Schnorr // CHECKSIG and Schnorr
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
Show All 28 Lines tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1)
"CHECKSIGVERIFY Schnorr other key", "CHECKSIGVERIFY Schnorr other key",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key1)); .PushSigSchnorr(keys.key1));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIGVERIFY << OP_1, << OP_CHECKSIGVERIFY << OP_1,
"CHECKSIGVERIFY Schnorr mismatched key", "CHECKSIGVERIFY Schnorr mismatched key",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key1) .PushSigSchnorr(keys.key1)
.ScriptError(SCRIPT_ERR_CHECKSIGVERIFY)); .SetScriptError(ScriptError::CHECKSIGVERIFY));
// CHECKDATASIG and Schnorr // CHECKDATASIG and Schnorr
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIG, << OP_CHECKDATASIG,
"CHECKDATASIG Schnorr", 0) "CHECKDATASIG Schnorr", 0)
.PushDataSigSchnorr(keys.key0, {})); .PushDataSigSchnorr(keys.key0, {}));
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIG, << OP_CHECKDATASIG,
Show All 36 Lines tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
"CHECKDATASIGVERIFY Schnorr other key", "CHECKDATASIGVERIFY Schnorr other key",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushDataSigSchnorr(keys.key1, {})); .PushDataSigSchnorr(keys.key1, {}));
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY Schnorr mismatched key", "CHECKDATASIGVERIFY Schnorr mismatched key",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushDataSigSchnorr(keys.key1, {}) .PushDataSigSchnorr(keys.key1, {})
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY Schnorr other message", "CHECKDATASIGVERIFY Schnorr other message",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushDataSigSchnorr(keys.key1, {1})); .PushDataSigSchnorr(keys.key1, {1}));
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY Schnorr wrong message", "CHECKDATASIGVERIFY Schnorr wrong message",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushDataSigSchnorr(keys.key1, {1}) .PushDataSigSchnorr(keys.key1, {1})
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
// CHECKMULTISIG 1-of-1 and Schnorr // CHECKMULTISIG 1-of-1 and Schnorr
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIG, << OP_1 << OP_CHECKMULTISIG,
"CHECKMULTISIG Schnorr w/ no STRICTENC", 0) "CHECKMULTISIG Schnorr w/ no STRICTENC", 0)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIG, << OP_1 << OP_CHECKMULTISIG,
"CHECKMULTISIG Schnorr w/ STRICTENC", "CHECKMULTISIG Schnorr w/ STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
// Test multisig with multiple Schnorr signatures // Test multisig with multiple Schnorr signatures
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"Schnorr 3-of-3", 0) "Schnorr 3-of-3", 0)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.PushSigSchnorr(keys.key1) .PushSigSchnorr(keys.key1)
.PushSigSchnorr(keys.key2) .PushSigSchnorr(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"Schnorr-ECDSA-mixed 3-of-3", 0) "Schnorr-ECDSA-mixed 3-of-3", 0)
.Num(0) .Num(0)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.PushSigSchnorr(keys.key2) .PushSigSchnorr(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
// CHECKMULTISIGVERIFY 1-of-1 and Schnorr // CHECKMULTISIGVERIFY 1-of-1 and Schnorr
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
<< OP_CHECKMULTISIGVERIFY << OP_1, << OP_CHECKMULTISIGVERIFY << OP_1,
"CHECKMULTISIGVERIFY Schnorr w/ no STRICTENC", 0) "CHECKMULTISIGVERIFY Schnorr w/ no STRICTENC", 0)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
tests.push_back(TestBuilder(CScript() tests.push_back(TestBuilder(CScript()
<< OP_1 << ToByteVector(keys.pubkey0) << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIGVERIFY << OP_1, << OP_1 << OP_CHECKMULTISIGVERIFY << OP_1,
"CHECKMULTISIGVERIFY Schnorr w/ STRICTENC", "CHECKMULTISIGVERIFY Schnorr w/ STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
// Test damaged Schnorr signatures // Test damaged Schnorr signatures
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"Schnorr P2PK, bad sig", 0) "Schnorr P2PK, bad sig", 0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.DamagePush(10)); .DamagePush(10));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"Schnorr P2PK, bad sig STRICTENC", "Schnorr P2PK, bad sig STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.DamagePush(10)); .DamagePush(10));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"Schnorr P2PK, bad sig NULLFAIL", "Schnorr P2PK, bad sig NULLFAIL",
SCRIPT_VERIFY_NULLFAIL) SCRIPT_VERIFY_NULLFAIL)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); .SetScriptError(ScriptError::SIG_NULLFAIL));
// Make sure P2PKH works with Schnorr // Make sure P2PKH works with Schnorr
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey1C.GetID()) << ToByteVector(keys.pubkey1C.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"Schnorr P2PKH", 0) "Schnorr P2PKH", 0)
.PushSigSchnorr(keys.key1) .PushSigSchnorr(keys.key1)
.Push(keys.pubkey1C)); .Push(keys.pubkey1C));
Show All 11 Lines tests.push_back(
.PushSigSchnorr(keys.key0, SigHashType())); .PushSigSchnorr(keys.key0, SigHashType()));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"Schnorr P2PK with uncompressed pubkey but " "Schnorr P2PK with uncompressed pubkey but "
"COMPRESSED_PUBKEYTYPE set", "COMPRESSED_PUBKEYTYPE set",
SCRIPT_VERIFY_STRICTENC | SCRIPT_VERIFY_STRICTENC |
SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE) SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE)
.PushSigSchnorr(keys.key0, SigHashType()) .PushSigSchnorr(keys.key0, SigHashType())
.ScriptError(SCRIPT_ERR_NONCOMPRESSED_PUBKEY)); .SetScriptError(ScriptError::NONCOMPRESSED_PUBKEY));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
"Schnorr P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC) "Schnorr P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key0, SigHashType()) .PushSigSchnorr(keys.key0, SigHashType())
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .SetScriptError(ScriptError::PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
"Schnorr P2PK with hybrid pubkey but no STRICTENC", 0) "Schnorr P2PK with hybrid pubkey but no STRICTENC", 0)
.PushSigSchnorr(keys.key0)); .PushSigSchnorr(keys.key0));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT, CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
"Schnorr P2PK NOT with damaged hybrid pubkey but no STRICTENC", 0) "Schnorr P2PK NOT with damaged hybrid pubkey but no STRICTENC", 0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.DamagePush(10)); .DamagePush(10));
// Ensure sighash types get checked with schnorr // Ensure sighash types get checked with schnorr
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"Schnorr P2PK with undefined basehashtype and STRICTENC", "Schnorr P2PK with undefined basehashtype and STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key1, SigHashType(5)) .PushSigSchnorr(keys.key1, SigHashType(5))
.ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); .SetScriptError(ScriptError::SIG_HASHTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_DUP << OP_HASH160 TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey0.GetID()) << ToByteVector(keys.pubkey0.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"Schnorr P2PKH with invalid sighashtype but no STRICTENC", "Schnorr P2PKH with invalid sighashtype but no STRICTENC",
0) 0)
.PushSigSchnorr(keys.key0, SigHashType(0x21), Amount::zero(), 0) .PushSigSchnorr(keys.key0, SigHashType(0x21), Amount::zero(), 0)
.Push(keys.pubkey0)); .Push(keys.pubkey0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_DUP << OP_HASH160 TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey0.GetID()) << ToByteVector(keys.pubkey0.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"Schnorr P2PKH with invalid sighashtype and STRICTENC", "Schnorr P2PKH with invalid sighashtype and STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key0, SigHashType(0x21), Amount::zero(), .PushSigSchnorr(keys.key0, SigHashType(0x21), Amount::zero(),
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Push(keys.pubkey0) .Push(keys.pubkey0)
.ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); .SetScriptError(ScriptError::SIG_HASHTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"Schnorr P2PK anyonecanpay", 0) "Schnorr P2PK anyonecanpay", 0)
.PushSigSchnorr(keys.key1, SigHashType().withAnyoneCanPay())); .PushSigSchnorr(keys.key1, SigHashType().withAnyoneCanPay()));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"Schnorr P2PK anyonecanpay marked with normal hashtype", 0) "Schnorr P2PK anyonecanpay marked with normal hashtype", 0)
.PushSigSchnorr(keys.key1, SigHashType().withAnyoneCanPay()) .PushSigSchnorr(keys.key1, SigHashType().withAnyoneCanPay())
.EditPush(64, "81", "01") .EditPush(64, "81", "01")
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"Schnorr P2PK with forkID", "Schnorr P2PK with forkID",
SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID) SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID)
.PushSigSchnorr(keys.key1, SigHashType().withForkId())); .PushSigSchnorr(keys.key1, SigHashType().withForkId()));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"Schnorr P2PK with non-forkID sig", "Schnorr P2PK with non-forkID sig",
SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID) SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID)
.PushSigSchnorr(keys.key1) .PushSigSchnorr(keys.key1)
.ScriptError(SCRIPT_ERR_MUST_USE_FORKID)); .SetScriptError(ScriptError::MUST_USE_FORKID));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"Schnorr P2PK with cheater forkID bit", "Schnorr P2PK with cheater forkID bit",
SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID) SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID)
.PushSigSchnorr(keys.key1) .PushSigSchnorr(keys.key1)
.EditPush(64, "01", "41") .EditPush(64, "01", "41")
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
{ {
// There is a point with x = 7 + order but not x = 7. // There is a point with x = 7 + order but not x = 7.
// Since r = x mod order, this can have valid signatures, as // Since r = x mod order, this can have valid signatures, as
// demonstrated here. // demonstrated here.
std::vector<uint8_t> rdata{7}; std::vector<uint8_t> rdata{7};
std::vector<uint8_t> sdata{7}; std::vector<uint8_t> sdata{7};
tests.push_back(TestBuilder(CScript() << OP_CHECKSIG, tests.push_back(TestBuilder(CScript() << OP_CHECKSIG,
Show All 21 Lines tests.push_back(
"776879206d757374207765207375666665722077697468206563647361"); "776879206d757374207765207375666665722077697468206563647361");
std::vector<uint8_t> sdata(58 - rdata.size(), 33); std::vector<uint8_t> sdata(58 - rdata.size(), 33);
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_CHECKSIG, TestBuilder(CScript() << OP_CHECKSIG,
"recovered-pubkey CHECKSIG with 64-byte DER", "recovered-pubkey CHECKSIG with 64-byte DER",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushECDSASigFromParts(rdata, sdata) .PushECDSASigFromParts(rdata, sdata)
.PushECDSARecoveredPubKey(rdata, sdata) .PushECDSARecoveredPubKey(rdata, sdata)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .SetScriptError(ScriptError::EVAL_FALSE));
} }
{ {
std::vector<uint8_t> rdata = ParseHex( std::vector<uint8_t> rdata = ParseHex(
"776879206d757374207765207375666665722077697468206563647361"); "776879206d757374207765207375666665722077697468206563647361");
std::vector<uint8_t> sdata(58 - rdata.size() + 1, 33); std::vector<uint8_t> sdata(58 - rdata.size() + 1, 33);
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_CHECKSIG, TestBuilder(CScript() << OP_CHECKSIG,
"recovered-pubkey CHECKSIG with 65-byte DER", "recovered-pubkey CHECKSIG with 65-byte DER",
Show All 9 Lines tests.push_back(
tests.push_back( tests.push_back(
TestBuilder(CScript() TestBuilder(CScript()
<< OP_1 << OP_SWAP << OP_1 << OP_CHECKMULTISIG, << OP_1 << OP_SWAP << OP_1 << OP_CHECKMULTISIG,
"recovered-pubkey CHECKMULTISIG with 64-byte DER", "recovered-pubkey CHECKMULTISIG with 64-byte DER",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushECDSASigFromParts(rdata, sdata) .PushECDSASigFromParts(rdata, sdata)
.PushECDSARecoveredPubKey(rdata, sdata) .PushECDSARecoveredPubKey(rdata, sdata)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
} }
// New-multisig tests follow. New multisig will activate with a bunch of // New-multisig tests follow. New multisig will activate with a bunch of
// related flags active from other upgrades, so we do tests with this group // related flags active from other upgrades, so we do tests with this group
// of flags turned on: // of flags turned on:
uint32_t newmultisigflags = uint32_t newmultisigflags =
SCRIPT_ENABLE_SCHNORR_MULTISIG | SCRIPT_VERIFY_NULLFAIL | SCRIPT_ENABLE_SCHNORR_MULTISIG | SCRIPT_VERIFY_NULLFAIL |
SCRIPT_VERIFY_MINIMALDATA | SCRIPT_VERIFY_STRICTENC; SCRIPT_VERIFY_MINIMALDATA | SCRIPT_VERIFY_STRICTENC;
Show All 12 Lines
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey0H) << OP_2 << ToByteVector(keys.pubkey0H) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"1-of-2 with checked hybrid pubkey with SCHNORR_MULTISIG", "1-of-2 with checked hybrid pubkey with SCHNORR_MULTISIG",
newmultisigflags) newmultisigflags)
.Num(0) .Num(0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .SetScriptError(ScriptError::PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG but no STRICTENC", "Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG but no STRICTENC",
newmultisigflags & ~SCRIPT_VERIFY_STRICTENC) newmultisigflags & ~SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIG, << OP_1 << OP_CHECKMULTISIG,
"Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG", "Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG",
newmultisigflags) newmultisigflags)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"Legacy 3-of-3 Schnorr w/ SCHNORR_MULTISIG", "Legacy 3-of-3 Schnorr w/ SCHNORR_MULTISIG",
newmultisigflags) newmultisigflags)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.PushSigSchnorr(keys.key1) .PushSigSchnorr(keys.key1)
.PushSigSchnorr(keys.key2) .PushSigSchnorr(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"Legacy 3-of-3 mixed Schnorr-ECDSA w/ SCHNORR_MULTISIG", "Legacy 3-of-3 mixed Schnorr-ECDSA w/ SCHNORR_MULTISIG",
newmultisigflags) newmultisigflags)
.Num(0) .Num(0)
.PushSigECDSA(keys.key0) .PushSigECDSA(keys.key0)
.PushSigECDSA(keys.key1) .PushSigECDSA(keys.key1)
.PushSigSchnorr(keys.key2) .PushSigSchnorr(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
{ {
// Try valid 64-byte ECDSA sig in multisig. // Try valid 64-byte ECDSA sig in multisig.
std::vector<uint8_t> rdata = ParseHex( std::vector<uint8_t> rdata = ParseHex(
"776879206d757374207765207375666665722077697468206563647361"); "776879206d757374207765207375666665722077697468206563647361");
std::vector<uint8_t> sdata(58 - rdata.size(), 33); std::vector<uint8_t> sdata(58 - rdata.size(), 33);
tests.push_back(TestBuilder(CScript() << OP_1 << OP_SWAP << OP_1 tests.push_back(TestBuilder(CScript() << OP_1 << OP_SWAP << OP_1
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"recovered-pubkey CHECKMULTISIG with " "recovered-pubkey CHECKMULTISIG with "
"64-byte DER w/ SCHNORR_MULTISIG", "64-byte DER w/ SCHNORR_MULTISIG",
newmultisigflags) newmultisigflags)
.Num(0) .Num(0)
.PushECDSASigFromParts(rdata, sdata) .PushECDSASigFromParts(rdata, sdata)
.PushECDSARecoveredPubKey(rdata, sdata) .PushECDSARecoveredPubKey(rdata, sdata)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .SetScriptError(ScriptError::SIG_BADLENGTH));
} }
std::set<std::string> tests_set; std::set<std::string> tests_set;
{ {
UniValue json_tests = read_json(std::string( UniValue json_tests = read_json(std::string(
json_tests::script_tests, json_tests::script_tests,
json_tests::script_tests + sizeof(json_tests::script_tests))); json_tests::script_tests + sizeof(json_tests::script_tests)));
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines for (unsigned int idx = 0; idx < tests.size(); idx++) {
} }
std::string scriptSigString = test[pos++].get_str(); std::string scriptSigString = test[pos++].get_str();
std::string scriptPubKeyString = test[pos++].get_str(); std::string scriptPubKeyString = test[pos++].get_str();
try { try {
CScript scriptSig = ParseScript(scriptSigString); CScript scriptSig = ParseScript(scriptSigString);
CScript scriptPubKey = ParseScript(scriptPubKeyString); CScript scriptPubKey = ParseScript(scriptPubKeyString);
unsigned int scriptflags = ParseScriptFlags(test[pos++].get_str()); unsigned int scriptflags = ParseScriptFlags(test[pos++].get_str());
int scriptError = ParseScriptError(test[pos++].get_str()); ScriptError scriptError = ParseScriptError(test[pos++].get_str());
DoTest(scriptPubKey, scriptSig, scriptflags, strTest, scriptError, DoTest(scriptPubKey, scriptSig, scriptflags, strTest, scriptError,
nValue); nValue);
} catch (std::runtime_error &e) { } catch (std::runtime_error &e) {
BOOST_TEST_MESSAGE("Script test failed. scriptSig: " BOOST_TEST_MESSAGE("Script test failed. scriptSig: "
<< scriptSigString << scriptSigString
<< " scriptPubKey: " << scriptPubKeyString); << " scriptPubKey: " << scriptPubKeyString);
BOOST_TEST_MESSAGE("Exception: " << e.what()); BOOST_TEST_MESSAGE("Exception: " << e.what());
Show All 10 LinesBOOST_AUTO_TEST_CASE(script_PushData) {
static const uint8_t pushdata2[] = {OP_PUSHDATA2, 1, 0, 0x5a}; static const uint8_t pushdata2[] = {OP_PUSHDATA2, 1, 0, 0x5a};
static const uint8_t pushdata4[] = {OP_PUSHDATA4, 1, 0, 0, 0, 0x5a}; static const uint8_t pushdata4[] = {OP_PUSHDATA4, 1, 0, 0, 0, 0x5a};
ScriptError err; ScriptError err;
std::vector<std::vector<uint8_t>> directStack; std::vector<std::vector<uint8_t>> directStack;
BOOST_CHECK(EvalScript(directStack, BOOST_CHECK(EvalScript(directStack,
CScript(&direct[0], &direct[sizeof(direct)]), CScript(&direct[0], &direct[sizeof(direct)]),
SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err)); SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
std::vector<std::vector<uint8_t>> pushdata1Stack; std::vector<std::vector<uint8_t>> pushdata1Stack;
BOOST_CHECK(EvalScript( BOOST_CHECK(EvalScript(
pushdata1Stack, CScript(&pushdata1[0], &pushdata1[sizeof(pushdata1)]), pushdata1Stack, CScript(&pushdata1[0], &pushdata1[sizeof(pushdata1)]),
SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err)); SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
BOOST_CHECK(pushdata1Stack == directStack); BOOST_CHECK(pushdata1Stack == directStack);
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
std::vector<std::vector<uint8_t>> pushdata2Stack; std::vector<std::vector<uint8_t>> pushdata2Stack;
BOOST_CHECK(EvalScript( BOOST_CHECK(EvalScript(
pushdata2Stack, CScript(&pushdata2[0], &pushdata2[sizeof(pushdata2)]), pushdata2Stack, CScript(&pushdata2[0], &pushdata2[sizeof(pushdata2)]),
SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err)); SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
BOOST_CHECK(pushdata2Stack == directStack); BOOST_CHECK(pushdata2Stack == directStack);
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
std::vector<std::vector<uint8_t>> pushdata4Stack; std::vector<std::vector<uint8_t>> pushdata4Stack;
BOOST_CHECK(EvalScript( BOOST_CHECK(EvalScript(
pushdata4Stack, CScript(&pushdata4[0], &pushdata4[sizeof(pushdata4)]), pushdata4Stack, CScript(&pushdata4[0], &pushdata4[sizeof(pushdata4)]),
SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err)); SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
BOOST_CHECK(pushdata4Stack == directStack); BOOST_CHECK(pushdata4Stack == directStack);
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
} }
static CScript sign_multisig(const CScript &scriptPubKey, static CScript sign_multisig(const CScript &scriptPubKey,
const std::vector<CKey> &keys, const std::vector<CKey> &keys,
const CTransaction &transaction) { const CTransaction &transaction) {
uint256 hash = SignatureHash(scriptPubKey, transaction, 0, SigHashType(), uint256 hash = SignatureHash(scriptPubKey, transaction, 0, SigHashType(),
Amount::zero()); Amount::zero());
Show All 39 LinesBOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12) {
CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), txFrom12); CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), txFrom12);
CScript goodsig1 = CScript goodsig1 =
sign_multisig(scriptPubKey12, key1, CTransaction(txTo12)); sign_multisig(scriptPubKey12, key1, CTransaction(txTo12));
BOOST_CHECK(VerifyScript( BOOST_CHECK(VerifyScript(
goodsig1, scriptPubKey12, gFlags, goodsig1, scriptPubKey12, gFlags,
MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
txTo12.vout[0].nValue = 2 * SATOSHI; txTo12.vout[0].nValue = 2 * SATOSHI;
BOOST_CHECK(!VerifyScript( BOOST_CHECK(!VerifyScript(
goodsig1, scriptPubKey12, gFlags, goodsig1, scriptPubKey12, gFlags,
MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
CScript goodsig2 = CScript goodsig2 =
sign_multisig(scriptPubKey12, key2, CTransaction(txTo12)); sign_multisig(scriptPubKey12, key2, CTransaction(txTo12));
BOOST_CHECK(VerifyScript( BOOST_CHECK(VerifyScript(
goodsig2, scriptPubKey12, gFlags, goodsig2, scriptPubKey12, gFlags,
MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
CScript badsig1 = sign_multisig(scriptPubKey12, key3, CTransaction(txTo12)); CScript badsig1 = sign_multisig(scriptPubKey12, key3, CTransaction(txTo12));
BOOST_CHECK(!VerifyScript( BOOST_CHECK(!VerifyScript(
badsig1, scriptPubKey12, gFlags, badsig1, scriptPubKey12, gFlags,
MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
} }
BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23) { BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23) {
ScriptError err; ScriptError err;
CKey key1, key2, key3, key4; CKey key1, key2, key3, key4;
key1.MakeNewKey(true); key1.MakeNewKey(true);
key2.MakeNewKey(false); key2.MakeNewKey(false);
key3.MakeNewKey(true); key3.MakeNewKey(true);
Show All 18 LinesBOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23) {
std::vector<CKey> keys; std::vector<CKey> keys;
keys.push_back(key1); keys.push_back(key1);
keys.push_back(key2); keys.push_back(key2);
CScript goodsig1 = sign_multisig(scriptPubKey23, keys, txTo23); CScript goodsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
BOOST_CHECK(VerifyScript( BOOST_CHECK(VerifyScript(
goodsig1, scriptPubKey23, gFlags, goodsig1, scriptPubKey23, gFlags,
TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
keys.clear(); keys.clear();
keys.push_back(key1); keys.push_back(key1);
keys.push_back(key3); keys.push_back(key3);
CScript goodsig2 = sign_multisig(scriptPubKey23, keys, txTo23); CScript goodsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
BOOST_CHECK(VerifyScript( BOOST_CHECK(VerifyScript(
goodsig2, scriptPubKey23, gFlags, goodsig2, scriptPubKey23, gFlags,
TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
keys.clear(); keys.clear();
keys.push_back(key2); keys.push_back(key2);
keys.push_back(key3); keys.push_back(key3);
CScript goodsig3 = sign_multisig(scriptPubKey23, keys, txTo23); CScript goodsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
BOOST_CHECK(VerifyScript( BOOST_CHECK(VerifyScript(
goodsig3, scriptPubKey23, gFlags, goodsig3, scriptPubKey23, gFlags,
TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
keys.clear(); keys.clear();
keys.push_back(key2); keys.push_back(key2);
keys.push_back(key2); // Can't re-use sig keys.push_back(key2); // Can't re-use sig
CScript badsig1 = sign_multisig(scriptPubKey23, keys, txTo23); CScript badsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
BOOST_CHECK(!VerifyScript( BOOST_CHECK(!VerifyScript(
badsig1, scriptPubKey23, gFlags, badsig1, scriptPubKey23, gFlags,
TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
keys.clear(); keys.clear();
keys.push_back(key2); keys.push_back(key2);
keys.push_back(key1); // sigs must be in correct order keys.push_back(key1); // sigs must be in correct order
CScript badsig2 = sign_multisig(scriptPubKey23, keys, txTo23); CScript badsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
BOOST_CHECK(!VerifyScript( BOOST_CHECK(!VerifyScript(
badsig2, scriptPubKey23, gFlags, badsig2, scriptPubKey23, gFlags,
TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
keys.clear(); keys.clear();
keys.push_back(key3); keys.push_back(key3);
keys.push_back(key2); // sigs must be in correct order keys.push_back(key2); // sigs must be in correct order
CScript badsig3 = sign_multisig(scriptPubKey23, keys, txTo23); CScript badsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
BOOST_CHECK(!VerifyScript( BOOST_CHECK(!VerifyScript(
badsig3, scriptPubKey23, gFlags, badsig3, scriptPubKey23, gFlags,
TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
keys.clear(); keys.clear();
keys.push_back(key4); keys.push_back(key4);
keys.push_back(key2); // sigs must match pubkeys keys.push_back(key2); // sigs must match pubkeys
CScript badsig4 = sign_multisig(scriptPubKey23, keys, txTo23); CScript badsig4 = sign_multisig(scriptPubKey23, keys, txTo23);
BOOST_CHECK(!VerifyScript( BOOST_CHECK(!VerifyScript(
badsig4, scriptPubKey23, gFlags, badsig4, scriptPubKey23, gFlags,
TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
keys.clear(); keys.clear();
keys.push_back(key1); keys.push_back(key1);
keys.push_back(key4); // sigs must match pubkeys keys.push_back(key4); // sigs must match pubkeys
CScript badsig5 = sign_multisig(scriptPubKey23, keys, txTo23); CScript badsig5 = sign_multisig(scriptPubKey23, keys, txTo23);
BOOST_CHECK(!VerifyScript( BOOST_CHECK(!VerifyScript(
badsig5, scriptPubKey23, gFlags, badsig5, scriptPubKey23, gFlags,
TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
keys.clear(); // Must have signatures keys.clear(); // Must have signatures
CScript badsig6 = sign_multisig(scriptPubKey23, keys, txTo23); CScript badsig6 = sign_multisig(scriptPubKey23, keys, txTo23);
BOOST_CHECK(!VerifyScript( BOOST_CHECK(!VerifyScript(
badsig6, scriptPubKey23, gFlags, badsig6, scriptPubKey23, gFlags,
TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
&err)); &err));
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, BOOST_CHECK_MESSAGE(err == ScriptError::INVALID_STACK_OPERATION,
ScriptErrorString(err)); ScriptErrorString(err));
} }
BOOST_AUTO_TEST_CASE(script_combineSigs) { BOOST_AUTO_TEST_CASE(script_combineSigs) {
// Test the CombineSignatures function // Test the CombineSignatures function
Amount amount = Amount::zero(); Amount amount = Amount::zero();
CBasicKeyStore keystore; CBasicKeyStore keystore;
std::vector<CKey> keys; std::vector<CKey> keys;
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines for (int i = 0; i < 67000; i++) {
CScript script; CScript script;
script << i; script << i;
BOOST_CHECK_MESSAGE(script.IsPushOnly(), BOOST_CHECK_MESSAGE(script.IsPushOnly(),
"Number " << i << " is not pure push."); "Number " << i << " is not pure push.");
BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1, BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1,
SCRIPT_VERIFY_MINIMALDATA, SCRIPT_VERIFY_MINIMALDATA,
BaseSignatureChecker(), &err), BaseSignatureChecker(), &err),
"Number " << i << " push is not minimal data."); "Number " << i << " push is not minimal data.");
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
} }
for (unsigned int i = 0; i <= MAX_SCRIPT_ELEMENT_SIZE; i++) { for (unsigned int i = 0; i <= MAX_SCRIPT_ELEMENT_SIZE; i++) {
std::vector<uint8_t> data(i, '\111'); std::vector<uint8_t> data(i, '\111');
CScript script; CScript script;
script << data; script << data;
BOOST_CHECK_MESSAGE(script.IsPushOnly(), BOOST_CHECK_MESSAGE(script.IsPushOnly(),
"Length " << i << " is not pure push."); "Length " << i << " is not pure push.");
BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1, BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1,
SCRIPT_VERIFY_MINIMALDATA, SCRIPT_VERIFY_MINIMALDATA,
BaseSignatureChecker(), &err), BaseSignatureChecker(), &err),
"Length " << i << " push is not minimal data."); "Length " << i << " push is not minimal data.");
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
} }
} }
BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts) { BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts) {
// IsPushOnly returns false when given a script containing only pushes that // IsPushOnly returns false when given a script containing only pushes that
// are invalid due to truncation. IsPushOnly() is consensus critical because // are invalid due to truncation. IsPushOnly() is consensus critical because
// P2SH evaluation uses it, although this specific behavior should not be // P2SH evaluation uses it, although this specific behavior should not be
// consensus critical as the P2SH evaluation would fail first due to the // consensus critical as the P2SH evaluation would fail first due to the
▲ Show 20 Lines • Show All 308 Lines • Show Last 20 Lines