Inside Bitcoin

1251        CHECK_SCRIPT_DYNAMIC_SIZE(script, 67, 67);
1252    }
1253
1254    // Bare multisig needs extra allocation
1255    {
1256        const auto script{GetScriptForMultisig(1, std::vector{2, dummy_pubkey})};
1257        BOOST_CHECK_EQUAL(GetTxoutType(script), TxoutType::MULTISIG);
1258        CHECK_SCRIPT_DYNAMIC_SIZE(script, 71, 103);
1259    }
1260}
1261
1262/* Wrapper around ProduceSignature to combine two scriptsigs */
1263SignatureData CombineSignatures(const CTxOut& txout, const CMutableTransaction& tx, const SignatureData& scriptSig1, const SignatureData& scriptSig2)
1264{
1265    SignatureData data;
1266    data.MergeSignatureData(scriptSig1);
1267    data.MergeSignatureData(scriptSig2);
1268    ProduceSignature(DUMMY_SIGNING_PROVIDER, MutableTransactionSignatureCreator(tx, 0, txout.nValue, {.sighash_type = SIGHASH_DEFAULT}), txout.scriptPubKey, data);
1269    return data;
1270}
1271
1272BOOST_AUTO_TEST_CASE(script_combineSigs)
1273{
1274    // Test the ProduceSignature's ability to combine signatures function
1275    FillableSigningProvider keystore;
1276    std::vector<CKey> keys;
1277    std::vector<CPubKey> pubkeys;
1278    for (int i = 0; i < 3; i++)
1279    {
1280        CKey key = GenerateRandomKey(/*compressed=*/i%2 == 1);
1281        keys.push_back(key);
1282        pubkeys.push_back(key.GetPubKey());
1283        BOOST_CHECK(keystore.AddKey(key));
1284    }
1285
1286    CMutableTransaction txFrom = BuildCreditingTransaction(GetScriptForDestination(PKHash(keys[0].GetPubKey())));
1287    CMutableTransaction txTo = BuildSpendingTransaction(CScript(), CScriptWitness(), CTransaction(txFrom));
1288    CScript& scriptPubKey = txFrom.vout[0].scriptPubKey;
1289    SignatureData scriptSig;
1290
1291    SignatureData empty;
1292    SignatureData combined = CombineSignatures(txFrom.vout[0], txTo, empty, empty);
1293    BOOST_CHECK(combined.scriptSig.empty());
1294
1295    // Single signature case:
1296    SignatureData dummy;
1297    BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy)); // changes scriptSig
1298    scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1299    combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
1300    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1301    combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
1302    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1303    SignatureData scriptSigCopy = scriptSig;
1304    // Signing again will give a different, valid signature:
1305    SignatureData dummy_b;
1306    BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_b));
1307    scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1308    combined = CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
1309    BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig || combined.scriptSig == scriptSig.scriptSig);
1310
1311    // P2SH, single-signature case:
1312    CScript pkSingle; pkSingle << ToByteVector(keys[0].GetPubKey()) << OP_CHECKSIG;
1313    BOOST_CHECK(keystore.AddCScript(pkSingle));
1314    scriptPubKey = GetScriptForDestination(ScriptHash(pkSingle));
1315    SignatureData dummy_c;
1316    BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_c));
1317    scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1318    combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
1319    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1320    combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
1321    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1322    scriptSigCopy = scriptSig;
1323    SignatureData dummy_d;
1324    BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_d));
1325    scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1326    combined = CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
1327    BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig || combined.scriptSig == scriptSig.scriptSig);
1328
1329    // Hardest case:  Multisig 2-of-3
1330    scriptPubKey = GetScriptForMultisig(2, pubkeys);
1331    BOOST_CHECK(keystore.AddCScript(scriptPubKey));
1332    SignatureData dummy_e;
1333    BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_e));
1334    scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1335    combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
1336    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1337    combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
1338    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1339
1340    // A couple of partially-signed versions:
1341    std::vector<unsigned char> sig1;
1342    uint256 hash1 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_ALL, 0, SigVersion::BASE);
1343    BOOST_CHECK(keys[0].Sign(hash1, sig1));
1344    sig1.push_back(SIGHASH_ALL);
1345    std::vector<unsigned char> sig2;
1346    uint256 hash2 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_NONE, 0, SigVersion::BASE);
1347    BOOST_CHECK(keys[1].Sign(hash2, sig2));
1348    sig2.push_back(SIGHASH_NONE);
1349    std::vector<unsigned char> sig3;
1350    uint256 hash3 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_SINGLE, 0, SigVersion::BASE);
1351    BOOST_CHECK(keys[2].Sign(hash3, sig3));
1352    sig3.push_back(SIGHASH_SINGLE);
1353
1354    // Not fussy about order (or even existence) of placeholders or signatures:
1355    CScript partial1a = CScript() << OP_0 << sig1 << OP_0;
1356    CScript partial1b = CScript() << OP_0 << OP_0 << sig1;
1357    CScript partial2a = CScript() << OP_0 << sig2;
1358    CScript partial2b = CScript() << sig2 << OP_0;
1359    CScript partial3a = CScript() << sig3;
1360    CScript partial3b = CScript() << OP_0 << OP_0 << sig3;
1361    CScript partial3c = CScript() << OP_0 << sig3 << OP_0;
1362    CScript complete12 = CScript() << OP_0 << sig1 << sig2;
1363    CScript complete13 = CScript() << OP_0 << sig1 << sig3;
1364    CScript complete23 = CScript() << OP_0 << sig2 << sig3;
1365    SignatureData partial1_sigs;
1366    partial1_sigs.signatures.emplace(keys[0].GetPubKey().GetID(), SigPair(keys[0].GetPubKey(), sig1));
1367    SignatureData partial2_sigs;
1368    partial2_sigs.signatures.emplace(keys[1].GetPubKey().GetID(), SigPair(keys[1].GetPubKey(), sig2));
1369    SignatureData partial3_sigs;
1370    partial3_sigs.signatures.emplace(keys[2].GetPubKey().GetID(), SigPair(keys[2].GetPubKey(), sig3));
1371
1372    combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial1_sigs);
1373    BOOST_CHECK(combined.scriptSig == partial1a);
1374    combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
1375    BOOST_CHECK(combined.scriptSig == complete12);
1376    combined = CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial1_sigs);
1377    BOOST_CHECK(combined.scriptSig == complete12);
1378    combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
1379    BOOST_CHECK(combined.scriptSig == complete12);
1380    combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial1_sigs);
1381    BOOST_CHECK(combined.scriptSig == complete13);
1382    combined = CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial3_sigs);
1383    BOOST_CHECK(combined.scriptSig == complete23);
1384    combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial2_sigs);
1385    BOOST_CHECK(combined.scriptSig == complete23);
1386    combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial3_sigs);
1387    BOOST_CHECK(combined.scriptSig == partial3c);
1388}
1389
1390/**
1391 * Reproduction of an exception incorrectly raised when parsing a public key inside a TapMiniscript.
1392 */
1393BOOST_AUTO_TEST_CASE(sign_invalid_miniscript)
1394{
1395    FillableSigningProvider keystore;
1396    SignatureData sig_data;
1397    CMutableTransaction prev, curr;
1398
1399    // Create a Taproot output which contains a leaf in which a non-32 bytes push is used where a public key is expected
1400    // by the Miniscript parser. This offending Script was found by the RPC fuzzer.
1401    const auto invalid_pubkey{"173d36c8c9c9c9ffffffffffff0200000000021e1e37373721361818181818181e1e1e1e19000000000000000000b19292929292926b006c9b9b9292"_hex_u8};
1402    TaprootBuilder builder;
1403    builder.Add(0, {invalid_pubkey}, 0xc0);
1404    builder.Finalize(XOnlyPubKey::NUMS_H);
1405    prev.vout.emplace_back(0, GetScriptForDestination(builder.GetOutput()));
1406    curr.vin.emplace_back(COutPoint{prev.GetHash(), 0});
1407    sig_data.tr_spenddata = builder.GetSpendData();
1408
1409    // SignSignature can fail but it shouldn't raise an exception (nor crash).
1410    BOOST_CHECK(!SignSignature(keystore, CTransaction(prev), curr, 0, SIGHASH_ALL, sig_data));
1411}
1412
1413/* P2A input should be considered signed. */
1414BOOST_AUTO_TEST_CASE(sign_paytoanchor)
1415{
1416    FillableSigningProvider keystore;
1417    SignatureData sig_data;
1418    CMutableTransaction prev, curr;
1419    prev.vout.emplace_back(0, GetScriptForDestination(PayToAnchor{}));
1420
1421    curr.vin.emplace_back(COutPoint{prev.GetHash(), 0});
1422
1423    BOOST_CHECK(SignSignature(keystore, CTransaction(prev), curr, 0, SIGHASH_ALL, sig_data));
1424}
1425
1426BOOST_AUTO_TEST_CASE(script_standard_push)
1427{
1428    ScriptError err;
1429    for (int i=0; i<67000; i++) {
1430        CScript script;
1431        script << i;
1432        BOOST_CHECK_MESSAGE(script.IsPushOnly(), "Number " << i << " is not pure push.");
1433        BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1, nullptr, SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err), "Number " << i << " push is not minimal data.");
1434        BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1435    }
1436
1437    for (unsigned int i=0; i<=MAX_SCRIPT_ELEMENT_SIZE; i++) {
1438        std::vector<unsigned char> data(i, '\111');
1439        CScript script;
1440        script << data;
1441        BOOST_CHECK_MESSAGE(script.IsPushOnly(), "Length " << i << " is not pure push.");
1442        BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1, nullptr, SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err), "Length " << i << " push is not minimal data.");
1443        BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1444    }
1445}
1446
1447BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts)
1448{
1449    // IsPushOnly returns false when given a script containing only pushes that
1450    // are invalid due to truncation. IsPushOnly() is consensus critical
1451    // because P2SH evaluation uses it, although this specific behavior should
1452    // not be consensus critical as the P2SH evaluation would fail first due to
1453    // the invalid push. Still, it doesn't hurt to test it explicitly.
1454    static const unsigned char direct[] = { 1 };
1455    BOOST_CHECK(!CScript(direct, direct+sizeof(direct)).IsPushOnly());
1456}
1457
1458BOOST_AUTO_TEST_CASE(script_CheckMinimalPush_boundary)
1459{
1460    // Test the boundary at exactly 65535 bytes: must use OP_PUSHDATA2, not OP_PUSHDATA4.
1461    std::vector<unsigned char> data(65535, '\x42');
1462    BOOST_CHECK(CheckMinimalPush(data, OP_PUSHDATA2));
1463    BOOST_CHECK(!CheckMinimalPush(data, OP_PUSHDATA4));
1464}
1465
1466BOOST_AUTO_TEST_CASE(script_GetScriptAsm)
1467{
1468    BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2, true));
1469    BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY, true));
1470    BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2));
1471    BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY));
1472
1473    std::string derSig("304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c5090");
1474    std::string pubKey("03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2");
1475    std::vector<unsigned char> vchPubKey = ToByteVector(ParseHex(pubKey));
1476
1477    BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey, true));
1478    BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey, true));
1479    BOOST_CHECK_EQUAL(derSig + "[ALL] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "01")) << vchPubKey, true));
1480    BOOST_CHECK_EQUAL(derSig + "[NONE] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "02")) << vchPubKey, true));
1481    BOOST_CHECK_EQUAL(derSig + "[SINGLE] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "03")) << vchPubKey, true));
1482    BOOST_CHECK_EQUAL(derSig + "[ALL|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "81")) << vchPubKey, true));
1483    BOOST_CHECK_EQUAL(derSig + "[NONE|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "82")) << vchPubKey, true));
1484    BOOST_CHECK_EQUAL(derSig + "[SINGLE|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "83")) << vchPubKey, true));
1485
1486    BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey));
1487    BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey));
1488    BOOST_CHECK_EQUAL(derSig + "01 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "01")) << vchPubKey));
1489    BOOST_CHECK_EQUAL(derSig + "02 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "02")) << vchPubKey));
1490    BOOST_CHECK_EQUAL(derSig + "03 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "03")) << vchPubKey));
1491    BOOST_CHECK_EQUAL(derSig + "81 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "81")) << vchPubKey));
1492    BOOST_CHECK_EQUAL(derSig + "82 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "82")) << vchPubKey));
1493    BOOST_CHECK_EQUAL(derSig + "83 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "83")) << vchPubKey));
1494}
1495
1496template <typename T>
1497CScript ToScript(const T& byte_container)
1498{
1499    auto span{MakeUCharSpan(byte_container)};
1500    return {span.begin(), span.end()};