Inside Bitcoin

251    not_p2sh.clear(); not_p2sh << OP_NOP << ToByteVector(dummy) << OP_EQUAL;
252    BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
253
254    not_p2sh.clear(); not_p2sh << OP_HASH160 << ToByteVector(dummy) << OP_CHECKSIG;
255    BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
256}
257
258BOOST_AUTO_TEST_CASE(switchover)
259{
260    // Test switch over code
261    CScript notValid;
262    ScriptError err;
263    notValid << OP_11 << OP_12 << OP_EQUALVERIFY;
264    CScript scriptSig;
265    scriptSig << Serialize(notValid);
266
267    CScript fund = GetScriptForDestination(ScriptHash(notValid));
268
269
270    // Validation should succeed under old rules (hash is correct):
271    BOOST_CHECK(Verify(scriptSig, fund, false, err));
272    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
273    // Fail under new:
274    BOOST_CHECK(!Verify(scriptSig, fund, true, err));
275    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EQUALVERIFY, ScriptErrorString(err));
276}
277
278BOOST_AUTO_TEST_CASE(ValidateInputsStandardness)
279{
280    CCoinsViewCache coins{&CoinsViewEmpty::Get()};
281    FillableSigningProvider keystore;
282    CKey key[6];
283    for (int i = 0; i < 6; i++)
284    {
285        key[i].MakeNewKey(true);
286        BOOST_CHECK(keystore.AddKey(key[i]));
287    }
288    std::vector<CPubKey> keys;
289    keys.reserve(3);
290    for (int i = 0; i < 3; i++)
291        keys.push_back(key[i].GetPubKey());
292
293    CMutableTransaction txFrom;
294    txFrom.vout.resize(10);
295
296    // First three are standard:
297    CScript pay1 = GetScriptForDestination(PKHash(key[0].GetPubKey()));
298    BOOST_CHECK(keystore.AddCScript(pay1));
299    CScript pay1of3 = GetScriptForMultisig(1, keys);
300
301    txFrom.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(pay1)); // P2SH (OP_CHECKSIG)
302    txFrom.vout[0].nValue = 1000;
303    txFrom.vout[1].scriptPubKey = pay1; // ordinary OP_CHECKSIG
304    txFrom.vout[1].nValue = 2000;
305    txFrom.vout[2].scriptPubKey = pay1of3; // ordinary OP_CHECKMULTISIG
306    txFrom.vout[2].nValue = 3000;
307
308    // vout[3] is complicated 1-of-3 AND 2-of-3
309    // ... that is OK if wrapped in P2SH:
310    CScript oneAndTwo;
311    oneAndTwo << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << ToByteVector(key[2].GetPubKey());
312    oneAndTwo << OP_3 << OP_CHECKMULTISIGVERIFY;
313    oneAndTwo << OP_2 << ToByteVector(key[3].GetPubKey()) << ToByteVector(key[4].GetPubKey()) << ToByteVector(key[5].GetPubKey());
314    oneAndTwo << OP_3 << OP_CHECKMULTISIG;
315    BOOST_CHECK(keystore.AddCScript(oneAndTwo));
316    txFrom.vout[3].scriptPubKey = GetScriptForDestination(ScriptHash(oneAndTwo));
317    txFrom.vout[3].nValue = 4000;
318
319    // vout[4] is max sigops:
320    CScript fifteenSigops; fifteenSigops << OP_1;
321    for (unsigned i = 0; i < MAX_P2SH_SIGOPS; i++)
322        fifteenSigops << ToByteVector(key[i%3].GetPubKey());
323    fifteenSigops << OP_15 << OP_CHECKMULTISIG;
324    BOOST_CHECK(keystore.AddCScript(fifteenSigops));
325    txFrom.vout[4].scriptPubKey = GetScriptForDestination(ScriptHash(fifteenSigops));
326    txFrom.vout[4].nValue = 5000;
327
328    // vout[5/6] are non-standard because they exceed MAX_P2SH_SIGOPS
329    CScript sixteenSigops; sixteenSigops << OP_16 << OP_CHECKMULTISIG;
330    BOOST_CHECK(keystore.AddCScript(sixteenSigops));
331    txFrom.vout[5].scriptPubKey = GetScriptForDestination(ScriptHash(sixteenSigops));
332    txFrom.vout[5].nValue = 5000;
333    CScript twentySigops; twentySigops << OP_CHECKMULTISIG;
334    BOOST_CHECK(keystore.AddCScript(twentySigops));
335    txFrom.vout[6].scriptPubKey = GetScriptForDestination(ScriptHash(twentySigops));
336    txFrom.vout[6].nValue = 3000;
337
338    // vout[7] is non-standard because it lacks sigops
339    CScript no_sigops;
340    txFrom.vout[7].scriptPubKey = no_sigops;
341    txFrom.vout[7].nValue = 1000;
342
343    // vout [8] is non-standard because it contains OP_RETURN in its redeemScript.
344    static const unsigned char op_return[] = {OP_RETURN};
345    const auto op_return_script = CScript(op_return, op_return + sizeof(op_return));
346    txFrom.vout[8].scriptPubKey = GetScriptForDestination(ScriptHash(op_return_script));
347    txFrom.vout[8].nValue = 1000;
348
349    // vout[9] is non-standard because its witness is unknown
350    CScript witnessUnknown;
351    witnessUnknown << OP_16 << ToByteVector(uint256::ONE);
352    txFrom.vout[9].scriptPubKey = witnessUnknown;
353    txFrom.vout[9].nValue = 1000;
354
355    AddCoins(coins, CTransaction(txFrom), 0);
356
357    {
358        CMutableTransaction txTo;
359        txTo.vout.resize(1);
360        txTo.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
361
362        txTo.vin.resize(5);
363        for (int i = 0; i < 5; i++)
364        {
365            txTo.vin[i].prevout.n = i;
366            txTo.vin[i].prevout.hash = txFrom.GetHash();
367        }
368        SignatureData empty;
369        BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, empty));
370        SignatureData empty_b;
371        BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 1, SIGHASH_ALL, empty_b));
372        SignatureData empty_c;
373        BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 2, SIGHASH_ALL, empty_c));
374        // SignSignature doesn't know how to sign these. We're
375        // not testing validating signatures, so just create
376        // dummy signatures that DO include the correct P2SH scripts:
377        txTo.vin[3].scriptSig << OP_11 << OP_11 << std::vector<unsigned char>(oneAndTwo.begin(), oneAndTwo.end());
378        txTo.vin[4].scriptSig << std::vector<unsigned char>(fifteenSigops.begin(), fifteenSigops.end());
379
380        BOOST_CHECK(::ValidateInputsStandardness(CTransaction(txTo), coins).IsValid());
381        // 22 P2SH sigops for all inputs (1 for vin[0], 6 for vin[3], 15 for vin[4]
382        BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txTo), coins), 22U);
383    }
384
385    {
386        CMutableTransaction coinbase_tx_mut;
387        coinbase_tx_mut.vin.resize(1);
388        CTransaction coinbase_tx{coinbase_tx_mut};
389        BOOST_CHECK(coinbase_tx.IsCoinBase());
390        BOOST_CHECK_EQUAL(GetP2SHSigOpCount(coinbase_tx, coins), 0U);
391    }
392
393    // TxoutType::SCRIPTHASH
394    {
395        CMutableTransaction txToNonStd1;
396        txToNonStd1.vout.resize(1);
397        txToNonStd1.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
398        txToNonStd1.vout[0].nValue = 1000;
399        txToNonStd1.vin.resize(1);
400        txToNonStd1.vin[0].prevout.n = 5;
401        txToNonStd1.vin[0].prevout.hash = txFrom.GetHash();
402        txToNonStd1.vin[0].scriptSig << std::vector<unsigned char>(sixteenSigops.begin(), sixteenSigops.end());
403
404        const auto txToNonStd1_res = ::ValidateInputsStandardness(CTransaction(txToNonStd1), coins);
405        BOOST_CHECK(txToNonStd1_res.IsInvalid());
406        BOOST_CHECK_EQUAL(txToNonStd1_res.GetRejectReason(), "bad-txns-nonstandard-inputs");
407        BOOST_CHECK_EQUAL(txToNonStd1_res.GetDebugMessage(), "p2sh redeemscript sigops exceed limit (input 0: 16 > 15)");
408
409        BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd1), coins), 16U);
410    }
411
412    {
413        CMutableTransaction txToNonStd2;
414        txToNonStd2.vout.resize(1);
415        txToNonStd2.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
416        txToNonStd2.vout[0].nValue = 1000;
417        txToNonStd2.vin.resize(1);
418        txToNonStd2.vin[0].prevout.n = 6;
419        txToNonStd2.vin[0].prevout.hash = txFrom.GetHash();
420        txToNonStd2.vin[0].scriptSig << std::vector<unsigned char>(twentySigops.begin(), twentySigops.end());
421
422        const auto txToNonStd2_res = ::ValidateInputsStandardness(CTransaction(txToNonStd2), coins);
423        BOOST_CHECK(txToNonStd2_res.IsInvalid());
424        BOOST_CHECK_EQUAL(txToNonStd2_res.GetRejectReason(), "bad-txns-nonstandard-inputs");
425        BOOST_CHECK_EQUAL(txToNonStd2_res.GetDebugMessage(), "p2sh redeemscript sigops exceed limit (input 0: 20 > 15)");
426        BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2), coins), 20U);
427    }
428
429    {
430        CMutableTransaction txToNonStd2_no_scriptSig;
431        txToNonStd2_no_scriptSig.vout.resize(1);
432        txToNonStd2_no_scriptSig.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
433        txToNonStd2_no_scriptSig.vout[0].nValue = 1000;
434        txToNonStd2_no_scriptSig.vin.resize(1);
435        txToNonStd2_no_scriptSig.vin[0].prevout.n = 6;
436        txToNonStd2_no_scriptSig.vin[0].prevout.hash = txFrom.GetHash();
437
438        const auto txToNonStd2_no_scriptSig_res = ::ValidateInputsStandardness(CTransaction(txToNonStd2_no_scriptSig), coins);
439        BOOST_CHECK(txToNonStd2_no_scriptSig_res.IsInvalid());
440        BOOST_CHECK_EQUAL(txToNonStd2_no_scriptSig_res.GetRejectReason(), "bad-txns-nonstandard-inputs");
441        BOOST_CHECK_EQUAL(txToNonStd2_no_scriptSig_res.GetDebugMessage(), "input 0 P2SH redeemscript missing");
442        BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2_no_scriptSig), coins), 0U);
443    }
444
445    // TxoutType::NONSTANDARD
446    {
447        CMutableTransaction txToNonStd3;
448        txToNonStd3.vout.resize(1);
449        txToNonStd3.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
450        txToNonStd3.vout[0].nValue = 1000;
451        txToNonStd3.vin.resize(1);
452        txToNonStd3.vin[0].prevout.n = 7;
453        txToNonStd3.vin[0].prevout.hash = txFrom.GetHash();
454
455        const auto txToNonStd3_res = ::ValidateInputsStandardness(CTransaction(txToNonStd3), coins);
456        BOOST_CHECK(txToNonStd3_res.IsInvalid());
457        BOOST_CHECK_EQUAL(txToNonStd3_res.GetRejectReason(), "bad-txns-nonstandard-inputs");
458        BOOST_CHECK_EQUAL(txToNonStd3_res.GetDebugMessage(), "input 0 script unknown");
459    }
460
461    // TxoutType::INCORRECT_SCRIPTSIG
462    {
463        CMutableTransaction txToNonStd4;
464        txToNonStd4.vout.resize(1);
465        txToNonStd4.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
466        txToNonStd4.vout[0].nValue = 1000;
467        txToNonStd4.vin.resize(1);
468        txToNonStd4.vin[0].prevout.n = 8;
469        txToNonStd4.vin[0].prevout.hash = txFrom.GetHash();
470        txToNonStd4.vin[0].scriptSig = op_return_script;
471
472        const auto txToNonStd4_res = ::ValidateInputsStandardness(CTransaction(txToNonStd4), coins);
473        BOOST_CHECK(txToNonStd4_res.IsInvalid());
474        BOOST_CHECK_EQUAL(txToNonStd4_res.GetRejectReason(), "bad-txns-nonstandard-inputs");
475        BOOST_CHECK_EQUAL(txToNonStd4_res.GetDebugMessage(), "p2sh scriptsig malformed (input 0: OP_RETURN was encountered)");
476    }
477
478    // TxoutType::WITNESS_UNKNOWN
479    {
480        CMutableTransaction txWitnessUnknown;
481        txWitnessUnknown.vout.resize(1);
482        txWitnessUnknown.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
483        txWitnessUnknown.vout[0].nValue = 1000;
484        txWitnessUnknown.vin.resize(1);
485        txWitnessUnknown.vin[0].prevout.n = 9;
486        txWitnessUnknown.vin[0].prevout.hash = txFrom.GetHash();
487        const auto txWitnessUnknown_res = ::ValidateInputsStandardness(CTransaction(txWitnessUnknown), coins);
488        BOOST_CHECK(txWitnessUnknown_res.IsInvalid());
489        BOOST_CHECK_EQUAL(txWitnessUnknown_res.GetRejectReason(), "bad-txns-nonstandard-inputs");
490        BOOST_CHECK_EQUAL(txWitnessUnknown_res.GetDebugMessage(), "input 0 witness program is undefined");
491    }
492}
493
494BOOST_AUTO_TEST_SUITE_END()
495