Bitcoin Core 28.0.0
P2P Digital Currency
Loading...
Searching...
No Matches
script_tests.cpp
Go to the documentation of this file.
1// Copyright (c) 2011-2022 The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <test/data/script_tests.json.h>
6#include <test/data/bip341_wallet_vectors.json.h>
7
8#include <common/system.h>
9#include <core_io.h>
10#include <key.h>
11#include <rpc/util.h>
12#include <script/script.h>
13#include <script/script_error.h>
14#include <script/sigcache.h>
15#include <script/sign.h>
16#include <script/signingprovider.h>
17#include <script/solver.h>
18#include <streams.h>
19#include <test/util/json.h>
20#include <test/util/random.h>
21#include <test/util/setup_common.h>
22#include <test/util/transaction_utils.h>
23#include <util/fs.h>
24#include <util/strencodings.h>
25
26#include <cstdint>
27#include <fstream>
28#include <string>
29#include <vector>
30
31#include <boost/test/unit_test.hpp>
32
33#include <univalue.h>
34
35// Uncomment if you want to output updated JSON tests.
36// #define UPDATE_JSON_TESTS
37
38static const unsigned int gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
39
40unsigned int ParseScriptFlags(std::string strFlags);
41std::string FormatScriptFlags(unsigned int flags);
42
43struct ScriptErrorDesc
44{
45 ScriptError_t err;
46 const char *name;
47};
48
49static ScriptErrorDesc script_errors[]={
50 {SCRIPT_ERR_OK, "OK"},
51 {SCRIPT_ERR_UNKNOWN_ERROR, "UNKNOWN_ERROR"},
52 {SCRIPT_ERR_EVAL_FALSE, "EVAL_FALSE"},
53 {SCRIPT_ERR_OP_RETURN, "OP_RETURN"},
54 {SCRIPT_ERR_SCRIPT_SIZE, "SCRIPT_SIZE"},
55 {SCRIPT_ERR_PUSH_SIZE, "PUSH_SIZE"},
56 {SCRIPT_ERR_OP_COUNT, "OP_COUNT"},
57 {SCRIPT_ERR_STACK_SIZE, "STACK_SIZE"},
58 {SCRIPT_ERR_SIG_COUNT, "SIG_COUNT"},
59 {SCRIPT_ERR_PUBKEY_COUNT, "PUBKEY_COUNT"},
60 {SCRIPT_ERR_VERIFY, "VERIFY"},
61 {SCRIPT_ERR_EQUALVERIFY, "EQUALVERIFY"},
62 {SCRIPT_ERR_CHECKMULTISIGVERIFY, "CHECKMULTISIGVERIFY"},
63 {SCRIPT_ERR_CHECKSIGVERIFY, "CHECKSIGVERIFY"},
64 {SCRIPT_ERR_NUMEQUALVERIFY, "NUMEQUALVERIFY"},
65 {SCRIPT_ERR_BAD_OPCODE, "BAD_OPCODE"},
66 {SCRIPT_ERR_DISABLED_OPCODE, "DISABLED_OPCODE"},
67 {SCRIPT_ERR_INVALID_STACK_OPERATION, "INVALID_STACK_OPERATION"},
68 {SCRIPT_ERR_INVALID_ALTSTACK_OPERATION, "INVALID_ALTSTACK_OPERATION"},
69 {SCRIPT_ERR_UNBALANCED_CONDITIONAL, "UNBALANCED_CONDITIONAL"},
70 {SCRIPT_ERR_NEGATIVE_LOCKTIME, "NEGATIVE_LOCKTIME"},
71 {SCRIPT_ERR_UNSATISFIED_LOCKTIME, "UNSATISFIED_LOCKTIME"},
72 {SCRIPT_ERR_SIG_HASHTYPE, "SIG_HASHTYPE"},
73 {SCRIPT_ERR_SIG_DER, "SIG_DER"},
74 {SCRIPT_ERR_MINIMALDATA, "MINIMALDATA"},
75 {SCRIPT_ERR_SIG_PUSHONLY, "SIG_PUSHONLY"},
76 {SCRIPT_ERR_SIG_HIGH_S, "SIG_HIGH_S"},
77 {SCRIPT_ERR_SIG_NULLDUMMY, "SIG_NULLDUMMY"},
78 {SCRIPT_ERR_PUBKEYTYPE, "PUBKEYTYPE"},
79 {SCRIPT_ERR_CLEANSTACK, "CLEANSTACK"},
80 {SCRIPT_ERR_MINIMALIF, "MINIMALIF"},
81 {SCRIPT_ERR_SIG_NULLFAIL, "NULLFAIL"},
82 {SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS, "DISCOURAGE_UPGRADABLE_NOPS"},
83 {SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM, "DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM"},
84 {SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH, "WITNESS_PROGRAM_WRONG_LENGTH"},
85 {SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY, "WITNESS_PROGRAM_WITNESS_EMPTY"},
86 {SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH, "WITNESS_PROGRAM_MISMATCH"},
87 {SCRIPT_ERR_WITNESS_MALLEATED, "WITNESS_MALLEATED"},
88 {SCRIPT_ERR_WITNESS_MALLEATED_P2SH, "WITNESS_MALLEATED_P2SH"},
89 {SCRIPT_ERR_WITNESS_UNEXPECTED, "WITNESS_UNEXPECTED"},
90 {SCRIPT_ERR_WITNESS_PUBKEYTYPE, "WITNESS_PUBKEYTYPE"},
91 {SCRIPT_ERR_OP_CODESEPARATOR, "OP_CODESEPARATOR"},
92 {SCRIPT_ERR_SIG_FINDANDDELETE, "SIG_FINDANDDELETE"},
93};
94
95static std::string FormatScriptError(ScriptError_t err)
96{
97 for (const auto& se : script_errors)
98 if (se.err == err)
99 return se.name;
100 BOOST_ERROR("Unknown scripterror enumeration value, update script_errors in script_tests.cpp.");
101 return "";
102}
103
104static ScriptError_t ParseScriptError(const std::string& name)
105{
106 for (const auto& se : script_errors)
107 if (se.name == name)
108 return se.err;
109 BOOST_ERROR("Unknown scripterror \"" << name << "\" in test description");
110 return SCRIPT_ERR_UNKNOWN_ERROR;
111}
112
113BOOST_FIXTURE_TEST_SUITE(script_tests, BasicTestingSetup)
114
115void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const CScriptWitness& scriptWitness, uint32_t flags, const std::string& message, int scriptError, CAmount nValue = 0)
116{
117 bool expect = (scriptError == SCRIPT_ERR_OK);
118 if (flags & SCRIPT_VERIFY_CLEANSTACK) {
119 flags |= SCRIPT_VERIFY_P2SH;
120 flags |= SCRIPT_VERIFY_WITNESS;
121 }
122 ScriptError err;
123 const CTransaction txCredit{BuildCreditingTransaction(scriptPubKey, nValue)};
124 CMutableTransaction tx = BuildSpendingTransaction(scriptSig, scriptWitness, txCredit);
125 CMutableTransaction tx2 = tx;
126 BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, &scriptWitness, flags, MutableTransactionSignatureChecker(&tx, 0, txCredit.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err) == expect, message);
127 BOOST_CHECK_MESSAGE(err == scriptError, FormatScriptError(err) + " where " + FormatScriptError((ScriptError_t)scriptError) + " expected: " + message);
128
129 // Verify that removing flags from a passing test or adding flags to a failing test does not change the result.
130 for (int i = 0; i < 16; ++i) {
131 uint32_t extra_flags(InsecureRandBits(16));
132 uint32_t combined_flags{expect ? (flags & ~extra_flags) : (flags | extra_flags)};
133 // Weed out some invalid flag combinations.
134 if (combined_flags & SCRIPT_VERIFY_CLEANSTACK && ~combined_flags & (SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS)) continue;
135 if (combined_flags & SCRIPT_VERIFY_WITNESS && ~combined_flags & SCRIPT_VERIFY_P2SH) continue;
136 BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, &scriptWitness, combined_flags, MutableTransactionSignatureChecker(&tx, 0, txCredit.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err) == expect, message + strprintf(" (with flags %x)", combined_flags));
137 }
138}
139
140void static NegateSignatureS(std::vector<unsigned char>& vchSig) {
141 // Parse the signature.
142 std::vector<unsigned char> r, s;
143 r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
144 s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
145
146 // Really ugly to implement mod-n negation here, but it would be feature creep to expose such functionality from libsecp256k1.
147 static const unsigned char order[33] = {
148 0x00,
149 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
150 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
151 0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
152 0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x41
153 };
154 while (s.size() < 33) {
155 s.insert(s.begin(), 0x00);
156 }
157 int carry = 0;
158 for (int p = 32; p >= 1; p--) {
159 int n = (int)order[p] - s[p] - carry;
160 s[p] = (n + 256) & 0xFF;
161 carry = (n < 0);
162 }
163 assert(carry == 0);
164 if (s.size() > 1 && s[0] == 0 && s[1] < 0x80) {
165 s.erase(s.begin());
166 }
167
168 // Reconstruct the signature.
169 vchSig.clear();
170 vchSig.push_back(0x30);
171 vchSig.push_back(4 + r.size() + s.size());
172 vchSig.push_back(0x02);
173 vchSig.push_back(r.size());
174 vchSig.insert(vchSig.end(), r.begin(), r.end());
175 vchSig.push_back(0x02);
176 vchSig.push_back(s.size());
177 vchSig.insert(vchSig.end(), s.begin(), s.end());
178}
179
180namespace
181{
182const unsigned char vchKey0[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
183const unsigned char vchKey1[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0};
184const unsigned char vchKey2[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0};
185
186struct KeyData
187{
188 CKey key0, key0C, key1, key1C, key2, key2C;
189 CPubKey pubkey0, pubkey0C, pubkey0H;
190 CPubKey pubkey1, pubkey1C;
191 CPubKey pubkey2, pubkey2C;
192
193 KeyData()
194 {
195 key0.Set(vchKey0, vchKey0 + 32, false);
196 key0C.Set(vchKey0, vchKey0 + 32, true);
197 pubkey0 = key0.GetPubKey();
198 pubkey0H = key0.GetPubKey();
199 pubkey0C = key0C.GetPubKey();
200 *const_cast<unsigned char*>(pubkey0H.data()) = 0x06 | (pubkey0H[64] & 1);
201
202 key1.Set(vchKey1, vchKey1 + 32, false);
203 key1C.Set(vchKey1, vchKey1 + 32, true);
204 pubkey1 = key1.GetPubKey();
205 pubkey1C = key1C.GetPubKey();
206
207 key2.Set(vchKey2, vchKey2 + 32, false);
208 key2C.Set(vchKey2, vchKey2 + 32, true);
209 pubkey2 = key2.GetPubKey();
210 pubkey2C = key2C.GetPubKey();
211 }
212};
213
214enum class WitnessMode {
215 NONE,
216 PKH,
217 SH
218};
219
220class TestBuilder
221{
222private:
224 CScript script;
226 CScript redeemscript;
228 CScript witscript;
229 CScriptWitness scriptWitness;
230 CTransactionRef creditTx;
231 CMutableTransaction spendTx;
232 bool havePush{false};
233 std::vector<unsigned char> push;
234 std::string comment;
235 uint32_t flags;
236 int scriptError{SCRIPT_ERR_OK};
237 CAmount nValue;
238
239 void DoPush()
240 {
241 if (havePush) {
242 spendTx.vin[0].scriptSig << push;
243 havePush = false;
244 }
245 }
246
247 void DoPush(const std::vector<unsigned char>& data)
248 {
249 DoPush();
250 push = data;
251 havePush = true;
252 }
253
254public:
255 TestBuilder(const CScript& script_, const std::string& comment_, uint32_t flags_, bool P2SH = false, WitnessMode wm = WitnessMode::NONE, int witnessversion = 0, CAmount nValue_ = 0) : script(script_), comment(comment_), flags(flags_), nValue(nValue_)
256 {
257 CScript scriptPubKey = script;
258 if (wm == WitnessMode::PKH) {
259 uint160 hash;
260 CHash160().Write(Span{script}.subspan(1)).Finalize(hash);
261 script = CScript() << OP_DUP << OP_HASH160 << ToByteVector(hash) << OP_EQUALVERIFY << OP_CHECKSIG;
262 scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
263 } else if (wm == WitnessMode::SH) {
264 witscript = scriptPubKey;
265 uint256 hash;
266 CSHA256().Write(witscript.data(), witscript.size()).Finalize(hash.begin());
267 scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
268 }
269 if (P2SH) {
270 redeemscript = scriptPubKey;
271 scriptPubKey = CScript() << OP_HASH160 << ToByteVector(CScriptID(redeemscript)) << OP_EQUAL;
272 }
273 creditTx = MakeTransactionRef(BuildCreditingTransaction(scriptPubKey, nValue));
274 spendTx = BuildSpendingTransaction(CScript(), CScriptWitness(), *creditTx);
275 }
276
277 TestBuilder& ScriptError(ScriptError_t err)
278 {
279 scriptError = err;
280 return *this;
281 }
282
283 TestBuilder& Opcode(const opcodetype& _op)
284 {
285 DoPush();
286 spendTx.vin[0].scriptSig << _op;
287 return *this;
288 }
289
290 TestBuilder& Num(int num)
291 {
292 DoPush();
293 spendTx.vin[0].scriptSig << num;
294 return *this;
295 }
296
297 TestBuilder& Push(const std::string& hex)
298 {
299 DoPush(ParseHex(hex));
300 return *this;
301 }
302
303 TestBuilder& Push(const CScript& _script)
304 {
305 DoPush(std::vector<unsigned char>(_script.begin(), _script.end()));
306 return *this;
307 }
308
309 TestBuilder& PushSig(const CKey& key, int nHashType = SIGHASH_ALL, unsigned int lenR = 32, unsigned int lenS = 32, SigVersion sigversion = SigVersion::BASE, CAmount amount = 0)
310 {
311 uint256 hash = SignatureHash(script, spendTx, 0, nHashType, amount, sigversion);
312 std::vector<unsigned char> vchSig, r, s;
313 uint32_t iter = 0;
314 do {
315 key.Sign(hash, vchSig, false, iter++);
316 if ((lenS == 33) != (vchSig[5 + vchSig[3]] == 33)) {
317 NegateSignatureS(vchSig);
318 }
319 r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
320 s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
321 } while (lenR != r.size() || lenS != s.size());
322 vchSig.push_back(static_cast<unsigned char>(nHashType));
323 DoPush(vchSig);
324 return *this;
325 }
326
327 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)
328 {
329 if (amount == -1)
330 amount = nValue;
331 return PushSig(key, nHashType, lenR, lenS, sigversion, amount).AsWit();
332 }
333
334 TestBuilder& Push(const CPubKey& pubkey)
335 {
336 DoPush(std::vector<unsigned char>(pubkey.begin(), pubkey.end()));
337 return *this;
338 }
339
340 TestBuilder& PushRedeem()
341 {
342 DoPush(std::vector<unsigned char>(redeemscript.begin(), redeemscript.end()));
343 return *this;
344 }
345
346 TestBuilder& PushWitRedeem()
347 {
348 DoPush(std::vector<unsigned char>(witscript.begin(), witscript.end()));
349 return AsWit();
350 }
351
352 TestBuilder& EditPush(unsigned int pos, const std::string& hexin, const std::string& hexout)
353 {
354 assert(havePush);
355 std::vector<unsigned char> datain = ParseHex(hexin);
356 std::vector<unsigned char> dataout = ParseHex(hexout);
357 assert(pos + datain.size() <= push.size());
358 BOOST_CHECK_MESSAGE(std::vector<unsigned char>(push.begin() + pos, push.begin() + pos + datain.size()) == datain, comment);
359 push.erase(push.begin() + pos, push.begin() + pos + datain.size());
360 push.insert(push.begin() + pos, dataout.begin(), dataout.end());
361 return *this;
362 }
363
364 TestBuilder& DamagePush(unsigned int pos)
365 {
366 assert(havePush);
367 assert(pos < push.size());
368 push[pos] ^= 1;
369 return *this;
370 }
371
372 TestBuilder& Test()
373 {
374 TestBuilder copy = *this; // Make a copy so we can rollback the push.
375 DoPush();
376 DoTest(creditTx->vout[0].scriptPubKey, spendTx.vin[0].scriptSig, scriptWitness, flags, comment, scriptError, nValue);
377 *this = copy;
378 return *this;
379 }
380
381 TestBuilder& AsWit()
382 {
383 assert(havePush);
384 scriptWitness.stack.push_back(push);
385 havePush = false;
386 return *this;
387 }
388
389 UniValue GetJSON()
390 {
391 DoPush();
392 UniValue array(UniValue::VARR);
393 if (!scriptWitness.stack.empty()) {
394 UniValue wit(UniValue::VARR);
395 for (unsigned i = 0; i < scriptWitness.stack.size(); i++) {
396 wit.push_back(HexStr(scriptWitness.stack[i]));
397 }
398 wit.push_back(ValueFromAmount(nValue));
399 array.push_back(std::move(wit));
400 }
401 array.push_back(FormatScript(spendTx.vin[0].scriptSig));
402 array.push_back(FormatScript(creditTx->vout[0].scriptPubKey));
403 array.push_back(FormatScriptFlags(flags));
404 array.push_back(FormatScriptError((ScriptError_t)scriptError));
405 array.push_back(comment);
406 return array;
407 }
408
409 std::string GetComment() const
410 {
411 return comment;
412 }
413};
414
415std::string JSONPrettyPrint(const UniValue& univalue)
416{
417 std::string ret = univalue.write(4);
418 // Workaround for libunivalue pretty printer, which puts a space between commas and newlines
419 size_t pos = 0;
420 while ((pos = ret.find(" \n", pos)) != std::string::npos) {
421 ret.replace(pos, 2, "\n");
422 pos++;
423 }
424 return ret;
425}
426} // namespace
427
428BOOST_AUTO_TEST_CASE(script_build)
429{
430 const KeyData keys;
431
432 std::vector<TestBuilder> tests;
433
434 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
435 "P2PK", 0
436 ).PushSig(keys.key0));
437 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
438 "P2PK, bad sig", 0
439 ).PushSig(keys.key0).DamagePush(10).ScriptError(SCRIPT_ERR_EVAL_FALSE));
440
441 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1C.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
442 "P2PKH", 0
443 ).PushSig(keys.key1).Push(keys.pubkey1C));
444 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey2C.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
445 "P2PKH, bad pubkey", 0
446 ).PushSig(keys.key2).Push(keys.pubkey2C).DamagePush(5).ScriptError(SCRIPT_ERR_EQUALVERIFY));
447
448 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
449 "P2PK anyonecanpay", 0
450 ).PushSig(keys.key1, SIGHASH_ALL | SIGHASH_ANYONECANPAY));
451 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
452 "P2PK anyonecanpay marked with normal hashtype", 0
453 ).PushSig(keys.key1, SIGHASH_ALL | SIGHASH_ANYONECANPAY).EditPush(70, "81", "01").ScriptError(SCRIPT_ERR_EVAL_FALSE));
454
455 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
456 "P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true
457 ).PushSig(keys.key0).PushRedeem());
458 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
459 "P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true
460 ).PushSig(keys.key0).PushRedeem().DamagePush(10).ScriptError(SCRIPT_ERR_EVAL_FALSE));
461
462 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey0.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
463 "P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true
464 ).PushSig(keys.key0).Push(keys.pubkey0).PushRedeem());
465 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
466 "P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0, true
467 ).PushSig(keys.key0).DamagePush(10).PushRedeem());
468 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
469 "P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH, true
470 ).PushSig(keys.key0).DamagePush(10).PushRedeem().ScriptError(SCRIPT_ERR_EQUALVERIFY));
471
472 tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
473 "3-of-3", 0
474 ).Num(0).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
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, 2 sigs", 0
477 ).Num(0).PushSig(keys.key0).PushSig(keys.key1).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
478
479 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
480 "P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true
481 ).Num(0).PushSig(keys.key1).PushSig(keys.key2).PushRedeem());
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), 1 sig", SCRIPT_VERIFY_P2SH, true
484 ).Num(0).PushSig(keys.key1).Num(0).PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
485
486 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
487 "P2PK with too much R padding but no DERSIG", 0
488 ).PushSig(keys.key1, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000"));
489 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
490 "P2PK with too much R padding", SCRIPT_VERIFY_DERSIG
491 ).PushSig(keys.key1, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_SIG_DER));
492 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
493 "P2PK with too much S padding but no DERSIG", 0
494 ).PushSig(keys.key1, SIGHASH_ALL).EditPush(1, "44", "45").EditPush(37, "20", "2100"));
495 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
496 "P2PK with too much S padding", SCRIPT_VERIFY_DERSIG
497 ).PushSig(keys.key1, SIGHASH_ALL).EditPush(1, "44", "45").EditPush(37, "20", "2100").ScriptError(SCRIPT_ERR_SIG_DER));
498 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
499 "P2PK with too little R padding but no DERSIG", 0
500 ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
501 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
502 "P2PK with too little R padding", SCRIPT_VERIFY_DERSIG
503 ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
504 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
505 "P2PK NOT with bad sig with too much R padding but no DERSIG", 0
506 ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").DamagePush(10));
507 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
508 "P2PK NOT with bad sig with too much R padding", SCRIPT_VERIFY_DERSIG
509 ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").DamagePush(10).ScriptError(SCRIPT_ERR_SIG_DER));
510 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
511 "P2PK NOT with too much R padding but no DERSIG", 0
512 ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_EVAL_FALSE));
513 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
514 "P2PK NOT with too much R padding", SCRIPT_VERIFY_DERSIG
515 ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_SIG_DER));
516
517 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
518 "BIP66 example 1, without DERSIG", 0
519 ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
520 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
521 "BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG
522 ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
523 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
524 "BIP66 example 2, without DERSIG", 0
525 ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_EVAL_FALSE));
526 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
527 "BIP66 example 2, with DERSIG", SCRIPT_VERIFY_DERSIG
528 ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
529 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
530 "BIP66 example 3, without DERSIG", 0
531 ).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
532 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
533 "BIP66 example 3, with DERSIG", SCRIPT_VERIFY_DERSIG
534 ).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
535 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
536 "BIP66 example 4, without DERSIG", 0
537 ).Num(0));
538 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
539 "BIP66 example 4, with DERSIG", SCRIPT_VERIFY_DERSIG
540 ).Num(0));
541 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
542 "BIP66 example 5, without DERSIG", 0
543 ).Num(1).ScriptError(SCRIPT_ERR_EVAL_FALSE));
544 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
545 "BIP66 example 5, with DERSIG", SCRIPT_VERIFY_DERSIG
546 ).Num(1).ScriptError(SCRIPT_ERR_SIG_DER));
547 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
548 "BIP66 example 6, without DERSIG", 0
549 ).Num(1));
550 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
551 "BIP66 example 6, with DERSIG", SCRIPT_VERIFY_DERSIG
552 ).Num(1).ScriptError(SCRIPT_ERR_SIG_DER));
553 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
554 "BIP66 example 7, without DERSIG", 0
555 ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2));
556 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
557 "BIP66 example 7, with DERSIG", SCRIPT_VERIFY_DERSIG
558 ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_DER));
559 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
560 "BIP66 example 8, without DERSIG", 0
561 ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_EVAL_FALSE));
562 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
563 "BIP66 example 8, with DERSIG", SCRIPT_VERIFY_DERSIG
564 ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_DER));
565 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
566 "BIP66 example 9, without DERSIG", 0
567 ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_EVAL_FALSE));
568 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
569 "BIP66 example 9, with DERSIG", SCRIPT_VERIFY_DERSIG
570 ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
571 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
572 "BIP66 example 10, without DERSIG", 0
573 ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
574 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
575 "BIP66 example 10, with DERSIG", SCRIPT_VERIFY_DERSIG
576 ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
577 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
578 "BIP66 example 11, without DERSIG", 0
579 ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
580 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
581 "BIP66 example 11, with DERSIG", SCRIPT_VERIFY_DERSIG
582 ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
583 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
584 "BIP66 example 12, without DERSIG", 0
585 ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0));
586 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
587 "BIP66 example 12, with DERSIG", SCRIPT_VERIFY_DERSIG
588 ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0));
589 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
590 "P2PK with multi-byte hashtype, without DERSIG", 0
591 ).PushSig(keys.key2, SIGHASH_ALL).EditPush(70, "01", "0101"));
592 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
593 "P2PK with multi-byte hashtype, with DERSIG", SCRIPT_VERIFY_DERSIG
594 ).PushSig(keys.key2, SIGHASH_ALL).EditPush(70, "01", "0101").ScriptError(SCRIPT_ERR_SIG_DER));
595
596 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
597 "P2PK with high S but no LOW_S", 0
598 ).PushSig(keys.key2, SIGHASH_ALL, 32, 33));
599 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
600 "P2PK with high S", SCRIPT_VERIFY_LOW_S
601 ).PushSig(keys.key2, SIGHASH_ALL, 32, 33).ScriptError(SCRIPT_ERR_SIG_HIGH_S));
602
603 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
604 "P2PK with hybrid pubkey but no STRICTENC", 0
605 ).PushSig(keys.key0, SIGHASH_ALL));
606 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
607 "P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC
608 ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
609 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
610 "P2PK NOT with hybrid pubkey but no STRICTENC", 0
611 ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_EVAL_FALSE));
612 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
613 "P2PK NOT with hybrid pubkey", SCRIPT_VERIFY_STRICTENC
614 ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
615 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
616 "P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0
617 ).PushSig(keys.key0, SIGHASH_ALL).DamagePush(10));
618 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
619 "P2PK NOT with invalid hybrid pubkey", SCRIPT_VERIFY_STRICTENC
620 ).PushSig(keys.key0, SIGHASH_ALL).DamagePush(10).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
621 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
622 "1-of-2 with the second 1 hybrid pubkey and no STRICTENC", 0
623 ).Num(0).PushSig(keys.key1, SIGHASH_ALL));
624 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
625 "1-of-2 with the second 1 hybrid pubkey", SCRIPT_VERIFY_STRICTENC
626 ).Num(0).PushSig(keys.key1, SIGHASH_ALL));
627 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0H) << OP_2 << OP_CHECKMULTISIG,
628 "1-of-2 with the first 1 hybrid pubkey", SCRIPT_VERIFY_STRICTENC
629 ).Num(0).PushSig(keys.key1, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
630
631 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
632 "P2PK with undefined hashtype but no STRICTENC", 0
633 ).PushSig(keys.key1, 5));
634 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
635 "P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC
636 ).PushSig(keys.key1, 5).ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
637 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
638 "P2PK NOT with invalid sig and undefined hashtype but no STRICTENC", 0
639 ).PushSig(keys.key1, 5).DamagePush(10));
640 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
641 "P2PK NOT with invalid sig and undefined hashtype", SCRIPT_VERIFY_STRICTENC
642 ).PushSig(keys.key1, 5).DamagePush(10).ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
643
644 tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
645 "3-of-3 with nonzero dummy but no NULLDUMMY", 0
646 ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
647 tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
648 "3-of-3 with nonzero dummy", SCRIPT_VERIFY_NULLDUMMY
649 ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_NULLDUMMY));
650 tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG << OP_NOT,
651 "3-of-3 NOT with invalid sig and nonzero dummy but no NULLDUMMY", 0
652 ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).DamagePush(10));
653 tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG << OP_NOT,
654 "3-of-3 NOT with invalid sig with nonzero dummy", SCRIPT_VERIFY_NULLDUMMY
655 ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).DamagePush(10).ScriptError(SCRIPT_ERR_SIG_NULLDUMMY));
656
657 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
658 "2-of-2 with two identical keys and sigs pushed using OP_DUP but no SIGPUSHONLY", 0
659 ).Num(0).PushSig(keys.key1).Opcode(OP_DUP));
660 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
661 "2-of-2 with two identical keys and sigs pushed using OP_DUP", SCRIPT_VERIFY_SIGPUSHONLY
662 ).Num(0).PushSig(keys.key1).Opcode(OP_DUP).ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
663 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
664 "P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0, true
665 ).PushSig(keys.key2).Opcode(OP_NOP8).PushRedeem());
666 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
667 "P2PK with non-push scriptSig but with P2SH validation", 0
668 ).PushSig(keys.key2).Opcode(OP_NOP8));
669 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
670 "P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY", SCRIPT_VERIFY_P2SH, true
671 ).PushSig(keys.key2).Opcode(OP_NOP8).PushRedeem().ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
672 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
673 "P2SH(P2PK) with non-push scriptSig but not P2SH", SCRIPT_VERIFY_SIGPUSHONLY, true
674 ).PushSig(keys.key2).Opcode(OP_NOP8).PushRedeem().ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
675 tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
676 "2-of-2 with two identical keys and sigs pushed", SCRIPT_VERIFY_SIGPUSHONLY
677 ).Num(0).PushSig(keys.key1).PushSig(keys.key1));
678 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
679 "P2PK with unnecessary input but no CLEANSTACK", SCRIPT_VERIFY_P2SH
680 ).Num(11).PushSig(keys.key0));
681 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
682 "P2PK with unnecessary input", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH
683 ).Num(11).PushSig(keys.key0).ScriptError(SCRIPT_ERR_CLEANSTACK));
684 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
685 "P2SH with unnecessary input but no CLEANSTACK", SCRIPT_VERIFY_P2SH, true
686 ).Num(11).PushSig(keys.key0).PushRedeem());
687 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
688 "P2SH with unnecessary input", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true
689 ).Num(11).PushSig(keys.key0).PushRedeem().ScriptError(SCRIPT_ERR_CLEANSTACK));
690 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
691 "P2SH with CLEANSTACK", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true
692 ).PushSig(keys.key0).PushRedeem());
693
694 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
695 "Basic P2WSH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
696 0, 1).PushWitSig(keys.key0).PushWitRedeem());
697 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
698 "Basic P2WPKH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH,
699 0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit());
700 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
701 "Basic P2SH(P2WSH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
702 0, 1).PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
703 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
704 "Basic P2SH(P2WPKH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH,
705 0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().PushRedeem());
706 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
707 "Basic P2WSH with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
708 ).PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
709 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
710 "Basic P2WPKH with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
711 ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().ScriptError(SCRIPT_ERR_EVAL_FALSE));
712 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
713 "Basic P2SH(P2WSH) with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH
714 ).PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
715 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
716 "Basic P2SH(P2WPKH) with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH
717 ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
718 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
719 "Basic P2WSH with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
720 ).PushWitSig(keys.key0).PushWitRedeem());
721 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
722 "Basic P2WPKH with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
723 ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit());
724 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
725 "Basic P2SH(P2WSH) with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, true, WitnessMode::SH
726 ).PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
727 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
728 "Basic P2SH(P2WPKH) with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH
729 ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().PushRedeem());
730 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
731 "Basic P2WSH with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
732 0, 0).PushWitSig(keys.key0, 1).PushWitRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
733 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
734 "Basic P2WPKH with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH,
735 0, 0).PushWitSig(keys.key0, 1).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_EVAL_FALSE));
736 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
737 "Basic P2SH(P2WSH) with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
738 0, 0).PushWitSig(keys.key0, 1).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
739 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
740 "Basic P2SH(P2WPKH) with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH,
741 0, 0).PushWitSig(keys.key0, 1).Push(keys.pubkey0).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
742
743 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
744 "P2WPKH with future witness version", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH |
745 SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM, false, WitnessMode::PKH, 1
746 ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM));
747 {
748 CScript witscript = CScript() << ToByteVector(keys.pubkey0);
749 uint256 hash;
750 CSHA256().Write(witscript.data(), witscript.size()).Finalize(hash.begin());
751 std::vector<unsigned char> hashBytes = ToByteVector(hash);
752 hashBytes.pop_back();
753 tests.push_back(TestBuilder(CScript() << OP_0 << hashBytes,
754 "P2WPKH with wrong witness program length", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false
755 ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH));
756 }
757 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
758 "P2WSH with empty witness", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
759 ).ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY));
760 {
761 CScript witscript = CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG;
762 tests.push_back(TestBuilder(witscript,
763 "P2WSH with witness program mismatch", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
764 ).PushWitSig(keys.key0).Push(witscript).DamagePush(0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH));
765 }
766 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
767 "P2WPKH with witness program mismatch", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
768 ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().Push("0").AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH));
769 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
770 "P2WPKH with non-empty scriptSig", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
771 ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().Num(11).ScriptError(SCRIPT_ERR_WITNESS_MALLEATED));
772 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
773 "P2SH(P2WPKH) with superfluous push in scriptSig", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH
774 ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().Num(11).PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_MALLEATED_P2SH));
775 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
776 "P2PK with witness", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH
777 ).PushSig(keys.key0).Push("0").AsWit().ScriptError(SCRIPT_ERR_WITNESS_UNEXPECTED));
778
779 // Compressed keys should pass SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
780 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
781 "Basic P2WSH with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
782 0, 1).PushWitSig(keys.key0C).PushWitRedeem());
783 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C),
784 "Basic P2WPKH with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::PKH,
785 0, 1).PushWitSig(keys.key0C).Push(keys.pubkey0C).AsWit());
786 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
787 "Basic P2SH(P2WSH) with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
788 0, 1).PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
789 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C),
790 "Basic P2SH(P2WPKH) with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::PKH,
791 0, 1).PushWitSig(keys.key0C).Push(keys.pubkey0C).AsWit().PushRedeem());
792
793 // Testing uncompressed key in witness with SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
794 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
795 "Basic P2WSH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
796 0, 1).PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
797 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
798 "Basic P2WPKH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::PKH,
799 0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
800 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
801 "Basic P2SH(P2WSH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
802 0, 1).PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
803 tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
804 "Basic P2SH(P2WPKH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::PKH,
805 0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
806
807 // P2WSH 1-of-2 multisig with compressed keys
808 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
809 "P2WSH CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
810 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
811 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
812 "P2SH(P2WSH) CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
813 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
814 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
815 "P2WSH CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
816 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem());
817 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
818 "P2SH(P2WSH) CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
819 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem());
820
821 // P2WSH 1-of-2 multisig with first key uncompressed
822 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
823 "P2WSH CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
824 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem());
825 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
826 "P2SH(P2WSH) CHECKMULTISIG first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
827 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
828 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
829 "P2WSH CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
830 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
831 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
832 "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
833 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
834 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
835 "P2WSH CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
836 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem());
837 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
838 "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
839 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem());
840 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
841 "P2WSH CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
842 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
843 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
844 "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
845 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
846 // P2WSH 1-of-2 multisig with second key uncompressed
847 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
848 "P2WSH CHECKMULTISIG with second key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
849 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
850 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
851 "P2SH(P2WSH) CHECKMULTISIG second key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
852 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
853 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
854 "P2WSH CHECKMULTISIG with second key uncompressed and signing with the first key should pass as the uncompressed key is not used", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
855 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
856 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
857 "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the first key should pass as the uncompressed key is not used", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
858 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
859 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
860 "P2WSH CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
861 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem());
862 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
863 "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
864 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().PushRedeem());
865 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
866 "P2WSH CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
867 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
868 tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
869 "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
870 0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
871
872 std::set<std::string> tests_set;
873
874 {
875 UniValue json_tests = read_json(json_tests::script_tests);
876
877 for (unsigned int idx = 0; idx < json_tests.size(); idx++) {
878 const UniValue& tv = json_tests[idx];
879 tests_set.insert(JSONPrettyPrint(tv.get_array()));
880 }
881 }
882
883#ifdef UPDATE_JSON_TESTS
884 std::string strGen;
885#endif
886 for (TestBuilder& test : tests) {
887 test.Test();
888 std::string str = JSONPrettyPrint(test.GetJSON());
889#ifdef UPDATE_JSON_TESTS
890 strGen += str + ",\n";
891#else
892 if (tests_set.count(str) == 0) {
893 BOOST_CHECK_MESSAGE(false, "Missing auto script_valid test: " + test.GetComment());
894 }
895#endif
896 }
897
898#ifdef UPDATE_JSON_TESTS
899 FILE* file = fsbridge::fopen("script_tests.json.gen", "w");
900 fputs(strGen.c_str(), file);
901 fclose(file);
902#endif
903}
904
905BOOST_AUTO_TEST_CASE(script_json_test)
906{
907 // Read tests from test/data/script_tests.json
908 // Format is an array of arrays
909 // Inner arrays are [ ["wit"..., nValue]?, "scriptSig", "scriptPubKey", "flags", "expected_scripterror" ]
910 // ... where scriptSig and scriptPubKey are stringified
911 // scripts.
912 // If a witness is given, then the last value in the array should be the
913 // amount (nValue) to use in the crediting tx
914 UniValue tests = read_json(json_tests::script_tests);
915
916 for (unsigned int idx = 0; idx < tests.size(); idx++) {
917 const UniValue& test = tests[idx];
918 std::string strTest = test.write();
919 CScriptWitness witness;
920 CAmount nValue = 0;
921 unsigned int pos = 0;
922 if (test.size() > 0 && test[pos].isArray()) {
923 unsigned int i=0;
924 for (i = 0; i < test[pos].size()-1; i++) {
925 witness.stack.push_back(ParseHex(test[pos][i].get_str()));
926 }
927 nValue = AmountFromValue(test[pos][i]);
928 pos++;
929 }
930 if (test.size() < 4 + pos) // Allow size > 3; extra stuff ignored (useful for comments)
931 {
932 if (test.size() != 1) {
933 BOOST_ERROR("Bad test: " << strTest);
934 }
935 continue;
936 }
937 std::string scriptSigString = test[pos++].get_str();
938 CScript scriptSig = ParseScript(scriptSigString);
939 std::string scriptPubKeyString = test[pos++].get_str();
940 CScript scriptPubKey = ParseScript(scriptPubKeyString);
941 unsigned int scriptflags = ParseScriptFlags(test[pos++].get_str());
942 int scriptError = ParseScriptError(test[pos++].get_str());
943
944 DoTest(scriptPubKey, scriptSig, witness, scriptflags, strTest, scriptError, nValue);
945 }
946}
947
948BOOST_AUTO_TEST_CASE(script_PushData)
949{
950 // Check that PUSHDATA1, PUSHDATA2, and PUSHDATA4 create the same value on
951 // the stack as the 1-75 opcodes do.
952 static const unsigned char direct[] = { 1, 0x5a };
953 static const unsigned char pushdata1[] = { OP_PUSHDATA1, 1, 0x5a };
954 static const unsigned char pushdata2[] = { OP_PUSHDATA2, 1, 0, 0x5a };
955 static const unsigned char pushdata4[] = { OP_PUSHDATA4, 1, 0, 0, 0, 0x5a };
956
957 ScriptError err;
958 std::vector<std::vector<unsigned char> > directStack;
959 BOOST_CHECK(EvalScript(directStack, CScript(direct, direct + sizeof(direct)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
960 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
961
962 std::vector<std::vector<unsigned char> > pushdata1Stack;
963 BOOST_CHECK(EvalScript(pushdata1Stack, CScript(pushdata1, pushdata1 + sizeof(pushdata1)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
964 BOOST_CHECK(pushdata1Stack == directStack);
965 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
966
967 std::vector<std::vector<unsigned char> > pushdata2Stack;
968 BOOST_CHECK(EvalScript(pushdata2Stack, CScript(pushdata2, pushdata2 + sizeof(pushdata2)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
969 BOOST_CHECK(pushdata2Stack == directStack);
970 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
971
972 std::vector<std::vector<unsigned char> > pushdata4Stack;
973 BOOST_CHECK(EvalScript(pushdata4Stack, CScript(pushdata4, pushdata4 + sizeof(pushdata4)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
974 BOOST_CHECK(pushdata4Stack == directStack);
975 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
976
977 const std::vector<unsigned char> pushdata1_trunc{OP_PUSHDATA1, 1};
978 const std::vector<unsigned char> pushdata2_trunc{OP_PUSHDATA2, 1, 0};
979 const std::vector<unsigned char> pushdata4_trunc{OP_PUSHDATA4, 1, 0, 0, 0};
980
981 std::vector<std::vector<unsigned char>> stack_ignore;
982 BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata1_trunc.begin(), pushdata1_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
983 BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
984 BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata2_trunc.begin(), pushdata2_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
985 BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
986 BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata4_trunc.begin(), pushdata4_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
987 BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
988}
989
990BOOST_AUTO_TEST_CASE(script_cltv_truncated)
991{
992 const auto script_cltv_trunc = CScript() << OP_CHECKLOCKTIMEVERIFY;
993
994 std::vector<std::vector<unsigned char>> stack_ignore;
995 ScriptError err;
996 BOOST_CHECK(!EvalScript(stack_ignore, script_cltv_trunc, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, BaseSignatureChecker(), SigVersion::BASE, &err));
997 BOOST_CHECK_EQUAL(err, SCRIPT_ERR_INVALID_STACK_OPERATION);
998}
999
1000static CScript
1001sign_multisig(const CScript& scriptPubKey, const std::vector<CKey>& keys, const CTransaction& transaction)
1002{
1003 uint256 hash = SignatureHash(scriptPubKey, transaction, 0, SIGHASH_ALL, 0, SigVersion::BASE);
1004
1005 CScript result;
1006 //
1007 // NOTE: CHECKMULTISIG has an unfortunate bug; it requires
1008 // one extra item on the stack, before the signatures.
1009 // Putting OP_0 on the stack is the workaround;
1010 // fixing the bug would mean splitting the block chain (old
1011 // clients would not accept new CHECKMULTISIG transactions,
1012 // and vice-versa)
1013 //
1014 result << OP_0;
1015 for (const CKey &key : keys)
1016 {
1017 std::vector<unsigned char> vchSig;
1018 BOOST_CHECK(key.Sign(hash, vchSig));
1019 vchSig.push_back((unsigned char)SIGHASH_ALL);
1020 result << vchSig;
1021 }
1022 return result;
1023}
1024static CScript
1025sign_multisig(const CScript& scriptPubKey, const CKey& key, const CTransaction& transaction)
1026{
1027 std::vector<CKey> keys;
1028 keys.push_back(key);
1029 return sign_multisig(scriptPubKey, keys, transaction);
1030}
1031
1032BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12)
1033{
1034 ScriptError err;
1035 CKey key1 = GenerateRandomKey();
1036 CKey key2 = GenerateRandomKey(/*compressed=*/false);
1037 CKey key3 = GenerateRandomKey();
1038
1039 CScript scriptPubKey12;
1040 scriptPubKey12 << OP_1 << ToByteVector(key1.GetPubKey()) << ToByteVector(key2.GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
1041
1042 const CTransaction txFrom12{BuildCreditingTransaction(scriptPubKey12)};
1043 CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom12);
1044
1045 CScript goodsig1 = sign_multisig(scriptPubKey12, key1, CTransaction(txTo12));
1046 BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1047 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1048 txTo12.vout[0].nValue = 2;
1049 BOOST_CHECK(!VerifyScript(goodsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1050 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1051
1052 CScript goodsig2 = sign_multisig(scriptPubKey12, key2, CTransaction(txTo12));
1053 BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1054 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1055
1056 CScript badsig1 = sign_multisig(scriptPubKey12, key3, CTransaction(txTo12));
1057 BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1058 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1059}
1060
1061BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23)
1062{
1063 ScriptError err;
1064 CKey key1 = GenerateRandomKey();
1065 CKey key2 = GenerateRandomKey(/*compressed=*/false);
1066 CKey key3 = GenerateRandomKey();
1067 CKey key4 = GenerateRandomKey(/*compressed=*/false);
1068
1069 CScript scriptPubKey23;
1070 scriptPubKey23 << OP_2 << ToByteVector(key1.GetPubKey()) << ToByteVector(key2.GetPubKey()) << ToByteVector(key3.GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
1071
1072 const CTransaction txFrom23{BuildCreditingTransaction(scriptPubKey23)};
1073 CMutableTransaction txTo23 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom23);
1074
1075 std::vector<CKey> keys;
1076 keys.push_back(key1); keys.push_back(key2);
1077 CScript goodsig1 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1078 BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1079 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1080
1081 keys.clear();
1082 keys.push_back(key1); keys.push_back(key3);
1083 CScript goodsig2 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1084 BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1085 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1086
1087 keys.clear();
1088 keys.push_back(key2); keys.push_back(key3);
1089 CScript goodsig3 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1090 BOOST_CHECK(VerifyScript(goodsig3, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1091 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1092
1093 keys.clear();
1094 keys.push_back(key2); keys.push_back(key2); // Can't reuse sig
1095 CScript badsig1 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1096 BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1097 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1098
1099 keys.clear();
1100 keys.push_back(key2); keys.push_back(key1); // sigs must be in correct order
1101 CScript badsig2 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1102 BOOST_CHECK(!VerifyScript(badsig2, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1103 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1104
1105 keys.clear();
1106 keys.push_back(key3); keys.push_back(key2); // sigs must be in correct order
1107 CScript badsig3 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1108 BOOST_CHECK(!VerifyScript(badsig3, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1109 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1110
1111 keys.clear();
1112 keys.push_back(key4); keys.push_back(key2); // sigs must match pubkeys
1113 CScript badsig4 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1114 BOOST_CHECK(!VerifyScript(badsig4, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1115 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1116
1117 keys.clear();
1118 keys.push_back(key1); keys.push_back(key4); // sigs must match pubkeys
1119 CScript badsig5 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1120 BOOST_CHECK(!VerifyScript(badsig5, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1121 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1122
1123 keys.clear(); // Must have signatures
1124 CScript badsig6 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1125 BOOST_CHECK(!VerifyScript(badsig6, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1126 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, ScriptErrorString(err));
1127}
1128
1129/* Wrapper around ProduceSignature to combine two scriptsigs */
1130SignatureData CombineSignatures(const CTxOut& txout, const CMutableTransaction& tx, const SignatureData& scriptSig1, const SignatureData& scriptSig2)
1131{
1132 SignatureData data;
1133 data.MergeSignatureData(scriptSig1);
1134 data.MergeSignatureData(scriptSig2);
1135 ProduceSignature(DUMMY_SIGNING_PROVIDER, MutableTransactionSignatureCreator(tx, 0, txout.nValue, SIGHASH_DEFAULT), txout.scriptPubKey, data);
1136 return data;
1137}
1138
1139BOOST_AUTO_TEST_CASE(script_combineSigs)
1140{
1141 // Test the ProduceSignature's ability to combine signatures function
1142 FillableSigningProvider keystore;
1143 std::vector<CKey> keys;
1144 std::vector<CPubKey> pubkeys;
1145 for (int i = 0; i < 3; i++)
1146 {
1147 CKey key = GenerateRandomKey(/*compressed=*/i%2 == 1);
1148 keys.push_back(key);
1149 pubkeys.push_back(key.GetPubKey());
1150 BOOST_CHECK(keystore.AddKey(key));
1151 }
1152
1153 CMutableTransaction txFrom = BuildCreditingTransaction(GetScriptForDestination(PKHash(keys[0].GetPubKey())));
1154 CMutableTransaction txTo = BuildSpendingTransaction(CScript(), CScriptWitness(), CTransaction(txFrom));
1155 CScript& scriptPubKey = txFrom.vout[0].scriptPubKey;
1156 SignatureData scriptSig;
1157
1158 SignatureData empty;
1159 SignatureData combined = CombineSignatures(txFrom.vout[0], txTo, empty, empty);
1160 BOOST_CHECK(combined.scriptSig.empty());
1161
1162 // Single signature case:
1163 SignatureData dummy;
1164 BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy)); // changes scriptSig
1165 scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1166 combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
1167 BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1168 combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
1169 BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1170 SignatureData scriptSigCopy = scriptSig;
1171 // Signing again will give a different, valid signature:
1172 SignatureData dummy_b;
1173 BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_b));
1174 scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1175 combined = CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
1176 BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig || combined.scriptSig == scriptSig.scriptSig);
1177
1178 // P2SH, single-signature case:
1179 CScript pkSingle; pkSingle << ToByteVector(keys[0].GetPubKey()) << OP_CHECKSIG;
1180 BOOST_CHECK(keystore.AddCScript(pkSingle));
1181 scriptPubKey = GetScriptForDestination(ScriptHash(pkSingle));
1182 SignatureData dummy_c;
1183 BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_c));
1184 scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1185 combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
1186 BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1187 combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
1188 BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1189 scriptSigCopy = scriptSig;
1190 SignatureData dummy_d;
1191 BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_d));
1192 scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1193 combined = CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
1194 BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig || combined.scriptSig == scriptSig.scriptSig);
1195
1196 // Hardest case: Multisig 2-of-3
1197 scriptPubKey = GetScriptForMultisig(2, pubkeys);
1198 BOOST_CHECK(keystore.AddCScript(scriptPubKey));
1199 SignatureData dummy_e;
1200 BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_e));
1201 scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1202 combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
1203 BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1204 combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
1205 BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1206
1207 // A couple of partially-signed versions:
1208 std::vector<unsigned char> sig1;
1209 uint256 hash1 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_ALL, 0, SigVersion::BASE);
1210 BOOST_CHECK(keys[0].Sign(hash1, sig1));
1211 sig1.push_back(SIGHASH_ALL);
1212 std::vector<unsigned char> sig2;
1213 uint256 hash2 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_NONE, 0, SigVersion::BASE);
1214 BOOST_CHECK(keys[1].Sign(hash2, sig2));
1215 sig2.push_back(SIGHASH_NONE);
1216 std::vector<unsigned char> sig3;
1217 uint256 hash3 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_SINGLE, 0, SigVersion::BASE);
1218 BOOST_CHECK(keys[2].Sign(hash3, sig3));
1219 sig3.push_back(SIGHASH_SINGLE);
1220
1221 // Not fussy about order (or even existence) of placeholders or signatures:
1222 CScript partial1a = CScript() << OP_0 << sig1 << OP_0;
1223 CScript partial1b = CScript() << OP_0 << OP_0 << sig1;
1224 CScript partial2a = CScript() << OP_0 << sig2;
1225 CScript partial2b = CScript() << sig2 << OP_0;
1226 CScript partial3a = CScript() << sig3;
1227 CScript partial3b = CScript() << OP_0 << OP_0 << sig3;
1228 CScript partial3c = CScript() << OP_0 << sig3 << OP_0;
1229 CScript complete12 = CScript() << OP_0 << sig1 << sig2;
1230 CScript complete13 = CScript() << OP_0 << sig1 << sig3;
1231 CScript complete23 = CScript() << OP_0 << sig2 << sig3;
1232 SignatureData partial1_sigs;
1233 partial1_sigs.signatures.emplace(keys[0].GetPubKey().GetID(), SigPair(keys[0].GetPubKey(), sig1));
1234 SignatureData partial2_sigs;
1235 partial2_sigs.signatures.emplace(keys[1].GetPubKey().GetID(), SigPair(keys[1].GetPubKey(), sig2));
1236 SignatureData partial3_sigs;
1237 partial3_sigs.signatures.emplace(keys[2].GetPubKey().GetID(), SigPair(keys[2].GetPubKey(), sig3));
1238
1239 combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial1_sigs);
1240 BOOST_CHECK(combined.scriptSig == partial1a);
1241 combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
1242 BOOST_CHECK(combined.scriptSig == complete12);
1243 combined = CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial1_sigs);
1244 BOOST_CHECK(combined.scriptSig == complete12);
1245 combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
1246 BOOST_CHECK(combined.scriptSig == complete12);
1247 combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial1_sigs);
1248 BOOST_CHECK(combined.scriptSig == complete13);
1249 combined = CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial3_sigs);
1250 BOOST_CHECK(combined.scriptSig == complete23);
1251 combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial2_sigs);
1252 BOOST_CHECK(combined.scriptSig == complete23);
1253 combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial3_sigs);
1254 BOOST_CHECK(combined.scriptSig == partial3c);
1255}
1256
1260BOOST_AUTO_TEST_CASE(sign_invalid_miniscript)
1261{
1262 FillableSigningProvider keystore;
1263 SignatureData sig_data;
1264 CMutableTransaction prev, curr;
1265
1266 // Create a Taproot output which contains a leaf in which a non-32 bytes push is used where a public key is expected
1267 // by the Miniscript parser. This offending Script was found by the RPC fuzzer.
1268 const auto invalid_pubkey{ParseHex("173d36c8c9c9c9ffffffffffff0200000000021e1e37373721361818181818181e1e1e1e19000000000000000000b19292929292926b006c9b9b9292")};
1269 TaprootBuilder builder;
1270 builder.Add(0, {invalid_pubkey}, 0xc0);
1271 builder.Finalize(XOnlyPubKey::NUMS_H);
1272 prev.vout.emplace_back(0, GetScriptForDestination(builder.GetOutput()));
1273 curr.vin.emplace_back(COutPoint{prev.GetHash(), 0});
1274 sig_data.tr_spenddata = builder.GetSpendData();
1275
1276 // SignSignature can fail but it shouldn't raise an exception (nor crash).
1277 BOOST_CHECK(!SignSignature(keystore, CTransaction(prev), curr, 0, SIGHASH_ALL, sig_data));
1278}
1279
1280/* P2A input should be considered signed. */
1281BOOST_AUTO_TEST_CASE(sign_paytoanchor)
1282{
1283 FillableSigningProvider keystore;
1284 SignatureData sig_data;
1285 CMutableTransaction prev, curr;
1286 prev.vout.emplace_back(0, GetScriptForDestination(PayToAnchor{}));
1287
1288 curr.vin.emplace_back(COutPoint{prev.GetHash(), 0});
1289
1290 BOOST_CHECK(SignSignature(keystore, CTransaction(prev), curr, 0, SIGHASH_ALL, sig_data));
1291}
1292
1293BOOST_AUTO_TEST_CASE(script_standard_push)
1294{
1295 ScriptError err;
1296 for (int i=0; i<67000; i++) {
1297 CScript script;
1298 script << i;
1299 BOOST_CHECK_MESSAGE(script.IsPushOnly(), "Number " << i << " is not pure push.");
1300 BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1, nullptr, SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err), "Number " << i << " push is not minimal data.");
1301 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1302 }
1303
1304 for (unsigned int i=0; i<=MAX_SCRIPT_ELEMENT_SIZE; i++) {
1305 std::vector<unsigned char> data(i, '\111');
1306 CScript script;
1307 script << data;
1308 BOOST_CHECK_MESSAGE(script.IsPushOnly(), "Length " << i << " is not pure push.");
1309 BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1, nullptr, SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err), "Length " << i << " push is not minimal data.");
1310 BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1311 }
1312}
1313
1314BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts)
1315{
1316 // IsPushOnly returns false when given a script containing only pushes that
1317 // are invalid due to truncation. IsPushOnly() is consensus critical
1318 // because P2SH evaluation uses it, although this specific behavior should
1319 // not be consensus critical as the P2SH evaluation would fail first due to
1320 // the invalid push. Still, it doesn't hurt to test it explicitly.
1321 static const unsigned char direct[] = { 1 };
1322 BOOST_CHECK(!CScript(direct, direct+sizeof(direct)).IsPushOnly());
1323}
1324
1325BOOST_AUTO_TEST_CASE(script_GetScriptAsm)
1326{
1327 BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2, true));
1328 BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY, true));
1329 BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2));
1330 BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY));
1331
1332 std::string derSig("304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c5090");
1333 std::string pubKey("03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2");
1334 std::vector<unsigned char> vchPubKey = ToByteVector(ParseHex(pubKey));
1335
1336 BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey, true));
1337 BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey, true));
1338 BOOST_CHECK_EQUAL(derSig + "[ALL] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "01")) << vchPubKey, true));
1339 BOOST_CHECK_EQUAL(derSig + "[NONE] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "02")) << vchPubKey, true));
1340 BOOST_CHECK_EQUAL(derSig + "[SINGLE] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "03")) << vchPubKey, true));
1341 BOOST_CHECK_EQUAL(derSig + "[ALL|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "81")) << vchPubKey, true));
1342 BOOST_CHECK_EQUAL(derSig + "[NONE|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "82")) << vchPubKey, true));
1343 BOOST_CHECK_EQUAL(derSig + "[SINGLE|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "83")) << vchPubKey, true));
1344
1345 BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey));
1346 BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey));
1347 BOOST_CHECK_EQUAL(derSig + "01 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "01")) << vchPubKey));
1348 BOOST_CHECK_EQUAL(derSig + "02 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "02")) << vchPubKey));
1349 BOOST_CHECK_EQUAL(derSig + "03 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "03")) << vchPubKey));
1350 BOOST_CHECK_EQUAL(derSig + "81 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "81")) << vchPubKey));
1351 BOOST_CHECK_EQUAL(derSig + "82 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "82")) << vchPubKey));
1352 BOOST_CHECK_EQUAL(derSig + "83 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "83")) << vchPubKey));
1353}
1354
1355static CScript ScriptFromHex(const std::string& str)
1356{
1357 std::vector<unsigned char> data = ParseHex(str);
1358 return CScript(data.begin(), data.end());
1359}
1360
1361BOOST_AUTO_TEST_CASE(script_FindAndDelete)
1362{
1363 // Exercise the FindAndDelete functionality
1364 CScript s;
1365 CScript d;
1366 CScript expect;
1367
1368 s = CScript() << OP_1 << OP_2;
1369 d = CScript(); // delete nothing should be a no-op
1370 expect = s;
1371 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1372 BOOST_CHECK(s == expect);
1373
1374 s = CScript() << OP_1 << OP_2 << OP_3;
1375 d = CScript() << OP_2;
1376 expect = CScript() << OP_1 << OP_3;
1377 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1378 BOOST_CHECK(s == expect);
1379
1380 s = CScript() << OP_3 << OP_1 << OP_3 << OP_3 << OP_4 << OP_3;
1381 d = CScript() << OP_3;
1382 expect = CScript() << OP_1 << OP_4;
1383 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 4);
1384 BOOST_CHECK(s == expect);
1385
1386 s = ScriptFromHex("0302ff03"); // PUSH 0x02ff03 onto stack
1387 d = ScriptFromHex("0302ff03");
1388 expect = CScript();
1389 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1390 BOOST_CHECK(s == expect);
1391
1392 s = ScriptFromHex("0302ff030302ff03"); // PUSH 0x2ff03 PUSH 0x2ff03
1393 d = ScriptFromHex("0302ff03");
1394 expect = CScript();
1395 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
1396 BOOST_CHECK(s == expect);
1397
1398 s = ScriptFromHex("0302ff030302ff03");
1399 d = ScriptFromHex("02");
1400 expect = s; // FindAndDelete matches entire opcodes
1401 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1402 BOOST_CHECK(s == expect);
1403
1404 s = ScriptFromHex("0302ff030302ff03");
1405 d = ScriptFromHex("ff");
1406 expect = s;
1407 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1408 BOOST_CHECK(s == expect);
1409
1410 // This is an odd edge case: strip of the push-three-bytes
1411 // prefix, leaving 02ff03 which is push-two-bytes:
1412 s = ScriptFromHex("0302ff030302ff03");
1413 d = ScriptFromHex("03");
1414 expect = CScript() << ParseHex("ff03") << ParseHex("ff03");
1415 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
1416 BOOST_CHECK(s == expect);
1417
1418 // Byte sequence that spans multiple opcodes:
1419 s = ScriptFromHex("02feed5169"); // PUSH(0xfeed) OP_1 OP_VERIFY
1420 d = ScriptFromHex("feed51");
1421 expect = s;
1422 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0); // doesn't match 'inside' opcodes
1423 BOOST_CHECK(s == expect);
1424
1425 s = ScriptFromHex("02feed5169"); // PUSH(0xfeed) OP_1 OP_VERIFY
1426 d = ScriptFromHex("02feed51");
1427 expect = ScriptFromHex("69");
1428 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1429 BOOST_CHECK(s == expect);
1430
1431 s = ScriptFromHex("516902feed5169");
1432 d = ScriptFromHex("feed51");
1433 expect = s;
1434 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1435 BOOST_CHECK(s == expect);
1436
1437 s = ScriptFromHex("516902feed5169");
1438 d = ScriptFromHex("02feed51");
1439 expect = ScriptFromHex("516969");
1440 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1441 BOOST_CHECK(s == expect);
1442
1443 s = CScript() << OP_0 << OP_0 << OP_1 << OP_1;
1444 d = CScript() << OP_0 << OP_1;
1445 expect = CScript() << OP_0 << OP_1; // FindAndDelete is single-pass
1446 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1447 BOOST_CHECK(s == expect);
1448
1449 s = CScript() << OP_0 << OP_0 << OP_1 << OP_0 << OP_1 << OP_1;
1450 d = CScript() << OP_0 << OP_1;
1451 expect = CScript() << OP_0 << OP_1; // FindAndDelete is single-pass
1452 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
1453 BOOST_CHECK(s == expect);
1454
1455 // Another weird edge case:
1456 // End with invalid push (not enough data)...
1457 s = ScriptFromHex("0003feed");
1458 d = ScriptFromHex("03feed"); // ... can remove the invalid push
1459 expect = ScriptFromHex("00");
1460 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1461 BOOST_CHECK(s == expect);
1462
1463 s = ScriptFromHex("0003feed");
1464 d = ScriptFromHex("00");
1465 expect = ScriptFromHex("03feed");
1466 BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1467 BOOST_CHECK(s == expect);
1468}
1469
1470BOOST_AUTO_TEST_CASE(script_HasValidOps)
1471{
1472 // Exercise the HasValidOps functionality
1473 CScript script;
1474 script = ScriptFromHex("76a9141234567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac"); // Normal script
1475 BOOST_CHECK(script.HasValidOps());
1476 script = ScriptFromHex("76a914ff34567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac");
1477 BOOST_CHECK(script.HasValidOps());
1478 script = ScriptFromHex("ff88ac"); // Script with OP_INVALIDOPCODE explicit
1479 BOOST_CHECK(!script.HasValidOps());
1480 script = ScriptFromHex("88acc0"); // Script with undefined opcode
1481 BOOST_CHECK(!script.HasValidOps());
1482}
1483
1484static CMutableTransaction TxFromHex(const std::string& str)
1485{
1486 CMutableTransaction tx;
1487 SpanReader{ParseHex(str)} >> TX_NO_WITNESS(tx);
1488 return tx;
1489}
1490
1491static std::vector<CTxOut> TxOutsFromJSON(const UniValue& univalue)
1492{
1493 assert(univalue.isArray());
1494 std::vector<CTxOut> prevouts;
1495 for (size_t i = 0; i < univalue.size(); ++i) {
1496 CTxOut txout;
1497 SpanReader{ParseHex(univalue[i].get_str())} >> txout;
1498 prevouts.push_back(std::move(txout));
1499 }
1500 return prevouts;
1501}
1502
1503static CScriptWitness ScriptWitnessFromJSON(const UniValue& univalue)
1504{
1505 assert(univalue.isArray());
1506 CScriptWitness scriptwitness;
1507 for (size_t i = 0; i < univalue.size(); ++i) {
1508 auto bytes = ParseHex(univalue[i].get_str());
1509 scriptwitness.stack.push_back(std::move(bytes));
1510 }
1511 return scriptwitness;
1512}
1513
1514static std::vector<unsigned int> AllConsensusFlags()
1515{
1516 std::vector<unsigned int> ret;
1517
1518 for (unsigned int i = 0; i < 128; ++i) {
1519 unsigned int flag = 0;
1520 if (i & 1) flag |= SCRIPT_VERIFY_P2SH;
1521 if (i & 2) flag |= SCRIPT_VERIFY_DERSIG;
1522 if (i & 4) flag |= SCRIPT_VERIFY_NULLDUMMY;
1523 if (i & 8) flag |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
1524 if (i & 16) flag |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
1525 if (i & 32) flag |= SCRIPT_VERIFY_WITNESS;
1526 if (i & 64) flag |= SCRIPT_VERIFY_TAPROOT;
1527
1528 // SCRIPT_VERIFY_WITNESS requires SCRIPT_VERIFY_P2SH
1529 if (flag & SCRIPT_VERIFY_WITNESS && !(flag & SCRIPT_VERIFY_P2SH)) continue;
1530 // SCRIPT_VERIFY_TAPROOT requires SCRIPT_VERIFY_WITNESS
1531 if (flag & SCRIPT_VERIFY_TAPROOT && !(flag & SCRIPT_VERIFY_WITNESS)) continue;
1532
1533 ret.push_back(flag);
1534 }
1535
1536 return ret;
1537}
1538
1540static const std::vector<unsigned int> ALL_CONSENSUS_FLAGS = AllConsensusFlags();
1541
1542static void AssetTest(const UniValue& test, SignatureCache& signature_cache)
1543{
1544 BOOST_CHECK(test.isObject());
1545
1546 CMutableTransaction mtx = TxFromHex(test["tx"].get_str());
1547 const std::vector<CTxOut> prevouts = TxOutsFromJSON(test["prevouts"]);
1548 BOOST_CHECK(prevouts.size() == mtx.vin.size());
1549 size_t idx = test["index"].getInt<int64_t>();
1550 uint32_t test_flags{ParseScriptFlags(test["flags"].get_str())};
1551 bool fin = test.exists("final") && test["final"].get_bool();
1552
1553 if (test.exists("success")) {
1554 mtx.vin[idx].scriptSig = ScriptFromHex(test["success"]["scriptSig"].get_str());
1555 mtx.vin[idx].scriptWitness = ScriptWitnessFromJSON(test["success"]["witness"]);
1556 CTransaction tx(mtx);
1557 PrecomputedTransactionData txdata;
1558 txdata.Init(tx, std::vector<CTxOut>(prevouts));
1559 CachingTransactionSignatureChecker txcheck(&tx, idx, prevouts[idx].nValue, true, signature_cache, txdata);
1560
1561 for (const auto flags : ALL_CONSENSUS_FLAGS) {
1562 // "final": true tests are valid for all flags. Others are only valid with flags that are
1563 // a subset of test_flags.
1564 if (fin || ((flags & test_flags) == flags)) {
1565 bool ret = VerifyScript(tx.vin[idx].scriptSig, prevouts[idx].scriptPubKey, &tx.vin[idx].scriptWitness, flags, txcheck, nullptr);
1566 BOOST_CHECK(ret);
1567 }
1568 }
1569 }
1570
1571 if (test.exists("failure")) {
1572 mtx.vin[idx].scriptSig = ScriptFromHex(test["failure"]["scriptSig"].get_str());
1573 mtx.vin[idx].scriptWitness = ScriptWitnessFromJSON(test["failure"]["witness"]);
1574 CTransaction tx(mtx);
1575 PrecomputedTransactionData txdata;
1576 txdata.Init(tx, std::vector<CTxOut>(prevouts));
1577 CachingTransactionSignatureChecker txcheck(&tx, idx, prevouts[idx].nValue, true, signature_cache, txdata);
1578
1579 for (const auto flags : ALL_CONSENSUS_FLAGS) {
1580 // If a test is supposed to fail with test_flags, it should also fail with any superset thereof.
1581 if ((flags & test_flags) == test_flags) {
1582 bool ret = VerifyScript(tx.vin[idx].scriptSig, prevouts[idx].scriptPubKey, &tx.vin[idx].scriptWitness, flags, txcheck, nullptr);
1583 BOOST_CHECK(!ret);
1584 }
1585 }
1586 }
1587}
1588
1589BOOST_AUTO_TEST_CASE(script_assets_test)
1590{
1591 // See src/test/fuzz/script_assets_test_minimizer.cpp for information on how to generate
1592 // the script_assets_test.json file used by this test.
1593 SignatureCache signature_cache{DEFAULT_SIGNATURE_CACHE_BYTES};
1594
1595 const char* dir = std::getenv("DIR_UNIT_TEST_DATA");
1596 BOOST_WARN_MESSAGE(dir != nullptr, "Variable DIR_UNIT_TEST_DATA unset, skipping script_assets_test");
1597 if (dir == nullptr) return;
1598 auto path = fs::path(dir) / "script_assets_test.json";
1599 bool exists = fs::exists(path);
1600 BOOST_WARN_MESSAGE(exists, "File $DIR_UNIT_TEST_DATA/script_assets_test.json not found, skipping script_assets_test");
1601 if (!exists) return;
1602 std::ifstream file{path};
1603 BOOST_CHECK(file.is_open());
1604 file.seekg(0, std::ios::end);
1605 size_t length = file.tellg();
1606 file.seekg(0, std::ios::beg);
1607 std::string data(length, '\0');
1608 file.read(data.data(), data.size());
1609 UniValue tests = read_json(data);
1610 BOOST_CHECK(tests.isArray());
1611 BOOST_CHECK(tests.size() > 0);
1612
1613 for (size_t i = 0; i < tests.size(); i++) {
1614 AssetTest(tests[i], signature_cache);
1615 }
1616 file.close();
1617}
1618
1619BOOST_AUTO_TEST_CASE(bip341_keypath_test_vectors)
1620{
1621 UniValue tests;
1622 tests.read(json_tests::bip341_wallet_vectors);
1623
1624 const auto& vectors = tests["keyPathSpending"];
1625
1626 for (const auto& vec : vectors.getValues()) {
1627 auto txhex = ParseHex(vec["given"]["rawUnsignedTx"].get_str());
1628 CMutableTransaction tx;
1629 SpanReader{txhex} >> TX_WITH_WITNESS(tx);
1630 std::vector<CTxOut> utxos;
1631 for (const auto& utxo_spent : vec["given"]["utxosSpent"].getValues()) {
1632 auto script_bytes = ParseHex(utxo_spent["scriptPubKey"].get_str());
1633 CScript script{script_bytes.begin(), script_bytes.end()};
1634 CAmount amount{utxo_spent["amountSats"].getInt<int>()};
1635 utxos.emplace_back(amount, script);
1636 }
1637
1638 PrecomputedTransactionData txdata;
1639 txdata.Init(tx, std::vector<CTxOut>{utxos}, true);
1640
1641 BOOST_CHECK(txdata.m_bip341_taproot_ready);
1642 BOOST_CHECK_EQUAL(HexStr(txdata.m_spent_amounts_single_hash), vec["intermediary"]["hashAmounts"].get_str());
1643 BOOST_CHECK_EQUAL(HexStr(txdata.m_outputs_single_hash), vec["intermediary"]["hashOutputs"].get_str());
1644 BOOST_CHECK_EQUAL(HexStr(txdata.m_prevouts_single_hash), vec["intermediary"]["hashPrevouts"].get_str());
1645 BOOST_CHECK_EQUAL(HexStr(txdata.m_spent_scripts_single_hash), vec["intermediary"]["hashScriptPubkeys"].get_str());
1646 BOOST_CHECK_EQUAL(HexStr(txdata.m_sequences_single_hash), vec["intermediary"]["hashSequences"].get_str());
1647
1648 for (const auto& input : vec["inputSpending"].getValues()) {
1649 int txinpos = input["given"]["txinIndex"].getInt<int>();
1650 int hashtype = input["given"]["hashType"].getInt<int>();
1651
1652 // Load key.
1653 auto privkey = ParseHex(input["given"]["internalPrivkey"].get_str());
1654 CKey key;
1655 key.Set(privkey.begin(), privkey.end(), true);
1656
1657 // Load Merkle root.
1658 uint256 merkle_root;
1659 if (!input["given"]["merkleRoot"].isNull()) {
1660 merkle_root = uint256{ParseHex(input["given"]["merkleRoot"].get_str())};
1661 }
1662
1663 // Compute and verify (internal) public key.
1664 XOnlyPubKey pubkey{key.GetPubKey()};
1665 BOOST_CHECK_EQUAL(HexStr(pubkey), input["intermediary"]["internalPubkey"].get_str());
1666
1667 // Sign and verify signature.
1668 FlatSigningProvider provider;
1669 provider.keys[key.GetPubKey().GetID()] = key;
1670 MutableTransactionSignatureCreator creator(tx, txinpos, utxos[txinpos].nValue, &txdata, hashtype);
1671 std::vector<unsigned char> signature;
1672 BOOST_CHECK(creator.CreateSchnorrSig(provider, signature, pubkey, nullptr, &merkle_root, SigVersion::TAPROOT));
1673 BOOST_CHECK_EQUAL(HexStr(signature), input["expected"]["witness"][0].get_str());
1674
1675 // We can't observe the tweak used inside the signing logic, so verify by recomputing it.
1676 BOOST_CHECK_EQUAL(HexStr(pubkey.ComputeTapTweakHash(merkle_root.IsNull() ? nullptr : &merkle_root)), input["intermediary"]["tweak"].get_str());
1677
1678 // We can't observe the sighash used inside the signing logic, so verify by recomputing it.
1679 ScriptExecutionData sed;
1680 sed.m_annex_init = true;
1681 sed.m_annex_present = false;
1682 uint256 sighash;
1683 BOOST_CHECK(SignatureHashSchnorr(sighash, sed, tx, txinpos, hashtype, SigVersion::TAPROOT, txdata, MissingDataBehavior::FAIL));
1684 BOOST_CHECK_EQUAL(HexStr(sighash), input["intermediary"]["sigHash"].get_str());
1685
1686 // To verify the sigmsg, hash the expected sigmsg, and compare it with the (expected) sighash.
1687 BOOST_CHECK_EQUAL(HexStr((HashWriter{HASHER_TAPSIGHASH} << Span{ParseHex(input["intermediary"]["sigMsg"].get_str())}).GetSHA256()), input["intermediary"]["sigHash"].get_str());
1688 }
1689
1690 }
1691}
1692
1693BOOST_AUTO_TEST_CASE(compute_tapbranch)
1694{
1695 constexpr uint256 hash1{"8ad69ec7cf41c2a4001fd1f738bf1e505ce2277acdcaa63fe4765192497f47a7"};
1696 constexpr uint256 hash2{"f224a923cd0021ab202ab139cc56802ddb92dcfc172b9212261a539df79a112a"};
1697 constexpr uint256 result{"a64c5b7b943315f9b805d7a7296bedfcfd08919270a1f7a1466e98f8693d8cd9"};
1698 BOOST_CHECK_EQUAL(ComputeTapbranchHash(hash1, hash2), result);
1699}
1700
1701BOOST_AUTO_TEST_CASE(compute_tapleaf)
1702{
1703 constexpr uint8_t script[6] = {'f','o','o','b','a','r'};
1704 constexpr uint256 tlc0{"edbc10c272a1215dcdcc11d605b9027b5ad6ed97cd45521203f136767b5b9c06"};
1705 constexpr uint256 tlc2{"8b5c4f90ae6bf76e259dbef5d8a59df06359c391b59263741b25eca76451b27a"};
1706
1707 BOOST_CHECK_EQUAL(ComputeTapleafHash(0xc0, Span(script)), tlc0);
1708 BOOST_CHECK_EQUAL(ComputeTapleafHash(0xc2, Span(script)), tlc2);
1709}
1710
1711BOOST_AUTO_TEST_SUITE_END()
GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
Definition addresstype.cpp:166
CAmount
int64_t CAmount
Amount in satoshis (Can be negative)
Definition amount.h:12
bip341_wallet_vectors.json.h
ret
int ret
Definition bitcoin-cli.cpp:1306
AmountFromValue
static CAmount AmountFromValue(const UniValue &value)
Definition bitcoin-tx.cpp:558
flags
int flags
Definition bitcoin-tx.cpp:533
CHash160
A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160).
Definition hash.h:49
CHash160::Finalize
void Finalize(Span< unsigned char > output)
Definition hash.h:55
CHash160::Write
CHash160 & Write(Span< const unsigned char > input)
Definition hash.h:62
CKey
An encapsulated private key.
Definition key.h:35
CKey::Sign
bool Sign(const uint256 &hash, std::vector< unsigned char > &vchSig, bool grind=true, uint32_t test_case=0) const
Create a DER-serialized signature.
Definition key.cpp:208
CKey::GetPubKey
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition key.cpp:182
CKey::Set
void Set(const T pbegin, const T pend, bool fCompressedIn)
Initialize using begin and end iterators to byte data.
Definition key.h:103
COutPoint
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition transaction.h:29
CPubKey
An encapsulated public key.
Definition pubkey.h:34
CPubKey::data
const unsigned char * data() const
Definition pubkey.h:113
CPubKey::GetID
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition pubkey.h:164
CPubKey::end
const unsigned char * end() const
Definition pubkey.h:115
CPubKey::begin
const unsigned char * begin() const
Definition pubkey.h:114
CSHA256
A hasher class for SHA-256.
Definition sha256.h:14
CSHA256::Finalize
void Finalize(unsigned char hash[OUTPUT_SIZE])
Definition sha256.cpp:727
CSHA256::Write
CSHA256 & Write(const unsigned char *data, size_t len)
Definition sha256.cpp:701
CScript
Serialized script, used inside transaction inputs and outputs.
Definition script.h:414
CScriptID
A reference to a CScript: the Hash160 of its serialization.
Definition script.h:591
CTransaction
The basic transaction that is broadcasted on the network and contained in blocks.
Definition transaction.h:296
CTransaction::vin
const std::vector< CTxIn > vin
Definition transaction.h:306
CTxOut
An output of a transaction.
Definition transaction.h:150
CTxOut::scriptPubKey
CScript scriptPubKey
Definition transaction.h:153
CTxOut::nValue
CAmount nValue
Definition transaction.h:152
FillableSigningProvider
Fillable signing provider that keeps keys in an address->secret map.
Definition signingprovider.h:227
FillableSigningProvider::AddCScript
virtual bool AddCScript(const CScript &redeemScript)
Definition signingprovider.cpp:158
FillableSigningProvider::AddKey
virtual bool AddKey(const CKey &key)
Definition signingprovider.h:287
HashWriter
A writer stream (for serialization) that computes a 256-bit hash.
Definition hash.h:101
MutableTransactionSignatureCreator
A signature creator for transactions.
Definition sign.h:40
MutableTransactionSignatureCreator::CreateSchnorrSig
bool CreateSchnorrSig(const SigningProvider &provider, std::vector< unsigned char > &sig, const XOnlyPubKey &pubkey, const uint256 *leaf_hash, const uint256 *merkle_root, SigVersion sigversion) const override
Definition sign.cpp:62
SignatureCache
Valid signature cache, to avoid doing expensive ECDSA signature checking twice for every transaction ...
Definition sigcache.h:39
Span
A Span is an object that can refer to a contiguous sequence of objects.
Definition span.h:98
Span::subspan
CONSTEXPR_IF_NOT_DEBUG Span< C > subspan(std::size_t offset) const noexcept
Definition span.h:195
SpanReader
Minimal stream for reading from an existing byte array by Span.
Definition streams.h:101
TaprootBuilder
Utility class to construct Taproot outputs from internal key and script tree.
Definition signingprovider.h:46
TaprootBuilder::GetOutput
WitnessV1Taproot GetOutput()
Compute scriptPubKey (after Finalize()).
Definition signingprovider.cpp:400
TaprootBuilder::GetSpendData
TaprootSpendData GetSpendData() const
Compute spending data (after Finalize()).
Definition signingprovider.cpp:402
TaprootBuilder::Add
TaprootBuilder & Add(int depth, Span< const unsigned char > script, int leaf_version, bool track=true)
Add a new script at a certain depth in the tree.
Definition signingprovider.cpp:366
TaprootBuilder::Finalize
TaprootBuilder & Finalize(const XOnlyPubKey &internal_key)
Finalize the construction.
Definition signingprovider.cpp:389
UniValue::get_str
const std::string & get_str() const
Definition univalue_get.cpp:66
UniValue::isArray
bool isArray() const
Definition univalue.h:85
UniValue::write
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
Definition univalue_write.cpp:31
UniValue::size
size_t size() const
Definition univalue.h:71
UniValue::read
bool read(std::string_view raw)
Definition univalue_read.cpp:263
UniValue::getInt
Int getInt() const
Definition univalue.h:138
UniValue::get_array
const UniValue & get_array() const
Definition univalue_get.cpp:87
UniValue::exists
bool exists(const std::string &key) const
Definition univalue.h:77
UniValue::get_bool
bool get_bool() const
Definition univalue_get.cpp:60
UniValue::isObject
bool isObject() const
Definition univalue.h:86
XOnlyPubKey::NUMS_H
static const XOnlyPubKey NUMS_H
Nothing Up My Sleeve point H Used as an internal key for provably disabling the key path spend see BI...
Definition pubkey.h:194
base_blob::IsNull
constexpr bool IsNull() const
Definition uint256.h:46
base_blob::begin
constexpr unsigned char * begin()
Definition uint256.h:102
fs::path
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Definition fs.h:33
prevector::empty
bool empty() const
Definition prevector.h:300
prevector::size
size_type size() const
Definition prevector.h:296
prevector::data
value_type * data()
Definition prevector.h:532
prevector::begin
iterator begin()
Definition prevector.h:304
prevector::end
iterator end()
Definition prevector.h:306
prevector::push_back
void push_back(const T &value)
Definition prevector.h:443
uint160
160-bit opaque blob.
Definition uint256.h:166
uint256
256-bit opaque blob.
Definition uint256.h:178
core_io.h
ParseScript
CScript ParseScript(const std::string &s)
Definition core_read.cpp:63
FormatScript
std::string FormatScript(const CScript &script)
Definition core_write.cpp:39
ScriptToAsmStr
std::string ScriptToAsmStr(const CScript &script, const bool fAttemptSighashDecode=false)
Create the assembly string representation of a CScript object.
Definition core_write.cpp:98
ValueFromAmount
UniValue ValueFromAmount(const CAmount amount)
Definition core_write.cpp:26
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
HexStr
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition hex_base.cpp:29
SignatureHashSchnorr
bool SignatureHashSchnorr(uint256 &hash_out, ScriptExecutionData &execdata, const T &tx_to, uint32_t in_pos, uint8_t hash_type, SigVersion sigversion, const PrecomputedTransactionData &cache, MissingDataBehavior mdb)
Definition interpreter.cpp:1478
FindAndDelete
int FindAndDelete(CScript &script, const CScript &b)
Definition interpreter.cpp:228
ComputeTapleafHash
uint256 ComputeTapleafHash(uint8_t leaf_version, Span< const unsigned char > script)
Compute the BIP341 tapleaf hash from leaf version & script.
Definition interpreter.cpp:1828
SignatureHash
uint256 SignatureHash(const CScript &scriptCode, const T &txTo, unsigned int nIn, int nHashType, const CAmount &amount, SigVersion sigversion, const PrecomputedTransactionData *cache)
Definition interpreter.cpp:1568
ComputeTapbranchHash
uint256 ComputeTapbranchHash(Span< const unsigned char > a, Span< const unsigned char > b)
Compute the BIP341 tapbranch hash from two branches.
Definition interpreter.cpp:1833
EvalScript
bool EvalScript(std::vector< std::vector< unsigned char > > &stack, const CScript &script, unsigned int flags, const BaseSignatureChecker &checker, SigVersion sigversion, ScriptExecutionData &execdata, ScriptError *serror)
Definition interpreter.cpp:406
VerifyScript
bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, unsigned int flags, const BaseSignatureChecker &checker, ScriptError *serror)
Definition interpreter.cpp:1958
HASHER_TAPSIGHASH
const HashWriter HASHER_TAPSIGHASH
Hasher with tag "TapSighash" pre-fed to it.
Definition interpreter.cpp:1461
SigVersion
SigVersion
Definition interpreter.h:191
SigVersion::TAPROOT
@ TAPROOT
Witness v1 with 32-byte program, not BIP16 P2SH-wrapped, key path spending; see BIP 341.
SigVersion::BASE
@ BASE
Bare scripts and BIP16 P2SH-wrapped redeemscripts.
SigVersion::WITNESS_V0
@ WITNESS_V0
Witness v0 (P2WPKH and P2WSH); see BIP 141.
MutableTransactionSignatureChecker
GenericTransactionSignatureChecker< CMutableTransaction > MutableTransactionSignatureChecker
Definition interpreter.h:307
SCRIPT_VERIFY_NULLDUMMY
@ SCRIPT_VERIFY_NULLDUMMY
Definition interpreter.h:64
SCRIPT_VERIFY_P2SH
@ SCRIPT_VERIFY_P2SH
Definition interpreter.h:49
SCRIPT_VERIFY_SIGPUSHONLY
@ SCRIPT_VERIFY_SIGPUSHONLY
Definition interpreter.h:67
SCRIPT_VERIFY_WITNESS
@ SCRIPT_VERIFY_WITNESS
Definition interpreter.h:108
SCRIPT_VERIFY_LOW_S
@ SCRIPT_VERIFY_LOW_S
Definition interpreter.h:61
SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
@ SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
Definition interpreter.h:99
SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
@ SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
Definition interpreter.h:126
SCRIPT_VERIFY_TAPROOT
@ SCRIPT_VERIFY_TAPROOT
Definition interpreter.h:134
SCRIPT_VERIFY_STRICTENC
@ SCRIPT_VERIFY_STRICTENC
Definition interpreter.h:54
SCRIPT_VERIFY_DERSIG
@ SCRIPT_VERIFY_DERSIG
Definition interpreter.h:57
SCRIPT_VERIFY_CLEANSTACK
@ SCRIPT_VERIFY_CLEANSTACK
Definition interpreter.h:94
SCRIPT_VERIFY_MINIMALDATA
@ SCRIPT_VERIFY_MINIMALDATA
Definition interpreter.h:73
SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
@ SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
Definition interpreter.h:104
SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
@ SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
Definition interpreter.h:112
SIGHASH_ANYONECANPAY
@ SIGHASH_ANYONECANPAY
Definition interpreter.h:33
SIGHASH_DEFAULT
@ SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
Definition interpreter.h:35
SIGHASH_ALL
@ SIGHASH_ALL
Definition interpreter.h:30
SIGHASH_NONE
@ SIGHASH_NONE
Definition interpreter.h:31
SIGHASH_SINGLE
@ SIGHASH_SINGLE
Definition interpreter.h:32
MissingDataBehavior::ASSERT_FAIL
@ ASSERT_FAIL
Abort execution through assertion failure (for consensus code)
MissingDataBehavior::FAIL
@ FAIL
Just act as if the signature was invalid.
read_json
UniValue read_json(const std::string &jsondata)
Definition json.cpp:12
GenerateRandomKey
CKey GenerateRandomKey(bool compressed) noexcept
Definition key.cpp:352
NONE
@ NONE
Definition mapport.h:13
fs::exists
static bool exists(const path &p)
Definition fs.h:89
fsbridge::fopen
FILE * fopen(const fs::path &p, const char *mode)
Definition fs.cpp:26
json_tests
Definition base58_encode_decode.json.h:2
json_tests::bip341_wallet_vectors
static const std::string bip341_wallet_vectors
Definition bip341_wallet_vectors.json.h:3
json_tests::script_tests
static const std::string script_tests
Definition script_tests.json.h:3
miniscript::Opcode
std::pair< opcodetype, std::vector< unsigned char > > Opcode
Definition miniscript.h:184
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition object.cpp:18
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition object.cpp:17
TX_NO_WITNESS
static constexpr TransactionSerParams TX_NO_WITNESS
Definition transaction.h:196
TX_WITH_WITNESS
static constexpr TransactionSerParams TX_WITH_WITNESS
Definition transaction.h:195
MakeTransactionRef
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition transaction.h:424
CTransactionRef
std::shared_ptr< const CTransaction > CTransactionRef
Definition transaction.h:423
name
const char * name
Definition rest.cpp:49
MAX_SCRIPT_ELEMENT_SIZE
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE
Definition script.h:27
opcodetype
opcodetype
Script opcodes.
Definition script.h:73
OP_2
@ OP_2
Definition script.h:84
OP_PUSHDATA4
@ OP_PUSHDATA4
Definition script.h:79
OP_CHECKMULTISIG
@ OP_CHECKMULTISIG
Definition script.h:191
OP_CHECKSIG
@ OP_CHECKSIG
Definition script.h:189
OP_CHECKLOCKTIMEVERIFY
@ OP_CHECKLOCKTIMEVERIFY
Definition script.h:196
OP_NOT
@ OP_NOT
Definition script.h:157
OP_EQUAL
@ OP_EQUAL
Definition script.h:145
OP_4
@ OP_4
Definition script.h:86
OP_DUP
@ OP_DUP
Definition script.h:124
OP_NOP2
@ OP_NOP2
Definition script.h:197
OP_NOP8
@ OP_NOP8
Definition script.h:204
OP_HASH160
@ OP_HASH160
Definition script.h:186
OP_1
@ OP_1
Definition script.h:82
OP_PUSHDATA1
@ OP_PUSHDATA1
Definition script.h:77
OP_3
@ OP_3
Definition script.h:85
OP_PUSHDATA2
@ OP_PUSHDATA2
Definition script.h:78
OP_0
@ OP_0
Definition script.h:75
OP_EQUALVERIFY
@ OP_EQUALVERIFY
Definition script.h:146
ToByteVector
std::vector< unsigned char > ToByteVector(const T &in)
Definition script.h:66
ScriptErrorString
std::string ScriptErrorString(const ScriptError serror)
Definition script_error.cpp:10
script_error.h
ScriptError
enum ScriptError_t ScriptError
ScriptError_t
ScriptError_t
Definition script_error.h:12
SCRIPT_ERR_OP_CODESEPARATOR
@ SCRIPT_ERR_OP_CODESEPARATOR
Definition script_error.h:82
SCRIPT_ERR_SIG_PUSHONLY
@ SCRIPT_ERR_SIG_PUSHONLY
Definition script_error.h:48
SCRIPT_ERR_OP_COUNT
@ SCRIPT_ERR_OP_COUNT
Definition script_error.h:21
SCRIPT_ERR_EVAL_FALSE
@ SCRIPT_ERR_EVAL_FALSE
Definition script_error.h:15
SCRIPT_ERR_NUMEQUALVERIFY
@ SCRIPT_ERR_NUMEQUALVERIFY
Definition script_error.h:31
SCRIPT_ERR_VERIFY
@ SCRIPT_ERR_VERIFY
Definition script_error.h:27
SCRIPT_ERR_DISABLED_OPCODE
@ SCRIPT_ERR_DISABLED_OPCODE
Definition script_error.h:35
SCRIPT_ERR_INVALID_ALTSTACK_OPERATION
@ SCRIPT_ERR_INVALID_ALTSTACK_OPERATION
Definition script_error.h:37
SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
@ SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
Definition script_error.h:58
SCRIPT_ERR_SCRIPT_SIZE
@ SCRIPT_ERR_SCRIPT_SIZE
Definition script_error.h:19
SCRIPT_ERR_UNKNOWN_ERROR
@ SCRIPT_ERR_UNKNOWN_ERROR
Definition script_error.h:14
SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH
@ SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH
Definition script_error.h:64
SCRIPT_ERR_SIG_HASHTYPE
@ SCRIPT_ERR_SIG_HASHTYPE
Definition script_error.h:45
SCRIPT_ERR_MINIMALDATA
@ SCRIPT_ERR_MINIMALDATA
Definition script_error.h:47
SCRIPT_ERR_CHECKSIGVERIFY
@ SCRIPT_ERR_CHECKSIGVERIFY
Definition script_error.h:30
SCRIPT_ERR_STACK_SIZE
@ SCRIPT_ERR_STACK_SIZE
Definition script_error.h:22
SCRIPT_ERR_WITNESS_MALLEATED_P2SH
@ SCRIPT_ERR_WITNESS_MALLEATED_P2SH
Definition script_error.h:68
SCRIPT_ERR_WITNESS_MALLEATED
@ SCRIPT_ERR_WITNESS_MALLEATED
Definition script_error.h:67
SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS
@ SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS
Definition script_error.h:57
SCRIPT_ERR_EQUALVERIFY
@ SCRIPT_ERR_EQUALVERIFY
Definition script_error.h:28
SCRIPT_ERR_INVALID_STACK_OPERATION
@ SCRIPT_ERR_INVALID_STACK_OPERATION
Definition script_error.h:36
SCRIPT_ERR_SIG_COUNT
@ SCRIPT_ERR_SIG_COUNT
Definition script_error.h:23
SCRIPT_ERR_SIG_HIGH_S
@ SCRIPT_ERR_SIG_HIGH_S
Definition script_error.h:49
SCRIPT_ERR_SIG_DER
@ SCRIPT_ERR_SIG_DER
Definition script_error.h:46
SCRIPT_ERR_WITNESS_UNEXPECTED
@ SCRIPT_ERR_WITNESS_UNEXPECTED
Definition script_error.h:69
SCRIPT_ERR_NEGATIVE_LOCKTIME
@ SCRIPT_ERR_NEGATIVE_LOCKTIME
Definition script_error.h:41
SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH
@ SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH
Definition script_error.h:66
SCRIPT_ERR_OP_RETURN
@ SCRIPT_ERR_OP_RETURN
Definition script_error.h:16
SCRIPT_ERR_PUSH_SIZE
@ SCRIPT_ERR_PUSH_SIZE
Definition script_error.h:20
SCRIPT_ERR_SIG_NULLFAIL
@ SCRIPT_ERR_SIG_NULLFAIL
Definition script_error.h:54
SCRIPT_ERR_OK
@ SCRIPT_ERR_OK
Definition script_error.h:13
SCRIPT_ERR_SIG_NULLDUMMY
@ SCRIPT_ERR_SIG_NULLDUMMY
Definition script_error.h:50
SCRIPT_ERR_PUBKEYTYPE
@ SCRIPT_ERR_PUBKEYTYPE
Definition script_error.h:51
SCRIPT_ERR_CHECKMULTISIGVERIFY
@ SCRIPT_ERR_CHECKMULTISIGVERIFY
Definition script_error.h:29
SCRIPT_ERR_UNSATISFIED_LOCKTIME
@ SCRIPT_ERR_UNSATISFIED_LOCKTIME
Definition script_error.h:42
SCRIPT_ERR_WITNESS_PUBKEYTYPE
@ SCRIPT_ERR_WITNESS_PUBKEYTYPE
Definition script_error.h:70
SCRIPT_ERR_SIG_FINDANDDELETE
@ SCRIPT_ERR_SIG_FINDANDDELETE
Definition script_error.h:83
SCRIPT_ERR_BAD_OPCODE
@ SCRIPT_ERR_BAD_OPCODE
Definition script_error.h:34
SCRIPT_ERR_PUBKEY_COUNT
@ SCRIPT_ERR_PUBKEY_COUNT
Definition script_error.h:24
SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY
@ SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY
Definition script_error.h:65
SCRIPT_ERR_CLEANSTACK
@ SCRIPT_ERR_CLEANSTACK
Definition script_error.h:52
SCRIPT_ERR_UNBALANCED_CONDITIONAL
@ SCRIPT_ERR_UNBALANCED_CONDITIONAL
Definition script_error.h:38
SCRIPT_ERR_MINIMALIF
@ SCRIPT_ERR_MINIMALIF
Definition script_error.h:53
FormatScriptError
static std::string FormatScriptError(ScriptError_t err)
Definition script_tests.cpp:95
NegateSignatureS
static void NegateSignatureS(std::vector< unsigned char > &vchSig)
Definition script_tests.cpp:140
ParseScriptError
static ScriptError_t ParseScriptError(const std::string &name)
Definition script_tests.cpp:104
ScriptFromHex
static CScript ScriptFromHex(const std::string &str)
Definition script_tests.cpp:1355
CombineSignatures
SignatureData CombineSignatures(const CTxOut &txout, const CMutableTransaction &tx, const SignatureData &scriptSig1, const SignatureData &scriptSig2)
Definition script_tests.cpp:1130
script_errors
static ScriptErrorDesc script_errors[]
Definition script_tests.cpp:49
TxFromHex
static CMutableTransaction TxFromHex(const std::string &str)
Definition script_tests.cpp:1484
DoTest
void DoTest(const CScript &scriptPubKey, const CScript &scriptSig, const CScriptWitness &scriptWitness, uint32_t flags, const std::string &message, int scriptError, CAmount nValue=0)
Definition script_tests.cpp:115
sign_multisig
static CScript sign_multisig(const CScript &scriptPubKey, const std::vector< CKey > &keys, const CTransaction &transaction)
Definition script_tests.cpp:1001
ParseScriptFlags
unsigned int ParseScriptFlags(std::string strFlags)
Definition transaction_tests.cpp:74
AllConsensusFlags
static std::vector< unsigned int > AllConsensusFlags()
Definition script_tests.cpp:1514
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(script_build)
Definition script_tests.cpp:428
FormatScriptFlags
std::string FormatScriptFlags(unsigned int flags)
Definition transaction_tests.cpp:99
gFlags
static const unsigned int gFlags
Definition script_tests.cpp:38
TxOutsFromJSON
static std::vector< CTxOut > TxOutsFromJSON(const UniValue &univalue)
Definition script_tests.cpp:1491
AssetTest
static void AssetTest(const UniValue &test, SignatureCache &signature_cache)
Definition script_tests.cpp:1542
ScriptWitnessFromJSON
static CScriptWitness ScriptWitnessFromJSON(const UniValue &univalue)
Definition script_tests.cpp:1503
ALL_CONSENSUS_FLAGS
static const std::vector< unsigned int > ALL_CONSENSUS_FLAGS
Precomputed list of all valid combinations of consensus-relevant script validation flags.
Definition script_tests.cpp:1540
script_tests.json.h
setup_common.h
DEFAULT_SIGNATURE_CACHE_BYTES
static constexpr size_t DEFAULT_SIGNATURE_CACHE_BYTES
Definition sigcache.h:29
ProduceSignature
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
Definition sign.cpp:502
GetPubKey
static bool GetPubKey(const SigningProvider &provider, const SignatureData &sigdata, const CKeyID &address, CPubKey &pubkey)
Definition sign.cpp:109
DataFromTransaction
SignatureData DataFromTransaction(const CMutableTransaction &tx, unsigned int nIn, const CTxOut &txout)
Extract signature data from a transaction input, and insert it.
Definition sign.cpp:610
SignSignature
bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey, CMutableTransaction &txTo, unsigned int nIn, const CAmount &amount, int nHashType, SignatureData &sig_data)
Produce a satisfying script (scriptSig or witness).
Definition sign.cpp:697
SigPair
std::pair< CPubKey, std::vector< unsigned char > > SigPair
Definition sign.h:63
DUMMY_SIGNING_PROVIDER
const SigningProvider & DUMMY_SIGNING_PROVIDER
Definition signingprovider.cpp:12
GetScriptForMultisig
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
Definition solver.cpp:218
Span
Span(T *, EndOrSize) -> Span< T >
ParseHex
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
Definition strencodings.h:66
BasicTestingSetup
Basic testing setup.
Definition setup_common.h:64
CMutableTransaction
A mutable version of CTransaction.
Definition transaction.h:378
CMutableTransaction::vout
std::vector< CTxOut > vout
Definition transaction.h:380
CMutableTransaction::GetHash
Txid GetHash() const
Compute the hash of this CMutableTransaction.
Definition transaction.cpp:69
CMutableTransaction::vin
std::vector< CTxIn > vin
Definition transaction.h:379
CScriptWitness::stack
std::vector< std::vector< unsigned char > > stack
Definition script.h:577
FlatSigningProvider::keys
std::map< CKeyID, CKey > keys
Definition signingprovider.h:212
Num
A type to represent integers in the type system.
Definition lintrans.h:13
PrecomputedTransactionData::Init
void Init(const T &tx, std::vector< CTxOut > &&spent_outputs, bool force=false)
Initialize this PrecomputedTransactionData with transaction data.
Definition interpreter.cpp:1398
PrecomputedTransactionData::m_bip341_taproot_ready
bool m_bip341_taproot_ready
Whether the 5 fields above are initialized.
Definition interpreter.h:163
ScriptErrorDesc::err
ScriptError_t err
Definition script_tests.cpp:45
ScriptErrorDesc::name
const char * name
Definition script_tests.cpp:46
ScriptExecutionData::m_annex_present
bool m_annex_present
Whether an annex is present.
Definition interpreter.h:213
ScriptExecutionData::m_annex_init
bool m_annex_init
Whether m_annex_present and (when needed) m_annex_hash are initialized.
Definition interpreter.h:211
SignatureData::MergeSignatureData
void MergeSignatureData(SignatureData sigdata)
Definition sign.cpp:681
SignatureData::signatures
std::map< CKeyID, SigPair > signatures
BIP 174 style partial signatures for the input. May contain all signatures necessary for producing a ...
Definition sign.h:77
SignatureData::tr_spenddata
TaprootSpendData tr_spenddata
Taproot spending data.
Definition sign.h:75
SignatureData::scriptSig
CScript scriptSig
The scriptSig of an input. Contains complete signatures or the traditional partial signatures format.
Definition sign.h:71
InsecureRandBits
static uint64_t InsecureRandBits(int bits)
Definition random.h:40
strprintf
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition tinyformat.h:1161
BuildSpendingTransaction
CMutableTransaction BuildSpendingTransaction(const CScript &scriptSig, const CScriptWitness &scriptWitness, const CTransaction &txCredit)
Definition transaction_utils.cpp:25
BuildCreditingTransaction
CMutableTransaction BuildCreditingTransaction(const CScript &scriptPubKey, int nValue)
Definition transaction_utils.cpp:9
transaction_utils.h
expect
#define expect(bit)
Definition univalue_read.cpp:259
assert
assert(!tx.IsCoinBase())
Generated on Thu Oct 3 2024 09:20:15 for Bitcoin Core by doxygen 1.12.0