valijson/tests/fuzzing/fuzzer.cpp

#include <valijson/adapters/rapidjson_adapter.hpp>
#include <valijson/schema_parser.hpp>
#include <valijson/validator.hpp>

using valijson::Schema;
using valijson::SchemaParser;
using valijson::ValidationResults;
using valijson::Validator;
using valijson::adapters::AdapterTraits;
using valijson::adapters::RapidJsonAdapter;
using AdapterType = RapidJsonAdapter;

void runOneTest(const AdapterType &test, const Schema &schema,
                Validator::TypeCheckingMode mode)
{
    try {
        if (!test.isObject()) {
            return;
        }

        const AdapterType::Object testObject = test.getObject();
        const auto dataItr = testObject.find("data");

        if (dataItr == testObject.end()) {
            return;
        }

        Validator validator(mode);
        ValidationResults results;
        validator.validate(schema, dataItr->second, &results);
    } catch (const std::exception &) {
    }
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    AdapterTraits<AdapterType>::DocumentType document;
    document.template Parse<rapidjson::kParseIterativeFlag>(reinterpret_cast<const char *>(data), size);

    if (document.HasParseError() || !document.IsArray()) {
        return 0;
    }

    for (const auto &testCase : AdapterType(document).getArray()) {
        if (!testCase.isObject()) {
            continue;
        }

        const AdapterType::Object object = testCase.getObject();
        const auto schemaItr = object.find("schema");
        const auto testsItr = object.find("tests");

        if (schemaItr == object.end() || testsItr == object.end() ||
            !testsItr->second.isArray()) {
            continue;
        }

        Schema schema;
        SchemaParser parser(size % 2 ? SchemaParser::kDraft4
                                     : SchemaParser::kDraft7);

        try {
            parser.populateSchema(schemaItr->second, schema);
        } catch (const std::exception &) {
            continue;
        }

        const auto mode = testsItr->second.hasStrictTypes()
                              ? Validator::kStrongTypes
                              : Validator::kWeakTypes;

        for (const AdapterType test : testsItr->second.getArray()) {
            runOneTest(test, schema, mode);
        }
    }

    return 0;
}