Files
wuffs/fuzz/c/std/json_fuzzer.cc
T
Nigel Tao 74a6ea2fcd all: relicense from Apache2 to dual Apache2/MIT
The LICENSE has changed from a single license (Apache2) to a dual
license (Apache2 or MIT, at your option).

If you've previously used Wuffs under the Apache2 license, you are able
to keep doing so. No further action required by you.

The two files listed below (previous releases) are exceptions, as they
are older snapshots, frozen in time. Their license has not changed:
release/c/wuffs-v0.2.c
release/c/wuffs-v0.3.c

Every name in the AUTHORS file, other than Google Inc., has signed
Google's CLA (Contributor License Agreement).
2023-10-06 10:00:59 +11:00

540 lines
18 KiB
C++

// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// ----------------
// 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 <vector>
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<uint32_t> 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);
}