Branch data Line data Source code
1 : : // Copyright (c) 2021-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 <core_io.h>
6 : : #include <hash.h>
7 : : #include <key.h>
8 : : #include <script/miniscript.h>
9 : : #include <script/script.h>
10 : : #include <script/signingprovider.h>
11 : : #include <test/fuzz/FuzzedDataProvider.h>
12 : : #include <test/fuzz/fuzz.h>
13 : : #include <test/fuzz/util.h>
14 : : #include <util/strencodings.h>
15 : :
16 : : #include <algorithm>
17 : :
18 : : namespace {
19 : :
20 : : using Fragment = miniscript::Fragment;
21 : : using NodeRef = miniscript::NodeRef<CPubKey>;
22 : : using Node = miniscript::Node<CPubKey>;
23 : : using Type = miniscript::Type;
24 : : using MsCtx = miniscript::MiniscriptContext;
25 : : using miniscript::operator"" _mst;
26 : :
27 : : //! Some pre-computed data for more efficient string roundtrips and to simulate challenges.
28 : : struct TestData {
29 : : typedef CPubKey Key;
30 : :
31 : : // Precomputed public keys, and a dummy signature for each of them.
32 : : std::vector<Key> dummy_keys;
33 : : std::map<Key, int> dummy_key_idx_map;
34 : : std::map<CKeyID, Key> dummy_keys_map;
35 : : std::map<Key, std::pair<std::vector<unsigned char>, bool>> dummy_sigs;
36 : : std::map<XOnlyPubKey, std::pair<std::vector<unsigned char>, bool>> schnorr_sigs;
37 : :
38 : : // Precomputed hashes of each kind.
39 : : std::vector<std::vector<unsigned char>> sha256;
40 : : std::vector<std::vector<unsigned char>> ripemd160;
41 : : std::vector<std::vector<unsigned char>> hash256;
42 : : std::vector<std::vector<unsigned char>> hash160;
43 : : std::map<std::vector<unsigned char>, std::vector<unsigned char>> sha256_preimages;
44 : : std::map<std::vector<unsigned char>, std::vector<unsigned char>> ripemd160_preimages;
45 : : std::map<std::vector<unsigned char>, std::vector<unsigned char>> hash256_preimages;
46 : : std::map<std::vector<unsigned char>, std::vector<unsigned char>> hash160_preimages;
47 : :
48 : : //! Set the precomputed data.
49 : 0 : void Init() {
50 : 0 : unsigned char keydata[32] = {1};
51 : : // All our signatures sign (and are required to sign) this constant message.
52 : 0 : constexpr uint256 MESSAGE_HASH{"0000000000000000f5cd94e18b6fe77dd7aca9e35c2b0c9cbd86356c80a71065"};
53 : : // We don't pass additional randomness when creating a schnorr signature.
54 : 0 : const auto EMPTY_AUX{uint256::ZERO};
55 : :
56 [ # # ]: 0 : for (size_t i = 0; i < 256; i++) {
57 : 0 : keydata[31] = i;
58 : 0 : CKey privkey;
59 [ # # ]: 0 : privkey.Set(keydata, keydata + 32, true);
60 [ # # ]: 0 : const Key pubkey = privkey.GetPubKey();
61 : :
62 [ # # ]: 0 : dummy_keys.push_back(pubkey);
63 [ # # ]: 0 : dummy_key_idx_map.emplace(pubkey, i);
64 [ # # # # ]: 0 : dummy_keys_map.insert({pubkey.GetID(), pubkey});
65 [ # # ]: 0 : XOnlyPubKey xonly_pubkey{pubkey};
66 [ # # ]: 0 : dummy_key_idx_map.emplace(xonly_pubkey, i);
67 [ # # ]: 0 : uint160 xonly_hash{Hash160(xonly_pubkey)};
68 [ # # ]: 0 : dummy_keys_map.emplace(xonly_hash, pubkey);
69 : :
70 [ # # ]: 0 : std::vector<unsigned char> sig, schnorr_sig(64);
71 [ # # ]: 0 : privkey.Sign(MESSAGE_HASH, sig);
72 [ # # ]: 0 : sig.push_back(1); // SIGHASH_ALL
73 [ # # # # : 0 : dummy_sigs.insert({pubkey, {sig, i & 1}});
# # ]
74 [ # # # # : 0 : assert(privkey.SignSchnorr(MESSAGE_HASH, schnorr_sig, nullptr, EMPTY_AUX));
# # ]
75 [ # # ]: 0 : schnorr_sig.push_back(1); // Maximally-sized signature has sighash byte
76 [ # # # # : 0 : schnorr_sigs.emplace(XOnlyPubKey{pubkey}, std::make_pair(std::move(schnorr_sig), i & 1));
# # ]
77 : :
78 : 0 : std::vector<unsigned char> hash;
79 [ # # ]: 0 : hash.resize(32);
80 [ # # # # : 0 : CSHA256().Write(keydata, 32).Finalize(hash.data());
# # ]
81 [ # # ]: 0 : sha256.push_back(hash);
82 [ # # # # : 0 : if (i & 1) sha256_preimages[hash] = std::vector<unsigned char>(keydata, keydata + 32);
# # ]
83 [ # # # # : 0 : CHash256().Write(keydata).Finalize(hash);
# # # # ]
84 [ # # ]: 0 : hash256.push_back(hash);
85 [ # # # # : 0 : if (i & 1) hash256_preimages[hash] = std::vector<unsigned char>(keydata, keydata + 32);
# # ]
86 [ # # ]: 0 : hash.resize(20);
87 [ # # # # : 0 : CRIPEMD160().Write(keydata, 32).Finalize(hash.data());
# # ]
88 [ # # ]: 0 : assert(hash.size() == 20);
89 [ # # ]: 0 : ripemd160.push_back(hash);
90 [ # # # # : 0 : if (i & 1) ripemd160_preimages[hash] = std::vector<unsigned char>(keydata, keydata + 32);
# # ]
91 [ # # # # : 0 : CHash160().Write(keydata).Finalize(hash);
# # # # ]
92 [ # # ]: 0 : hash160.push_back(hash);
93 [ # # # # : 0 : if (i & 1) hash160_preimages[hash] = std::vector<unsigned char>(keydata, keydata + 32);
# # ]
94 : 0 : }
95 : 0 : }
96 : :
97 : : //! Get the (Schnorr or ECDSA, depending on context) signature for this pubkey.
98 : 278943 : const std::pair<std::vector<unsigned char>, bool>* GetSig(const MsCtx script_ctx, const Key& key) const {
99 [ + + ]: 278943 : if (!miniscript::IsTapscript(script_ctx)) {
100 : 194460 : const auto it = dummy_sigs.find(key);
101 [ - + ]: 194460 : if (it == dummy_sigs.end()) return nullptr;
102 : 194460 : return &it->second;
103 : 194460 : } else {
104 : 84483 : const auto it = schnorr_sigs.find(XOnlyPubKey{key});
105 [ - + ]: 84483 : if (it == schnorr_sigs.end()) return nullptr;
106 : 84483 : return &it->second;
107 : 84483 : }
108 : 278943 : }
109 : 1 : } TEST_DATA;
110 : :
111 : : /**
112 : : * Context to parse a Miniscript node to and from Script or text representation.
113 : : * Uses an integer (an index in the dummy keys array from the test data) as keys in order
114 : : * to focus on fuzzing the Miniscript nodes' test representation, not the key representation.
115 : : */
116 : : struct ParserContext {
117 : : typedef CPubKey Key;
118 : :
119 : : const MsCtx script_ctx;
120 : :
121 : 11777 : constexpr ParserContext(MsCtx ctx) noexcept : script_ctx(ctx) {}
122 : :
123 : 752810 : bool KeyCompare(const Key& a, const Key& b) const {
124 : 752810 : return a < b;
125 : : }
126 : :
127 : 161220 : std::optional<std::string> ToString(const Key& key) const
128 : : {
129 : 161220 : auto it = TEST_DATA.dummy_key_idx_map.find(key);
130 [ - + ]: 161220 : if (it == TEST_DATA.dummy_key_idx_map.end()) return {};
131 : 161220 : uint8_t idx = it->second;
132 : 161220 : return HexStr(Span{&idx, 1});
133 : 161220 : }
134 : :
135 : 190321 : std::vector<unsigned char> ToPKBytes(const Key& key) const {
136 [ + + ]: 190321 : if (!miniscript::IsTapscript(script_ctx)) {
137 [ + - ]: 133575 : return {key.begin(), key.end()};
138 : : }
139 : 56746 : const XOnlyPubKey xonly_pubkey{key};
140 [ + - ]: 56746 : return {xonly_pubkey.begin(), xonly_pubkey.end()};
141 : 190321 : }
142 : :
143 : 14201 : std::vector<unsigned char> ToPKHBytes(const Key& key) const {
144 [ + + ]: 14201 : if (!miniscript::IsTapscript(script_ctx)) {
145 : 8831 : const auto h = Hash160(key);
146 [ + - ]: 8831 : return {h.begin(), h.end()};
147 : 8831 : }
148 : 5370 : const auto h = Hash160(XOnlyPubKey{key});
149 [ + - ]: 5370 : return {h.begin(), h.end()};
150 : 14201 : }
151 : :
152 : : template<typename I>
153 : 184533 : std::optional<Key> FromString(I first, I last) const {
154 [ + + ]: 184533 : if (last - first != 2) return {};
155 [ + - + - ]: 184523 : auto idx = ParseHex(std::string(first, last));
156 [ + + ]: 184523 : if (idx.size() != 1) return {};
157 : 184497 : return TEST_DATA.dummy_keys[idx[0]];
158 : 184533 : }
159 : :
160 : : template<typename I>
161 : 86078 : std::optional<Key> FromPKBytes(I first, I last) const {
162 [ + + ]: 86078 : if (!miniscript::IsTapscript(script_ctx)) {
163 : 60570 : Key key{first, last};
164 [ + - ]: 60570 : if (key.IsValid()) return key;
165 : 0 : return {};
166 : 60570 : }
167 [ - + ]: 25508 : if (last - first != 32) return {};
168 : 25508 : XOnlyPubKey xonly_pubkey;
169 : 25508 : std::copy(first, last, xonly_pubkey.begin());
170 : 25508 : return xonly_pubkey.GetEvenCorrespondingCPubKey();
171 : 86078 : }
172 : :
173 : : template<typename I>
174 : 6903 : std::optional<Key> FromPKHBytes(I first, I last) const {
175 [ + - ]: 6903 : assert(last - first == 20);
176 : 6903 : CKeyID keyid;
177 : 6903 : std::copy(first, last, keyid.begin());
178 : 6903 : const auto it = TEST_DATA.dummy_keys_map.find(keyid);
179 [ - + ]: 6903 : if (it == TEST_DATA.dummy_keys_map.end()) return {};
180 : 6903 : return it->second;
181 : 6903 : }
182 : :
183 : 11606214 : MsCtx MsContext() const {
184 : 11606214 : return script_ctx;
185 : : }
186 : : };
187 : :
188 : : //! Context that implements naive conversion from/to script only, for roundtrip testing.
189 : : struct ScriptParserContext {
190 : : const MsCtx script_ctx;
191 : :
192 : 1195 : constexpr ScriptParserContext(MsCtx ctx) noexcept : script_ctx(ctx) {}
193 : :
194 : : //! For Script roundtrip we never need the key from a key hash.
195 : : struct Key {
196 : : bool is_hash;
197 : : std::vector<unsigned char> data;
198 : : };
199 : :
200 : 27970 : bool KeyCompare(const Key& a, const Key& b) const {
201 : 27970 : return a.data < b.data;
202 : : }
203 : :
204 : 1466 : const std::vector<unsigned char>& ToPKBytes(const Key& key) const
205 : : {
206 [ + - ]: 1466 : assert(!key.is_hash);
207 : 1466 : return key.data;
208 : : }
209 : :
210 : 953 : std::vector<unsigned char> ToPKHBytes(const Key& key) const
211 : : {
212 [ + - ]: 953 : if (key.is_hash) return key.data;
213 : 0 : const auto h = Hash160(key.data);
214 [ # # ]: 0 : return {h.begin(), h.end()};
215 : 953 : }
216 : :
217 : : template<typename I>
218 : 5536 : std::optional<Key> FromPKBytes(I first, I last) const
219 : : {
220 : 5536 : Key key;
221 [ + - ]: 5536 : key.data.assign(first, last);
222 : 5536 : key.is_hash = false;
223 : 5536 : return key;
224 : 5536 : }
225 : :
226 : : template<typename I>
227 : 2939 : std::optional<Key> FromPKHBytes(I first, I last) const
228 : : {
229 : 2939 : Key key;
230 [ + - ]: 2939 : key.data.assign(first, last);
231 : 2939 : key.is_hash = true;
232 : 2939 : return key;
233 : 2939 : }
234 : :
235 : 3663420 : MsCtx MsContext() const {
236 : 3663420 : return script_ctx;
237 : : }
238 : : };
239 : :
240 : : //! Context to produce a satisfaction for a Miniscript node using the pre-computed data.
241 : : struct SatisfierContext : ParserContext {
242 : :
243 : 4863 : constexpr SatisfierContext(MsCtx ctx) noexcept : ParserContext(ctx) {}
244 : :
245 : : // Timelock challenges satisfaction. Make the value (deterministically) vary to explore different
246 : : // paths.
247 : 9486 : bool CheckAfter(uint32_t value) const { return value % 2; }
248 : 10120 : bool CheckOlder(uint32_t value) const { return value % 2; }
249 : :
250 : : // Signature challenges fulfilled with a dummy signature, if it was one of our dummy keys.
251 : 185962 : miniscript::Availability Sign(const CPubKey& key, std::vector<unsigned char>& sig) const {
252 : 185962 : bool sig_available{false};
253 [ - + ]: 371924 : if (auto res = TEST_DATA.GetSig(script_ctx, key)) {
254 : 185962 : std::tie(sig, sig_available) = *res;
255 : 185962 : }
256 : 371924 : return sig_available ? miniscript::Availability::YES : miniscript::Availability::NO;
257 : 185962 : }
258 : :
259 : : //! Lookup generalization for all the hash satisfactions below
260 : 31588 : miniscript::Availability LookupHash(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage,
261 : : const std::map<std::vector<unsigned char>, std::vector<unsigned char>>& map) const
262 : : {
263 : 31588 : const auto it = map.find(hash);
264 [ + + ]: 31588 : if (it == map.end()) return miniscript::Availability::NO;
265 : 19898 : preimage = it->second;
266 : 19898 : return miniscript::Availability::YES;
267 : 31588 : }
268 : 7998 : miniscript::Availability SatSHA256(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
269 : 7998 : return LookupHash(hash, preimage, TEST_DATA.sha256_preimages);
270 : : }
271 : 7128 : miniscript::Availability SatRIPEMD160(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
272 : 7128 : return LookupHash(hash, preimage, TEST_DATA.ripemd160_preimages);
273 : : }
274 : 8926 : miniscript::Availability SatHASH256(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
275 : 8926 : return LookupHash(hash, preimage, TEST_DATA.hash256_preimages);
276 : : }
277 : 7536 : miniscript::Availability SatHASH160(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
278 : 7536 : return LookupHash(hash, preimage, TEST_DATA.hash160_preimages);
279 : : }
280 : : };
281 : :
282 : : //! Context to check a satisfaction against the pre-computed data.
283 : : const struct CheckerContext: BaseSignatureChecker {
284 : : // Signature checker methods. Checks the right dummy signature is used.
285 : 34375 : bool CheckECDSASignature(const std::vector<unsigned char>& sig, const std::vector<unsigned char>& vchPubKey,
286 : : const CScript& scriptCode, SigVersion sigversion) const override
287 : : {
288 : 34375 : const CPubKey key{vchPubKey};
289 : 34375 : const auto it = TEST_DATA.dummy_sigs.find(key);
290 [ - + ]: 34375 : if (it == TEST_DATA.dummy_sigs.end()) return false;
291 : 34375 : return it->second.first == sig;
292 : 34375 : }
293 : 8157 : bool CheckSchnorrSignature(Span<const unsigned char> sig, Span<const unsigned char> pubkey, SigVersion,
294 : : ScriptExecutionData&, ScriptError*) const override {
295 : 8157 : XOnlyPubKey pk{pubkey};
296 : 8157 : auto it = TEST_DATA.schnorr_sigs.find(pk);
297 [ - + ]: 8157 : if (it == TEST_DATA.schnorr_sigs.end()) return false;
298 : 8157 : return std::ranges::equal(it->second.first, sig);
299 : 8157 : }
300 : 1581 : bool CheckLockTime(const CScriptNum& nLockTime) const override { return nLockTime.GetInt64() & 1; }
301 : 1645 : bool CheckSequence(const CScriptNum& nSequence) const override { return nSequence.GetInt64() & 1; }
302 : : } CHECKER_CTX;
303 : :
304 : : //! Context to check for duplicates when instancing a Node.
305 : : const struct KeyComparator {
306 : 294244 : bool KeyCompare(const CPubKey& a, const CPubKey& b) const {
307 : 294244 : return a < b;
308 : : }
309 : : } KEY_COMP;
310 : :
311 : : // A dummy scriptsig to pass to VerifyScript (we always use Segwit v0).
312 : : const CScript DUMMY_SCRIPTSIG;
313 : :
314 : : //! Construct a miniscript node as a shared_ptr.
315 : 389998 : template<typename... Args> NodeRef MakeNodeRef(Args&&... args) {
316 : 389998 : return miniscript::MakeNodeRef<CPubKey>(miniscript::internal::NoDupCheck{}, std::forward<Args>(args)...);
317 : : }
318 : :
319 : : /** Information about a yet to be constructed Miniscript node. */
320 [ # # ]: 0 : struct NodeInfo {
321 : : //! The type of this node
322 : : Fragment fragment;
323 : : //! The timelock value for older() and after(), the threshold value for multi() and thresh()
324 : : uint32_t k;
325 : : //! Keys for this node, if it has some
326 : : std::vector<CPubKey> keys;
327 : : //! The hash value for this node, if it has one
328 : : std::vector<unsigned char> hash;
329 : : //! The type requirements for the children of this node.
330 : : std::vector<Type> subtypes;
331 : :
332 : 45005 : NodeInfo(Fragment frag): fragment(frag), k(0) {}
333 [ + - ]: 24620 : NodeInfo(Fragment frag, CPubKey key): fragment(frag), k(0), keys({key}) {}
334 : 11562 : NodeInfo(Fragment frag, uint32_t _k): fragment(frag), k(_k) {}
335 : 18455 : NodeInfo(Fragment frag, std::vector<unsigned char> h): fragment(frag), k(0), hash(std::move(h)) {}
336 : 295182 : NodeInfo(std::vector<Type> subt, Fragment frag): fragment(frag), k(0), subtypes(std::move(subt)) {}
337 : 13803 : NodeInfo(std::vector<Type> subt, Fragment frag, uint32_t _k): fragment(frag), k(_k), subtypes(std::move(subt)) {}
338 : 14195 : NodeInfo(Fragment frag, uint32_t _k, std::vector<CPubKey> _keys): fragment(frag), k(_k), keys(std::move(_keys)) {}
339 : : };
340 : :
341 : : /** Pick an index in a collection from a single byte in the fuzzer's output. */
342 : : template<typename T, typename A>
343 : 133293 : T ConsumeIndex(FuzzedDataProvider& provider, A& col) {
344 : 133293 : const uint8_t i = provider.ConsumeIntegral<uint8_t>();
345 : 133293 : return col[i];
346 : 133293 : }
347 : :
348 : 122242 : CPubKey ConsumePubKey(FuzzedDataProvider& provider) {
349 : 122242 : return ConsumeIndex<CPubKey>(provider, TEST_DATA.dummy_keys);
350 : : }
351 : :
352 : 2566 : std::vector<unsigned char> ConsumeSha256(FuzzedDataProvider& provider) {
353 : 2566 : return ConsumeIndex<std::vector<unsigned char>>(provider, TEST_DATA.sha256);
354 : : }
355 : :
356 : 3701 : std::vector<unsigned char> ConsumeHash256(FuzzedDataProvider& provider) {
357 : 3701 : return ConsumeIndex<std::vector<unsigned char>>(provider, TEST_DATA.hash256);
358 : : }
359 : :
360 : 2483 : std::vector<unsigned char> ConsumeRipemd160(FuzzedDataProvider& provider) {
361 : 2483 : return ConsumeIndex<std::vector<unsigned char>>(provider, TEST_DATA.ripemd160);
362 : : }
363 : :
364 : 2301 : std::vector<unsigned char> ConsumeHash160(FuzzedDataProvider& provider) {
365 : 2301 : return ConsumeIndex<std::vector<unsigned char>>(provider, TEST_DATA.hash160);
366 : : }
367 : :
368 : 7270 : std::optional<uint32_t> ConsumeTimeLock(FuzzedDataProvider& provider) {
369 : 7270 : const uint32_t k = provider.ConsumeIntegral<uint32_t>();
370 [ + + + + ]: 7270 : if (k == 0 || k >= 0x80000000) return {};
371 : 7241 : return k;
372 : 7270 : }
373 : :
374 : : /**
375 : : * Consume a Miniscript node from the fuzzer's output.
376 : : *
377 : : * This version is intended to have a fixed, stable, encoding for Miniscript nodes:
378 : : * - The first byte sets the type of the fragment. 0, 1 and all non-leaf fragments but thresh() are a
379 : : * single byte.
380 : : * - For the other leaf fragments, the following bytes depend on their type.
381 : : * - For older() and after(), the next 4 bytes define the timelock value.
382 : : * - For pk_k(), pk_h(), and all hashes, the next byte defines the index of the value in the test data.
383 : : * - For multi(), the next 2 bytes define respectively the threshold and the number of keys. Then as many
384 : : * bytes as the number of keys define the index of each key in the test data.
385 : : * - For multi_a(), same as for multi() but the threshold and the keys count are encoded on two bytes.
386 : : * - For thresh(), the next byte defines the threshold value and the following one the number of subs.
387 : : */
388 : 237994 : std::optional<NodeInfo> ConsumeNodeStable(MsCtx script_ctx, FuzzedDataProvider& provider, Type type_needed) {
389 [ + + ]: 237994 : bool allow_B = (type_needed == ""_mst) || (type_needed << "B"_mst);
390 [ + + ]: 237994 : bool allow_K = (type_needed == ""_mst) || (type_needed << "K"_mst);
391 [ + + ]: 237994 : bool allow_V = (type_needed == ""_mst) || (type_needed << "V"_mst);
392 [ + + ]: 237994 : bool allow_W = (type_needed == ""_mst) || (type_needed << "W"_mst);
393 : : static constexpr auto B{"B"_mst}, K{"K"_mst}, V{"V"_mst}, W{"W"_mst};
394 : :
395 [ + + + + : 237994 : switch (provider.ConsumeIntegral<uint8_t>()) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + ]
396 : : case 0:
397 [ + + ]: 34798 : if (!allow_B) return {};
398 : 34707 : return {{Fragment::JUST_0}};
399 : : case 1:
400 [ + + ]: 10307 : if (!allow_B) return {};
401 : 10298 : return {{Fragment::JUST_1}};
402 : : case 2:
403 [ + + ]: 8424 : if (!allow_K) return {};
404 : 8416 : return {{Fragment::PK_K, ConsumePubKey(provider)}};
405 : : case 3:
406 [ + + ]: 4947 : if (!allow_K) return {};
407 : 4943 : return {{Fragment::PK_H, ConsumePubKey(provider)}};
408 : : case 4: {
409 [ + + ]: 3561 : if (!allow_B) return {};
410 : 3555 : const auto k = ConsumeTimeLock(provider);
411 [ + + ]: 3555 : if (!k) return {};
412 : 3540 : return {{Fragment::OLDER, *k}};
413 : 3555 : }
414 : : case 5: {
415 [ + + ]: 3719 : if (!allow_B) return {};
416 : 3715 : const auto k = ConsumeTimeLock(provider);
417 [ + + ]: 3715 : if (!k) return {};
418 : 3701 : return {{Fragment::AFTER, *k}};
419 : 3715 : }
420 : : case 6:
421 [ + + ]: 2573 : if (!allow_B) return {};
422 [ + - ]: 2566 : return {{Fragment::SHA256, ConsumeSha256(provider)}};
423 : : case 7:
424 [ + + ]: 3709 : if (!allow_B) return {};
425 [ + - ]: 3701 : return {{Fragment::HASH256, ConsumeHash256(provider)}};
426 : : case 8:
427 [ + + ]: 2487 : if (!allow_B) return {};
428 [ + - ]: 2483 : return {{Fragment::RIPEMD160, ConsumeRipemd160(provider)}};
429 : : case 9:
430 [ + + ]: 2305 : if (!allow_B) return {};
431 [ + - ]: 2301 : return {{Fragment::HASH160, ConsumeHash160(provider)}};
432 : : case 10: {
433 [ + + + + ]: 7991 : if (!allow_B || IsTapscript(script_ctx)) return {};
434 : 6869 : const auto k = provider.ConsumeIntegral<uint8_t>();
435 : 6869 : const auto n_keys = provider.ConsumeIntegral<uint8_t>();
436 [ + + + + : 6869 : if (n_keys > 20 || k == 0 || k > n_keys) return {};
+ + ]
437 [ + - ]: 6861 : std::vector<CPubKey> keys{n_keys};
438 [ + + + - ]: 36890 : for (auto& key: keys) key = ConsumePubKey(provider);
439 [ + - ]: 6861 : return {{Fragment::MULTI, k, std::move(keys)}};
440 : 6869 : }
441 : : case 11:
442 [ + + + + : 11759 : if (!(allow_B || allow_K || allow_V)) return {};
+ + ]
443 [ + - + - ]: 11754 : return {{{B, type_needed, type_needed}, Fragment::ANDOR}};
444 : : case 12:
445 [ + + + + : 30482 : if (!(allow_B || allow_K || allow_V)) return {};
+ + ]
446 [ + - + - ]: 30479 : return {{{V, type_needed}, Fragment::AND_V}};
447 : : case 13:
448 [ + + ]: 5739 : if (!allow_B) return {};
449 [ + - + - ]: 5734 : return {{{B, W}, Fragment::AND_B}};
450 : : case 15:
451 [ + + ]: 4426 : if (!allow_B) return {};
452 [ + - + - ]: 4421 : return {{{B, W}, Fragment::OR_B}};
453 : : case 16:
454 [ + + ]: 2263 : if (!allow_V) return {};
455 [ + - + - ]: 2256 : return {{{B, V}, Fragment::OR_C}};
456 : : case 17:
457 [ + + ]: 7815 : if (!allow_B) return {};
458 [ + - + - ]: 7807 : return {{{B, B}, Fragment::OR_D}};
459 : : case 18:
460 [ + + + + : 16021 : if (!(allow_B || allow_K || allow_V)) return {};
+ + ]
461 [ + - + - ]: 16017 : return {{{type_needed, type_needed}, Fragment::OR_I}};
462 : : case 19: {
463 [ + + ]: 6330 : if (!allow_B) return {};
464 : 6321 : auto k = provider.ConsumeIntegral<uint8_t>();
465 : 6321 : auto n_subs = provider.ConsumeIntegral<uint8_t>();
466 [ + + + + ]: 6321 : if (k == 0 || k > n_subs) return {};
467 : 6296 : std::vector<Type> subtypes;
468 [ + - ]: 6296 : subtypes.reserve(n_subs);
469 [ + - ]: 6296 : subtypes.emplace_back("B"_mst);
470 [ + + + - ]: 25950 : for (size_t i = 1; i < n_subs; ++i) subtypes.emplace_back("W"_mst);
471 [ + - ]: 6296 : return {{std::move(subtypes), Fragment::THRESH, k}};
472 : 6321 : }
473 : : case 20:
474 [ + + ]: 14292 : if (!allow_W) return {};
475 [ + - + - ]: 14284 : return {{{B}, Fragment::WRAP_A}};
476 : : case 21:
477 [ + + ]: 1593 : if (!allow_W) return {};
478 [ + - + - ]: 1589 : return {{{B}, Fragment::WRAP_S}};
479 : : case 22:
480 [ + + ]: 10877 : if (!allow_B) return {};
481 [ + - + - ]: 10872 : return {{{K}, Fragment::WRAP_C}};
482 : : case 23:
483 [ + + ]: 1139 : if (!allow_B) return {};
484 [ + - + - ]: 1133 : return {{{V}, Fragment::WRAP_D}};
485 : : case 24:
486 [ + + ]: 29780 : if (!allow_V) return {};
487 [ + - + - ]: 29769 : return {{{B}, Fragment::WRAP_V}};
488 : : case 25:
489 [ + + ]: 3233 : if (!allow_B) return {};
490 [ + - + - ]: 3229 : return {{{B}, Fragment::WRAP_J}};
491 : : case 26:
492 [ + + ]: 6049 : if (!allow_B) return {};
493 [ + - + - ]: 6046 : return {{{B}, Fragment::WRAP_N}};
494 : : case 27: {
495 [ + + + + ]: 1353 : if (!allow_B || !IsTapscript(script_ctx)) return {};
496 : 1095 : const auto k = provider.ConsumeIntegral<uint16_t>();
497 : 1095 : const auto n_keys = provider.ConsumeIntegral<uint16_t>();
498 [ + + + + : 1095 : if (n_keys > 999 || k == 0 || k > n_keys) return {};
+ + ]
499 [ + - ]: 1085 : std::vector<CPubKey> keys{n_keys};
500 [ + + + - ]: 18198 : for (auto& key: keys) key = ConsumePubKey(provider);
501 [ + - ]: 1085 : return {{Fragment::MULTI_A, k, std::move(keys)}};
502 : 1095 : }
503 : : default:
504 : 22 : break;
505 : : }
506 : 22 : return {};
507 : 237994 : }
508 : :
509 : : /* This structure contains a table which for each "target" Type a list of recipes
510 : : * to construct it, automatically inferred from the behavior of ComputeType.
511 : : * Note that the Types here are not the final types of the constructed Nodes, but
512 : : * just the subset that are required. For example, a recipe for the "Bo" type
513 : : * might construct a "Bondu" sha256() NodeInfo, but cannot construct a "Bz" older().
514 : : * Each recipe is a Fragment together with a list of required types for its subnodes.
515 : : */
516 : : struct SmartInfo
517 : : {
518 : : using recipe = std::pair<Fragment, std::vector<Type>>;
519 : : std::map<Type, std::vector<recipe>> wsh_table, tap_table;
520 : :
521 : 0 : void Init()
522 : : {
523 : 0 : Init(wsh_table, MsCtx::P2WSH);
524 : 0 : Init(tap_table, MsCtx::TAPSCRIPT);
525 : 0 : }
526 : :
527 : 0 : void Init(std::map<Type, std::vector<recipe>>& table, MsCtx script_ctx)
528 : : {
529 : : /* Construct a set of interesting type requirements to reason with (sections of BKVWzondu). */
530 : 0 : std::vector<Type> types;
531 : : static constexpr auto B_mst{"B"_mst}, K_mst{"K"_mst}, V_mst{"V"_mst}, W_mst{"W"_mst};
532 : : static constexpr auto d_mst{"d"_mst}, n_mst{"n"_mst}, o_mst{"o"_mst}, u_mst{"u"_mst}, z_mst{"z"_mst};
533 : : static constexpr auto NONE_mst{""_mst};
534 [ # # ]: 0 : for (int base = 0; base < 4; ++base) { /* select from B,K,V,W */
535 [ # # # # : 0 : Type type_base = base == 0 ? B_mst : base == 1 ? K_mst : base == 2 ? V_mst : W_mst;
# # ]
536 [ # # ]: 0 : for (int zo = 0; zo < 3; ++zo) { /* select from z,o,(none) */
537 [ # # # # ]: 0 : Type type_zo = zo == 0 ? z_mst : zo == 1 ? o_mst : NONE_mst;
538 [ # # ]: 0 : for (int n = 0; n < 2; ++n) { /* select from (none),n */
539 [ # # # # ]: 0 : if (zo == 0 && n == 1) continue; /* z conflicts with n */
540 [ # # # # ]: 0 : if (base == 3 && n == 1) continue; /* W conflicts with n */
541 [ # # ]: 0 : Type type_n = n == 0 ? NONE_mst : n_mst;
542 [ # # ]: 0 : for (int d = 0; d < 2; ++d) { /* select from (none),d */
543 [ # # # # ]: 0 : if (base == 2 && d == 1) continue; /* V conflicts with d */
544 [ # # ]: 0 : Type type_d = d == 0 ? NONE_mst : d_mst;
545 [ # # ]: 0 : for (int u = 0; u < 2; ++u) { /* select from (none),u */
546 [ # # # # ]: 0 : if (base == 2 && u == 1) continue; /* V conflicts with u */
547 [ # # ]: 0 : Type type_u = u == 0 ? NONE_mst : u_mst;
548 [ # # # # : 0 : Type type = type_base | type_zo | type_n | type_d | type_u;
# # # # ]
549 [ # # ]: 0 : types.push_back(type);
550 : 0 : }
551 : 0 : }
552 : 0 : }
553 : 0 : }
554 : 0 : }
555 : :
556 : : /* We define a recipe a to be a super-recipe of recipe b if they use the same
557 : : * fragment, the same number of subexpressions, and each of a's subexpression
558 : : * types is a supertype of the corresponding subexpression type of b.
559 : : * Within the set of recipes for the construction of a given type requirement,
560 : : * no recipe should be a super-recipe of another (as the super-recipe is
561 : : * applicable in every place the sub-recipe is, the sub-recipe is redundant). */
562 : 0 : auto is_super_of = [](const recipe& a, const recipe& b) {
563 [ # # ]: 0 : if (a.first != b.first) return false;
564 [ # # ]: 0 : if (a.second.size() != b.second.size()) return false;
565 [ # # # # : 0 : for (size_t i = 0; i < a.second.size(); ++i) {
# ]
566 [ # # ]: 0 : if (!(b.second[i] << a.second[i])) return false;
567 : 0 : }
568 : 0 : return true;
569 : 0 : };
570 : :
571 : : /* Sort the type requirements. Subtypes will always sort later (e.g. Bondu will
572 : : * sort after Bo or Bu). As we'll be constructing recipes using these types, in
573 : : * order, in what follows, we'll construct super-recipes before sub-recipes.
574 : : * That means we never need to go back and delete a sub-recipe because a
575 : : * super-recipe got added. */
576 [ # # ]: 0 : std::sort(types.begin(), types.end());
577 : :
578 : : // Iterate over all possible fragments.
579 [ # # ]: 0 : for (int fragidx = 0; fragidx <= int(Fragment::MULTI_A); ++fragidx) {
580 : 0 : int sub_count = 0; //!< The minimum number of child nodes this recipe has.
581 : 0 : int sub_range = 1; //!< The maximum number of child nodes for this recipe is sub_count+sub_range-1.
582 : 0 : size_t data_size = 0;
583 : 0 : size_t n_keys = 0;
584 : 0 : uint32_t k = 0;
585 : 0 : Fragment frag{fragidx};
586 : :
587 : : // Only produce recipes valid in the given context.
588 [ # # # # : 0 : if ((!miniscript::IsTapscript(script_ctx) && frag == Fragment::MULTI_A)
# # ]
589 [ # # # # : 0 : || (miniscript::IsTapscript(script_ctx) && frag == Fragment::MULTI)) {
# # ]
590 : 0 : continue;
591 : : }
592 : :
593 : : // Based on the fragment, determine #subs/data/k/keys to pass to ComputeType. */
594 [ # # # # : 0 : switch (frag) {
# # # # #
# # ]
595 : : case Fragment::PK_K:
596 : : case Fragment::PK_H:
597 : 0 : n_keys = 1;
598 : 0 : break;
599 : : case Fragment::MULTI:
600 : : case Fragment::MULTI_A:
601 : 0 : n_keys = 1;
602 : 0 : k = 1;
603 : 0 : break;
604 : : case Fragment::OLDER:
605 : : case Fragment::AFTER:
606 : 0 : k = 1;
607 : 0 : break;
608 : : case Fragment::SHA256:
609 : : case Fragment::HASH256:
610 : 0 : data_size = 32;
611 : 0 : break;
612 : : case Fragment::RIPEMD160:
613 : : case Fragment::HASH160:
614 : 0 : data_size = 20;
615 : 0 : break;
616 : : case Fragment::JUST_0:
617 : : case Fragment::JUST_1:
618 : 0 : break;
619 : : case Fragment::WRAP_A:
620 : : case Fragment::WRAP_S:
621 : : case Fragment::WRAP_C:
622 : : case Fragment::WRAP_D:
623 : : case Fragment::WRAP_V:
624 : : case Fragment::WRAP_J:
625 : : case Fragment::WRAP_N:
626 : 0 : sub_count = 1;
627 : 0 : break;
628 : : case Fragment::AND_V:
629 : : case Fragment::AND_B:
630 : : case Fragment::OR_B:
631 : : case Fragment::OR_C:
632 : : case Fragment::OR_D:
633 : : case Fragment::OR_I:
634 : 0 : sub_count = 2;
635 : 0 : break;
636 : : case Fragment::ANDOR:
637 : 0 : sub_count = 3;
638 : 0 : break;
639 : : case Fragment::THRESH:
640 : : // Thresh logic is executed for 1 and 2 arguments. Larger numbers use ad-hoc code to extend.
641 : 0 : sub_count = 1;
642 : 0 : sub_range = 2;
643 : 0 : k = 1;
644 : 0 : break;
645 : : }
646 : :
647 : : // Iterate over the number of subnodes (sub_count...sub_count+sub_range-1).
648 : 0 : std::vector<Type> subt;
649 [ # # ]: 0 : for (int subs = sub_count; subs < sub_count + sub_range; ++subs) {
650 : : // Iterate over the possible subnode types (at most 3).
651 [ # # ]: 0 : for (Type x : types) {
652 [ # # ]: 0 : for (Type y : types) {
653 [ # # ]: 0 : for (Type z : types) {
654 : : // Compute the resulting type of a node with the selected fragment / subnode types.
655 : 0 : subt.clear();
656 [ # # # # ]: 0 : if (subs > 0) subt.push_back(x);
657 [ # # # # ]: 0 : if (subs > 1) subt.push_back(y);
658 [ # # # # ]: 0 : if (subs > 2) subt.push_back(z);
659 [ # # ]: 0 : Type res = miniscript::internal::ComputeType(frag, x, y, z, subt, k, data_size, subs, n_keys, script_ctx);
660 : : // Continue if the result is not a valid node.
661 [ # # # # : 0 : if ((res << "K"_mst) + (res << "V"_mst) + (res << "B"_mst) + (res << "W"_mst) != 1) continue;
# # # # #
# ]
662 : :
663 [ # # ]: 0 : recipe entry{frag, subt};
664 : 0 : auto super_of_entry = [&](const recipe& rec) { return is_super_of(rec, entry); };
665 : : // Iterate over all supertypes of res (because if e.g. our selected fragment/subnodes result
666 : : // in a Bondu, they can form a recipe that is also applicable for constructing a B, Bou, Bdu, ...).
667 [ # # ]: 0 : for (Type s : types) {
668 [ # # # # : 0 : if ((res & "BKVWzondu"_mst) << s) {
# # ]
669 [ # # ]: 0 : auto& recipes = table[s];
670 : : // If we don't already have a super-recipe to the new one, add it.
671 [ # # # # ]: 0 : if (!std::any_of(recipes.begin(), recipes.end(), super_of_entry)) {
672 [ # # ]: 0 : recipes.push_back(entry);
673 : 0 : }
674 : 0 : }
675 : 0 : }
676 : :
677 [ # # ]: 0 : if (subs <= 2) break;
678 [ # # # # : 0 : }
# ]
679 [ # # ]: 0 : if (subs <= 1) break;
680 [ # # ]: 0 : }
681 [ # # ]: 0 : if (subs <= 0) break;
682 [ # # ]: 0 : }
683 : 0 : }
684 [ # # ]: 0 : }
685 : :
686 : : /* Find which types are useful. The fuzzer logic only cares about constructing
687 : : * B,V,K,W nodes, so any type that isn't needed in any recipe (directly or
688 : : * indirectly) for the construction of those is uninteresting. */
689 [ # # ]: 0 : std::set<Type> useful_types{B_mst, V_mst, K_mst, W_mst};
690 : : // Find the transitive closure by adding types until the set of types does not change.
691 : 0 : while (true) {
692 : 0 : size_t set_size = useful_types.size();
693 [ # # ]: 0 : for (const auto& [type, recipes] : table) {
694 [ # # # # ]: 0 : if (useful_types.count(type) != 0) {
695 [ # # ]: 0 : for (const auto& [_, subtypes] : recipes) {
696 [ # # # # ]: 0 : for (auto subtype : subtypes) useful_types.insert(subtype);
697 : 0 : }
698 : 0 : }
699 : 0 : }
700 [ # # ]: 0 : if (useful_types.size() == set_size) break;
701 [ # # ]: 0 : }
702 : : // Remove all rules that construct uninteresting types.
703 [ # # ]: 0 : for (auto type_it = table.begin(); type_it != table.end();) {
704 [ # # # # ]: 0 : if (useful_types.count(type_it->first) == 0) {
705 [ # # ]: 0 : type_it = table.erase(type_it);
706 : 0 : } else {
707 : 0 : ++type_it;
708 : : }
709 : : }
710 : :
711 : : /* Find which types are constructible. A type is constructible if there is a leaf
712 : : * node recipe for constructing it, or a recipe whose subnodes are all constructible.
713 : : * Types can be non-constructible because they have no recipes to begin with,
714 : : * because they can only be constructed using recipes that involve otherwise
715 : : * non-constructible types, or because they require infinite recursion. */
716 : 0 : std::set<Type> constructible_types{};
717 : 0 : auto known_constructible = [&](Type type) { return constructible_types.count(type) != 0; };
718 : : // Find the transitive closure by adding types until the set of types does not change.
719 : 0 : while (true) {
720 : 0 : size_t set_size = constructible_types.size();
721 : : // Iterate over all types we have recipes for.
722 [ # # ]: 0 : for (const auto& [type, recipes] : table) {
723 [ # # # # ]: 0 : if (!known_constructible(type)) {
724 : : // For not (yet known to be) constructible types, iterate over their recipes.
725 [ # # ]: 0 : for (const auto& [_, subt] : recipes) {
726 : : // If any recipe involves only (already known to be) constructible types,
727 : : // add the recipe's type to the set.
728 [ # # # # : 0 : if (std::all_of(subt.begin(), subt.end(), known_constructible)) {
# # ]
729 [ # # ]: 0 : constructible_types.insert(type);
730 : 0 : break;
731 : : }
732 [ # # ]: 0 : }
733 : 0 : }
734 : 0 : }
735 [ # # ]: 0 : if (constructible_types.size() == set_size) break;
736 [ # # ]: 0 : }
737 [ # # ]: 0 : for (auto type_it = table.begin(); type_it != table.end();) {
738 : : // Remove all recipes which involve non-constructible types.
739 [ # # # # : 0 : type_it->second.erase(std::remove_if(type_it->second.begin(), type_it->second.end(),
# # # # ]
740 : 0 : [&](const recipe& rec) {
741 : 0 : return !std::all_of(rec.second.begin(), rec.second.end(), known_constructible);
742 : 0 : }), type_it->second.end());
743 : : // Delete types entirely which have no recipes left.
744 [ # # ]: 0 : if (type_it->second.empty()) {
745 [ # # ]: 0 : type_it = table.erase(type_it);
746 : 0 : } else {
747 : 0 : ++type_it;
748 : : }
749 : : }
750 : :
751 [ # # ]: 0 : for (auto& [type, recipes] : table) {
752 : : // Sort recipes for determinism, and place those using fewer subnodes first.
753 : : // This avoids runaway expansion (when reaching the end of the fuzz input,
754 : : // all zeroes are read, resulting in the first available recipe being picked).
755 [ # # # # ]: 0 : std::sort(recipes.begin(), recipes.end(),
756 : 0 : [](const recipe& a, const recipe& b) {
757 [ # # ]: 0 : if (a.second.size() < b.second.size()) return true;
758 [ # # ]: 0 : if (a.second.size() > b.second.size()) return false;
759 : 0 : return a < b;
760 : 0 : }
761 : : );
762 : 0 : }
763 : 0 : }
764 : 1 : } SMARTINFO;
765 : :
766 : : /**
767 : : * Consume a Miniscript node from the fuzzer's output.
768 : : *
769 : : * This is similar to ConsumeNodeStable, but uses a precomputed table with permitted
770 : : * fragments/subnode type for each required type. It is intended to more quickly explore
771 : : * interesting miniscripts, at the cost of higher implementation complexity (which could
772 : : * cause it miss things if incorrect), and with less regard for stability of the seeds
773 : : * (as improvements to the tables or changes to the typing rules could invalidate
774 : : * everything).
775 : : */
776 : 186534 : std::optional<NodeInfo> ConsumeNodeSmart(MsCtx script_ctx, FuzzedDataProvider& provider, Type type_needed) {
777 : : /** Table entry for the requested type. */
778 [ + + ]: 186534 : const auto& table{IsTapscript(script_ctx) ? SMARTINFO.tap_table : SMARTINFO.wsh_table};
779 : 186534 : auto recipes_it = table.find(type_needed);
780 [ + - ]: 186534 : assert(recipes_it != table.end());
781 : : /** Pick one recipe from the available ones for that type. */
782 : 201591 : const auto& [frag, subt] = PickValue(provider, recipes_it->second);
783 : :
784 : : // Based on the fragment the recipe uses, fill in other data (k, keys, data).
785 [ - + + + : 186534 : switch (frag) {
+ + + + +
+ + ]
786 : : case Fragment::PK_K:
787 : : case Fragment::PK_H:
788 : 22522 : return {{frag, ConsumePubKey(provider)}};
789 : : case Fragment::MULTI: {
790 : 5448 : const auto n_keys = provider.ConsumeIntegralInRange<uint8_t>(1, 20);
791 : 5448 : const auto k = provider.ConsumeIntegralInRange<uint8_t>(1, n_keys);
792 [ + - ]: 5448 : std::vector<CPubKey> keys{n_keys};
793 [ + + + - ]: 33626 : for (auto& key: keys) key = ConsumePubKey(provider);
794 [ + - + - ]: 10896 : return {{frag, k, std::move(keys)}};
795 : 5448 : }
796 : : case Fragment::MULTI_A: {
797 : 801 : const auto n_keys = provider.ConsumeIntegralInRange<uint16_t>(1, 999);
798 : 801 : const auto k = provider.ConsumeIntegralInRange<uint16_t>(1, n_keys);
799 [ + - ]: 801 : std::vector<CPubKey> keys{n_keys};
800 [ + + + - ]: 23103 : for (auto& key: keys) key = ConsumePubKey(provider);
801 [ + - + - ]: 1602 : return {{frag, k, std::move(keys)}};
802 : 801 : }
803 : : case Fragment::OLDER:
804 : : case Fragment::AFTER:
805 : 8642 : return {{frag, provider.ConsumeIntegralInRange<uint32_t>(1, 0x7FFFFFF)}};
806 : : case Fragment::SHA256:
807 [ + - + - ]: 4146 : return {{frag, PickValue(provider, TEST_DATA.sha256)}};
808 : : case Fragment::HASH256:
809 [ + - + - ]: 3476 : return {{frag, PickValue(provider, TEST_DATA.hash256)}};
810 : : case Fragment::RIPEMD160:
811 [ + - + - ]: 3286 : return {{frag, PickValue(provider, TEST_DATA.ripemd160)}};
812 : : case Fragment::HASH160:
813 [ + - + - ]: 3900 : return {{frag, PickValue(provider, TEST_DATA.hash160)}};
814 : : case Fragment::JUST_0:
815 : : case Fragment::JUST_1:
816 : : case Fragment::WRAP_A:
817 : : case Fragment::WRAP_S:
818 : : case Fragment::WRAP_C:
819 : : case Fragment::WRAP_D:
820 : : case Fragment::WRAP_V:
821 : : case Fragment::WRAP_J:
822 : : case Fragment::WRAP_N:
823 : : case Fragment::AND_V:
824 : : case Fragment::AND_B:
825 : : case Fragment::OR_B:
826 : : case Fragment::OR_C:
827 : : case Fragment::OR_D:
828 : : case Fragment::OR_I:
829 : : case Fragment::ANDOR:
830 [ + - + - : 449376 : return {{subt, frag}};
+ - ]
831 : : case Fragment::THRESH: {
832 : 7507 : uint32_t children;
833 [ + + ]: 7507 : if (subt.size() < 2) {
834 : 6206 : children = subt.size();
835 : 6206 : } else {
836 : : // If we hit a thresh with 2 subnodes, artificially extend it to any number
837 : : // (2 or larger) by replicating the type of the last subnode.
838 : 1301 : children = provider.ConsumeIntegralInRange<uint32_t>(2, MAX_OPS_PER_SCRIPT / 2);
839 : : }
840 : 7507 : auto k = provider.ConsumeIntegralInRange<uint32_t>(1, children);
841 : 15014 : std::vector<Type> subs = subt;
842 [ + + + - ]: 28989 : while (subs.size() < children) subs.push_back(subs.back());
843 [ + - + - ]: 15014 : return {{std::move(subs), frag, k}};
844 : 7507 : }
845 : : }
846 : :
847 : 0 : assert(false);
848 : 186534 : }
849 : :
850 : : /**
851 : : * Generate a Miniscript node based on the fuzzer's input.
852 : : *
853 : : * - ConsumeNode is a function object taking a Type, and returning an std::optional<NodeInfo>.
854 : : * - root_type is the required type properties of the constructed NodeRef.
855 : : * - strict_valid sets whether ConsumeNode is expected to guarantee a NodeInfo that results in
856 : : * a NodeRef whose Type() matches the type fed to ConsumeNode.
857 : : */
858 : : template<typename F>
859 : 7566 : NodeRef GenNode(MsCtx script_ctx, F ConsumeNode, Type root_type, bool strict_valid = false) {
860 : : /** A stack of miniscript Nodes being built up. */
861 : 7566 : std::vector<NodeRef> stack;
862 : : /** The queue of instructions. */
863 [ + - + - : 7566 : std::vector<std::pair<Type, std::optional<NodeInfo>>> todo{{root_type, {}}};
# # + - +
- # # ]
864 : : /** Predict the number of (static) script ops. */
865 : 7566 : uint32_t ops{0};
866 : : /** Predict the total script size (every unexplored subnode is counted as one, as every leaf is
867 : : * at least one script byte). */
868 : 7566 : uint32_t scriptsize{1};
869 : :
870 [ + + + + ]: 819921 : while (!todo.empty()) {
871 : : // The expected type we have to construct.
872 : 814526 : auto type_needed = todo.back().first;
873 [ + + + + ]: 814526 : if (!todo.back().second) {
874 : : // Fragment/children have not been decided yet. Decide them.
875 [ - + - + ]: 424528 : auto node_info = ConsumeNode(type_needed);
876 [ + + + - ]: 424528 : if (!node_info) return {};
877 : : // Update predicted resource limits. Since every leaf Miniscript node is at least one
878 : : // byte long, we move one byte from each child to their parent. A similar technique is
879 : : // used in the miniscript::internal::Parse function to prevent runaway string parsing.
880 [ + - + - : 845644 : scriptsize += miniscript::internal::ComputeScriptLen(node_info->fragment, ""_mst, node_info->subtypes.size(), node_info->k, node_info->subtypes.size(),
+ - + - ]
881 : 422822 : node_info->keys.size(), script_ctx) - 1;
882 [ + + + + ]: 422822 : if (scriptsize > MAX_STANDARD_P2WSH_SCRIPT_SIZE) return {};
883 [ + + + + : 422775 : switch (node_info->fragment) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + ]
884 : : case Fragment::JUST_0:
885 : : case Fragment::JUST_1:
886 : 87357 : break;
887 : : case Fragment::PK_K:
888 : : break;
889 : : case Fragment::PK_H:
890 : 7744 : ops += 3;
891 : 7744 : break;
892 : : case Fragment::OLDER:
893 : : case Fragment::AFTER:
894 : 11560 : ops += 1;
895 : 11560 : break;
896 : : case Fragment::RIPEMD160:
897 : : case Fragment::SHA256:
898 : : case Fragment::HASH160:
899 : : case Fragment::HASH256:
900 : 18455 : ops += 4;
901 : 18455 : break;
902 : : case Fragment::ANDOR:
903 : 19533 : ops += 3;
904 : 19533 : break;
905 : : case Fragment::AND_V:
906 : : break;
907 : : case Fragment::AND_B:
908 : : case Fragment::OR_B:
909 : 20189 : ops += 1;
910 : 20189 : break;
911 : : case Fragment::OR_C:
912 : 5548 : ops += 2;
913 : 5548 : break;
914 : : case Fragment::OR_D:
915 : 13137 : ops += 3;
916 : 13137 : break;
917 : : case Fragment::OR_I:
918 : 25269 : ops += 3;
919 : 25269 : break;
920 : : case Fragment::THRESH:
921 : 13803 : ops += node_info->subtypes.size();
922 : 13803 : break;
923 : : case Fragment::MULTI:
924 : 12309 : ops += 1;
925 : 12309 : break;
926 : : case Fragment::MULTI_A:
927 : 1851 : ops += node_info->keys.size() + 1;
928 : 1851 : break;
929 : : case Fragment::WRAP_A:
930 : 33635 : ops += 2;
931 : 33635 : break;
932 : : case Fragment::WRAP_S:
933 : 4201 : ops += 1;
934 : 4201 : break;
935 : : case Fragment::WRAP_C:
936 : 17694 : ops += 1;
937 : 17694 : break;
938 : : case Fragment::WRAP_D:
939 : 1889 : ops += 3;
940 : 1889 : break;
941 : : case Fragment::WRAP_V:
942 : : // We don't account for OP_VERIFY here; that will be corrected for when the actual
943 : : // node is constructed below.
944 : : break;
945 : : case Fragment::WRAP_J:
946 : 4946 : ops += 4;
947 : 4946 : break;
948 : : case Fragment::WRAP_N:
949 : 11969 : ops += 1;
950 : 11969 : break;
951 : : }
952 [ + + + + ]: 422775 : if (ops > MAX_OPS_PER_SCRIPT) return {};
953 [ + - - + ]: 422589 : auto subtypes = node_info->subtypes;
954 : 422589 : todo.back().second = std::move(node_info);
955 [ + - - + ]: 422589 : todo.reserve(todo.size() + subtypes.size());
956 : : // As elements on the todo stack are processed back to front, construct
957 : : // them in reverse order (so that the first subnode is generated first).
958 [ + + + + ]: 879596 : for (size_t i = 0; i < subtypes.size(); ++i) {
959 [ + - + - : 457007 : todo.emplace_back(*(subtypes.rbegin() + i), std::nullopt);
+ - + - ]
960 : 457007 : }
961 [ + + + + ]: 424528 : } else {
962 : : // The back of todo has fragment and number of children decided, and
963 : : // those children have been constructed at the back of stack. Pop
964 : : // that entry off todo, and use it to construct a new NodeRef on
965 : : // stack.
966 : 389998 : NodeInfo& info = *todo.back().second;
967 : : // Gather children from the back of stack.
968 : 389998 : std::vector<NodeRef> sub;
969 [ - + + - ]: 389998 : sub.reserve(info.subtypes.size());
970 [ + + + + ]: 767032 : for (size_t i = 0; i < info.subtypes.size(); ++i) {
971 [ + - + - ]: 377034 : sub.push_back(std::move(*(stack.end() - info.subtypes.size() + i)));
972 : 377034 : }
973 [ - + - + ]: 389998 : stack.erase(stack.end() - info.subtypes.size(), stack.end());
974 : : // Construct new NodeRef.
975 : 389998 : NodeRef node;
976 [ + + + + ]: 389998 : if (info.keys.empty()) {
977 [ - + - + ]: 351241 : node = MakeNodeRef(script_ctx, info.fragment, std::move(sub), std::move(info.hash), info.k);
978 : 351241 : } else {
979 [ - + - + ]: 38757 : assert(sub.empty());
980 [ - + - + ]: 38757 : assert(info.hash.empty());
981 [ + - + - ]: 38757 : node = MakeNodeRef(script_ctx, info.fragment, std::move(info.keys), info.k);
982 : : }
983 : : // Verify acceptability.
984 [ - + + + : 389998 : if (!node || (node->GetType() & "KVWB"_mst) == ""_mst) {
- + - + ]
985 [ + - # # ]: 206 : assert(!strict_valid);
986 : 206 : return {};
987 : : }
988 [ + + - + ]: 389792 : if (!(type_needed == ""_mst)) {
989 [ + - + - ]: 366887 : assert(node->GetType() << type_needed);
990 : 366887 : }
991 [ + - + + : 389792 : if (!node->IsValid()) return {};
+ - + + ]
992 : : // Update resource predictions.
993 [ + + + + : 389789 : if (node->fragment == Fragment::WRAP_V && node->subs[0]->GetType() << "x"_mst) {
+ + + + ]
994 : 21248 : ops += 1;
995 : 21248 : scriptsize += 1;
996 : 21248 : }
997 [ + + + + : 389789 : if (!miniscript::IsTapscript(script_ctx) && ops > MAX_OPS_PER_SCRIPT) return {};
+ + + + ]
998 [ + - + + : 389770 : if (scriptsize > miniscript::internal::MaxScriptSize(script_ctx)) {
+ - + + ]
999 : 4 : return {};
1000 : : }
1001 : : // Move it to the stack.
1002 [ + - + - ]: 389766 : stack.push_back(std::move(node));
1003 : 389766 : todo.pop_back();
1004 [ + + + + ]: 389998 : }
1005 [ + + + + ]: 814526 : }
1006 [ + - + - ]: 5395 : assert(stack.size() == 1);
1007 [ + - + - : 5395 : assert(stack[0]->GetStaticOps() == ops);
+ - ]
1008 [ + - + - ]: 5395 : assert(stack[0]->ScriptSize() == scriptsize);
1009 [ + - + - ]: 5395 : stack[0]->DuplicateKeyCheck(KEY_COMP);
1010 : 5395 : return std::move(stack[0]);
1011 : 7566 : }
1012 : :
1013 : : //! The spk for this script under the given context. If it's a Taproot output also record the spend data.
1014 : 4863 : CScript ScriptPubKey(MsCtx ctx, const CScript& script, TaprootBuilder& builder)
1015 : : {
1016 [ + + + - : 4863 : if (!miniscript::IsTapscript(ctx)) return CScript() << OP_0 << WitnessV0ScriptHash(script);
+ - + - +
- + - ]
1017 : :
1018 : : // For Taproot outputs we always use a tree with a single script and a dummy internal key.
1019 : 1783 : builder.Add(0, script, TAPROOT_LEAF_TAPSCRIPT);
1020 : 1783 : builder.Finalize(XOnlyPubKey::NUMS_H);
1021 [ + - ]: 1783 : return GetScriptForDestination(builder.GetOutput());
1022 : 4863 : }
1023 : :
1024 : : //! Fill the witness with the data additional to the script satisfaction.
1025 : 4164 : void SatisfactionToWitness(MsCtx ctx, CScriptWitness& witness, const CScript& script, TaprootBuilder& builder) {
1026 : : // For P2WSH, it's only the witness script.
1027 : 4164 : witness.stack.emplace_back(script.begin(), script.end());
1028 [ + + ]: 4164 : if (!miniscript::IsTapscript(ctx)) return;
1029 : : // For Tapscript we also need the control block.
1030 [ + - ]: 1483 : witness.stack.push_back(*builder.GetSpendData().scripts.begin()->second.begin());
1031 : 4164 : }
1032 : :
1033 : : /** Perform various applicable tests on a miniscript Node. */
1034 : 7566 : void TestNode(const MsCtx script_ctx, const NodeRef& node, FuzzedDataProvider& provider)
1035 : : {
1036 [ + + ]: 7566 : if (!node) return;
1037 : :
1038 : : // Check that it roundtrips to text representation
1039 : 5395 : const ParserContext parser_ctx{script_ctx};
1040 : 5395 : std::optional<std::string> str{node->ToString(parser_ctx)};
1041 [ + - ]: 5395 : assert(str);
1042 [ + - ]: 5395 : auto parsed = miniscript::FromString(*str, parser_ctx);
1043 [ + - ]: 5395 : assert(parsed);
1044 [ + - + - ]: 5395 : assert(*parsed == *node);
1045 : :
1046 : : // Check consistency between script size estimation and real size.
1047 [ + - ]: 5395 : auto script = node->ToScript(parser_ctx);
1048 [ + - + - : 5395 : assert(node->ScriptSize() == script.size());
+ - ]
1049 : :
1050 : : // Check consistency of "x" property with the script (type K is excluded, because it can end
1051 : : // with a push of a key, which could match these opcodes).
1052 [ + - + + ]: 5395 : if (!(node->GetType() << "K"_mst)) {
1053 [ + - ]: 5268 : bool ends_in_verify = !(node->GetType() << "x"_mst);
1054 [ + - + + : 5268 : assert(ends_in_verify == (script.back() == OP_CHECKSIG || script.back() == OP_CHECKMULTISIG || script.back() == OP_EQUAL || script.back() == OP_NUMEQUAL));
+ - + + +
- + + + -
+ - ]
1055 : 5268 : }
1056 : :
1057 : : // The rest of the checks only apply when testing a valid top-level script.
1058 [ + - + + ]: 5395 : if (!node->IsValidTopLevel()) return;
1059 : :
1060 : : // Check roundtrip to script
1061 [ + - ]: 4863 : auto decoded = miniscript::FromScript(script, parser_ctx);
1062 [ + - ]: 4863 : assert(decoded);
1063 : : // Note we can't use *decoded == *node because the miniscript representation may differ, so we check that:
1064 : : // - The script corresponding to that decoded form matches exactly
1065 : : // - The type matches exactly
1066 [ + - + - : 4863 : assert(decoded->ToScript(parser_ctx) == script);
+ - ]
1067 [ + - + - : 4863 : assert(decoded->GetType() == node->GetType());
+ - + - ]
1068 : :
1069 : : // Optionally pad the script or the witness in order to increase the sensitivity of the tests of
1070 : : // the resources limits logic.
1071 : 4863 : CScriptWitness witness_mal, witness_nonmal;
1072 [ + - + + ]: 4863 : if (provider.ConsumeBool()) {
1073 : : // Under P2WSH, optionally pad the script with OP_NOPs to max op the ops limit of the constructed script.
1074 : : // This makes the script obviously not actually miniscript-compatible anymore, but the
1075 : : // signatures constructed in this test don't commit to the script anyway, so the same
1076 : : // miniscript satisfier will work. This increases the sensitivity of the test to the ops
1077 : : // counting logic being too low, especially for simple scripts.
1078 : : // Do this optionally because we're not solely interested in cases where the number of ops is
1079 : : // maximal.
1080 : : // Do not pad more than what would cause MAX_STANDARD_P2WSH_SCRIPT_SIZE to be reached, however,
1081 : : // as that also invalidates scripts.
1082 [ + - ]: 720 : const auto node_ops{node->GetOps()};
1083 [ + + + + : 1063 : if (!IsTapscript(script_ctx) && node_ops && *node_ops < MAX_OPS_PER_SCRIPT
+ + ]
1084 [ + + + - ]: 376 : && node->ScriptSize() < MAX_STANDARD_P2WSH_SCRIPT_SIZE) {
1085 [ + - ]: 338 : int add = std::min<int>(
1086 : 338 : MAX_OPS_PER_SCRIPT - *node_ops,
1087 [ + - ]: 338 : MAX_STANDARD_P2WSH_SCRIPT_SIZE - node->ScriptSize());
1088 [ + + + - ]: 34056 : for (int i = 0; i < add; ++i) script.push_back(OP_NOP);
1089 : 338 : }
1090 : :
1091 : : // Under Tapscript, optionally pad the stack up to the limit minus the calculated maximum execution stack
1092 : : // size to assert a Miniscript would never add more elements to the stack during execution than anticipated.
1093 [ + - ]: 720 : const auto node_exec_ss{node->GetExecStackSize()};
1094 [ + + + + : 720 : if (miniscript::IsTapscript(script_ctx) && node_exec_ss && *node_exec_ss < MAX_STACK_SIZE) {
- + ]
1095 : 256 : unsigned add{(unsigned)MAX_STACK_SIZE - *node_exec_ss};
1096 [ + - ]: 256 : witness_mal.stack.resize(add);
1097 [ + - ]: 256 : witness_nonmal.stack.resize(add);
1098 [ + - ]: 256 : script.reserve(add);
1099 [ + + + - ]: 247936 : for (unsigned i = 0; i < add; ++i) script.push_back(OP_NIP);
1100 : 256 : }
1101 : 720 : }
1102 : :
1103 : 4863 : const SatisfierContext satisfier_ctx{script_ctx};
1104 : :
1105 : : // Get the ScriptPubKey for this script, filling spend data if it's Taproot.
1106 [ + - ]: 4863 : TaprootBuilder builder;
1107 [ + - ]: 4863 : const CScript script_pubkey{ScriptPubKey(script_ctx, script, builder)};
1108 : :
1109 : : // Run malleable satisfaction algorithm.
1110 : 4863 : std::vector<std::vector<unsigned char>> stack_mal;
1111 [ + - ]: 4863 : const bool mal_success = node->Satisfy(satisfier_ctx, stack_mal, false) == miniscript::Availability::YES;
1112 : :
1113 : : // Run non-malleable satisfaction algorithm.
1114 : 4863 : std::vector<std::vector<unsigned char>> stack_nonmal;
1115 [ + - ]: 4863 : const bool nonmal_success = node->Satisfy(satisfier_ctx, stack_nonmal, true) == miniscript::Availability::YES;
1116 : :
1117 [ + + ]: 4863 : if (nonmal_success) {
1118 : : // Non-malleable satisfactions are bounded by the satisfaction size plus:
1119 : : // - For P2WSH spends, the witness script
1120 : : // - For Tapscript spends, both the witness script and the control block
1121 [ + - ]: 1195 : const size_t max_stack_size{*node->GetStackSize() + 1 + miniscript::IsTapscript(script_ctx)};
1122 [ + - ]: 1195 : assert(stack_nonmal.size() <= max_stack_size);
1123 : : // If a non-malleable satisfaction exists, the malleable one must also exist, and be identical to it.
1124 [ + - ]: 1195 : assert(mal_success);
1125 [ + - + - ]: 1195 : assert(stack_nonmal == stack_mal);
1126 : : // Compute witness size (excluding script push, control block, and witness count encoding).
1127 [ + - + - ]: 1195 : const size_t wit_size = GetSerializeSize(stack_nonmal) - GetSizeOfCompactSize(stack_nonmal.size());
1128 [ + - + - ]: 1195 : assert(wit_size <= *node->GetWitnessSize());
1129 : :
1130 : : // Test non-malleable satisfaction.
1131 [ + - + - : 1195 : witness_nonmal.stack.insert(witness_nonmal.stack.end(), std::make_move_iterator(stack_nonmal.begin()), std::make_move_iterator(stack_nonmal.end()));
+ - ]
1132 [ + - ]: 1195 : SatisfactionToWitness(script_ctx, witness_nonmal, script, builder);
1133 : 1195 : ScriptError serror;
1134 [ + - ]: 1195 : bool res = VerifyScript(DUMMY_SCRIPTSIG, script_pubkey, &witness_nonmal, STANDARD_SCRIPT_VERIFY_FLAGS, CHECKER_CTX, &serror);
1135 : : // Non-malleable satisfactions are guaranteed to be valid if ValidSatisfactions().
1136 [ + - + + : 1195 : if (node->ValidSatisfactions()) assert(res);
+ - ]
1137 : : // More detailed: non-malleable satisfactions must be valid, or could fail with ops count error (if CheckOpsLimit failed),
1138 : : // or with a stack size error (if CheckStackSize check failed).
1139 [ + + + - : 1195 : assert(res ||
+ - + - #
# # # +
- ]
1140 : : (!node->CheckOpsLimit() && serror == ScriptError::SCRIPT_ERR_OP_COUNT) ||
1141 : : (!node->CheckStackSize() && serror == ScriptError::SCRIPT_ERR_STACK_SIZE));
1142 : 1195 : }
1143 : :
1144 [ + + + + : 4863 : if (mal_success && (!nonmal_success || witness_mal.stack != witness_nonmal.stack)) {
+ - + - ]
1145 : : // Test malleable satisfaction only if it's different from the non-malleable one.
1146 [ + - + - : 2969 : witness_mal.stack.insert(witness_mal.stack.end(), std::make_move_iterator(stack_mal.begin()), std::make_move_iterator(stack_mal.end()));
+ - ]
1147 [ + - ]: 2969 : SatisfactionToWitness(script_ctx, witness_mal, script, builder);
1148 : 2969 : ScriptError serror;
1149 [ + - ]: 2969 : bool res = VerifyScript(DUMMY_SCRIPTSIG, script_pubkey, &witness_mal, STANDARD_SCRIPT_VERIFY_FLAGS, CHECKER_CTX, &serror);
1150 : : // Malleable satisfactions are not guaranteed to be valid under any conditions, but they can only
1151 : : // fail due to stack or ops limits.
1152 [ + + + + : 2969 : assert(res || serror == ScriptError::SCRIPT_ERR_OP_COUNT || serror == ScriptError::SCRIPT_ERR_STACK_SIZE);
+ - ]
1153 : 2969 : }
1154 : :
1155 [ + - + + ]: 4863 : if (node->IsSane()) {
1156 : : // For sane nodes, the two algorithms behave identically.
1157 [ + - ]: 644 : assert(mal_success == nonmal_success);
1158 : 644 : }
1159 : :
1160 : : // Verify that if a node is policy-satisfiable, the malleable satisfaction
1161 : : // algorithm succeeds. Given that under IsSane() both satisfactions
1162 : : // are identical, this implies that for such nodes, the non-malleable
1163 : : // satisfaction will also match the expected policy.
1164 : 97844 : const auto is_key_satisfiable = [script_ctx](const CPubKey& pubkey) -> bool {
1165 : 92981 : auto sig_ptr{TEST_DATA.GetSig(script_ctx, pubkey)};
1166 [ - + ]: 92981 : return sig_ptr != nullptr && sig_ptr->second;
1167 : 92981 : };
1168 [ + - ]: 65372 : bool satisfiable = node->IsSatisfiable([&](const Node& node) -> bool {
1169 [ + + + - : 60509 : switch (node.fragment) {
+ + + + ]
1170 : : case Fragment::PK_K:
1171 : : case Fragment::PK_H:
1172 : 21920 : return is_key_satisfiable(node.keys[0]);
1173 : : case Fragment::MULTI:
1174 : : case Fragment::MULTI_A: {
1175 : 84053 : size_t sats = std::count_if(node.keys.begin(), node.keys.end(), [&](const auto& key) {
1176 : 71061 : return size_t(is_key_satisfiable(key));
1177 : : });
1178 : 12992 : return sats >= node.k;
1179 : 12992 : }
1180 : : case Fragment::OLDER:
1181 : : case Fragment::AFTER:
1182 : 9803 : return node.k & 1;
1183 : : case Fragment::SHA256:
1184 : 3999 : return TEST_DATA.sha256_preimages.count(node.data);
1185 : : case Fragment::HASH256:
1186 : 4463 : return TEST_DATA.hash256_preimages.count(node.data);
1187 : : case Fragment::RIPEMD160:
1188 : 3564 : return TEST_DATA.ripemd160_preimages.count(node.data);
1189 : : case Fragment::HASH160:
1190 : 3768 : return TEST_DATA.hash160_preimages.count(node.data);
1191 : : default:
1192 : 0 : assert(false);
1193 : : }
1194 : : return false;
1195 : 60509 : });
1196 [ + - ]: 4863 : assert(mal_success == satisfiable);
1197 [ - + ]: 7566 : }
1198 : :
1199 : : } // namespace
1200 : :
1201 : 0 : void FuzzInit()
1202 : : {
1203 [ # # # # : 0 : static ECC_Context ecc_context{};
# # ]
1204 : 0 : TEST_DATA.Init();
1205 : 0 : }
1206 : :
1207 : 0 : void FuzzInitSmart()
1208 : : {
1209 : 0 : FuzzInit();
1210 : 0 : SMARTINFO.Init();
1211 : 0 : }
1212 : :
1213 : : /** Fuzz target that runs TestNode on nodes generated using ConsumeNodeStable. */
1214 [ + - ]: 2641 : FUZZ_TARGET(miniscript_stable, .init = FuzzInit)
1215 : : {
1216 : : // Run it under both P2WSH and Tapscript contexts.
1217 [ + + ]: 7917 : for (const auto script_ctx: {MsCtx::P2WSH, MsCtx::TAPSCRIPT}) {
1218 : 5278 : FuzzedDataProvider provider(buffer.data(), buffer.size());
1219 [ + - + - ]: 248550 : TestNode(script_ctx, GenNode(script_ctx, [&](Type needed_type) {
1220 : 237994 : return ConsumeNodeStable(script_ctx, provider, needed_type);
1221 : 5278 : }, ""_mst), provider);
1222 : 5278 : }
1223 : 2639 : }
1224 : :
1225 : : /** Fuzz target that runs TestNode on nodes generated using ConsumeNodeSmart. */
1226 [ + - ]: 2290 : FUZZ_TARGET(miniscript_smart, .init = FuzzInitSmart)
1227 : : {
1228 : : /** The set of types we aim to construct nodes for. Together they cover all. */
1229 : : static constexpr std::array<Type, 4> BASE_TYPES{"B"_mst, "V"_mst, "K"_mst, "W"_mst};
1230 : :
1231 : 2288 : FuzzedDataProvider provider(buffer.data(), buffer.size());
1232 : 2288 : const auto script_ctx{(MsCtx)provider.ConsumeBool()};
1233 [ + - + - ]: 191110 : TestNode(script_ctx, GenNode(script_ctx, [&](Type needed_type) {
1234 : 186534 : return ConsumeNodeSmart(script_ctx, provider, needed_type);
1235 : 2288 : }, PickValue(provider, BASE_TYPES), true), provider);
1236 : 2288 : }
1237 : :
1238 : : /* Fuzz tests that test parsing from a string, and roundtripping via string. */
1239 [ + - ]: 1522 : FUZZ_TARGET(miniscript_string, .init = FuzzInit)
1240 : : {
1241 [ + + ]: 1520 : if (buffer.empty()) return;
1242 : 1519 : FuzzedDataProvider provider(buffer.data(), buffer.size());
1243 : 1519 : auto str = provider.ConsumeBytesAsString(provider.remaining_bytes() - 1);
1244 [ + - ]: 1519 : const ParserContext parser_ctx{(MsCtx)provider.ConsumeBool()};
1245 [ + - ]: 1519 : auto parsed = miniscript::FromString(str, parser_ctx);
1246 [ + + ]: 1519 : if (!parsed) return;
1247 : :
1248 [ + - ]: 770 : const auto str2 = parsed->ToString(parser_ctx);
1249 [ + - ]: 770 : assert(str2);
1250 [ + - ]: 770 : auto parsed2 = miniscript::FromString(*str2, parser_ctx);
1251 [ + - ]: 770 : assert(parsed2);
1252 [ + - + - ]: 770 : assert(*parsed == *parsed2);
1253 [ - + ]: 1520 : }
1254 : :
1255 : : /* Fuzz tests that test parsing from a script, and roundtripping via script. */
1256 [ + - + - ]: 1225 : FUZZ_TARGET(miniscript_script)
1257 : : {
1258 : 1222 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
1259 : 1222 : const std::optional<CScript> script = ConsumeDeserializable<CScript>(fuzzed_data_provider);
1260 [ + + ]: 1222 : if (!script) return;
1261 : :
1262 [ + - ]: 1195 : const ScriptParserContext script_parser_ctx{(MsCtx)fuzzed_data_provider.ConsumeBool()};
1263 [ + - ]: 1195 : const auto ms = miniscript::FromScript(*script, script_parser_ctx);
1264 [ + + ]: 1195 : if (!ms) return;
1265 : :
1266 [ + - + - : 385 : assert(ms->ToScript(script_parser_ctx) == *script);
+ - ]
1267 [ - + ]: 1222 : }
|
