electrobun 0.0.1 → 0.0.2

package/src/bsdiff/zstd/tests/fuzz/Makefile

@@ -1,277 +0,0 @@
-# ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under both the BSD-style license (found in the
-# LICENSE file in the root directory of this source tree) and the GPLv2 (found
-# in the COPYING file in the root directory of this source tree).
-# You may select, at your option, one of the above-listed licenses.
-# ################################################################
-
-# Optionally user defined flags
-CFLAGS ?= -O3
-CXXFLAGS ?= -O3
-CPPFLAGS ?=
-ASFLAGS ?=
-LDFLAGS ?=
-ARFLAGS ?=
-LIB_FUZZING_ENGINE ?= libregression.a
-PYTHON ?= python
-ifeq ($(shell uname), Darwin)
-	DOWNLOAD?=curl -L -o
-else
-	DOWNLOAD?=wget -O
-endif
-CORPORA_URL_PREFIX:=https://github.com/facebook/zstd/releases/download/fuzz-corpora/
-
-LIBZSTD_MK_DIR = ../../lib
-DEBUGLEVEL ?= 2
-ZSTD_LEGACY_SUPPORT ?= 1
-
-include $(LIBZSTD_MK_DIR)/libzstd.mk
-
-PRGDIR = ../../programs
-CONTRIBDIR = ../../contrib
-
-DEFAULT_SEQ_PROD_DIR = $(CONTRIBDIR)/externalSequenceProducer
-DEFAULT_SEQ_PROD_SRC = $(DEFAULT_SEQ_PROD_DIR)/sequence_producer.c
-THIRD_PARTY_SEQ_PROD_OBJ ?=
-
-FUZZ_CPPFLAGS := -I$(LIB_SRCDIR) -I$(LIB_SRCDIR)/common -I$(LIB_SRCDIR)/compress \
-	-I$(LIB_SRCDIR)/dictBuilder -I$(LIB_SRCDIR)/deprecated -I$(LIB_SRCDIR)/legacy \
-	-I$(CONTRIBDIR)/seekable_format -I$(PRGDIR) -I$(DEFAULT_SEQ_PROD_DIR) \
-	-DZSTD_MULTITHREAD -DZSTD_LEGACY_SUPPORT=1 $(CPPFLAGS)
-FUZZ_EXTRA_FLAGS := -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
-	-Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
-	-Wstrict-prototypes -Wundef \
-	-Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \
-	-Wredundant-decls -Wno-deprecated-declarations \
-	-g -fno-omit-frame-pointer
-FUZZ_CFLAGS := $(FUZZ_EXTRA_FLAGS) $(CFLAGS)
-FUZZ_ASFLAGS := $(FUZZ_EXTRA_FLAGS) $(ASFLAGS)
-FUZZ_CXXFLAGS := $(FUZZ_EXTRA_FLAGS) -std=c++11 $(CXXFLAGS)
-FUZZ_LDFLAGS := -pthread $(LDFLAGS)
-FUZZ_ARFLAGS := $(ARFLAGS)
-FUZZ_TARGET_FLAGS = $(FUZZ_CPPFLAGS) $(FUZZ_CXXFLAGS) $(FUZZ_LDFLAGS)
-
-FUZZ_ROUND_TRIP_FLAGS := -DFUZZING_ASSERT_VALID_SEQUENCE
-
-FUZZ_HEADERS := fuzz_helpers.h fuzz.h zstd_helpers.h fuzz_data_producer.h
-FUZZ_SRC := $(PRGDIR)/util.c ./fuzz_helpers.c ./zstd_helpers.c ./fuzz_data_producer.c
-
-SEEKABLE_HEADERS = $(CONTRIBDIR)/seekable_format/zstd_seekable.h
-SEEKABLE_OBJS = $(CONTRIBDIR)/seekable_format/zstdseek_compress.c $(CONTRIBDIR)/seekable_format/zstdseek_decompress.c
-
-ZSTDCOMMON_SRC := $(ZSTD_COMMON_FILES)
-ZSTDCOMP_SRC   := $(ZSTD_COMPRESS_FILES)
-ZSTDDECOMP_SRC := $(ZSTD_DECOMPRESS_FILES)
-ZSTDDICT_SRC := $(ZSTD_DICTBUILDER_FILES)
-ZSTDLEGACY_SRC := $(ZSTD_LEGACY_FILES)
-FUZZ_SRC       := \
-	$(FUZZ_SRC) \
-	$(ZSTDDECOMP_SRC) \
-	$(ZSTDCOMMON_SRC) \
-	$(ZSTDCOMP_SRC) \
-	$(ZSTDDICT_SRC) \
-	$(ZSTDLEGACY_SRC) \
-	$(DEFAULT_SEQ_PROD_SRC)
-FUZZ_SRC := $(sort $(wildcard $(FUZZ_SRC)))
-
-FUZZ_D_OBJ1 := $(subst $(LIB_SRCDIR)/common/,d_lib_common_,$(FUZZ_SRC))
-FUZZ_D_OBJ2 := $(subst $(LIB_SRCDIR)/compress/,d_lib_compress_,$(FUZZ_D_OBJ1))
-FUZZ_D_OBJ3 := $(subst $(LIB_SRCDIR)/decompress/,d_lib_decompress_,$(FUZZ_D_OBJ2))
-FUZZ_D_OBJ4 := $(subst $(LIB_SRCDIR)/dictBuilder/,d_lib_dictBuilder_,$(FUZZ_D_OBJ3))
-FUZZ_D_OBJ5 := $(subst $(LIB_SRCDIR)/legacy/,d_lib_legacy_,$(FUZZ_D_OBJ4))
-FUZZ_D_OBJ6 := $(subst $(PRGDIR)/,d_prg_,$(FUZZ_D_OBJ5))
-FUZZ_D_OBJ7 := $(subst $(DEFAULT_SEQ_PROD_DIR)/,d_default_seq_prod_,$(FUZZ_D_OBJ6))
-FUZZ_D_OBJ8 := $(subst $\./,d_fuzz_,$(FUZZ_D_OBJ7))
-FUZZ_D_OBJ9 := $(FUZZ_D_OBJ8:.c=.o)
-FUZZ_D_OBJ10 := $(THIRD_PARTY_SEQ_PROD_OBJ) $(FUZZ_D_OBJ9)
-FUZZ_DECOMPRESS_OBJ := $(FUZZ_D_OBJ10:.S=.o)
-
-FUZZ_RT_OBJ1 := $(subst $(LIB_SRCDIR)/common/,rt_lib_common_,$(FUZZ_SRC))
-FUZZ_RT_OBJ2 := $(subst $(LIB_SRCDIR)/compress/,rt_lib_compress_,$(FUZZ_RT_OBJ1))
-FUZZ_RT_OBJ3 := $(subst $(LIB_SRCDIR)/decompress/,rt_lib_decompress_,$(FUZZ_RT_OBJ2))
-FUZZ_RT_OBJ4 := $(subst $(LIB_SRCDIR)/dictBuilder/,rt_lib_dictBuilder_,$(FUZZ_RT_OBJ3))
-FUZZ_RT_OBJ5 := $(subst $(LIB_SRCDIR)/legacy/,rt_lib_legacy_,$(FUZZ_RT_OBJ4))
-FUZZ_RT_OBJ6 := $(subst $(PRGDIR)/,rt_prg_,$(FUZZ_RT_OBJ5))
-FUZZ_RT_OBJ7 := $(subst $(DEFAULT_SEQ_PROD_DIR)/,rt_default_seq_prod_,$(FUZZ_RT_OBJ6))
-FUZZ_RT_OBJ8 := $(subst $\./,rt_fuzz_,$(FUZZ_RT_OBJ7))
-FUZZ_RT_OBJ9 := $(FUZZ_RT_OBJ8:.c=.o)
-FUZZ_RT_OBJ10 := $(THIRD_PARTY_SEQ_PROD_OBJ) $(FUZZ_RT_OBJ9)
-FUZZ_ROUND_TRIP_OBJ := $(FUZZ_RT_OBJ10:.S=.o)
-
-.PHONY: default all clean cleanall
-
-default: all
-
-FUZZ_TARGETS :=       \
-	simple_round_trip \
-	stream_round_trip \
-	block_round_trip  \
-	simple_decompress \
-	stream_decompress \
-	block_decompress  \
-	dictionary_round_trip \
-	dictionary_decompress \
-	zstd_frame_info \
-	simple_compress \
-	dictionary_loader \
-	raw_dictionary_round_trip \
-	dictionary_stream_round_trip \
-	decompress_dstSize_tooSmall \
-	fse_read_ncount \
-	sequence_compression_api \
-	seekable_roundtrip \
-	huf_round_trip \
-	huf_decompress \
-	decompress_cross_format \
-	generate_sequences
-
-all: libregression.a $(FUZZ_TARGETS)
-
-rt_lib_common_%.o: $(LIB_SRCDIR)/common/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $(FUZZ_ROUND_TRIP_FLAGS) $< -c -o $@
-
-rt_lib_compress_%.o: $(LIB_SRCDIR)/compress/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $(FUZZ_ROUND_TRIP_FLAGS) $< -c -o $@
-
-rt_lib_decompress_%.o: $(LIB_SRCDIR)/decompress/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $(FUZZ_ROUND_TRIP_FLAGS) $< -c -o $@
-
-rt_lib_decompress_%.o: $(LIB_SRCDIR)/decompress/%.S
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_ASFLAGS) $(FUZZ_ROUND_TRIP_FLAGS) $< -c -o $@
-
-rt_lib_dictBuilder_%.o: $(LIB_SRCDIR)/dictBuilder/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $(FUZZ_ROUND_TRIP_FLAGS) $< -c -o $@
-
-rt_lib_legacy_%.o: $(LIB_SRCDIR)/legacy/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $(FUZZ_ROUND_TRIP_FLAGS) $< -c -o $@
-
-rt_prg_%.o: $(PRGDIR)/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $(FUZZ_ROUND_TRIP_FLAGS) $< -c -o $@
-
-rt_fuzz_%.o: %.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $(FUZZ_ROUND_TRIP_FLAGS) $< -c -o $@
-
-rt_default_seq_prod_%.o: $(DEFAULT_SEQ_PROD_DIR)/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $(FUZZ_ROUND_TRIP_FLAGS) $< -c -o $@
-
-d_lib_common_%.o: $(LIB_SRCDIR)/common/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $< -c -o $@
-
-d_lib_compress_%.o: $(LIB_SRCDIR)/compress/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $< -c -o $@
-
-d_lib_decompress_%.o: $(LIB_SRCDIR)/decompress/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $< -c -o $@
-
-d_lib_decompress_%.o: $(LIB_SRCDIR)/decompress/%.S
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_ASFLAGS) $< -c -o $@
-
-d_lib_dictBuilder_%.o: $(LIB_SRCDIR)/dictBuilder/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $< -c -o $@
-
-d_lib_legacy_%.o: $(LIB_SRCDIR)/legacy/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $< -c -o $@
-
-d_prg_%.o: $(PRGDIR)/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $< -c -o $@
-
-d_fuzz_%.o: %.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $< -c -o $@
-
-d_default_seq_prod_%.o: $(DEFAULT_SEQ_PROD_DIR)/%.c
-	$(CC) $(FUZZ_CPPFLAGS) $(FUZZ_CFLAGS) $< -c -o $@
-
-simple_round_trip: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_simple_round_trip.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_simple_round_trip.o $(LIB_FUZZING_ENGINE) -o $@
-
-stream_round_trip: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_stream_round_trip.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_stream_round_trip.o $(LIB_FUZZING_ENGINE) -o $@
-
-block_round_trip: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_block_round_trip.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_block_round_trip.o $(LIB_FUZZING_ENGINE) -o $@
-
-simple_decompress: $(FUZZ_HEADERS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_simple_decompress.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_simple_decompress.o $(LIB_FUZZING_ENGINE) -o $@
-
-stream_decompress: $(FUZZ_HEADERS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_stream_decompress.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_stream_decompress.o $(LIB_FUZZING_ENGINE) -o $@
-
-block_decompress: $(FUZZ_HEADERS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_block_decompress.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_block_decompress.o $(LIB_FUZZING_ENGINE) -o $@
-
-dictionary_round_trip: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_dictionary_round_trip.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_dictionary_round_trip.o $(LIB_FUZZING_ENGINE) -o $@
-
-raw_dictionary_round_trip: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_raw_dictionary_round_trip.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_raw_dictionary_round_trip.o $(LIB_FUZZING_ENGINE) -o $@
-
-dictionary_stream_round_trip: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_dictionary_stream_round_trip.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_dictionary_stream_round_trip.o $(LIB_FUZZING_ENGINE) -o $@
-
-dictionary_decompress: $(FUZZ_HEADERS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_dictionary_decompress.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_dictionary_decompress.o $(LIB_FUZZING_ENGINE) -o $@
-
-simple_compress: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_simple_compress.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_simple_compress.o $(LIB_FUZZING_ENGINE) -o $@
-
-zstd_frame_info: $(FUZZ_HEADERS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_zstd_frame_info.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_zstd_frame_info.o $(LIB_FUZZING_ENGINE) -o $@
-
-dictionary_loader: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_dictionary_loader.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_dictionary_loader.o $(LIB_FUZZING_ENGINE) -o $@
-
-decompress_dstSize_tooSmall: $(FUZZ_HEADERS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_decompress_dstSize_tooSmall.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_decompress_dstSize_tooSmall.o $(LIB_FUZZING_ENGINE) -o $@
-
-fse_read_ncount: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_fse_read_ncount.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_fse_read_ncount.o $(LIB_FUZZING_ENGINE) -o $@
-
-sequence_compression_api: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_sequence_compression_api.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_sequence_compression_api.o $(LIB_FUZZING_ENGINE) -o $@
-
-seekable_roundtrip: $(FUZZ_HEADERS) $(SEEKABLE_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) $(SEEKABLE_OBJS)  rt_fuzz_seekable_roundtrip.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) $(SEEKABLE_OBJS) rt_fuzz_seekable_roundtrip.o $(LIB_FUZZING_ENGINE) -o $@
-
-huf_round_trip: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_huf_round_trip.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_huf_round_trip.o $(LIB_FUZZING_ENGINE) -o $@
-
-huf_decompress: $(FUZZ_HEADERS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_huf_decompress.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_huf_decompress.o $(LIB_FUZZING_ENGINE) -o $@
-
-decompress_cross_format: $(FUZZ_HEADERS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_decompress_cross_format.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_DECOMPRESS_OBJ) d_fuzz_decompress_cross_format.o $(LIB_FUZZING_ENGINE) -o $@
-
-generate_sequences: $(FUZZ_HEADERS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_generate_sequences.o
-	$(CXX) $(FUZZ_TARGET_FLAGS) $(FUZZ_ROUND_TRIP_OBJ) rt_fuzz_generate_sequences.o $(LIB_FUZZING_ENGINE) -o $@
-
-libregression.a: $(FUZZ_HEADERS) $(PRGDIR)/util.h $(PRGDIR)/util.c d_fuzz_regression_driver.o
-	$(AR) $(FUZZ_ARFLAGS) $@ d_fuzz_regression_driver.o
-
-corpora/%_seed_corpus.zip:
-	@mkdir -p corpora
-	$(DOWNLOAD) $@ $(CORPORA_URL_PREFIX)$*_seed_corpus.zip
-
-corpora/%: corpora/%_seed_corpus.zip
-	unzip -q $^ -d $@
-
-.PHONY: corpora
-corpora: $(patsubst %,corpora/%,$(FUZZ_TARGETS))
-
-.PHONY: seedcorpora
-seedcorpora: $(patsubst %,corpora/%_seed_corpus.zip,$(FUZZ_TARGETS))
-
-regressiontest: corpora
-	CC="$(CC)" CXX="$(CXX)" CFLAGS="$(CFLAGS)" CXXFLAGS="$(CXXFLAGS)" LDFLAGS="$(LDFLAGS)" $(PYTHON) ./fuzz.py build all --debug=$(DEBUGLEVEL)
-	$(PYTHON) ./fuzz.py regression all
-
-clean:
-	@$(RM) *.a *.o $(FUZZ_TARGETS)
-	@echo Cleaning completed
-
-cleanall:
-	@$(RM) -r Fuzzer
-	@$(RM) -r corpora
-	@echo Cleaning completed

package/src/bsdiff/zstd/tests/fuzz/README.md

@@ -1,161 +0,0 @@
-# Fuzzing
-
-Each fuzzing target can be built with multiple engines.
-Zstd provides a fuzz corpus for each target that can be downloaded with
-the command:
-
-```
-make corpora
-```
-
-It will download each corpus into `./corpora/TARGET`.
-
-## fuzz.py
-
-`fuzz.py` is a helper script for building and running fuzzers.
-Run `./fuzz.py -h` for the commands and run `./fuzz.py COMMAND -h` for
-command specific help.
-
-### Generating Data
-
-`fuzz.py` provides a utility to generate seed data for each fuzzer.
-
-```
-make -C ../tests decodecorpus
-./fuzz.py gen TARGET
-```
-
-By default it outputs 100 samples, each at most 8KB into `corpora/TARGET-seed`,
-but that can be configured with the `--number`, `--max-size-log` and `--seed`
-flags.
-
-### Build
-It respects the usual build environment variables `CC`, `CFLAGS`, etc.
-The environment variables can be overridden with the corresponding flags
-`--cc`, `--cflags`, etc.
-The specific fuzzing engine is selected with `LIB_FUZZING_ENGINE` or
-`--lib-fuzzing-engine`, the default is `libregression.a`.
-Alternatively, you can use Clang's built in fuzzing engine with
-`--enable-fuzzer`.
-It has flags that can easily set up sanitizers `--enable-{a,ub,m}san`, and
-coverage instrumentation `--enable-coverage`.
-It sets sane defaults which can be overridden with flags `--debug`,
-`--enable-ubsan-pointer-overflow`, etc.
-Run `./fuzz.py build -h` for help.
-
-### Running Fuzzers
-
-`./fuzz.py` can run `libfuzzer`, `afl`, and `regression` tests.
-See the help of the relevant command for options.
-Flags not parsed by `fuzz.py` are passed to the fuzzing engine.
-The command used to run the fuzzer is printed for debugging.
-
-Here's a helpful command to fuzz each target across all cores,
-stopping only if a bug is found:
-```
-for target in $(./fuzz.py list); do
-    ./fuzz.py libfuzzer $target -jobs=10 -workers=10 -max_total_time=1000 || break;
-done
-```
-Alternatively, you can fuzz all targets in parallel, using one core per target:
-```
-python3 ./fuzz.py list | xargs -P$(python3 ./fuzz.py list | wc -l) -I__ sh -c "python3 ./fuzz.py libfuzzer __ 2>&1 | tee __.log"
-```
-Either way, to double-check that no crashes were found, run `ls corpora/*crash`.
-If any crashes were found, you can use the hashes to reproduce them.
-
-## LibFuzzer
-
-```
-# Build the fuzz targets
-./fuzz.py build all --enable-fuzzer --enable-asan --enable-ubsan --cc clang --cxx clang++
-# OR equivalently
-CC=clang CXX=clang++ ./fuzz.py build all --enable-fuzzer --enable-asan --enable-ubsan
-# Run the fuzzer
-./fuzz.py libfuzzer TARGET <libfuzzer args like -jobs=4>
-```
-
-where `TARGET` could be `simple_decompress`, `stream_round_trip`, etc.
-
-### MSAN
-
-Fuzzing with `libFuzzer` and `MSAN` is as easy as:
-
-```
-CC=clang CXX=clang++ ./fuzz.py build all --enable-fuzzer --enable-msan
-./fuzz.py libfuzzer TARGET <libfuzzer args>
-```
-
-`fuzz.py` respects the environment variables / flags `MSAN_EXTRA_CPPFLAGS`,
-`MSAN_EXTRA_CFLAGS`, `MSAN_EXTRA_CXXFLAGS`, `MSAN_EXTRA_LDFLAGS` to easily pass
-the extra parameters only for MSAN.
-
-## AFL
-
-The default `LIB_FUZZING_ENGINE` is `libregression.a`, which produces a binary
-that AFL can use.
-
-```
-# Build the fuzz targets
-CC=afl-clang CXX=afl-clang++ ./fuzz.py build all --enable-asan --enable-ubsan
-# Run the fuzzer without a memory limit because of ASAN
-./fuzz.py afl TARGET -m none
-```
-
-## Regression Testing
-
-The regression test supports the `all` target to run all the fuzzers in one
-command.
-
-```
-CC=clang CXX=clang++ ./fuzz.py build all --enable-asan --enable-ubsan
-./fuzz.py regression all
-CC=clang CXX=clang++ ./fuzz.py build all --enable-msan
-./fuzz.py regression all
-```
-
-## Fuzzing a custom sequence producer plugin
-Sequence producer plugin authors can use the zstd fuzzers to stress-test their code.
-See the documentation in `fuzz_third_party_seq_prod.h` for details.
-
-## Adding a new fuzzer
-There are several steps involved in adding a new fuzzer harness.
-
-### Build your harness
-1. Create a new your fuzzer harness `tests/fuzz/your_harness.c`.
-
-2. Add your harness to the Makefile
-
-    2.1 Follow [this example](https://github.com/facebook/zstd/blob/e124e39301381de8f323436a3e4c46539747ba24/tests/fuzz/Makefile#L216) if your fuzzer requires both compression and decompression symbols (prefix `rt_`). If your fuzzer only requires decompression symbols, follow [this example](https://github.com/facebook/zstd/blob/6a0052a409e2604bd40354b76b86272b712edd7d/tests/fuzz/Makefile#L194) (prefix `d_`).
-    
-    2.2 Add your target to [`FUZZ_TARGETS`](https://github.com/facebook/zstd/blob/6a0052a409e2604bd40354b76b86272b712edd7d/tests/fuzz/Makefile#L108).
-    
-3. Add your harness to [`fuzz.py`](https://github.com/facebook/zstd/blob/6a0052a409e2604bd40354b76b86272b712edd7d/tests/fuzz/fuzz.py#L48).
-
-### Generate seed data
-Follow the instructions above to generate seed data:
-```
-make -C ../tests decodecorpus
-./fuzz.py gen your_harness
-```
-
-### Run the harness
-Follow the instructions above to run your harness and fix any crashes:
-```
-./fuzz.py build your_harness --enable-fuzzer --enable-asan --enable-ubsan --cc clang --cxx clang++
-./fuzz.py libfuzzer your_harness
-```
-
-### Minimize and zip the corpus
-After running the fuzzer for a while, you will have a large corpus at `tests/fuzz/corpora/your_harness*`.
-This corpus must be minimized and zipped before uploading to GitHub for regression testing:
-```
-./fuzz.py minimize your_harness
-./fuzz.py zip your_harness 
-```
-
-### Upload the zip file to GitHub
-The previous step should produce a `.zip` file containing the corpus for your new harness.
-This corpus must be uploaded to GitHub here: https://github.com/facebook/zstd/releases/tag/fuzz-corpora
-
-

package/src/bsdiff/zstd/tests/fuzz/block_decompress.c

@@ -1,53 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/**
- * This fuzz target attempts to decompress the fuzzed data with the simple
- * decompression function to ensure the decompressor never crashes.
- */
-
-#include "fuzz_data_producer.h"
-#define ZSTD_STATIC_LINKING_ONLY
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "fuzz_helpers.h"
-#include "zstd.h"
-
-static ZSTD_DCtx *dctx = NULL;
-static void* rBuf = NULL;
-static size_t bufSize = 0;
-
-int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
-{
-    size_t const neededBufSize = ZSTD_BLOCKSIZE_MAX;
-    FUZZ_dataProducer_t *producer = FUZZ_dataProducer_create(src, size);
-
-    /* Allocate all buffers and contexts if not already allocated */
-    if (neededBufSize > bufSize) {
-        free(rBuf);
-        rBuf = FUZZ_malloc_rand(neededBufSize, producer);
-        bufSize = neededBufSize;
-    }
-    if (!dctx) {
-        dctx = ZSTD_createDCtx();
-        FUZZ_ASSERT(dctx);
-    }
-    ZSTD_decompressBegin(dctx);
-    ZSTD_decompressBlock(dctx, rBuf, neededBufSize, src, size);
-
-    FUZZ_dataProducer_free(producer);
-
-#ifndef STATEFUL_FUZZING
-    ZSTD_freeDCtx(dctx); dctx = NULL;
-#endif
-    return 0;
-}

package/src/bsdiff/zstd/tests/fuzz/block_round_trip.c

@@ -1,103 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/**
- * This fuzz target performs a zstd round-trip test (compress & decompress),
- * compares the result with the original, and calls abort() on corruption.
- */
-
-#define ZSTD_STATIC_LINKING_ONLY
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "fuzz_helpers.h"
-#include "zstd.h"
-#include "zstd_helpers.h"
-#include "fuzz_data_producer.h"
-#include "fuzz_third_party_seq_prod.h"
-
-static ZSTD_CCtx *cctx = NULL;
-static ZSTD_DCtx *dctx = NULL;
-static void* cBuf = NULL;
-static void* rBuf = NULL;
-static size_t bufSize = 0;
-
-static size_t roundTripTest(void *result, size_t resultCapacity,
-                            void *compressed, size_t compressedCapacity,
-                            const void *src, size_t srcSize,
-                            int cLevel)
-{
-    ZSTD_parameters const params = ZSTD_getParams(cLevel, srcSize, 0);
-    size_t ret = ZSTD_compressBegin_advanced(cctx, NULL, 0, params, srcSize);
-    FUZZ_ZASSERT(ret);
-
-    ret = ZSTD_compressBlock(cctx, compressed, compressedCapacity, src, srcSize);
-    FUZZ_ZASSERT(ret);
-    if (ret == 0) {
-        FUZZ_ASSERT(resultCapacity >= srcSize);
-        if (srcSize > 0) {
-            memcpy(result, src, srcSize);
-        }
-        return srcSize;
-    }
-    ZSTD_decompressBegin(dctx);
-    return ZSTD_decompressBlock(dctx, result, resultCapacity, compressed, ret);
-}
-
-int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
-{
-    FUZZ_SEQ_PROD_SETUP();
-
-    /* Give a random portion of src data to the producer, to use for
-    parameter generation. The rest will be used for (de)compression */
-    FUZZ_dataProducer_t *producer = FUZZ_dataProducer_create(src, size);
-    size = FUZZ_dataProducer_reserveDataPrefix(producer);
-
-    int const cLevel = FUZZ_dataProducer_int32Range(producer, kMinClevel, kMaxClevel);
-
-    size_t neededBufSize = size;
-    if (size > ZSTD_BLOCKSIZE_MAX)
-        size = ZSTD_BLOCKSIZE_MAX;
-
-    /* Allocate all buffers and contexts if not already allocated */
-    if (neededBufSize > bufSize || !cBuf || !rBuf) {
-        free(cBuf);
-        free(rBuf);
-        cBuf = FUZZ_malloc(neededBufSize);
-        rBuf = FUZZ_malloc(neededBufSize);
-        bufSize = neededBufSize;
-    }
-    if (!cctx) {
-        cctx = ZSTD_createCCtx();
-        FUZZ_ASSERT(cctx);
-    }
-    if (!dctx) {
-        dctx = ZSTD_createDCtx();
-        FUZZ_ASSERT(dctx);
-    }
-
-    {
-        size_t const result =
-            roundTripTest(rBuf, neededBufSize, cBuf, neededBufSize, src, size,
-              cLevel);
-        FUZZ_ZASSERT(result);
-        FUZZ_ASSERT_MSG(result == size, "Incorrect regenerated size");
-        FUZZ_ASSERT_MSG(!FUZZ_memcmp(src, rBuf, size), "Corruption!");
-    }
-    FUZZ_dataProducer_free(producer);
-#ifndef STATEFUL_FUZZING
-    ZSTD_freeCCtx(cctx); cctx = NULL;
-    ZSTD_freeDCtx(dctx); dctx = NULL;
-#endif
-    FUZZ_SEQ_PROD_TEARDOWN();
-    return 0;
-}