Branch data Line data Source code
1 : : // Copyright (c) 2012-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 <consensus/tx_verify.h>
6 : : #include <key.h>
7 : : #include <policy/policy.h>
8 : : #include <policy/settings.h>
9 : : #include <script/script.h>
10 : : #include <script/script_error.h>
11 : : #include <script/sign.h>
12 : : #include <script/signingprovider.h>
13 : : #include <test/util/setup_common.h>
14 : : #include <validation.h>
15 : :
16 : : #include <vector>
17 : 0 :
18 : 0 : #include <boost/test/unit_test.hpp>
19 : :
20 : : // Helpers:
21 : 0 : static bool IsStandardTx(const CTransaction& tx, std::string& reason)
22 : : {
23 : 0 : return IsStandardTx(tx, std::nullopt, DEFAULT_PERMIT_BAREMULTISIG, CFeeRate{DUST_RELAY_TX_FEE}, reason);
24 : : }
25 : :
26 : 0 : static std::vector<unsigned char> Serialize(const CScript& s)
27 : : {
28 : 0 : std::vector<unsigned char> sSerialized(s.begin(), s.end());
29 : 0 : return sSerialized;
30 : 0 : }
31 : :
32 : 0 : static bool Verify(const CScript& scriptSig, const CScript& scriptPubKey, bool fStrict, ScriptError& err)
33 : : {
34 : : // Create dummy to/from transactions:
35 : 0 : CMutableTransaction txFrom;
36 : 0 : txFrom.vout.resize(1);
37 : 0 : txFrom.vout[0].scriptPubKey = scriptPubKey;
38 : :
39 : 0 : CMutableTransaction txTo;
40 : 0 : txTo.vin.resize(1);
41 : 0 : txTo.vout.resize(1);
42 : 0 : txTo.vin[0].prevout.n = 0;
43 : 0 : txTo.vin[0].prevout.hash = txFrom.GetHash();
44 : 0 : txTo.vin[0].scriptSig = scriptSig;
45 : 0 : txTo.vout[0].nValue = 1;
46 : :
47 : 0 : return VerifyScript(scriptSig, scriptPubKey, nullptr, fStrict ? SCRIPT_VERIFY_P2SH : SCRIPT_VERIFY_NONE, MutableTransactionSignatureChecker(&txTo, 0, txFrom.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err);
48 : 0 : }
49 : :
50 : :
51 : 0 : BOOST_FIXTURE_TEST_SUITE(script_p2sh_tests, BasicTestingSetup)
52 : :
53 : 0 : BOOST_AUTO_TEST_CASE(sign)
54 : : {
55 : : // Pay-to-script-hash looks like this:
56 : : // scriptSig: <sig> <sig...> <serialized_script>
57 : : // scriptPubKey: HASH160 <hash> EQUAL
58 : :
59 : : // Test SignSignature() (and therefore the version of Solver() that signs transactions)
60 : 0 : FillableSigningProvider keystore;
61 : 0 : CKey key[4];
62 : 0 : for (int i = 0; i < 4; i++)
63 : : {
64 : 0 : key[i].MakeNewKey(true);
65 : 0 : BOOST_CHECK(keystore.AddKey(key[i]));
66 : 0 : }
67 : :
68 : : // 8 Scripts: checking all combinations of
69 : : // different keys, straight/P2SH, pubkey/pubkeyhash
70 : 0 : CScript standardScripts[4];
71 : 0 : standardScripts[0] << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
72 : 0 : standardScripts[1] = GetScriptForDestination(PKHash(key[1].GetPubKey()));
73 : 0 : standardScripts[2] << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
74 : 0 : standardScripts[3] = GetScriptForDestination(PKHash(key[2].GetPubKey()));
75 : 0 : CScript evalScripts[4];
76 : 0 : for (int i = 0; i < 4; i++)
77 : : {
78 : 0 : BOOST_CHECK(keystore.AddCScript(standardScripts[i]));
79 : 0 : evalScripts[i] = GetScriptForDestination(ScriptHash(standardScripts[i]));
80 : 0 : }
81 : :
82 : 0 : CMutableTransaction txFrom; // Funding transaction:
83 : 0 : std::string reason;
84 : 0 : txFrom.vout.resize(8);
85 : 0 : for (int i = 0; i < 4; i++)
86 : : {
87 : 0 : txFrom.vout[i].scriptPubKey = evalScripts[i];
88 : 0 : txFrom.vout[i].nValue = COIN;
89 : 0 : txFrom.vout[i+4].scriptPubKey = standardScripts[i];
90 : 0 : txFrom.vout[i+4].nValue = COIN;
91 : 0 : }
92 : 0 : BOOST_CHECK(IsStandardTx(CTransaction(txFrom), reason));
93 : :
94 : 0 : CMutableTransaction txTo[8]; // Spending transactions
95 : 0 : for (int i = 0; i < 8; i++)
96 : : {
97 : 0 : txTo[i].vin.resize(1);
98 : 0 : txTo[i].vout.resize(1);
99 : 0 : txTo[i].vin[0].prevout.n = i;
100 : 0 : txTo[i].vin[0].prevout.hash = txFrom.GetHash();
101 : 0 : txTo[i].vout[0].nValue = 1;
102 : 0 : }
103 : 0 : for (int i = 0; i < 8; i++)
104 : : {
105 : 0 : SignatureData empty;
106 : 0 : BOOST_CHECK_MESSAGE(SignSignature(keystore, CTransaction(txFrom), txTo[i], 0, SIGHASH_ALL, empty), strprintf("SignSignature %d", i));
107 : 0 : }
108 : : // All of the above should be OK, and the txTos have valid signatures
109 : : // Check to make sure signature verification fails if we use the wrong ScriptSig:
110 : 0 : for (int i = 0; i < 8; i++) {
111 : 0 : PrecomputedTransactionData txdata(txTo[i]);
112 : 0 : for (int j = 0; j < 8; j++)
113 : : {
114 : 0 : CScript sigSave = txTo[i].vin[0].scriptSig;
115 : 0 : txTo[i].vin[0].scriptSig = txTo[j].vin[0].scriptSig;
116 : 0 : bool sigOK = CScriptCheck(txFrom.vout[txTo[i].vin[0].prevout.n], CTransaction(txTo[i]), 0, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, false, &txdata)();
117 : 0 : if (i == j)
118 : 0 : BOOST_CHECK_MESSAGE(sigOK, strprintf("VerifySignature %d %d", i, j));
119 : : else
120 : 0 : BOOST_CHECK_MESSAGE(!sigOK, strprintf("VerifySignature %d %d", i, j));
121 : 0 : txTo[i].vin[0].scriptSig = sigSave;
122 : 0 : }
123 : 0 : }
124 : 0 : }
125 : :
126 : 0 : BOOST_AUTO_TEST_CASE(norecurse)
127 : : {
128 : : ScriptError err;
129 : : // Make sure only the outer pay-to-script-hash does the
130 : : // extra-validation thing:
131 : 0 : CScript invalidAsScript;
132 : 0 : invalidAsScript << OP_INVALIDOPCODE << OP_INVALIDOPCODE;
133 : :
134 : 0 : CScript p2sh = GetScriptForDestination(ScriptHash(invalidAsScript));
135 : :
136 : 0 : CScript scriptSig;
137 : 0 : scriptSig << Serialize(invalidAsScript);
138 : :
139 : : // Should not verify, because it will try to execute OP_INVALIDOPCODE
140 : 0 : BOOST_CHECK(!Verify(scriptSig, p2sh, true, err));
141 : 0 : BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_BAD_OPCODE, ScriptErrorString(err));
142 : :
143 : : // Try to recur, and verification should succeed because
144 : : // the inner HASH160 <> EQUAL should only check the hash:
145 : 0 : CScript p2sh2 = GetScriptForDestination(ScriptHash(p2sh));
146 : 0 : CScript scriptSig2;
147 : 0 : scriptSig2 << Serialize(invalidAsScript) << Serialize(p2sh);
148 : :
149 : 0 : BOOST_CHECK(Verify(scriptSig2, p2sh2, true, err));
150 : 0 : BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
151 : 0 : }
152 : :
153 : 0 : BOOST_AUTO_TEST_CASE(set)
154 : : {
155 : : // Test the CScript::Set* methods
156 : 0 : FillableSigningProvider keystore;
157 : 0 : CKey key[4];
158 : 0 : std::vector<CPubKey> keys;
159 : 0 : keys.reserve(4);
160 : 0 : for (int i = 0; i < 4; i++)
161 : : {
162 : 0 : key[i].MakeNewKey(true);
163 : 0 : BOOST_CHECK(keystore.AddKey(key[i]));
164 : 0 : keys.push_back(key[i].GetPubKey());
165 : 0 : }
166 : :
167 : 0 : CScript inner[4];
168 : 0 : inner[0] = GetScriptForDestination(PKHash(key[0].GetPubKey()));
169 : 0 : inner[1] = GetScriptForMultisig(2, std::vector<CPubKey>(keys.begin(), keys.begin()+2));
170 : 0 : inner[2] = GetScriptForMultisig(1, std::vector<CPubKey>(keys.begin(), keys.begin()+2));
171 : 0 : inner[3] = GetScriptForMultisig(2, std::vector<CPubKey>(keys.begin(), keys.begin()+3));
172 : :
173 : 0 : CScript outer[4];
174 : 0 : for (int i = 0; i < 4; i++)
175 : : {
176 : 0 : outer[i] = GetScriptForDestination(ScriptHash(inner[i]));
177 : 0 : BOOST_CHECK(keystore.AddCScript(inner[i]));
178 : 0 : }
179 : :
180 : 0 : CMutableTransaction txFrom; // Funding transaction:
181 : 0 : std::string reason;
182 : 0 : txFrom.vout.resize(4);
183 : 0 : for (int i = 0; i < 4; i++)
184 : : {
185 : 0 : txFrom.vout[i].scriptPubKey = outer[i];
186 : 0 : txFrom.vout[i].nValue = CENT;
187 : 0 : }
188 : 0 : BOOST_CHECK(IsStandardTx(CTransaction(txFrom), reason));
189 : :
190 : 0 : CMutableTransaction txTo[4]; // Spending transactions
191 : 0 : for (int i = 0; i < 4; i++)
192 : : {
193 : 0 : txTo[i].vin.resize(1);
194 : 0 : txTo[i].vout.resize(1);
195 : 0 : txTo[i].vin[0].prevout.n = i;
196 : 0 : txTo[i].vin[0].prevout.hash = txFrom.GetHash();
197 : 0 : txTo[i].vout[0].nValue = 1*CENT;
198 : 0 : txTo[i].vout[0].scriptPubKey = inner[i];
199 : 0 : }
200 : 0 : for (int i = 0; i < 4; i++)
201 : : {
202 : 0 : SignatureData empty;
203 : 0 : BOOST_CHECK_MESSAGE(SignSignature(keystore, CTransaction(txFrom), txTo[i], 0, SIGHASH_ALL, empty), strprintf("SignSignature %d", i));
204 : 0 : BOOST_CHECK_MESSAGE(IsStandardTx(CTransaction(txTo[i]), reason), strprintf("txTo[%d].IsStandard", i));
205 : 0 : }
206 : 0 : }
207 : :
208 : 0 : BOOST_AUTO_TEST_CASE(is)
209 : : {
210 : : // Test CScript::IsPayToScriptHash()
211 : 0 : uint160 dummy;
212 : 0 : CScript p2sh;
213 : 0 : p2sh << OP_HASH160 << ToByteVector(dummy) << OP_EQUAL;
214 : 0 : BOOST_CHECK(p2sh.IsPayToScriptHash());
215 : :
216 : 0 : std::vector<unsigned char> direct = {OP_HASH160, 20};
217 : 0 : direct.insert(direct.end(), 20, 0);
218 : 0 : direct.push_back(OP_EQUAL);
219 : 0 : BOOST_CHECK(CScript(direct.begin(), direct.end()).IsPayToScriptHash());
220 : :
221 : : // Not considered pay-to-script-hash if using one of the OP_PUSHDATA opcodes:
222 : 0 : std::vector<unsigned char> pushdata1 = {OP_HASH160, OP_PUSHDATA1, 20};
223 : 0 : pushdata1.insert(pushdata1.end(), 20, 0);
224 : 0 : pushdata1.push_back(OP_EQUAL);
225 : 0 : BOOST_CHECK(!CScript(pushdata1.begin(), pushdata1.end()).IsPayToScriptHash());
226 : 0 : std::vector<unsigned char> pushdata2 = {OP_HASH160, OP_PUSHDATA2, 20, 0};
227 : 0 : pushdata2.insert(pushdata2.end(), 20, 0);
228 : 0 : pushdata2.push_back(OP_EQUAL);
229 : 0 : BOOST_CHECK(!CScript(pushdata2.begin(), pushdata2.end()).IsPayToScriptHash());
230 : 0 : std::vector<unsigned char> pushdata4 = {OP_HASH160, OP_PUSHDATA4, 20, 0, 0, 0};
231 : 0 : pushdata4.insert(pushdata4.end(), 20, 0);
232 : 0 : pushdata4.push_back(OP_EQUAL);
233 : 0 : BOOST_CHECK(!CScript(pushdata4.begin(), pushdata4.end()).IsPayToScriptHash());
234 : :
235 : 0 : CScript not_p2sh;
236 : 0 : BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
237 : :
238 : 0 : not_p2sh.clear(); not_p2sh << OP_HASH160 << ToByteVector(dummy) << ToByteVector(dummy) << OP_EQUAL;
239 : 0 : BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
240 : :
241 : 0 : not_p2sh.clear(); not_p2sh << OP_NOP << ToByteVector(dummy) << OP_EQUAL;
242 : 0 : BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
243 : :
244 : 0 : not_p2sh.clear(); not_p2sh << OP_HASH160 << ToByteVector(dummy) << OP_CHECKSIG;
245 : 0 : BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
246 : 0 : }
247 : :
248 : 0 : BOOST_AUTO_TEST_CASE(switchover)
249 : : {
250 : : // Test switch over code
251 : 0 : CScript notValid;
252 : : ScriptError err;
253 : 0 : notValid << OP_11 << OP_12 << OP_EQUALVERIFY;
254 : 0 : CScript scriptSig;
255 : 0 : scriptSig << Serialize(notValid);
256 : :
257 : 0 : CScript fund = GetScriptForDestination(ScriptHash(notValid));
258 : :
259 : :
260 : : // Validation should succeed under old rules (hash is correct):
261 : 0 : BOOST_CHECK(Verify(scriptSig, fund, false, err));
262 : 0 : BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
263 : : // Fail under new:
264 : 0 : BOOST_CHECK(!Verify(scriptSig, fund, true, err));
265 : 0 : BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EQUALVERIFY, ScriptErrorString(err));
266 : 0 : }
267 : :
268 : 0 : BOOST_AUTO_TEST_CASE(AreInputsStandard)
269 : : {
270 : 0 : CCoinsView coinsDummy;
271 : 0 : CCoinsViewCache coins(&coinsDummy);
272 : 0 : FillableSigningProvider keystore;
273 : 0 : CKey key[6];
274 : 0 : for (int i = 0; i < 6; i++)
275 : : {
276 : 0 : key[i].MakeNewKey(true);
277 : 0 : BOOST_CHECK(keystore.AddKey(key[i]));
278 : 0 : }
279 : 0 : std::vector<CPubKey> keys;
280 : 0 : keys.reserve(3);
281 : 0 : for (int i = 0; i < 3; i++)
282 : 0 : keys.push_back(key[i].GetPubKey());
283 : :
284 : 0 : CMutableTransaction txFrom;
285 : 0 : txFrom.vout.resize(7);
286 : :
287 : : // First three are standard:
288 : 0 : CScript pay1 = GetScriptForDestination(PKHash(key[0].GetPubKey()));
289 : 0 : BOOST_CHECK(keystore.AddCScript(pay1));
290 : 0 : CScript pay1of3 = GetScriptForMultisig(1, keys);
291 : :
292 : 0 : txFrom.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(pay1)); // P2SH (OP_CHECKSIG)
293 : 0 : txFrom.vout[0].nValue = 1000;
294 : 0 : txFrom.vout[1].scriptPubKey = pay1; // ordinary OP_CHECKSIG
295 : 0 : txFrom.vout[1].nValue = 2000;
296 : 0 : txFrom.vout[2].scriptPubKey = pay1of3; // ordinary OP_CHECKMULTISIG
297 : 0 : txFrom.vout[2].nValue = 3000;
298 : :
299 : : // vout[3] is complicated 1-of-3 AND 2-of-3
300 : : // ... that is OK if wrapped in P2SH:
301 : 0 : CScript oneAndTwo;
302 : 0 : oneAndTwo << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << ToByteVector(key[2].GetPubKey());
303 : 0 : oneAndTwo << OP_3 << OP_CHECKMULTISIGVERIFY;
304 : 0 : oneAndTwo << OP_2 << ToByteVector(key[3].GetPubKey()) << ToByteVector(key[4].GetPubKey()) << ToByteVector(key[5].GetPubKey());
305 : 0 : oneAndTwo << OP_3 << OP_CHECKMULTISIG;
306 : 0 : BOOST_CHECK(keystore.AddCScript(oneAndTwo));
307 : 0 : txFrom.vout[3].scriptPubKey = GetScriptForDestination(ScriptHash(oneAndTwo));
308 : 0 : txFrom.vout[3].nValue = 4000;
309 : :
310 : : // vout[4] is max sigops:
311 : 0 : CScript fifteenSigops; fifteenSigops << OP_1;
312 : 0 : for (unsigned i = 0; i < MAX_P2SH_SIGOPS; i++)
313 : 0 : fifteenSigops << ToByteVector(key[i%3].GetPubKey());
314 : 0 : fifteenSigops << OP_15 << OP_CHECKMULTISIG;
315 : 0 : BOOST_CHECK(keystore.AddCScript(fifteenSigops));
316 : 0 : txFrom.vout[4].scriptPubKey = GetScriptForDestination(ScriptHash(fifteenSigops));
317 : 0 : txFrom.vout[4].nValue = 5000;
318 : :
319 : : // vout[5/6] are non-standard because they exceed MAX_P2SH_SIGOPS
320 : 0 : CScript sixteenSigops; sixteenSigops << OP_16 << OP_CHECKMULTISIG;
321 : 0 : BOOST_CHECK(keystore.AddCScript(sixteenSigops));
322 : 0 : txFrom.vout[5].scriptPubKey = GetScriptForDestination(ScriptHash(sixteenSigops));
323 : 0 : txFrom.vout[5].nValue = 5000;
324 : 0 : CScript twentySigops; twentySigops << OP_CHECKMULTISIG;
325 : 0 : BOOST_CHECK(keystore.AddCScript(twentySigops));
326 : 0 : txFrom.vout[6].scriptPubKey = GetScriptForDestination(ScriptHash(twentySigops));
327 : 0 : txFrom.vout[6].nValue = 6000;
328 : :
329 : 0 : AddCoins(coins, CTransaction(txFrom), 0);
330 : :
331 : 0 : CMutableTransaction txTo;
332 : 0 : txTo.vout.resize(1);
333 : 0 : txTo.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
334 : :
335 : 0 : txTo.vin.resize(5);
336 : 0 : for (int i = 0; i < 5; i++)
337 : : {
338 : 0 : txTo.vin[i].prevout.n = i;
339 : 0 : txTo.vin[i].prevout.hash = txFrom.GetHash();
340 : 0 : }
341 : 0 : SignatureData empty;
342 : 0 : BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, empty));
343 : 0 : SignatureData empty_b;
344 : 0 : BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 1, SIGHASH_ALL, empty_b));
345 : 0 : SignatureData empty_c;
346 : 0 : BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 2, SIGHASH_ALL, empty_c));
347 : : // SignSignature doesn't know how to sign these. We're
348 : : // not testing validating signatures, so just create
349 : : // dummy signatures that DO include the correct P2SH scripts:
350 : 0 : txTo.vin[3].scriptSig << OP_11 << OP_11 << std::vector<unsigned char>(oneAndTwo.begin(), oneAndTwo.end());
351 : 0 : txTo.vin[4].scriptSig << std::vector<unsigned char>(fifteenSigops.begin(), fifteenSigops.end());
352 : :
353 : 0 : BOOST_CHECK(::AreInputsStandard(CTransaction(txTo), coins));
354 : : // 22 P2SH sigops for all inputs (1 for vin[0], 6 for vin[3], 15 for vin[4]
355 : 0 : BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txTo), coins), 22U);
356 : :
357 : 0 : CMutableTransaction txToNonStd1;
358 : 0 : txToNonStd1.vout.resize(1);
359 : 0 : txToNonStd1.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
360 : 0 : txToNonStd1.vout[0].nValue = 1000;
361 : 0 : txToNonStd1.vin.resize(1);
362 : 0 : txToNonStd1.vin[0].prevout.n = 5;
363 : 0 : txToNonStd1.vin[0].prevout.hash = txFrom.GetHash();
364 : 0 : txToNonStd1.vin[0].scriptSig << std::vector<unsigned char>(sixteenSigops.begin(), sixteenSigops.end());
365 : :
366 : 0 : BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd1), coins));
367 : 0 : BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd1), coins), 16U);
368 : :
369 : 0 : CMutableTransaction txToNonStd2;
370 : 0 : txToNonStd2.vout.resize(1);
371 : 0 : txToNonStd2.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
372 : 0 : txToNonStd2.vout[0].nValue = 1000;
373 : 0 : txToNonStd2.vin.resize(1);
374 : 0 : txToNonStd2.vin[0].prevout.n = 6;
375 : 0 : txToNonStd2.vin[0].prevout.hash = txFrom.GetHash();
376 : 0 : txToNonStd2.vin[0].scriptSig << std::vector<unsigned char>(twentySigops.begin(), twentySigops.end());
377 : :
378 : 0 : BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd2), coins));
379 : 0 : BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2), coins), 20U);
380 : 0 : }
381 : :
382 : 0 : BOOST_AUTO_TEST_SUITE_END()
|
