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

Changeset View

Standalone View

View Options

src/test/checkdatasig_tests.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines CheckErrorForAllFlags({{0x00}, {0x00}}, CScript() << OP_CHECKDATASIG,
SCRIPT_ERR_INVALID_STACK_OPERATION); SCRIPT_ERR_INVALID_STACK_OPERATION);
CheckErrorForAllFlags({}, CScript() << OP_CHECKDATASIGVERIFY, CheckErrorForAllFlags({}, CScript() << OP_CHECKDATASIGVERIFY,
SCRIPT_ERR_INVALID_STACK_OPERATION); SCRIPT_ERR_INVALID_STACK_OPERATION);
CheckErrorForAllFlags({{0x00}}, CScript() << OP_CHECKDATASIGVERIFY, CheckErrorForAllFlags({{0x00}}, CScript() << OP_CHECKDATASIGVERIFY,
SCRIPT_ERR_INVALID_STACK_OPERATION); SCRIPT_ERR_INVALID_STACK_OPERATION);
CheckErrorForAllFlags({{0x00}, {0x00}}, CScript() << OP_CHECKDATASIGVERIFY, CheckErrorForAllFlags({{0x00}, {0x00}}, CScript() << OP_CHECKDATASIGVERIFY,
SCRIPT_ERR_INVALID_STACK_OPERATION); SCRIPT_ERR_INVALID_STACK_OPERATION);
// Check invalid message sizes.
for (valtype message; message.size() < 42; message.push_back(0x00)) {
if (message.size() == 32) {
// 32 is the expected size, skip.
continue;
}
CheckErrorForAllFlags({{0x00}, message, {0x00}},
CScript() << OP_CHECKDATASIG,
SCRIPT_ERR_INVALID_OPERAND_SIZE);
CheckErrorForAllFlags({{0x00}, message, {0x00}},
CScript() << OP_CHECKDATASIGVERIFY,
SCRIPT_ERR_INVALID_OPERAND_SIZE);
}
// Check various pubkey encoding. // Check various pubkey encoding.
const valtype message(32, 0x00); const valtype message{};
CHashWriter ss(SER_GETHASH, 0);
ss << message;
uint256 messageHash = ss.GetHash();
KeyData kd; KeyData kd;
valtype pubkey = ToByteVector(kd.pubkey); valtype pubkey = ToByteVector(kd.pubkey);
valtype pubkeyC = ToByteVector(kd.pubkeyC); valtype pubkeyC = ToByteVector(kd.pubkeyC);
valtype pubkeyH = ToByteVector(kd.pubkeyH); valtype pubkeyH = ToByteVector(kd.pubkeyH);
CheckTestResultForAllFlags({{}, message, pubkey}, CheckTestResultForAllFlags({{}, message, pubkey},
CScript() << OP_CHECKDATASIG, {{}}); CScript() << OP_CHECKDATASIG, {{}});
CheckTestResultForAllFlags({{}, message, pubkeyC}, CheckTestResultForAllFlags({{}, message, pubkeyC},
CScript() << OP_CHECKDATASIG, {{}}); CScript() << OP_CHECKDATASIG, {{}});
CheckErrorForAllFlags({{}, message, pubkey}, CheckErrorForAllFlags({{}, message, pubkey},
CScript() << OP_CHECKDATASIGVERIFY, CScript() << OP_CHECKDATASIGVERIFY,
SCRIPT_ERR_CHECKDATASIGVERIFY); SCRIPT_ERR_CHECKDATASIGVERIFY);
CheckErrorForAllFlags({{}, message, pubkeyC}, CheckErrorForAllFlags({{}, message, pubkeyC},
CScript() << OP_CHECKDATASIGVERIFY, CScript() << OP_CHECKDATASIGVERIFY,
SCRIPT_ERR_CHECKDATASIGVERIFY); SCRIPT_ERR_CHECKDATASIGVERIFY);
// Flags dependent checks. // Flags dependent checks.
const CScript script = CScript() << OP_CHECKDATASIG << OP_NOT << OP_VERIFY; const CScript script = CScript() << OP_CHECKDATASIG << OP_NOT << OP_VERIFY;
const CScript scriptverify = CScript() << OP_CHECKDATASIGVERIFY; const CScript scriptverify = CScript() << OP_CHECKDATASIGVERIFY;
// Check valid signatures. // Check valid signatures (as in the signature format is valid).
const uint256 one(uint256S(
"0000000000000000000000000000000000000000000000000000000000000001"));
const uint256 two(uint256S(
"0000000000000000000000000000000000000000000000000000000000000002"));
valtype validsig; valtype validsig;
kd.privkey.Sign(one, validsig); kd.privkey.Sign(messageHash, validsig);
CheckTestResultForAllFlags({validsig, ToByteVector(one), pubkey}, CheckTestResultForAllFlags({validsig, message, pubkey},
CScript() << OP_CHECKDATASIG, {{0x01}}); CScript() << OP_CHECKDATASIG, {{0x01}});
CheckTestResultForAllFlags({validsig, ToByteVector(one), pubkey}, CheckTestResultForAllFlags({validsig, message, pubkey},
CScript() << OP_CHECKDATASIGVERIFY, {}); CScript() << OP_CHECKDATASIGVERIFY, {});
const valtype minimalsig{0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01}; const valtype minimalsig{0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01};
const valtype nondersig{0x30, 0x80, 0x06, 0x02, 0x01, const valtype nondersig{0x30, 0x80, 0x06, 0x02, 0x01,
0x01, 0x02, 0x01, 0x01}; 0x01, 0x02, 0x01, 0x01};
const valtype highSSig{ const valtype highSSig{
0x30, 0x45, 0x02, 0x20, 0x3e, 0x45, 0x16, 0xda, 0x72, 0x53, 0xcf, 0x06, 0x30, 0x45, 0x02, 0x20, 0x3e, 0x45, 0x16, 0xda, 0x72, 0x53, 0xcf, 0x06,
0x8e, 0xff, 0xec, 0x6b, 0x95, 0xc4, 0x12, 0x21, 0xc0, 0xcf, 0x3a, 0x8e, 0x8e, 0xff, 0xec, 0x6b, 0x95, 0xc4, 0x12, 0x21, 0xc0, 0xcf, 0x3a, 0x8e,
Show All 24 Lines for (uint32_t flags = 0; flags < (1U << 17); flags++) {
if (flags & SCRIPT_VERIFY_NULLFAIL) { if (flags & SCRIPT_VERIFY_NULLFAIL) {
// When strict encoding is enforced, hybrid key are invalid. // When strict encoding is enforced, hybrid key are invalid.
CheckError(flags, {minimalsig, message, pubkey}, script, CheckError(flags, {minimalsig, message, pubkey}, script,
SCRIPT_ERR_SIG_NULLFAIL); SCRIPT_ERR_SIG_NULLFAIL);
CheckError(flags, {minimalsig, message, pubkey}, scriptverify, CheckError(flags, {minimalsig, message, pubkey}, scriptverify,
SCRIPT_ERR_SIG_NULLFAIL); SCRIPT_ERR_SIG_NULLFAIL);
// Invalid message cause checkdatasig to fail. // Invalid message cause checkdatasig to fail.
CheckError(flags, {validsig, ToByteVector(two), pubkey}, script, CheckError(flags, {validsig, {0x01}, pubkey}, script,
SCRIPT_ERR_SIG_NULLFAIL);
CheckError(flags, {validsig, {0x01}, pubkey}, scriptverify,
SCRIPT_ERR_SIG_NULLFAIL); SCRIPT_ERR_SIG_NULLFAIL);
CheckError(flags, {validsig, ToByteVector(two), pubkey},
scriptverify, SCRIPT_ERR_SIG_NULLFAIL);
} else { } else {
// When nullfail is not enforced, invalid signature are just false. // When nullfail is not enforced, invalid signature are just false.
CheckPass(flags, {minimalsig, message, pubkey}, script, {}); CheckPass(flags, {minimalsig, message, pubkey}, script, {});
CheckError(flags, {minimalsig, message, pubkey}, scriptverify, CheckError(flags, {minimalsig, message, pubkey}, scriptverify,
SCRIPT_ERR_CHECKDATASIGVERIFY); SCRIPT_ERR_CHECKDATASIGVERIFY);
// Invalid message cause checkdatasig to fail. // Invalid message cause checkdatasig to fail.
CheckPass(flags, {validsig, ToByteVector(two), pubkey}, script, {}); CheckPass(flags, {validsig, {0x01}, pubkey}, script, {});
CheckError(flags, {validsig, ToByteVector(two), pubkey}, CheckError(flags, {validsig, {0x01}, pubkey}, scriptverify,
scriptverify, SCRIPT_ERR_CHECKDATASIGVERIFY); SCRIPT_ERR_CHECKDATASIGVERIFY);
} }
if (flags & SCRIPT_VERIFY_LOW_S) { if (flags & SCRIPT_VERIFY_LOW_S) {
// If we do enforce low S, then high S sigs are rejected. // If we do enforce low S, then high S sigs are rejected.
CheckError(flags, {highSSig, message, pubkey}, script, CheckError(flags, {highSSig, message, pubkey}, script,
SCRIPT_ERR_SIG_HIGH_S); SCRIPT_ERR_SIG_HIGH_S);
CheckError(flags, {highSSig, message, pubkey}, scriptverify, CheckError(flags, {highSSig, message, pubkey}, scriptverify,
SCRIPT_ERR_SIG_HIGH_S); SCRIPT_ERR_SIG_HIGH_S);
Show All 25 Lines