Inside Bitcoin

251    bool CheckAfter(uint32_t value) const { return value % 2; }
252    bool CheckOlder(uint32_t value) const { return value % 2; }
253
254    // Signature challenges fulfilled with a dummy signature, if it was one of our dummy keys.
255    miniscript::Availability Sign(const CPubKey& key, std::vector<unsigned char>& sig) const {
256        bool sig_available{false};
257        if (auto res = TEST_DATA.GetSig(script_ctx, key)) {
258            std::tie(sig, sig_available) = *res;
259        }
260        return sig_available ? miniscript::Availability::YES : miniscript::Availability::NO;
261    }
262
263    //! Lookup generalization for all the hash satisfactions below
264    miniscript::Availability LookupHash(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage,
265                                        const std::map<std::vector<unsigned char>, std::vector<unsigned char>>& map) const
266    {
267        const auto it = map.find(hash);
268        if (it == map.end()) return miniscript::Availability::NO;
269        preimage = it->second;
270        return miniscript::Availability::YES;
271    }
272    miniscript::Availability SatSHA256(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
273        return LookupHash(hash, preimage, TEST_DATA.sha256_preimages);
274    }
275    miniscript::Availability SatRIPEMD160(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
276        return LookupHash(hash, preimage, TEST_DATA.ripemd160_preimages);
277    }
278    miniscript::Availability SatHASH256(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
279        return LookupHash(hash, preimage, TEST_DATA.hash256_preimages);
280    }
281    miniscript::Availability SatHASH160(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
282        return LookupHash(hash, preimage, TEST_DATA.hash160_preimages);
283    }
284};
285
286//! Context to check a satisfaction against the pre-computed data.
287const struct CheckerContext: BaseSignatureChecker {
288    // Signature checker methods. Checks the right dummy signature is used.
289    bool CheckECDSASignature(const std::vector<unsigned char>& sig, const std::vector<unsigned char>& vchPubKey,
290                             const CScript& scriptCode, SigVersion sigversion) const override
291    {
292        const CPubKey key{vchPubKey};
293        const auto it = TEST_DATA.dummy_sigs.find(key);
294        if (it == TEST_DATA.dummy_sigs.end()) return false;
295        return it->second.first == sig;
296    }
297    bool CheckSchnorrSignature(std::span<const unsigned char> sig, std::span<const unsigned char> pubkey, SigVersion,
298                               ScriptExecutionData&, ScriptError*) const override {
299        XOnlyPubKey pk{pubkey};
300        auto it = TEST_DATA.schnorr_sigs.find(pk);
301        if (it == TEST_DATA.schnorr_sigs.end()) return false;
302        return std::ranges::equal(it->second.first, sig);
303    }
304    bool CheckLockTime(const CScriptNum& nLockTime) const override { return nLockTime.GetInt64() & 1; }
305    bool CheckSequence(const CScriptNum& nSequence) const override { return nSequence.GetInt64() & 1; }
306} CHECKER_CTX;
307
308//! Context to check for duplicates when instancing a Node.
309const struct KeyComparator {
310    bool KeyCompare(const CPubKey& a, const CPubKey& b) const {
311        return a < b;
312    }
313} KEY_COMP;
314
315// A dummy scriptsig to pass to VerifyScript (we always use Segwit v0).
316const CScript DUMMY_SCRIPTSIG;
317
318/** Information about a yet to be constructed Miniscript node. */
319struct NodeInfo {
320    //! The type of this node
321    Fragment fragment;
322    //! The timelock value for older() and after(), the threshold value for multi() and thresh()
323    uint32_t k;
324    //! Keys for this node, if it has some
325    std::vector<CPubKey> keys;
326    //! The hash value for this node, if it has one
327    std::vector<unsigned char> hash;
328    //! The type requirements for the children of this node.
329    std::vector<Type> subtypes;
330
331    NodeInfo(Fragment frag): fragment(frag), k(0) {}
332    NodeInfo(Fragment frag, CPubKey key): fragment(frag), k(0), keys({key}) {}
333    NodeInfo(Fragment frag, uint32_t _k): fragment(frag), k(_k) {}
334    NodeInfo(Fragment frag, std::vector<unsigned char> h): fragment(frag), k(0), hash(std::move(h)) {}
335    NodeInfo(std::vector<Type> subt, Fragment frag): fragment(frag), k(0), subtypes(std::move(subt)) {}
336    NodeInfo(std::vector<Type> subt, Fragment frag, uint32_t _k): fragment(frag), k(_k), subtypes(std::move(subt))  {}
337    NodeInfo(Fragment frag, uint32_t _k, std::vector<CPubKey> _keys): fragment(frag), k(_k), keys(std::move(_keys)) {}
338};
339
340/** Pick an index in a collection from a single byte in the fuzzer's output. */
341template<typename T, typename A>
342T ConsumeIndex(FuzzedDataProvider& provider, A& col) {
343    const uint8_t i = provider.ConsumeIntegral<uint8_t>();
344    return col[i];
345}
346
347CPubKey ConsumePubKey(FuzzedDataProvider& provider) {
348    return ConsumeIndex<CPubKey>(provider, TEST_DATA.dummy_keys);
349}
350
351std::vector<unsigned char> ConsumeSha256(FuzzedDataProvider& provider) {
352    return ConsumeIndex<std::vector<unsigned char>>(provider, TEST_DATA.sha256);
353}
354
355std::vector<unsigned char> ConsumeHash256(FuzzedDataProvider& provider) {
356    return ConsumeIndex<std::vector<unsigned char>>(provider, TEST_DATA.hash256);
357}
358
359std::vector<unsigned char> ConsumeRipemd160(FuzzedDataProvider& provider) {
360    return ConsumeIndex<std::vector<unsigned char>>(provider, TEST_DATA.ripemd160);
361}
362
363std::vector<unsigned char> ConsumeHash160(FuzzedDataProvider& provider) {
364    return ConsumeIndex<std::vector<unsigned char>>(provider, TEST_DATA.hash160);
365}
366
367std::optional<uint32_t> ConsumeTimeLock(FuzzedDataProvider& provider) {
368    const uint32_t k = provider.ConsumeIntegral<uint32_t>();
369    if (k == 0 || k >= 0x80000000) return {};
370    return k;
371}
372
373/**
374 * Consume a Miniscript node from the fuzzer's output.
375 *
376 * This version is intended to have a fixed, stable, encoding for Miniscript nodes:
377 *  - The first byte sets the type of the fragment. 0, 1 and all non-leaf fragments but thresh() are a
378 *    single byte.
379 *  - For the other leaf fragments, the following bytes depend on their type.
380 *    - For older() and after(), the next 4 bytes define the timelock value.
381 *    - For pk_k(), pk_h(), and all hashes, the next byte defines the index of the value in the test data.
382 *    - For multi(), the next 2 bytes define respectively the threshold and the number of keys. Then as many
383 *      bytes as the number of keys define the index of each key in the test data.
384 *    - For multi_a(), same as for multi() but the threshold and the keys count are encoded on two bytes.
385 *    - For thresh(), the next byte defines the threshold value and the following one the number of subs.
386 */
387std::optional<NodeInfo> ConsumeNodeStable(MsCtx script_ctx, FuzzedDataProvider& provider, Type type_needed) {
388    bool allow_B = (type_needed == ""_mst) || (type_needed << "B"_mst);
389    bool allow_K = (type_needed == ""_mst) || (type_needed << "K"_mst);
390    bool allow_V = (type_needed == ""_mst) || (type_needed << "V"_mst);
391    bool allow_W = (type_needed == ""_mst) || (type_needed << "W"_mst);
392
393    switch (provider.ConsumeIntegral<uint8_t>()) {
394        case 0:
395            if (!allow_B) return {};
396            return {{Fragment::JUST_0}};
397        case 1:
398            if (!allow_B) return {};
399            return {{Fragment::JUST_1}};
400        case 2:
401            if (!allow_K) return {};
402            return {{Fragment::PK_K, ConsumePubKey(provider)}};
403        case 3:
404            if (!allow_K) return {};
405            return {{Fragment::PK_H, ConsumePubKey(provider)}};
406        case 4: {
407            if (!allow_B) return {};
408            const auto k = ConsumeTimeLock(provider);
409            if (!k) return {};
410            return {{Fragment::OLDER, *k}};
411        }
412        case 5: {
413            if (!allow_B) return {};
414            const auto k = ConsumeTimeLock(provider);
415            if (!k) return {};
416            return {{Fragment::AFTER, *k}};
417        }
418        case 6:
419            if (!allow_B) return {};
420            return {{Fragment::SHA256, ConsumeSha256(provider)}};
421        case 7:
422            if (!allow_B) return {};
423            return {{Fragment::HASH256, ConsumeHash256(provider)}};
424        case 8:
425            if (!allow_B) return {};
426            return {{Fragment::RIPEMD160, ConsumeRipemd160(provider)}};
427        case 9:
428            if (!allow_B) return {};
429            return {{Fragment::HASH160, ConsumeHash160(provider)}};
430        case 10: {
431            if (!allow_B || IsTapscript(script_ctx)) return {};
432            const auto k = provider.ConsumeIntegral<uint8_t>();
433            const auto n_keys = provider.ConsumeIntegral<uint8_t>();
434            if (n_keys > 20 || k == 0 || k > n_keys) return {};
435            std::vector<CPubKey> keys{n_keys};
436            for (auto& key: keys) key = ConsumePubKey(provider);
437            return {{Fragment::MULTI, k, std::move(keys)}};
438        }
439        case 11:
440            if (!(allow_B || allow_K || allow_V)) return {};
441            return {{{"B"_mst, type_needed, type_needed}, Fragment::ANDOR}};
442        case 12:
443            if (!(allow_B || allow_K || allow_V)) return {};
444            return {{{"V"_mst, type_needed}, Fragment::AND_V}};
445        case 13:
446            if (!allow_B) return {};
447            return {{{"B"_mst, "W"_mst}, Fragment::AND_B}};
448        case 15:
449            if (!allow_B) return {};
450            return {{{"B"_mst, "W"_mst}, Fragment::OR_B}};
451        case 16:
452            if (!allow_V) return {};
453            return {{{"B"_mst, "V"_mst}, Fragment::OR_C}};
454        case 17:
455            if (!allow_B) return {};
456            return {{{"B"_mst, "B"_mst}, Fragment::OR_D}};
457        case 18:
458            if (!(allow_B || allow_K || allow_V)) return {};
459            return {{{type_needed, type_needed}, Fragment::OR_I}};
460        case 19: {
461            if (!allow_B) return {};
462            auto k = provider.ConsumeIntegral<uint8_t>();
463            auto n_subs = provider.ConsumeIntegral<uint8_t>();
464            if (k == 0 || k > n_subs) return {};
465            std::vector<Type> subtypes;
466            subtypes.reserve(n_subs);
467            subtypes.emplace_back("B"_mst);
468            for (size_t i = 1; i < n_subs; ++i) subtypes.emplace_back("W"_mst);
469            return {{std::move(subtypes), Fragment::THRESH, k}};
470        }
471        case 20:
472            if (!allow_W) return {};
473            return {{{"B"_mst}, Fragment::WRAP_A}};
474        case 21:
475            if (!allow_W) return {};
476            return {{{"B"_mst}, Fragment::WRAP_S}};
477        case 22:
478            if (!allow_B) return {};
479            return {{{"K"_mst}, Fragment::WRAP_C}};
480        case 23:
481            if (!allow_B) return {};
482            return {{{"V"_mst}, Fragment::WRAP_D}};
483        case 24:
484            if (!allow_V) return {};
485            return {{{"B"_mst}, Fragment::WRAP_V}};
486        case 25:
487            if (!allow_B) return {};
488            return {{{"B"_mst}, Fragment::WRAP_J}};
489        case 26:
490            if (!allow_B) return {};
491            return {{{"B"_mst}, Fragment::WRAP_N}};
492        case 27: {
493            if (!allow_B || !IsTapscript(script_ctx)) return {};
494            const auto k = provider.ConsumeIntegral<uint16_t>();
495            const auto n_keys = provider.ConsumeIntegral<uint16_t>();
496            if (n_keys > 999 || k == 0 || k > n_keys) return {};
497            std::vector<CPubKey> keys{n_keys};
498            for (auto& key: keys) key = ConsumePubKey(provider);
499            return {{Fragment::MULTI_A, k, std::move(keys)}};
500        }