Inside Bitcoin

1// Copyright (c) 2017-present 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 <addresstype.h>
6#include <key.h>
7#include <key_io.h>
8#include <script/script.h>
9#include <script/signingprovider.h>
10#include <script/solver.h>
11#include <test/data/bip341_wallet_vectors.json.h>
12#include <test/util/common.h>
13#include <test/util/setup_common.h>
14#include <univalue.h>
15#include <util/check.h>
16#include <util/strencodings.h>
17
18#include <boost/test/unit_test.hpp>
19
20using namespace util::hex_literals;
21
22BOOST_FIXTURE_TEST_SUITE(script_standard_tests, BasicTestingSetup)
23
24BOOST_AUTO_TEST_CASE(dest_default_is_no_dest)
25{
26    CTxDestination dest;
27    BOOST_CHECK(!IsValidDestination(dest));
28}
29
30BOOST_AUTO_TEST_CASE(script_standard_Solver_success)
31{
32    CKey keys[3];
33    CPubKey pubkeys[3];
34    for (int i = 0; i < 3; i++) {
35        keys[i].MakeNewKey(true);
36        pubkeys[i] = keys[i].GetPubKey();
37    }
38
39    CScript s;
40    std::vector<std::vector<unsigned char> > solutions;
41
42    // TxoutType::PUBKEY
43    s.clear();
44    s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
45    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEY);
46    BOOST_CHECK_EQUAL(solutions.size(), 1U);
47    BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));
48
49    // TxoutType::PUBKEYHASH
50    s.clear();
51    s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
52    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEYHASH);
53    BOOST_CHECK_EQUAL(solutions.size(), 1U);
54    BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
55
56    // TxoutType::SCRIPTHASH
57    CScript redeemScript(s); // initialize with leftover P2PKH script
58    s.clear();
59    s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
60    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::SCRIPTHASH);
61    BOOST_CHECK_EQUAL(solutions.size(), 1U);
62    BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));
63
64    // TxoutType::MULTISIG
65    s.clear();
66    s << OP_1 <<
67        ToByteVector(pubkeys[0]) <<
68        ToByteVector(pubkeys[1]) <<
69        OP_2 << OP_CHECKMULTISIG;
70    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
71    BOOST_CHECK_EQUAL(solutions.size(), 4U);
72    BOOST_CHECK(solutions[0] == std::vector<unsigned char>({1}));
73    BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
74    BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
75    BOOST_CHECK(solutions[3] == std::vector<unsigned char>({2}));
76
77    s.clear();
78    s << OP_2 <<
79        ToByteVector(pubkeys[0]) <<
80        ToByteVector(pubkeys[1]) <<
81        ToByteVector(pubkeys[2]) <<
82        OP_3 << OP_CHECKMULTISIG;
83    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
84    BOOST_CHECK_EQUAL(solutions.size(), 5U);
85    BOOST_CHECK(solutions[0] == std::vector<unsigned char>({2}));
86    BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
87    BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
88    BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
89    BOOST_CHECK(solutions[4] == std::vector<unsigned char>({3}));
90
91    // TxoutType::NULL_DATA
92    s.clear();
93    s << OP_RETURN <<
94        std::vector<unsigned char>({0}) <<
95        std::vector<unsigned char>({75}) <<
96        std::vector<unsigned char>({255});
97    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NULL_DATA);
98    BOOST_CHECK_EQUAL(solutions.size(), 0U);
99
100    // TxoutType::WITNESS_V0_KEYHASH
101    s.clear();
102    s << OP_0 << ToByteVector(pubkeys[0].GetID());
103    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V0_KEYHASH);
104    BOOST_CHECK_EQUAL(solutions.size(), 1U);
105    BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
106
107    // TxoutType::WITNESS_V0_SCRIPTHASH
108    uint256 scriptHash;
109    CSHA256().Write(redeemScript.data(), redeemScript.size())
110        .Finalize(scriptHash.begin());
111
112    s.clear();
113    s << OP_0 << ToByteVector(scriptHash);
114    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V0_SCRIPTHASH);
115    BOOST_CHECK_EQUAL(solutions.size(), 1U);
116    BOOST_CHECK(solutions[0] == ToByteVector(scriptHash));
117
118    // TxoutType::WITNESS_V1_TAPROOT
119    s.clear();
120    s << OP_1 << ToByteVector(uint256::ZERO);
121    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V1_TAPROOT);
122    BOOST_CHECK_EQUAL(solutions.size(), 1U);
123    BOOST_CHECK(solutions[0] == ToByteVector(uint256::ZERO));
124
125    // TxoutType::WITNESS_UNKNOWN
126    s.clear();
127    s << OP_16 << ToByteVector(uint256::ONE);
128    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
129    BOOST_CHECK_EQUAL(solutions.size(), 2U);
130    BOOST_CHECK(solutions[0] == std::vector<unsigned char>{16});
131    BOOST_CHECK(solutions[1] == ToByteVector(uint256::ONE));
132
133    // TxoutType::ANCHOR
134    s.clear();
135    s << OP_1 << ANCHOR_BYTES;
136    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::ANCHOR);
137    BOOST_CHECK(solutions.empty());
138
139    // Sanity-check IsPayToAnchor
140    int version{-1};
141    std::vector<unsigned char> witness_program;
142    BOOST_CHECK(s.IsPayToAnchor());
143    BOOST_CHECK(s.IsWitnessProgram(version, witness_program));
144    BOOST_CHECK(CScript::IsPayToAnchor(version, witness_program));
145
146    // TxoutType::NONSTANDARD
147    s.clear();
148    s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
149    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
150}
151
152BOOST_AUTO_TEST_CASE(script_standard_Solver_failure)
153{
154    CKey key = GenerateRandomKey();
155    CPubKey pubkey = key.GetPubKey();
156
157    CScript s;
158    std::vector<std::vector<unsigned char> > solutions;
159
160    // TxoutType::PUBKEY with incorrectly sized pubkey
161    s.clear();
162    s << std::vector<unsigned char>(30, 0x01) << OP_CHECKSIG;
163    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
164
165    // TxoutType::PUBKEYHASH with incorrectly sized key hash
166    s.clear();
167    s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY << OP_CHECKSIG;
168    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
169
170    // TxoutType::SCRIPTHASH with incorrectly sized script hash
171    s.clear();
172    s << OP_HASH160 << std::vector<unsigned char>(21, 0x01) << OP_EQUAL;
173    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
174
175    // TxoutType::MULTISIG 0/2
176    s.clear();
177    s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
178    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
179
180    // TxoutType::MULTISIG 2/1
181    s.clear();
182    s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
183    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
184
185    // TxoutType::MULTISIG n = 2 with 1 pubkey
186    s.clear();
187    s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
188    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
189
190    // TxoutType::MULTISIG n = 1 with 0 pubkeys
191    s.clear();
192    s << OP_1 << OP_1 << OP_CHECKMULTISIG;
193    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
194
195    // TxoutType::NULL_DATA with other opcodes
196    s.clear();
197    s << OP_RETURN << std::vector<unsigned char>({75}) << OP_ADD;
198    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
199
200    // TxoutType::WITNESS_V0_{KEY,SCRIPT}HASH with incorrect program size (-> consensus-invalid, i.e. non-standard)
201    s.clear();
202    s << OP_0 << std::vector<unsigned char>(19, 0x01);
203    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
204
205    // TxoutType::WITNESS_V1_TAPROOT with incorrect program size (-> undefined, but still policy-valid)
206    s.clear();
207    s << OP_1 << std::vector<unsigned char>(31, 0x01);
208    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
209    s.clear();
210    s << OP_1 << std::vector<unsigned char>(33, 0x01);
211    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
212
213    // TxoutType::ANCHOR but wrong witness version
214    s.clear();
215    s << OP_2 << ANCHOR_BYTES;
216    BOOST_CHECK(!s.IsPayToAnchor());
217    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
218
219    // TxoutType::ANCHOR but wrong 2-byte data push
220    s.clear();
221    s << OP_1 << std::vector<unsigned char>{0xff, 0xff};
222    BOOST_CHECK(!s.IsPayToAnchor());
223    BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
224}
225
226BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
227{
228    CKey key = GenerateRandomKey();
229    CPubKey pubkey = key.GetPubKey();
230
231    CScript s;
232    CTxDestination address;
233
234    // TxoutType::PUBKEY
235    s.clear();
236    s << ToByteVector(pubkey) << OP_CHECKSIG;
237    BOOST_CHECK(!ExtractDestination(s, address));
238    BOOST_CHECK(std::get<PubKeyDestination>(address) == PubKeyDestination(pubkey));
239
240    // TxoutType::PUBKEYHASH
241    s.clear();
242    s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
243    BOOST_CHECK(ExtractDestination(s, address));
244    BOOST_CHECK(std::get<PKHash>(address) == PKHash(pubkey));
245
246    // TxoutType::SCRIPTHASH
247    CScript redeemScript(s); // initialize with leftover P2PKH script
248    s.clear();
249    s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
250    BOOST_CHECK(ExtractDestination(s, address));