// Copyright 2020 The Wuffs Authors. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. // // SPDX-License-Identifier: Apache-2.0 OR MIT // ---------------- // Silence the nested slash-star warning for the next comment's command line. #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wcomment" /* This fuzzer (the fuzz function) is typically run indirectly, by a framework such as https://github.com/google/oss-fuzz calling LLVMFuzzerTestOneInput. When working on the fuzz implementation, or as a coherence check, defining WUFFS_CONFIG__FUZZLIB_MAIN will let you manually run fuzz over a set of files: gcc -DWUFFS_CONFIG__FUZZLIB_MAIN json_fuzzer.c ./a.out ../../../test/data/*.json rm -f ./a.out It should print "PASS", amongst other information, and exit(0). */ #pragma clang diagnostic pop // Wuffs ships as a "single file C library" or "header file library" as per // https://github.com/nothings/stb/blob/master/docs/stb_howto.txt // // To use that single file as a "foo.c"-like implementation, instead of a // "foo.h"-like header, #define WUFFS_IMPLEMENTATION before #include'ing or // compiling it. #define WUFFS_IMPLEMENTATION #if defined(WUFFS_CONFIG__FUZZLIB_MAIN) // Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when // combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs' // functions have static storage. // // This can help the compiler ignore or discard unused code, which can produce // faster compiles and smaller binaries. Other motivations are discussed in the // "ALLOW STATIC IMPLEMENTATION" section of // https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt #define WUFFS_CONFIG__STATIC_FUNCTIONS #endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN) // Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of // release/c/etc.c choose which parts of Wuffs to build. That file contains the // entire Wuffs standard library, implementing a variety of codecs and file // formats. Without this macro definition, an optimizing compiler or linker may // very well discard Wuffs code for unused codecs, but listing the Wuffs // modules we use makes that process explicit. Preprocessing means that such // code simply isn't compiled. #define WUFFS_CONFIG__MODULES #define WUFFS_CONFIG__MODULE__AUX__BASE #define WUFFS_CONFIG__MODULE__AUX__JSON #define WUFFS_CONFIG__MODULE__BASE #define WUFFS_CONFIG__MODULE__JSON // If building this program in an environment that doesn't easily accommodate // relative includes, you can use the script/inline-c-relative-includes.go // program to generate a stand-alone C file. #include "../../../release/c/wuffs-unsupported-snapshot.c" #include "../fuzzlib/fuzzlib.c" #define TOK_BUFFER_ARRAY_SIZE 4096 #define STACK_SIZE (WUFFS_JSON__DECODER_DEPTH_MAX_INCL + 1) // Wuffs allows either statically or dynamically allocated work buffers. This // program exercises static allocation. #define WORK_BUFFER_ARRAY_SIZE \ WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE #if WORK_BUFFER_ARRAY_SIZE > 0 uint8_t g_work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; #else // Not all C/C++ compilers support 0-length arrays. uint8_t g_work_buffer_array[1]; #endif // Each stack element is 1 byte. The low 7 bits denote the container: // - 0x01 means no container: we are at the top level. // - 0x02 means a [] list. // - 0x04 means a {} dictionary. // // The high 0x80 bit holds the even/odd-ness of the number of elements in that // container. A valid dictionary contains key-value pairs and should therefore // contain an even number of elements. typedef uint8_t stack_element; const char* // fuzz_one_token(wuffs_base__token t, wuffs_base__token prev_token, wuffs_base__io_buffer* src, size_t* ti, stack_element* stack, size_t* depth) { uint64_t len = wuffs_base__token__length(&t); if (len > 0xFFFF) { return "fuzz: internal error: length too long (vs 0xFFFF)"; } else if (len > (src->meta.wi - *ti)) { return "fuzz: internal error: length too long (vs wi - ti)"; } *ti += len; if ((wuffs_base__token__value_extension(&t) >= 0) && !wuffs_base__token__continued(&prev_token)) { return "fuzz: internal error: extended token not after continued token"; } int64_t vbc = wuffs_base__token__value_base_category(&t); uint64_t vbd = wuffs_base__token__value_base_detail(&t); switch (vbc) { case WUFFS_BASE__TOKEN__VBC__STRUCTURE: { bool from_consistent = false; if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE) { from_consistent = stack[*depth] & 0x01; } else if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST) { from_consistent = stack[*depth] & 0x02; } else if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT) { from_consistent = stack[*depth] & 0x04; } if (!from_consistent) { return "fuzz: internal error: inconsistent VBD__STRUCTURE__FROM_ETC"; } if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) { (*depth)++; if ((*depth >= STACK_SIZE) || (*depth == 0)) { return "fuzz: internal error: depth too large"; } if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE) { return "fuzz: internal error: push to the 'none' container"; } else if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST) { stack[*depth] = 0x02; } else if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT) { stack[*depth] = 0x04; } else { return "fuzz: internal error: unrecognized VBD__STRUCTURE__TO_ETC"; } } else if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP) { if ((vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT) && (0 != (0x80 & stack[*depth]))) { return "fuzz: internal error: dictionary had an incomplete key/value " "pair"; } if (*depth <= 0) { return "fuzz: internal error: depth too small"; } (*depth)--; bool to_consistent = false; if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE) { to_consistent = stack[*depth] & 0x01; } else if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST) { to_consistent = stack[*depth] & 0x02; } else if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT) { to_consistent = stack[*depth] & 0x04; } if (!to_consistent) { return "fuzz: internal error: inconsistent VBD__STRUCTURE__TO_ETC"; } } else { return "fuzz: internal error: unrecognized VBC__STRUCTURE"; } break; } case WUFFS_BASE__TOKEN__VBC__STRING: { if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) { wuffs_base__slice_u8 s = wuffs_base__make_slice_u8(src->data.ptr + *ti - len, len); if ((vbd & WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_UTF_8) && (s.len != wuffs_base__utf_8__longest_valid_prefix(s.ptr, s.len))) { return "fuzz: internal error: invalid UTF-8"; } if ((vbd & WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_ASCII) && (s.len != wuffs_base__ascii__longest_valid_prefix(s.ptr, s.len))) { return "fuzz: internal error: invalid ASCII"; } } break; } case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: { if ((WUFFS_BASE__UNICODE_SURROGATE__MIN_INCL <= vbd) && (vbd <= WUFFS_BASE__UNICODE_SURROGATE__MAX_INCL)) { return "fuzz: internal error: invalid Unicode surrogate"; } else if (WUFFS_BASE__UNICODE_CODE_POINT__MAX_INCL < vbd) { return "fuzz: internal error: invalid Unicode code point"; } break; } default: break; } // After a complete JSON value, update the parity (even/odd count) of the // container. if (!wuffs_base__token__continued(&t) && (vbc != WUFFS_BASE__TOKEN__VBC__FILLER) && ((vbc != WUFFS_BASE__TOKEN__VBC__STRUCTURE) || (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP))) { stack[*depth] ^= 0x80; } return NULL; } uint64_t // buffer_limit(uint64_t hash, uint64_t min, uint64_t max) { hash &= 0x3F; uint64_t n; if (hash < 0x20) { n = min + hash; } else { n = max - (0x3F - hash); } if (n < min) { return min; } else if (n > max) { return max; } return n; } uint32_t g_quirks[] = { WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_A, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_CAPITAL_U, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_E, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_QUESTION_MARK, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_SINGLE_QUOTE, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_V, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_ZERO, WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK, WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE, WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA, WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS, WUFFS_JSON__QUIRK_ALLOW_LEADING_ASCII_RECORD_SEPARATOR, WUFFS_JSON__QUIRK_ALLOW_LEADING_UNICODE_BYTE_ORDER_MARK, WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER, WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T, WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE, 0, }; void set_quirks(wuffs_json__decoder* dec, uint64_t hash) { for (uint32_t i = 0; g_quirks[i]; i++) { uint64_t bit = 1 << (i & 63); if (hash & bit) { wuffs_json__decoder__set_quirk(dec, g_quirks[i], 1); } } } const char* // fuzz_complex(wuffs_base__io_buffer* full_src, uint64_t hash) { uint64_t tok_limit = buffer_limit( hash & 0x3F, WUFFS_JSON__DECODER_DST_TOKEN_BUFFER_LENGTH_MIN_INCL, TOK_BUFFER_ARRAY_SIZE); hash = wuffs_base__u64__rotate_right(hash, 6); uint64_t src_limit = buffer_limit( hash & 0x3F, WUFFS_JSON__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL, 4096); hash = wuffs_base__u64__rotate_right(hash, 6); // ---- wuffs_json__decoder dec; wuffs_base__status status = wuffs_json__decoder__initialize( &dec, sizeof dec, WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED); if (!wuffs_base__status__is_ok(&status)) { return wuffs_base__status__message(&status); } set_quirks(&dec, hash); wuffs_base__token tok_array[TOK_BUFFER_ARRAY_SIZE]; wuffs_base__token_buffer tok = ((wuffs_base__token_buffer){ .data = ((wuffs_base__slice_token){ .ptr = tok_array, .len = (size_t)((tok_limit < TOK_BUFFER_ARRAY_SIZE) ? tok_limit : TOK_BUFFER_ARRAY_SIZE), }), }); wuffs_base__token prev_token = wuffs_base__make_token(0); uint32_t no_progress_count = 0; stack_element stack[STACK_SIZE]; stack[0] = 0x01; // We start in the 'none' container. size_t depth = 0; // ---- while (true) { // Outer loop. wuffs_base__io_buffer src = make_limited_reader(*full_src, src_limit); size_t old_tok_wi = tok.meta.wi; size_t old_tok_ri = tok.meta.ri; size_t old_src_wi = src.meta.wi; size_t old_src_ri = src.meta.ri; size_t ti = old_src_ri; status = wuffs_json__decoder__decode_tokens( &dec, &tok, &src, wuffs_base__make_slice_u8(g_work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); if ((tok.data.len < tok.meta.wi) || // (tok.meta.wi < tok.meta.ri) || // (tok.meta.ri != old_tok_ri)) { return "fuzz: internal error: inconsistent tok indexes"; } else if ((src.data.len < src.meta.wi) || // (src.meta.wi < src.meta.ri) || // (src.meta.wi != old_src_wi)) { return "fuzz: internal error: inconsistent src indexes"; } full_src->meta.ri += src.meta.ri - old_src_ri; if ((tok.meta.wi > old_tok_wi) || (src.meta.ri > old_src_ri) || !wuffs_base__status__is_suspension(&status)) { no_progress_count = 0; } else if (no_progress_count < 999) { no_progress_count++; } else if (!full_src->meta.closed && (status.repr == wuffs_base__suspension__short_read)) { return wuffs_base__status__message(&status); } else { return "fuzz: internal error: no progress"; } // ---- while (tok.meta.ri < tok.meta.wi) { // Inner loop. wuffs_base__token t = tok.data.ptr[tok.meta.ri++]; const char* z = fuzz_one_token(t, prev_token, &src, &ti, &stack[0], &depth); if (z != NULL) { return z; } prev_token = t; } // Inner loop. // ---- // Check that, starting from old_src_ri, summing the token lengths brings // us to the new src.meta.ri. if (ti != src.meta.ri) { return "fuzz: internal error: ti != ri"; } if (status.repr == NULL) { break; } else if (status.repr == wuffs_base__suspension__short_read) { if (src.meta.closed) { return "fuzz: internal error: short read on a closed io_reader"; } // We don't compact full_src as it may be mmap'ed read-only. continue; } else if (status.repr == wuffs_base__suspension__short_write) { wuffs_base__token_buffer__compact(&tok); continue; } return wuffs_base__status__message(&status); } // Outer loop. // ---- if (depth != 0) { return "fuzz: internal error: decoded OK but final depth was not zero"; } else if (wuffs_base__token__continued(&prev_token)) { return "fuzz: internal error: decoded OK but final token was continued"; } return NULL; } const char* // fuzz_simple(wuffs_base__io_buffer* full_src) { wuffs_json__decoder dec; wuffs_base__status status = wuffs_json__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION, 0); if (!wuffs_base__status__is_ok(&status)) { return wuffs_base__status__message(&status); } wuffs_base__token tok_array[TOK_BUFFER_ARRAY_SIZE]; wuffs_base__token_buffer tok = ((wuffs_base__token_buffer){ .data = ((wuffs_base__slice_token){ .ptr = tok_array, .len = TOK_BUFFER_ARRAY_SIZE, }), }); while (true) { status = wuffs_json__decoder__decode_tokens( &dec, &tok, full_src, wuffs_base__make_slice_u8(g_work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); if (status.repr == NULL) { break; } else if (status.repr == wuffs_base__suspension__short_write) { tok.meta.ri = tok.meta.wi; wuffs_base__token_buffer__compact(&tok); continue; } return wuffs_base__status__message(&status); } return NULL; } #if defined(__cplusplus) #include class Callbacks : public wuffs_aux::DecodeJsonCallbacks { public: Callbacks() : m_depth(0) {} std::string AppendNull() override { return ""; } std::string AppendBool(bool val) override { return ""; } std::string AppendI64(int64_t val) override { return ""; } std::string AppendF64(double val) override { return ""; } std::string AppendTextString(std::string&& val) override { return ""; } std::string Push(uint32_t flags) override { m_depth++; return ""; } std::string Pop(uint32_t flags) override { m_depth--; if (m_depth < 0) { fprintf(stderr, "negative depth\n"); intentional_segfault(); } return ""; } void Done(wuffs_aux::DecodeJsonResult& result, wuffs_aux::sync_io::Input& input, wuffs_aux::IOBuffer& buffer) override { if (result.error_message.empty()) { if (m_depth != 0) { fprintf(stderr, "no error message but final depth is non-zero\n"); intentional_segfault(); } } else if (result.error_message.find("internal error:") != std::string::npos) { fprintf(stderr, "internal errors shouldn't occur: \"%s\"\n", result.error_message.c_str()); intentional_segfault(); } } private: int64_t m_depth; }; void // fuzz_cpp(const uint8_t* in_ptr, size_t in_len, uint64_t hash) { static const char* json_pointers[16] = { "", // "", // "", // "", // "", // "", // "", // "", // "", // "", // "/", // "/2/3/4/5", // "/k0", // "/k0/1", // "/x/y", // "/~0/~1/~n", // }; const char* json_pointer = json_pointers[hash & 15]; hash = wuffs_base__u64__rotate_right(hash, 4); std::vector quirks; for (uint32_t i = 0; g_quirks[i]; i++) { uint64_t bit = 1 << (i & 63); if (hash & bit) { quirks.push_back(g_quirks[i]); } } Callbacks callbacks; wuffs_aux::sync_io::MemoryInput input(in_ptr, in_len); wuffs_aux::DecodeJson( callbacks, input, wuffs_aux::DecodeJsonArgQuirks(quirks.data(), quirks.size()), wuffs_aux::DecodeJsonArgJsonPointer(json_pointer)); } #endif // defined(__cplusplus) const char* // fuzz(wuffs_base__io_buffer* full_src, uint64_t hash) { #if defined(__cplusplus) fuzz_cpp(full_src->reader_pointer(), full_src->reader_length(), wuffs_base__u64__rotate_right(hash, 32)); #endif // defined(__cplusplus) // Send 99.6% of inputs to fuzz_complex and the remainder to fuzz_simple. The // 0xA5 constant is arbitrary but non-zero. If the hash function maps the // empty input to 0, this still sends the empty input to fuzz_complex. // // The fuzz_simple implementation shows how easy decoding with Wuffs is when // all you want is to run LLVMFuzzerTestOneInput's built-in (Wuffs API // independent) checks (e.g. the ASan address sanitizer) and you don't really // care what the output is, just that it doesn't crash. // // The fuzz_complex implementation adds many more Wuffs API specific checks // (e.g. that the sum of the tokens' lengths do not exceed the input length). if ((hash & 0xFF) != 0xA5) { return fuzz_complex(full_src, wuffs_base__u64__rotate_right(hash, 8)); } return fuzz_simple(full_src); }