| /* |
| * Copyright 2014 Google Inc. All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <clocale> |
| #include <filesystem> |
| #include <string> |
| |
| #include "cpp17/generated_cpp17/monster_test_generated.h" |
| #include "flatbuffers/idl.h" |
| #include "test_assert.h" |
| #include "test_init.h" |
| |
| namespace fs = std::filesystem; |
| |
| // Utility for test run. |
| OneTimeTestInit OneTimeTestInit::one_time_init_; |
| // The current executable path (see LLVMFuzzerInitialize). |
| static fs::path exe_path_; |
| |
| static flatbuffers::Parser parser_; |
| |
| namespace { |
| |
| static constexpr size_t kMinInputLength = 1; |
| static constexpr size_t kMaxInputLength = 16384; |
| |
| static constexpr uint8_t flags_strict_json = 0x80; |
| static constexpr uint8_t flags_skip_unexpected_fields_in_json = 0x40; |
| static constexpr uint8_t flags_allow_non_utf8 = 0x20; |
| |
| bool TestFileExists(fs::path file_path) { |
| if (file_path.has_filename() && fs::exists(file_path)) return true; |
| |
| TEST_OUTPUT_LINE("@DEBUG: file '%s' not found", file_path.string().c_str()); |
| for (const auto &entry : fs::directory_iterator(file_path.parent_path())) { |
| TEST_OUTPUT_LINE("@DEBUG: parent path entry: '%s'", |
| entry.path().string().c_str()); |
| } |
| return false; |
| } |
| |
| std::string LoadBinarySchema(const char *file_name) { |
| const auto file_path = exe_path_.parent_path() / file_name; |
| TEST_EQ(true, TestFileExists(file_path)); |
| std::string schemafile; |
| TEST_EQ(true, |
| flatbuffers::LoadFile(file_path.string().c_str(), true, &schemafile)); |
| |
| flatbuffers::Verifier verifier( |
| reinterpret_cast<const uint8_t *>(schemafile.c_str()), schemafile.size()); |
| TEST_EQ(true, reflection::VerifySchemaBuffer(verifier)); |
| return schemafile; |
| } |
| |
| std::string do_test(const flatbuffers::IDLOptions &opts, |
| const std::string input_json, const bool check_parser) { |
| // (re)define parser options |
| parser_.opts = opts; |
| |
| std::string jsongen; |
| if (parser_.ParseJson(input_json.c_str())) { |
| flatbuffers::Verifier verifier(parser_.builder_.GetBufferPointer(), |
| parser_.builder_.GetSize()); |
| TEST_EQ(true, MyGame::Example::VerifyMonsterBuffer(verifier)); |
| TEST_ASSERT( |
| GenerateText(parser_, parser_.builder_.GetBufferPointer(), &jsongen)); |
| } else if (check_parser) { |
| TEST_OUTPUT_LINE("parser failed with JSON:\n%s", input_json.c_str()); |
| TEST_EQ_STR("", parser_.error_.c_str()); |
| TEST_ASSERT(false); |
| } |
| return jsongen; |
| }; |
| } // namespace |
| |
| // https://google.github.io/oss-fuzz/further-reading/fuzzer-environment/ |
| // Current working directory |
| // You should not make any assumptions about the current working directory of |
| // your fuzz target. If you need to load data files, please use argv[0] to get |
| // the directory where your fuzz target executable is located. |
| // You must not modify argv[0]. |
| extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) { |
| (void)argc; |
| exe_path_ = (*argv)[0]; |
| |
| static const std::string schemafile = LoadBinarySchema("monster_test.bfbs"); |
| // parse schema first, so we can use it to parse the data after |
| parser_.Deserialize(reinterpret_cast<const uint8_t *>(schemafile.c_str()), |
| schemafile.size()); |
| return 0; |
| } |
| |
| extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { |
| // Reserve one byte for Parser flags and one byte for repetition counter. |
| if (size < 3) return 0; |
| const uint8_t flags = data[0]; |
| (void)data[1]; // reserved |
| data += 2; |
| size -= 2; // bypass |
| |
| const std::string original(reinterpret_cast<const char *>(data), size); |
| auto input = std::string(original.c_str()); // until '\0' |
| if (input.size() < kMinInputLength || input.size() > kMaxInputLength) |
| return 0; |
| |
| flatbuffers::IDLOptions opts; |
| opts.strict_json = (flags & flags_strict_json); |
| opts.skip_unexpected_fields_in_json = |
| (flags & flags_skip_unexpected_fields_in_json); |
| opts.allow_non_utf8 = (flags & flags_allow_non_utf8); |
| |
| do { |
| const std::string jsongen_1 = do_test(opts, input, false); |
| if (!jsongen_1.empty()) { |
| const std::string jsongen_2 = do_test(opts, jsongen_1, true); |
| if (jsongen_1 != jsongen_2 && !opts.output_default_scalars_in_json) { |
| // This gets tricky when the jsongen_1 includes a default-value, as the |
| // generated jsongen_2 doesn't emit default-values. So enable default |
| // scalars and re-run it. |
| opts.output_default_scalars_in_json = true; |
| continue; |
| } |
| TEST_EQ(jsongen_1, jsongen_2); |
| } |
| } while (0); |
| |
| return 0; |
| } |