driver.cpp

#include <cassert>
#include <set>
#include <algorithm>
#include <unistd.h>
#include <string>
#include <span>
#include <fuzzer/FuzzedDataProvider.h>

#include "driver.h"
#include <bitcoinfuzz/basemodule.h>

namespace bitcoinfuzz
{
    void Driver::LoadModule(std::shared_ptr<BaseModule> module)
    {
        modules[module->name] = module;
    }

    void Driver::ScriptTarget(std::span<const uint8_t> buffer) const
    {
        std::optional<std::string> last_response{std::nullopt};
        for (auto& module : modules)
        {
            std::optional<std::string> res{module.second->script_parse(buffer)};
            if (!res.has_value()) continue;
            if (last_response.has_value()) assert(*res == *last_response);
            last_response = *res;
        }
    }

    void Driver::BlockDeserializationTarget(std::span<const uint8_t> buffer) const
    {
        std::optional<std::vector<bool>> last_response{std::nullopt};
        for (auto& module : modules)
        {
            std::optional<std::vector<bool>> res{module.second->deserialize_block(buffer)};
            if (!res.has_value() || res->empty()) continue;
            if (last_response.has_value()) assert(*res == *last_response);
            last_response = res.value();
        }
    }

    void Driver::ScriptEvalTarget(std::span<const uint8_t> buffer) const
    {
        FuzzedDataProvider provider(buffer.data(), buffer.size());
        std::vector<uint8_t> input_data = provider.ConsumeBytes<uint8_t>(
            provider.ConsumeIntegralInRange<size_t>(0, 1024)
        );

        auto flags = provider.ConsumeIntegral<unsigned int>();

        std::optional<bool> last_response{std::nullopt};
        for (auto& module : modules)
        {
            std::optional<bool> res{module.second->script_eval(input_data, flags, /*version=*/0)};
            if (!res.has_value()) continue;
            if (last_response.has_value()) assert(*res == *last_response);
            last_response = *res;
        }
    }

    void Driver::DescriptorParseTarget(std::span<const uint8_t> buffer) const
    {
        FuzzedDataProvider provider(buffer.data(), buffer.size());
        std::string desc{provider.ConsumeRemainingBytesAsString()};
        std::optional<bool> last_response{std::nullopt};
        for (auto& module : modules)
        {
            std::optional<bool> res{module.second->descriptor_parse(desc)};
            if (!res.has_value()) continue;
            if (last_response.has_value()) assert(*res == *last_response);
            last_response = *res;
        }
    }

    void Driver::MiniscriptParseTarget(std::span<const uint8_t> buffer) const
    {
        FuzzedDataProvider provider(buffer.data(), buffer.size());
        std::string miniscript{provider.ConsumeRemainingBytesAsString()};
        // Skip these cases
        if (miniscript == "1" || miniscript == "0") return;
        std::optional<bool> last_response{std::nullopt};
        for (auto& module : modules)
        {
            std::optional<bool> res{module.second->miniscript_parse(miniscript)};
            if (!res.has_value()) continue;
            if (last_response.has_value()) assert(*res == *last_response);
            last_response = *res;
        }
    }

    void Driver::ScriptAsmTarget(std::span<const uint8_t> buffer) const
    {
        std::optional<std::string> last_response{std::nullopt};
        for (auto& module : modules)
        {
            std::optional<std::string> res{module.second->script_asm(buffer)};
            if (!res.has_value()) continue;
            if (last_response.has_value()) {
                assert(*res == *last_response);
            }
            last_response = *res;
        }
    }

    void Driver::InvoiceDeserializationTarget(std::span<const uint8_t> buffer) const
    {
        FuzzedDataProvider provider(buffer.data(), buffer.size());
        std::string invoice{provider.ConsumeRemainingBytesAsString()};
        std::optional<std::string> last_response{std::nullopt};
        std::string last_module_name;

        for (auto &module : modules)
        {
            std::optional<std::string> res{module.second->deserialize_invoice(invoice)};
            if (!res.has_value()) continue;
            if (last_response.has_value()) {
                if (*res != *last_response) {
                    std::cout << "Invoice deserialization failed for " << invoice << std::endl;
                    std::cout << "Module: " << module.first << std::endl;
                    std::cout << "Result: " << *res << std::endl;
                    std::cout << "Module: " << last_module_name << std::endl;
                    std::cout << "Result: " << *last_response << std::endl;
                }
                assert(*res == *last_response);
            }

            last_response = res.value();
            last_module_name = module.first;
        }
    }

    void Driver::AddressParseTarget(std::span<const uint8_t> buffer) const
    {
        FuzzedDataProvider provider(buffer.data(), buffer.size());
        std::string address{provider.ConsumeRemainingBytesAsString()};

        std::optional<std::string> last_response{std::nullopt};
        std::string last_module_name;

        for(auto module: modules)
        {
            std::optional<std::string> res{module.second->address_parse(address)};
            if(!res.has_value()) continue;

            if(last_response.has_value())
            {
                if(*res != *last_response)
                {
                    std::cout << "Input address: " << address << "\n";
                    std::cout << "MISMATCH DETECTED between " << last_module_name << " and " << module.first << "!" << "\n";
                    std::cout << "  " << last_module_name << ": " << *last_response << "\n";
                    std::cout << "  " << module.first << ": " << *res << "\n";
                }

                assert(*res == *last_response);
            }
            last_response = *res;
            last_module_name = module.first;
        }
    }

    void Driver::PSBTParseTarget(std::span<const uint8_t> buffer) const
    {
        std::optional<std::string> last_response{std::nullopt};
        std::string last_module_name;

        for (auto& module : modules)
        {
            std::optional<std::string> res{module.second->psbt_parse(buffer)};
            if (!res.has_value()) continue;

            if (last_response.has_value())
            {
                if (*res != *last_response)
                {
                    std::cout << "Input PSBT (truncated): ";
                    for (size_t i = 0; i < std::min(size_t(32), buffer.size()); ++i)
                        printf("%02x", buffer[i]);
                    if (buffer.size() > 32) std::cout << "...";
                    std::cout << " (" << buffer.size() << " bytes)\n";

                    std::cout << "MISMATCH DETECTED between " << last_module_name << " and " << module.first << "!" << "\n";

                    // Find and highlight the differences
                    std::string last = *last_response;
                    std::string current = *res;

                    // Print the full outputs only if they're reasonably sized
                    if (last.size() < 1000 && current.size() < 1000) {
                        std::cout << "  " << last_module_name << ": " << last << "\n";
                        std::cout << "  " << module.first << ": " << current << "\n";
                    } else {
                        // Find first differing position
                        size_t pos = 0;
                        while (pos < last.size() && pos < current.size() && last[pos] == current[pos]) pos++;

                        // Print context around the difference
                        size_t context = 20;
                        size_t start = (pos > context) ? pos - context : 0;

                        std::cout << "  Difference at position " << pos << "\n";
                        std::cout << "  " << last_module_name << " (excerpt): ..." << last.substr(start, context * 2) << "...\n";
                        std::cout << "  " << module.first << " (excerpt): ..." << current.substr(start, context * 2) << "...\n";
                    }
                }

                assert(*res == *last_response);
            }
            last_response = *res;
            last_module_name = module.first;
        }
    }

    void Driver::AddrV2Target(std::span<const uint8_t> buffer) const
    {
        std::optional<std::string> last_response{std::nullopt};
        for (auto& module : modules)
        {
            std::optional<std::string> res{module.second->addrv2_parse(buffer)};
            if (!res.has_value()) continue;
            if (last_response.has_value()) {
                assert(*res == *last_response);
            }
            last_response = *res;
        }
    }
    
    void Driver::OfferDeserializationTarget(std::span<const uint8_t> buffer) const
    {
        FuzzedDataProvider provider(buffer.data(), buffer.size());
        std::string offer{provider.ConsumeRemainingBytesAsString()};
        std::optional<std::string> last_response{std::nullopt};
        std::string last_module_name;

        for (auto &module : modules)
        {
            std::optional<std::string> res{module.second->deserialize_offer(offer)};
            if (!res.has_value()) continue;
            if (last_response.has_value()) {
                if (*res != *last_response) {
                    std::cout << "Offer deserialization failed for " << offer << std::endl;
                    std::cout << "Module: " << module.first << std::endl;
                    std::cout << "Result: " << *res << std::endl;
                    std::cout << "Module: " << last_module_name << std::endl;
                    std::cout << "Result: " << *last_response << std::endl;
                }
                assert(*res == *last_response);
            }

            last_response = res.value();
            last_module_name = module.first;
        }
    }

    void Driver::Run(const uint8_t *data, const size_t size, const std::string &target) const
    {
        std::span<const uint8_t> buffer{data, size};
        if (target == "script") {
            this->ScriptTarget(buffer);
        } else if (target == "deserialize_block") {
            this->BlockDeserializationTarget(buffer);
        } else if (target == "script_eval") {
            this->ScriptEvalTarget(buffer);
        } else if (target == "descriptor_parse") {
            this->DescriptorParseTarget(buffer);
        } else if (target == "miniscript_parse") {
	        this->MiniscriptParseTarget(buffer);
        } else if (target == "script_asm") {
            this->ScriptAsmTarget(buffer);
	    } else if (target == "deserialize_invoice") {
            this->InvoiceDeserializationTarget(buffer);
        } else if (target == "address_parse") {
            this->AddressParseTarget(buffer);
        } else if (target == "psbt_parse") {
            this->PSBTParseTarget(buffer);
        } else if (target == "addrv2") {
            this->AddrV2Target(buffer);
        } else if (target == "deserialize_offer") {
            this->OfferDeserializationTarget(buffer);
        } else {
            std::cout << "Target not defined!" << std::endl;
            assert(false);
        }
    };

}