Page MenuHomePhabricator
Differential D3265 Diff 9767 src/test/sigencoding_tests.cpp

Changeset View

Standalone View

View Options

src/test/sigencoding_tests.cpp

Show All 38 Linesstatic void CheckSignatureEncodingWithSigHashType(const valtype &vchSig,
for (const SigHashType baseSigHash : baseSigHashes) { for (const SigHashType baseSigHash : baseSigHashes) {
// Check the signature with the proper forkid flag. // Check the signature with the proper forkid flag.
SigHashType sigHash = baseSigHash.withForkId(hasForkId); SigHashType sigHash = baseSigHash.withForkId(hasForkId);
valtype validSig = SignatureWithHashType(vchSig, sigHash); valtype validSig = SignatureWithHashType(vchSig, sigHash);
BOOST_CHECK(CheckTransactionSignatureEncoding(validSig, flags, &err)); BOOST_CHECK(CheckTransactionSignatureEncoding(validSig, flags, &err));
BOOST_CHECK_EQUAL(!is64, CheckTransactionECDSASignatureEncoding( BOOST_CHECK_EQUAL(!is64, CheckTransactionECDSASignatureEncoding(
validSig, flags, &err)); validSig, flags, &err));
BOOST_CHECK_EQUAL(is64, CheckTransactionSchnorrSignatureEncoding(
validSig, flags, &err));
// If we have strict encoding, we prevent the use of undefined flags. // If we have strict encoding, we prevent the use of undefined flags.
std::array<SigHashType, 2> undefSigHashes{ std::array<SigHashType, 2> undefSigHashes{
{SigHashType(sigHash.getRawSigHashType() | 0x20), {SigHashType(sigHash.getRawSigHashType() | 0x20),
sigHash.withBaseType(BaseSigHashType::UNSUPPORTED)}}; sigHash.withBaseType(BaseSigHashType::UNSUPPORTED)}};
for (SigHashType undefSigHash : undefSigHashes) { for (SigHashType undefSigHash : undefSigHashes) {
valtype undefSighash = SignatureWithHashType(vchSig, undefSigHash); valtype undefSighash = SignatureWithHashType(vchSig, undefSigHash);
BOOST_CHECK_EQUAL( BOOST_CHECK_EQUAL(
CheckTransactionSignatureEncoding(undefSighash, flags, &err), CheckTransactionSignatureEncoding(undefSighash, flags, &err),
!hasStrictEnc); !hasStrictEnc);
if (hasStrictEnc) { if (hasStrictEnc) {
BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_HASHTYPE); BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_HASHTYPE);
} }
BOOST_CHECK_EQUAL(CheckTransactionECDSASignatureEncoding( BOOST_CHECK_EQUAL(CheckTransactionECDSASignatureEncoding(
undefSighash, flags, &err), undefSighash, flags, &err),
!(hasStrictEnc || is64)); !(hasStrictEnc || is64));
if (is64 || hasStrictEnc) { if (is64 || hasStrictEnc) {
BOOST_CHECK_EQUAL(err, is64 ? SCRIPT_ERR_SIG_BADLENGTH BOOST_CHECK_EQUAL(err, is64 ? SCRIPT_ERR_SIG_BADLENGTH
: SCRIPT_ERR_SIG_HASHTYPE); : SCRIPT_ERR_SIG_HASHTYPE);
} }
BOOST_CHECK_EQUAL(CheckTransactionSchnorrSignatureEncoding(
undefSighash, flags, &err),
!(hasStrictEnc || !is64));
if (!is64 || hasStrictEnc) {
BOOST_CHECK_EQUAL(err, !is64 ? SCRIPT_ERR_SIG_NONSCHNORR
: SCRIPT_ERR_SIG_HASHTYPE);
}
} }
// If we check strict encoding, then invalid forkid is an error. // If we check strict encoding, then invalid forkid is an error.
SigHashType invalidSigHash = baseSigHash.withForkId(!hasForkId); SigHashType invalidSigHash = baseSigHash.withForkId(!hasForkId);
valtype invalidSig = SignatureWithHashType(vchSig, invalidSigHash); valtype invalidSig = SignatureWithHashType(vchSig, invalidSigHash);
BOOST_CHECK_EQUAL( BOOST_CHECK_EQUAL(
CheckTransactionSignatureEncoding(invalidSig, flags, &err), CheckTransactionSignatureEncoding(invalidSig, flags, &err),
!hasStrictEnc); !hasStrictEnc);
if (hasStrictEnc) { if (hasStrictEnc) {
BOOST_CHECK_EQUAL(err, hasForkId ? SCRIPT_ERR_MUST_USE_FORKID BOOST_CHECK_EQUAL(err, hasForkId ? SCRIPT_ERR_MUST_USE_FORKID
: SCRIPT_ERR_ILLEGAL_FORKID); : SCRIPT_ERR_ILLEGAL_FORKID);
} }
BOOST_CHECK_EQUAL( BOOST_CHECK_EQUAL(
CheckTransactionECDSASignatureEncoding(invalidSig, flags, &err), CheckTransactionECDSASignatureEncoding(invalidSig, flags, &err),
!(hasStrictEnc || is64)); !(hasStrictEnc || is64));
if (is64 || hasStrictEnc) { if (is64 || hasStrictEnc) {
BOOST_CHECK_EQUAL(err, is64 BOOST_CHECK_EQUAL(err, is64
? SCRIPT_ERR_SIG_BADLENGTH ? SCRIPT_ERR_SIG_BADLENGTH
: hasForkId ? SCRIPT_ERR_MUST_USE_FORKID : hasForkId ? SCRIPT_ERR_MUST_USE_FORKID
: SCRIPT_ERR_ILLEGAL_FORKID); : SCRIPT_ERR_ILLEGAL_FORKID);
} }
BOOST_CHECK_EQUAL(
CheckTransactionSchnorrSignatureEncoding(invalidSig, flags, &err),
!(hasStrictEnc || !is64));
if (!is64 || hasStrictEnc) {
BOOST_CHECK_EQUAL(err, !is64
? SCRIPT_ERR_SIG_NONSCHNORR
: hasForkId ? SCRIPT_ERR_MUST_USE_FORKID
: SCRIPT_ERR_ILLEGAL_FORKID);
}
} }
} }
BOOST_AUTO_TEST_CASE(checksignatureencoding_test) { BOOST_AUTO_TEST_CASE(checksignatureencoding_test) {
valtype minimalSig{0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01}; valtype minimalSig{0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01};
valtype highSSig{ 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 20 Lines • Show All 85 Lines • ▼ Show 20 Lines for (int i = 0; i < 4096; i++) {
uint32_t flags = lcg.next(); uint32_t flags = lcg.next();
ScriptError err = SCRIPT_ERR_OK; ScriptError err = SCRIPT_ERR_OK;
// Empty sig is always validly encoded. // Empty sig is always validly encoded.
BOOST_CHECK(CheckDataSignatureEncoding({}, flags, &err)); BOOST_CHECK(CheckDataSignatureEncoding({}, flags, &err));
BOOST_CHECK(CheckTransactionSignatureEncoding({}, flags, &err)); BOOST_CHECK(CheckTransactionSignatureEncoding({}, flags, &err));
BOOST_CHECK(CheckTransactionECDSASignatureEncoding({}, flags, &err)); BOOST_CHECK(CheckTransactionECDSASignatureEncoding({}, flags, &err));
BOOST_CHECK(CheckTransactionSchnorrSignatureEncoding({}, flags, &err));
// 64-byte signatures are valid as long as the hashtype is correct. // 64-byte signatures are valid as long as the hashtype is correct.
CheckSignatureEncodingWithSigHashType(Zero64, flags); CheckSignatureEncodingWithSigHashType(Zero64, flags);
// Signatures are valid as long as the hashtype is correct. // Signatures are valid as long as the hashtype is correct.
CheckSignatureEncodingWithSigHashType(minimalSig, flags); CheckSignatureEncodingWithSigHashType(minimalSig, flags);
if (flags & SCRIPT_VERIFY_LOW_S) { if (flags & SCRIPT_VERIFY_LOW_S) {
▲ Show 20 Lines • Show All 212 Lines • ▼ Show 20 Lines for (int i = 0; i < 4096; i++) {
valtype Zero65_hb = valtype Zero65_hb =
SignatureWithHashType(Zero64, SigHashType().withForkId(hasForkId)); SignatureWithHashType(Zero64, SigHashType().withForkId(hasForkId));
BOOST_CHECK(CheckDataSignatureEncoding(DER64, flags, &err)); BOOST_CHECK(CheckDataSignatureEncoding(DER64, flags, &err));
BOOST_CHECK(CheckTransactionSignatureEncoding(DER65_hb, flags, &err)); BOOST_CHECK(CheckTransactionSignatureEncoding(DER65_hb, flags, &err));
BOOST_CHECK( BOOST_CHECK(
!CheckTransactionECDSASignatureEncoding(DER65_hb, flags, &err)); !CheckTransactionECDSASignatureEncoding(DER65_hb, flags, &err));
BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_BADLENGTH); BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_BADLENGTH);
BOOST_CHECK(
CheckTransactionSchnorrSignatureEncoding(DER65_hb, flags, &err));
BOOST_CHECK(CheckDataSignatureEncoding(Zero64, flags, &err)); BOOST_CHECK(CheckDataSignatureEncoding(Zero64, flags, &err));
BOOST_CHECK(CheckTransactionSignatureEncoding(Zero65_hb, flags, &err)); BOOST_CHECK(CheckTransactionSignatureEncoding(Zero65_hb, flags, &err));
BOOST_CHECK( BOOST_CHECK(
!CheckTransactionECDSASignatureEncoding(Zero65_hb, flags, &err)); !CheckTransactionECDSASignatureEncoding(Zero65_hb, flags, &err));
BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_BADLENGTH); BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_BADLENGTH);
BOOST_CHECK(
CheckTransactionSchnorrSignatureEncoding(Zero65_hb, flags, &err));
} }
} }
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()