Inside Bitcoin

251        push = data;
252        havePush = true;
253    }
254
255public:
256    TestBuilder(const CScript& script_, const std::string& comment_, script_verify_flags flags_, bool P2SH = false, WitnessMode wm = WitnessMode::NONE, int witnessversion = 0, CAmount nValue_ = 0) : script(script_), comment(comment_), flags(flags_), nValue(nValue_)
257    {
258        CScript scriptPubKey = script;
259        if (wm == WitnessMode::PKH) {
260            uint160 hash;
261            CHash160().Write(std::span{script}.subspan(1)).Finalize(hash);
262            script = CScript() << OP_DUP << OP_HASH160 << ToByteVector(hash) << OP_EQUALVERIFY << OP_CHECKSIG;
263            scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
264        } else if (wm == WitnessMode::SH) {
265            witscript = scriptPubKey;
266            uint256 hash;
267            CSHA256().Write(witscript.data(), witscript.size()).Finalize(hash.begin());
268            scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
269        }
270        if (P2SH) {
271            redeemscript = scriptPubKey;
272            scriptPubKey = CScript() << OP_HASH160 << ToByteVector(CScriptID(redeemscript)) << OP_EQUAL;
273        }
274        creditTx = MakeTransactionRef(BuildCreditingTransaction(scriptPubKey, nValue));
275        spendTx = BuildSpendingTransaction(CScript(), CScriptWitness(), *creditTx);
276    }
277
278    TestBuilder& ScriptError(ScriptError_t err)
279    {
280        scriptError = err;
281        return *this;
282    }
283
284    TestBuilder& Opcode(const opcodetype& _op)
285    {
286        DoPush();
287        spendTx.vin[0].scriptSig << _op;
288        return *this;
289    }
290
291    TestBuilder& Num(int num)
292    {
293        DoPush();
294        spendTx.vin[0].scriptSig << num;
295        return *this;
296    }
297
298    TestBuilder& Push(const std::string& hex)
299    {
300        DoPush(ParseHex(hex));
301        return *this;
302    }
303
304    TestBuilder& Push(const CScript& _script)
305    {
306        DoPush(std::vector<unsigned char>(_script.begin(), _script.end()));
307        return *this;
308    }
309
310    TestBuilder& PushSig(const CKey& key, int nHashType = SIGHASH_ALL, unsigned int lenR = 32, unsigned int lenS = 32, SigVersion sigversion = SigVersion::BASE, CAmount amount = 0)
311    {
312        uint256 hash = SignatureHash(script, spendTx, 0, nHashType, amount, sigversion);
313        std::vector<unsigned char> vchSig, r, s;
314        uint32_t iter = 0;
315        do {
316            key.Sign(hash, vchSig, false, iter++);
317            if ((lenS == 33) != (vchSig[5 + vchSig[3]] == 33)) {
318                NegateSignatureS(vchSig);
319            }
320            r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
321            s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
322        } while (lenR != r.size() || lenS != s.size());
323        vchSig.push_back(static_cast<unsigned char>(nHashType));
324        DoPush(vchSig);
325        return *this;
326    }
327
328    TestBuilder& PushWitSig(const CKey& key, CAmount amount = -1, int nHashType = SIGHASH_ALL, unsigned int lenR = 32, unsigned int lenS = 32, SigVersion sigversion = SigVersion::WITNESS_V0)
329    {
330        if (amount == -1)
331            amount = nValue;
332        return PushSig(key, nHashType, lenR, lenS, sigversion, amount).AsWit();
333    }
334
335    TestBuilder& Push(const CPubKey& pubkey)
336    {
337        DoPush(std::vector<unsigned char>(pubkey.begin(), pubkey.end()));
338        return *this;
339    }
340
341    TestBuilder& PushRedeem()
342    {
343        DoPush(std::vector<unsigned char>(redeemscript.begin(), redeemscript.end()));
344        return *this;
345    }
346
347    TestBuilder& PushWitRedeem()
348    {
349        DoPush(std::vector<unsigned char>(witscript.begin(), witscript.end()));
350        return AsWit();
351    }
352
353    TestBuilder& EditPush(unsigned int pos, const std::string& hexin, const std::string& hexout)
354    {
355        assert(havePush);
356        std::vector<unsigned char> datain = ParseHex(hexin);
357        std::vector<unsigned char> dataout = ParseHex(hexout);
358        assert(pos + datain.size() <= push.size());
359        BOOST_CHECK_MESSAGE(std::vector<unsigned char>(push.begin() + pos, push.begin() + pos + datain.size()) == datain, comment);
360        push.erase(push.begin() + pos, push.begin() + pos + datain.size());
361        push.insert(push.begin() + pos, dataout.begin(), dataout.end());
362        return *this;
363    }
364
365    TestBuilder& DamagePush(unsigned int pos)
366    {
367        assert(havePush);
368        assert(pos < push.size());
369        push[pos] ^= 1;
370        return *this;
371    }
372
373    TestBuilder& Test(ScriptTest& test)
374    {
375        TestBuilder copy = *this; // Make a copy so we can rollback the push.
376        DoPush();
377        test.DoTest(creditTx->vout[0].scriptPubKey, spendTx.vin[0].scriptSig, scriptWitness, flags, comment, scriptError, nValue);
378        *this = copy;
379        return *this;
380    }
381
382    TestBuilder& AsWit()
383    {
384        assert(havePush);
385        scriptWitness.stack.push_back(push);
386        havePush = false;
387        return *this;
388    }
389
390    UniValue GetJSON()
391    {
392        DoPush();
393        UniValue array(UniValue::VARR);
394        if (!scriptWitness.stack.empty()) {
395            UniValue wit(UniValue::VARR);
396            for (unsigned i = 0; i < scriptWitness.stack.size(); i++) {
397                wit.push_back(HexStr(scriptWitness.stack[i]));
398            }
399            wit.push_back(ValueFromAmount(nValue));
400            array.push_back(std::move(wit));
401        }
402        array.push_back(FormatScript(spendTx.vin[0].scriptSig));
403        array.push_back(FormatScript(creditTx->vout[0].scriptPubKey));
404        array.push_back(FormatScriptFlags(flags));
405        array.push_back(FormatScriptError((ScriptError_t)scriptError));
406        array.push_back(comment);
407        return array;
408    }
409
410    std::string GetComment() const
411    {
412        return comment;
413    }
414};
415
416std::string JSONPrettyPrint(const UniValue& univalue)
417{
418    std::string ret = univalue.write(4);
419    // Workaround for libunivalue pretty printer, which puts a space between commas and newlines
420    size_t pos = 0;
421    while ((pos = ret.find(" \n", pos)) != std::string::npos) {
422        ret.replace(pos, 2, "\n");
423        pos++;
424    }
425    return ret;
426}
427} // namespace
428
429BOOST_FIXTURE_TEST_SUITE(script_tests, ScriptTest)
430
431BOOST_AUTO_TEST_CASE(script_build)
432{
433    const KeyData keys;
434
435    std::vector<TestBuilder> tests;
436
437    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
438                                "P2PK", 0
439                               ).PushSig(keys.key0));
440    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
441                                "P2PK, bad sig", 0
442                               ).PushSig(keys.key0).DamagePush(10).ScriptError(SCRIPT_ERR_EVAL_FALSE));
443
444    tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1C.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
445                                "P2PKH", 0
446                               ).PushSig(keys.key1).Push(keys.pubkey1C));
447    tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey2C.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
448                                "P2PKH, bad pubkey", 0
449                               ).PushSig(keys.key2).Push(keys.pubkey2C).DamagePush(5).ScriptError(SCRIPT_ERR_EQUALVERIFY));
450
451    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
452                                "P2PK anyonecanpay", 0
453                               ).PushSig(keys.key1, SIGHASH_ALL | SIGHASH_ANYONECANPAY));
454    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
455                                "P2PK anyonecanpay marked with normal hashtype", 0
456                               ).PushSig(keys.key1, SIGHASH_ALL | SIGHASH_ANYONECANPAY).EditPush(70, "81", "01").ScriptError(SCRIPT_ERR_EVAL_FALSE));
457
458    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
459                                "P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true
460                               ).PushSig(keys.key0).PushRedeem());
461    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
462                                "P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true
463                               ).PushSig(keys.key0).PushRedeem().DamagePush(10).ScriptError(SCRIPT_ERR_EVAL_FALSE));
464
465    tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey0.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
466                                "P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true
467                               ).PushSig(keys.key0).Push(keys.pubkey0).PushRedeem());
468    tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
469                                "P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0, true
470                               ).PushSig(keys.key0).DamagePush(10).PushRedeem());
471    tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
472                                "P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH, true
473                               ).PushSig(keys.key0).DamagePush(10).PushRedeem().ScriptError(SCRIPT_ERR_EQUALVERIFY));
474
475    tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
476                                "3-of-3", 0
477                               ).Num(0).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
478    tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
479                                "3-of-3, 2 sigs", 0
480                               ).Num(0).PushSig(keys.key0).PushSig(keys.key1).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
481
482    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
483                                "P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true
484                               ).Num(0).PushSig(keys.key1).PushSig(keys.key2).PushRedeem());
485    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
486                                "P2SH(2-of-3), 1 sig", SCRIPT_VERIFY_P2SH, true
487                               ).Num(0).PushSig(keys.key1).Num(0).PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
488
489    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
490                                "P2PK with too much R padding but no DERSIG", 0
491                               ).PushSig(keys.key1, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000"));
492    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
493                                "P2PK with too much R padding", SCRIPT_VERIFY_DERSIG
494                               ).PushSig(keys.key1, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_SIG_DER));
495    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
496                                "P2PK with too much S padding but no DERSIG", 0
497                               ).PushSig(keys.key1, SIGHASH_ALL).EditPush(1, "44", "45").EditPush(37, "20", "2100"));
498    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
499                                "P2PK with too much S padding", SCRIPT_VERIFY_DERSIG
500                               ).PushSig(keys.key1, SIGHASH_ALL).EditPush(1, "44", "45").EditPush(37, "20", "2100").ScriptError(SCRIPT_ERR_SIG_DER));