Page MenuHomePhabricator
Differential D1646 Diff 4580 src/test/script_tests.cpp

Changeset View

Standalone View

View Options

src/test/script_tests.cpp

Show First 20 Lines • Show All 336 Lines • ▼ Show 20 Lines TestBuilder &PushSig(const CKey &key,
uint256 hash = SignatureHash(script, CTransaction(spendTx), 0, uint256 hash = SignatureHash(script, CTransaction(spendTx), 0,
sigHashType, amount, nullptr, flags); sigHashType, amount, nullptr, flags);
std::vector<uint8_t> vchSig = DoSign(key, hash, lenR, lenS); std::vector<uint8_t> vchSig = DoSign(key, hash, lenR, lenS);
vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType())); vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType()));
DoPush(vchSig); DoPush(vchSig);
return *this; return *this;
} }
TestBuilder &PushDataSig(const CKey &key, const uint256 &hash, TestBuilder &PushDataSig(const CKey &key, const std::vector<uint8_t> &data,
unsigned int lenR = 32, unsigned int lenS = 32) { unsigned int lenR = 32, unsigned int lenS = 32) {
DoPush(DoSign(key, hash, lenR, lenS)); CHashWriter ss(SER_GETHASH, 0);
ss << data;
DoPush(DoSign(key, ss.GetHash(), lenR, lenS));
return *this; return *this;
} }
TestBuilder &Push(const CPubKey &pubkey) { TestBuilder &Push(const CPubKey &pubkey) {
DoPush(std::vector<uint8_t>(pubkey.begin(), pubkey.end())); DoPush(std::vector<uint8_t>(pubkey.begin(), pubkey.end()));
return *this; return *this;
} }
▲ Show 20 Lines • Show All 766 Lines • ▼ Show 20 Lines tests.push_back(
SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_ENABLE_SIGHASH_FORKID |
SCRIPT_ENABLE_REPLAY_PROTECTION, SCRIPT_ENABLE_REPLAY_PROTECTION,
false, TEST_AMOUNT) false, TEST_AMOUNT)
.PushSig(keys.key0, SigHashType().withForkId(), 32, 32, TEST_AMOUNT, .PushSig(keys.key0, SigHashType().withForkId(), 32, 32, TEST_AMOUNT,
SCRIPT_ENABLE_SIGHASH_FORKID) SCRIPT_ENABLE_SIGHASH_FORKID)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
// Test OP_CHECKDATASIG // Test OP_CHECKDATASIG
static const uint256 one(uint256S(
"0000000000000000000000000000000000000000000000000000000000000001"));
static const uint256 two(uint256S(
"0000000000000000000000000000000000000000000000000000000000000002"));
const uint32_t checkdatasigflags = SCRIPT_VERIFY_STRICTENC | const uint32_t checkdatasigflags = SCRIPT_VERIFY_STRICTENC |
SCRIPT_VERIFY_NULLFAIL | SCRIPT_VERIFY_NULLFAIL |
SCRIPT_ENABLE_CHECKDATASIG; SCRIPT_ENABLE_CHECKDATASIG;
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)
.PushDataSig(keys.key1, one) .PushDataSig(keys.key1, {})
.Push(one)); .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)
.PushDataSig(keys.key1, one) .PushDataSig(keys.key1, {})
.Push(two) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); .ScriptError(SCRIPT_ERR_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)
.PushDataSig(keys.key1, one) .PushDataSig(keys.key1, {})
.Push(two)); .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)
.Push(one)); .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)
.PushDataSig(keys.key1, one, 32, 33) .PushDataSig(keys.key1, {}, 32, 33)
.Push(one)); .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)
.PushDataSig(keys.key1, one, 32, 33) .PushDataSig(keys.key1, {}, 32, 33)
.Push(one) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .ScriptError(SCRIPT_ERR_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)
.PushDataSig(keys.key1, one, 33, 32) .PushDataSig(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Push(one)); .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)
.PushDataSig(keys.key1, one, 33, 32) .PushDataSig(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Push(one) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_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)
.PushDataSig(keys.key0, one) .PushDataSig(keys.key0, {})
.Push(one)); .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)
.PushDataSig(keys.key0, one) .PushDataSig(keys.key0, {})
.Push(one) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_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",
SCRIPT_ENABLE_CHECKDATASIG) SCRIPT_ENABLE_CHECKDATASIG)
.PushDataSig(keys.key0, one) .PushDataSig(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Push(one)); .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)
.PushDataSig(keys.key0, one) .PushDataSig(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Push(one) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_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)
.PushDataSig(keys.key1, one) .PushDataSig(keys.key1, {})
.Push(one)); .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)
.PushDataSig(keys.key1, one) .PushDataSig(keys.key1, {})
.Push(two) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); .ScriptError(SCRIPT_ERR_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)
.PushDataSig(keys.key1, one) .PushDataSig(keys.key1, {})
.Push(two) .Num(1)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .ScriptError(SCRIPT_ERR_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)
.Push(one) .Num(0)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .ScriptError(SCRIPT_ERR_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)
.PushDataSig(keys.key1, one, 32, 33) .PushDataSig(keys.key1, {}, 32, 33)
.Push(one)); .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)
.PushDataSig(keys.key1, one, 32, 33) .PushDataSig(keys.key1, {}, 32, 33)
.Push(one) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .ScriptError(SCRIPT_ERR_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)
.PushDataSig(keys.key1, one, 33, 32) .PushDataSig(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Push(one)); .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)
.PushDataSig(keys.key1, one, 33, 32) .PushDataSig(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Push(one) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_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)
.PushDataSig(keys.key0, one) .PushDataSig(keys.key0, {})
.Push(one)); .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)
.PushDataSig(keys.key0, one) .PushDataSig(keys.key0, {})
.Push(one) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_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", "CHECKDATASIGVERIFY with invalid hybrid pubkey but no STRICTENC",
SCRIPT_ENABLE_CHECKDATASIG) SCRIPT_ENABLE_CHECKDATASIG)
.PushDataSig(keys.key0, one) .PushDataSig(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Push(one) .Num(0)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .ScriptError(SCRIPT_ERR_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)
.PushDataSig(keys.key0, one) .PushDataSig(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Push(one) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
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 756 Lines • Show Last 20 Lines