Inside Bitcoin

1001    BOOST_CHECK(pushdata2Stack == directStack);
1002    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1003
1004    std::vector<std::vector<unsigned char> > pushdata4Stack;
1005    BOOST_CHECK(EvalScript(pushdata4Stack, CScript(pushdata4, pushdata4 + sizeof(pushdata4)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
1006    BOOST_CHECK(pushdata4Stack == directStack);
1007    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1008
1009    const std::vector<unsigned char> pushdata1_trunc{OP_PUSHDATA1, 1};
1010    const std::vector<unsigned char> pushdata2_trunc{OP_PUSHDATA2, 1, 0};
1011    const std::vector<unsigned char> pushdata4_trunc{OP_PUSHDATA4, 1, 0, 0, 0};
1012
1013    std::vector<std::vector<unsigned char>> stack_ignore;
1014    BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata1_trunc.begin(), pushdata1_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
1015    BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
1016    BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata2_trunc.begin(), pushdata2_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
1017    BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
1018    BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata4_trunc.begin(), pushdata4_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
1019    BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
1020}
1021
1022BOOST_AUTO_TEST_CASE(script_cltv_truncated)
1023{
1024    const auto script_cltv_trunc = CScript() << OP_CHECKLOCKTIMEVERIFY;
1025
1026    std::vector<std::vector<unsigned char>> stack_ignore;
1027    ScriptError err;
1028    BOOST_CHECK(!EvalScript(stack_ignore, script_cltv_trunc, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, BaseSignatureChecker(), SigVersion::BASE, &err));
1029    BOOST_CHECK_EQUAL(err, SCRIPT_ERR_INVALID_STACK_OPERATION);
1030}
1031
1032static CScript
1033sign_multisig(const CScript& scriptPubKey, const std::vector<CKey>& keys, const CTransaction& transaction)
1034{
1035    uint256 hash = SignatureHash(scriptPubKey, transaction, 0, SIGHASH_ALL, 0, SigVersion::BASE);
1036
1037    CScript result;
1038    //
1039    // NOTE: CHECKMULTISIG has an unfortunate bug; it requires
1040    // one extra item on the stack, before the signatures.
1041    // Putting OP_0 on the stack is the workaround;
1042    // fixing the bug would mean splitting the block chain (old
1043    // clients would not accept new CHECKMULTISIG transactions,
1044    // and vice-versa)
1045    //
1046    result << OP_0;
1047    for (const CKey &key : keys)
1048    {
1049        std::vector<unsigned char> vchSig;
1050        BOOST_CHECK(key.Sign(hash, vchSig));
1051        vchSig.push_back((unsigned char)SIGHASH_ALL);
1052        result << vchSig;
1053    }
1054    return result;
1055}
1056static CScript
1057sign_multisig(const CScript& scriptPubKey, const CKey& key, const CTransaction& transaction)
1058{
1059    std::vector<CKey> keys;
1060    keys.push_back(key);
1061    return sign_multisig(scriptPubKey, keys, transaction);
1062}
1063
1064BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12)
1065{
1066    ScriptError err;
1067    CKey key1 = GenerateRandomKey();
1068    CKey key2 = GenerateRandomKey(/*compressed=*/false);
1069    CKey key3 = GenerateRandomKey();
1070
1071    CScript scriptPubKey12;
1072    scriptPubKey12 << OP_1 << ToByteVector(key1.GetPubKey()) << ToByteVector(key2.GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
1073
1074    const CTransaction txFrom12{BuildCreditingTransaction(scriptPubKey12)};
1075    CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom12);
1076
1077    CScript goodsig1 = sign_multisig(scriptPubKey12, key1, CTransaction(txTo12));
1078    BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1079    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1080    txTo12.vout[0].nValue = 2;
1081    BOOST_CHECK(!VerifyScript(goodsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1082    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1083
1084    CScript goodsig2 = sign_multisig(scriptPubKey12, key2, CTransaction(txTo12));
1085    BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1086    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1087
1088    CScript badsig1 = sign_multisig(scriptPubKey12, key3, CTransaction(txTo12));
1089    BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1090    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1091}
1092
1093BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23)
1094{
1095    ScriptError err;
1096    CKey key1 = GenerateRandomKey();
1097    CKey key2 = GenerateRandomKey(/*compressed=*/false);
1098    CKey key3 = GenerateRandomKey();
1099    CKey key4 = GenerateRandomKey(/*compressed=*/false);
1100
1101    CScript scriptPubKey23;
1102    scriptPubKey23 << OP_2 << ToByteVector(key1.GetPubKey()) << ToByteVector(key2.GetPubKey()) << ToByteVector(key3.GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
1103
1104    const CTransaction txFrom23{BuildCreditingTransaction(scriptPubKey23)};
1105    CMutableTransaction txTo23 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom23);
1106
1107    std::vector<CKey> keys;
1108    keys.push_back(key1); keys.push_back(key2);
1109    CScript goodsig1 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1110    BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1111    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1112
1113    keys.clear();
1114    keys.push_back(key1); keys.push_back(key3);
1115    CScript goodsig2 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1116    BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1117    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1118
1119    keys.clear();
1120    keys.push_back(key2); keys.push_back(key3);
1121    CScript goodsig3 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1122    BOOST_CHECK(VerifyScript(goodsig3, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1123    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1124
1125    keys.clear();
1126    keys.push_back(key2); keys.push_back(key2); // Can't reuse sig
1127    CScript badsig1 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1128    BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1129    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1130
1131    keys.clear();
1132    keys.push_back(key2); keys.push_back(key1); // sigs must be in correct order
1133    CScript badsig2 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1134    BOOST_CHECK(!VerifyScript(badsig2, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1135    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1136
1137    keys.clear();
1138    keys.push_back(key3); keys.push_back(key2); // sigs must be in correct order
1139    CScript badsig3 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1140    BOOST_CHECK(!VerifyScript(badsig3, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1141    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1142
1143    keys.clear();
1144    keys.push_back(key4); keys.push_back(key2); // sigs must match pubkeys
1145    CScript badsig4 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1146    BOOST_CHECK(!VerifyScript(badsig4, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1147    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1148
1149    keys.clear();
1150    keys.push_back(key1); keys.push_back(key4); // sigs must match pubkeys
1151    CScript badsig5 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1152    BOOST_CHECK(!VerifyScript(badsig5, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1153    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1154
1155    keys.clear(); // Must have signatures
1156    CScript badsig6 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1157    BOOST_CHECK(!VerifyScript(badsig6, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1158    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, ScriptErrorString(err));
1159}
1160
1161/** Return the TxoutType of a script without exposing Solver details. */
1162static TxoutType GetTxoutType(const CScript& output_script)
1163{
1164    std::vector<std::vector<uint8_t>> unused;
1165    return Solver(output_script, unused);
1166}
1167
1168#define CHECK_SCRIPT_STATIC_SIZE(script, expected_size)                   \
1169    do {                                                                  \
1170        BOOST_CHECK_EQUAL((script).size(), (expected_size));              \
1171        BOOST_CHECK_EQUAL((script).capacity(), CScriptBase::STATIC_SIZE); \
1172        BOOST_CHECK_EQUAL((script).allocated_memory(), 0);                \
1173    } while (0)
1174
1175#define CHECK_SCRIPT_DYNAMIC_SIZE(script, expected_size, expected_extra)                 \
1176    do {                                                                 \
1177        BOOST_CHECK_EQUAL((script).size(), (expected_size));             \
1178        BOOST_CHECK_EQUAL((script).capacity(), (expected_extra));         \
1179        BOOST_CHECK_EQUAL((script).allocated_memory(), (expected_extra)); \
1180    } while (0)
1181
1182BOOST_AUTO_TEST_CASE(script_size_and_capacity_test)
1183{
1184    BOOST_CHECK_EQUAL(sizeof(CompressedScript), 40);
1185    BOOST_CHECK_EQUAL(sizeof(CScriptBase), 40);
1186    BOOST_CHECK_NE(sizeof(CScriptBase), sizeof(prevector<CScriptBase::STATIC_SIZE + 1, uint8_t>)); // CScriptBase size should be set to avoid wasting space in padding
1187    BOOST_CHECK_EQUAL(sizeof(CScript), 40);
1188    BOOST_CHECK_EQUAL(sizeof(CTxOut), 48);
1189
1190    CKey dummy_key;
1191    dummy_key.MakeNewKey(/*fCompressed=*/true);
1192    const CPubKey dummy_pubkey{dummy_key.GetPubKey()};
1193
1194    // Small OP_RETURN has direct allocation
1195    {
1196        const auto script{CScript() << OP_RETURN << std::vector<uint8_t>(10, 0xaa)};
1197        BOOST_CHECK_EQUAL(GetTxoutType(script), TxoutType::NULL_DATA);
1198        CHECK_SCRIPT_STATIC_SIZE(script, 12);
1199    }
1200
1201    // P2WPKH has direct allocation
1202    {
1203        const auto script{GetScriptForDestination(WitnessV0KeyHash{PKHash{dummy_pubkey}})};
1204        BOOST_CHECK_EQUAL(GetTxoutType(script), TxoutType::WITNESS_V0_KEYHASH);
1205        CHECK_SCRIPT_STATIC_SIZE(script, 22);
1206    }
1207
1208    // P2SH has direct allocation
1209    {
1210        const auto script{GetScriptForDestination(ScriptHash{CScript{} << OP_TRUE})};
1211        BOOST_CHECK(script.IsPayToScriptHash());
1212        CHECK_SCRIPT_STATIC_SIZE(script, 23);
1213    }
1214
1215    // P2PKH has direct allocation
1216    {
1217        const auto script{GetScriptForDestination(PKHash{dummy_pubkey})};
1218        BOOST_CHECK_EQUAL(GetTxoutType(script), TxoutType::PUBKEYHASH);
1219        CHECK_SCRIPT_STATIC_SIZE(script, 25);
1220    }
1221
1222    // P2WSH has direct allocation
1223    {
1224        const auto script{GetScriptForDestination(WitnessV0ScriptHash{CScript{} << OP_TRUE})};
1225        BOOST_CHECK(script.IsPayToWitnessScriptHash());
1226        CHECK_SCRIPT_STATIC_SIZE(script, 34);
1227    }
1228
1229    // P2TR has direct allocation
1230    {
1231        const auto script{GetScriptForDestination(WitnessV1Taproot{XOnlyPubKey{dummy_pubkey}})};
1232        BOOST_CHECK_EQUAL(GetTxoutType(script), TxoutType::WITNESS_V1_TAPROOT);
1233        CHECK_SCRIPT_STATIC_SIZE(script, 34);
1234    }
1235
1236    // Compressed P2PK has direct allocation
1237    {
1238        const auto script{GetScriptForRawPubKey(dummy_pubkey)};
1239        BOOST_CHECK_EQUAL(GetTxoutType(script), TxoutType::PUBKEY);
1240        CHECK_SCRIPT_STATIC_SIZE(script, 35);
1241    }
1242
1243    // Uncompressed P2PK needs extra allocation
1244    {
1245        CKey uncompressed_key;
1246        uncompressed_key.MakeNewKey(/*fCompressed=*/false);
1247        const CPubKey uncompressed_pubkey{uncompressed_key.GetPubKey()};
1248
1249        const auto script{GetScriptForRawPubKey(uncompressed_pubkey)};
1250        BOOST_CHECK_EQUAL(GetTxoutType(script), TxoutType::PUBKEY);