diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-javascript/Dockerfile b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-javascript/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..1f5b27da6c1607355ce2296bda4fd15ec2d8b129
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-javascript/Dockerfile
@@ -0,0 +1,20 @@
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-builder:${IMG_TAG}
+
+RUN install_javascript.sh
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-jvm/Dockerfile b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-jvm/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..6ae5da8afd452877d486cd9c91aaca9cf2c655d8
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-jvm/Dockerfile
@@ -0,0 +1,68 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-builder:${IMG_TAG} AS base
+
+ENV JAVA_HOME /usr/lib/jvm/java-17-openjdk-amd64
+ENV JAVA_15_HOME /usr/lib/jvm/java-15-openjdk-amd64
+ENV JVM_LD_LIBRARY_PATH $JAVA_HOME/lib/server
+ENV PATH $PATH:$JAVA_HOME/bin
+ENV JAZZER_API_PATH "/usr/local/lib/jazzer_api_deploy.jar"
+ENV JAZZER_JUNIT_PATH "/usr/local/bin/jazzer_junit.jar"
+
+RUN install_java.sh
+
+RUN chmod 777 /usr/local/bin && chmod 777 /usr/local/lib
+
+FROM base AS builder
+RUN useradd -m jazzer_user
+
+USER jazzer_user
+
+WORKDIR $SRC
+
+RUN git clone https://github.com/aixcc-finals/jazzer-aixcc jazzer && \
+ cd jazzer && \
+ git checkout 43791565a765b854b537d878c9cab757ff1f2140
+
+WORKDIR $SRC/jazzer
+
+RUN echo "build --java_runtime_version=local_jdk_17" >> .bazelrc \
+ && echo "build --cxxopt=-stdlib=libc++" >> .bazelrc \
+ && echo "build --linkopt=-lc++" >> .bazelrc
+
+RUN bazel build \
+ //src/main/java/com/code_intelligence/jazzer:jazzer_standalone_deploy.jar \
+ //deploy:jazzer-api \
+ //deploy:jazzer-junit \
+ //launcher:jazzer
+
+RUN cp $(bazel cquery --output=files //src/main/java/com/code_intelligence/jazzer:jazzer_standalone_deploy.jar) /usr/local/bin/jazzer_agent_deploy.jar && \
+ cp $(bazel cquery --output=files //launcher:jazzer) /usr/local/bin/jazzer_driver && \
+ cp $(bazel cquery --output=files //deploy:jazzer-api) $JAZZER_API_PATH && \
+ cp $(bazel cquery --output=files //deploy:jazzer-junit) $JAZZER_JUNIT_PATH
+
+FROM base AS final
+
+COPY --from=builder /usr/local/bin/jazzer_agent_deploy.jar /usr/local/bin/jazzer_agent_deploy.jar
+COPY --from=builder /usr/local/bin/jazzer_driver /usr/local/bin/jazzer_driver
+COPY --from=builder $JAZZER_API_PATH $JAZZER_API_PATH
+COPY --from=builder $JAZZER_JUNIT_PATH $JAZZER_JUNIT_PATH
+
+RUN chmod 755 /usr/local/bin && chmod 755 /usr/local/lib
+
+WORKDIR $SRC
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-ruby/Dockerfile b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-ruby/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..b478d07b516a7d7bbb064db949e0bf7acee08c47
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-ruby/Dockerfile
@@ -0,0 +1,56 @@
+# Copyright 2024 Google LLC
+#
+# 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.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-builder:${IMG_TAG}
+
+RUN git clone https://github.com/trailofbits/ruzzy.git $SRC/ruzzy
+
+RUN install_ruby.sh
+ENV PATH="$PATH:/usr/local/rvm/rubies/ruby-3.3.1/bin"
+
+RUN gem update --system 3.5.11
+
+# Install ruzzy
+WORKDIR $SRC/ruzzy
+
+# The MAKE variable allows overwriting the make command at runtime. This forces the
+# Ruby C extension to respect ENV variables when compiling, like CC, CFLAGS, etc.
+ENV MAKE="make --environment-overrides V=1"
+
+RUN CC="clang" \
+CXX="clang++" \
+LDSHARED="clang -shared" \
+LDSHAREDXX="clang++ -shared" \
+gem build
+
+RUN MAKE="make --environment-overrides V=1" \
+CC="clang" \
+CXX="clang++" \
+LDSHARED="clang -shared" \
+LDSHAREDXX="clang++ -shared" \
+CXXFLAGS="-fPIC" \
+CFLAGS="-fPIC" \
+RUZZY_DEBUG=1 gem install --install-dir /install/ruzzy --development --verbose ruzzy-*.gem
+
+
+ENV LDSHARED="$CC -shared"
+ENV LDSHAREDXX="$CXX -shared"
+
+ENV GEM_HOME="$OUT/fuzz-gem"
+ENV GEM_PATH="/install/ruzzy"
+
+COPY ruzzy-build /usr/bin/ruzzy-build
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-ruby/ruzzy-build b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-ruby/ruzzy-build
new file mode 100644
index 0000000000000000000000000000000000000000..459e909905d57466667a49ed4e5291798e1715f1
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-ruby/ruzzy-build
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash -e
+# Copyright 2024 Google LLC
+#
+# 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.
+#
+################################################################################
+
+fuzz_target=$(basename "$1")
+echo "BASENAME: $fuzz_target ---"
+harness_sh=${fuzz_target::-3}
+
+cp $1 $OUT/$fuzz_target
+
+echo """#!/usr/bin/env bash
+
+ruzzy $fuzz_target
+""" > $OUT/$harness_sh
+chmod +x $OUT/$harness_sh
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-rust/Dockerfile b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-rust/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..899adc9cff849fa96b422bba682c300ec04af5c0
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder-rust/Dockerfile
@@ -0,0 +1,37 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-builder:${IMG_TAG}
+
+ENV CARGO_HOME=/rust
+ENV RUSTUP_HOME=/rust/rustup
+ENV PATH=$PATH:/rust/bin
+# Set up custom environment variable for source code copy for coverage reports
+ENV OSSFUZZ_RUSTPATH /rust
+
+# Force rustup to ignore `rust-toolchain` and `rust-toolchain.toml` files by
+# manually specifying what toolchain to use. Note that this environment variable
+# is additionally used by `install_rust.sh` as the toolchain to install.
+# cf https://rust-lang.github.io/rustup/overrides.html
+ENV RUSTUP_TOOLCHAIN nightly-2024-07-12
+
+# Configure the linker used by default for x86_64 linux to be `clang` instead of
+# rustc's default of `cc` which is able to find custom-built libraries like
+# `libc++` by default more easily.
+ENV CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER clang
+
+RUN install_rust.sh
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/Dockerfile b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..59b24d7a6cd9c4102df408d45dd71def7711c6f3
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/Dockerfile
@@ -0,0 +1,213 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-clang:${IMG_TAG}
+
+COPY install_deps.sh /
+RUN /install_deps.sh && rm /install_deps.sh
+
+# Build and install latest Python 3.10.
+ENV PYTHON_VERSION 3.10.14
+RUN PYTHON_DEPS="\
+ zlib1g-dev \
+ libncurses5-dev \
+ libgdbm-dev \
+ libnss3-dev \
+ libssl-dev \
+ libsqlite3-dev \
+ libreadline-dev \
+ libffi-dev \
+ libbz2-dev \
+ liblzma-dev" && \
+ unset CFLAGS CXXFLAGS && \
+ apt-get install -y $PYTHON_DEPS && \
+ cd /tmp && \
+ curl -O https://www.python.org/ftp/python/$PYTHON_VERSION/Python-$PYTHON_VERSION.tar.xz && \
+ tar -xvf Python-$PYTHON_VERSION.tar.xz && \
+ cd Python-$PYTHON_VERSION && \
+ ./configure --enable-optimizations --enable-shared && \
+ make -j$(nproc) install && \
+ ldconfig && \
+ ln -s /usr/local/bin/python3 /usr/local/bin/python && \
+ cd .. && \
+ rm -r /tmp/Python-$PYTHON_VERSION.tar.xz /tmp/Python-$PYTHON_VERSION && \
+ rm -rf /usr/local/lib/python${PYTHON_VERSION%.*}/test && \
+ python3 -m ensurepip && \
+ python3 -m pip install --upgrade pip && \
+ apt-get remove -y $PYTHON_DEPS # https://github.com/google/oss-fuzz/issues/3888
+
+
+ENV CCACHE_VERSION 4.10.2
+RUN cd /tmp && curl -OL https://github.com/ccache/ccache/releases/download/v$CCACHE_VERSION/ccache-$CCACHE_VERSION.tar.xz && \
+ tar -xvf ccache-$CCACHE_VERSION.tar.xz && cd ccache-$CCACHE_VERSION && \
+ mkdir build && cd build && \
+ export LDFLAGS='-lpthread' && \
+ cmake -D CMAKE_BUILD_TYPE=Release .. && \
+ make -j && make install && \
+ rm -rf /tmp/ccache-$CCACHE_VERSION /tmp/ccache-$CCACHE_VERSION.tar.xz
+
+# Install six for Bazel rules.
+RUN unset CFLAGS CXXFLAGS && pip3 install -v --no-cache-dir \
+ six==1.15.0 && rm -rf /tmp/*
+
+# Install Bazel through Bazelisk, which automatically fetches the latest Bazel version.
+ENV BAZELISK_VERSION 1.9.0
+RUN curl -L https://github.com/bazelbuild/bazelisk/releases/download/v$BAZELISK_VERSION/bazelisk-linux-amd64 -o /usr/local/bin/bazel && \
+ chmod +x /usr/local/bin/bazel
+
+# Default build flags for various sanitizers.
+ENV SANITIZER_FLAGS_address "-fsanitize=address -fsanitize-address-use-after-scope"
+ENV SANITIZER_FLAGS_hwaddress "-fsanitize=hwaddress -fuse-ld=lld -Wno-unused-command-line-argument"
+
+# Set of '-fsanitize' flags matches '-fno-sanitize-recover' + 'unsigned-integer-overflow'.
+ENV SANITIZER_FLAGS_undefined "-fsanitize=array-bounds,bool,builtin,enum,function,integer-divide-by-zero,null,object-size,return,returns-nonnull-attribute,shift,signed-integer-overflow,unsigned-integer-overflow,unreachable,vla-bound,vptr -fno-sanitize-recover=array-bounds,bool,builtin,enum,function,integer-divide-by-zero,null,object-size,return,returns-nonnull-attribute,shift,signed-integer-overflow,unreachable,vla-bound,vptr"
+
+# Don't include "function" since it is unsupported on aarch64.
+ENV SANITIZER_FLAGS_undefined_aarch64 "-fsanitize=array-bounds,bool,builtin,enum,integer-divide-by-zero,null,object-size,return,returns-nonnull-attribute,shift,signed-integer-overflow,unsigned-integer-overflow,unreachable,vla-bound,vptr -fno-sanitize-recover=array-bounds,bool,builtin,enum,integer-divide-by-zero,null,object-size,return,returns-nonnull-attribute,shift,signed-integer-overflow,unreachable,vla-bound,vptr"
+
+ENV SANITIZER_FLAGS_memory "-fsanitize=memory -fsanitize-memory-track-origins"
+
+ENV SANITIZER_FLAGS_thread "-fsanitize=thread"
+
+ENV SANITIZER_FLAGS_introspector "-O0 -flto -fno-inline-functions -fuse-ld=gold -Wno-unused-command-line-argument"
+
+# Do not use any sanitizers in the coverage build.
+ENV SANITIZER_FLAGS_coverage ""
+
+# We use unsigned-integer-overflow as an additional coverage signal and have to
+# suppress error messages. See https://github.com/google/oss-fuzz/issues/910.
+ENV UBSAN_OPTIONS="silence_unsigned_overflow=1"
+
+# To suppress warnings from binaries running during compilation.
+ENV DFSAN_OPTIONS='warn_unimplemented=0'
+
+# Default build flags for coverage feedback.
+ENV COVERAGE_FLAGS="-fsanitize=fuzzer-no-link"
+
+# Use '-Wno-unused-command-line-argument' to suppress "warning: -ldl: 'linker' input unused"
+# messages which are treated as errors by some projects.
+ENV COVERAGE_FLAGS_coverage "-fprofile-instr-generate -fcoverage-mapping -pthread -Wl,--no-as-needed -Wl,-ldl -Wl,-lm -Wno-unused-command-line-argument"
+
+# Default sanitizer, fuzzing engine and architecture to use.
+ENV SANITIZER="address"
+ENV FUZZING_ENGINE="libfuzzer"
+ENV ARCHITECTURE="x86_64"
+
+# DEPRECATED - NEW CODE SHOULD NOT USE THIS. OLD CODE SHOULD STOP. Please use
+# LIB_FUZZING_ENGINE instead.
+# Path to fuzzing engine library to support some old users of
+# LIB_FUZZING_ENGINE.
+ENV LIB_FUZZING_ENGINE_DEPRECATED="/usr/lib/libFuzzingEngine.a"
+
+# Argument passed to compiler to link against fuzzing engine.
+# Defaults to the path, but is "-fsanitize=fuzzer" in libFuzzer builds.
+ENV LIB_FUZZING_ENGINE="/usr/lib/libFuzzingEngine.a"
+
+# TODO: remove after tpm2 catchup.
+ENV FUZZER_LDFLAGS ""
+
+WORKDIR $SRC
+
+RUN git clone https://github.com/AFLplusplus/AFLplusplus.git aflplusplus && \
+ cd aflplusplus && \
+ git checkout daaefcddc063b356018c29027494a00bcfc3e240 && \
+ wget --no-check-certificate -O oss.sh https://raw.githubusercontent.com/vanhauser-thc/binary_blobs/master/oss.sh && \
+ rm -rf .git && \
+ chmod 755 oss.sh
+
+# Do precompiles before copying other scripts for better cache efficiency.
+COPY precompile_afl /usr/local/bin/
+RUN precompile_afl
+
+RUN cd $SRC && \
+ curl -L -O https://github.com/google/honggfuzz/archive/oss-fuzz.tar.gz && \
+ mkdir honggfuzz && \
+ cd honggfuzz && \
+ tar -xz --strip-components=1 -f $SRC/oss-fuzz.tar.gz && \
+ rm -rf examples $SRC/oss-fuzz.tar.gz
+
+
+COPY precompile_honggfuzz /usr/local/bin/
+RUN precompile_honggfuzz
+
+RUN cd $SRC && \
+ git clone https://github.com/google/fuzztest && \
+ cd fuzztest && \
+ git checkout a37d133f714395cabc20dd930969a889495c9f53 && \
+ rm -rf .git
+
+ENV CENTIPEDE_BIN_DIR=$SRC/fuzztest/bazel-bin
+COPY precompile_centipede /usr/local/bin/
+RUN precompile_centipede
+
+COPY sanitizers /usr/local/lib/sanitizers
+
+COPY bazel_build_fuzz_tests \
+ cargo \
+ compile \
+ compile_afl \
+ compile_centipede \
+ compile_honggfuzz \
+ compile_fuzztests.sh \
+ compile_go_fuzzer \
+ compile_javascript_fuzzer \
+ compile_libfuzzer \
+ compile_native_go_fuzzer \
+ compile_python_fuzzer \
+ debug_afl \
+ # Go, JavaScript, Java, Python, Rust, and Swift installation scripts.
+ install_go.sh \
+ install_javascript.sh \
+ install_java.sh \
+ install_python.sh \
+ install_ruby.sh \
+ install_rust.sh \
+ install_swift.sh \
+ python_coverage_helper.py \
+ bash_parser.py \
+ srcmap \
+ write_labels.py \
+ /usr/local/bin/
+
+# TODO: Build this as part of a multi-stage build.
+ADD https://commondatastorage.googleapis.com/clusterfuzz-builds/jcc/clang-jcc /usr/local/bin/
+ADD https://commondatastorage.googleapis.com/clusterfuzz-builds/jcc/clang++-jcc /usr/local/bin
+ADD https://commondatastorage.googleapis.com/clusterfuzz-builds/jcc/clang-jcc2 /usr/local/bin/
+ADD https://commondatastorage.googleapis.com/clusterfuzz-builds/jcc/clang++-jcc2 /usr/local/bin
+RUN chmod +x /usr/local/bin/clang-jcc /usr/local/bin/clang++-jcc /usr/local/bin/clang-jcc2 /usr/local/bin/clang++-jcc2
+
+COPY llvmsymbol.diff $SRC
+COPY detect_repo.py /opt/cifuzz/
+COPY bazel.bazelrc /root/.bazelrc
+
+# Set up ccache binary and cache directory.
+# /ccache/bin will contain the compiler wrappers, and /ccache/cache will
+# contain the actual cache, which can be saved.
+# To use this, set PATH=/ccache/bin:$PATH.
+RUN mkdir -p /ccache/bin && mkdir -p /ccache/cache && \
+ ln -s /usr/local/bin/ccache /ccache/bin/clang && \
+ ln -s /usr/local/bin/ccache /ccache/bin/clang++ && \
+ ln -s /usr/local/bin/ccache /ccache/bin/clang-jcc && \
+ ln -s /usr/local/bin/ccache /ccache/bin/clang++-jcc
+ENV CCACHE_DIR /ccache/cache
+
+# Don't check that the compiler is the same, so we can switch between jcc and
+# clang under the hood and re-use the same build cache.
+ENV CCACHE_COMPILERCHECK none
+ENV CCACHE_COMPILERTYPE clang
+
+CMD ["compile"]
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/README.md b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4e94bb0888c92f094cfefea3b9bf70d41bb8db22
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/README.md
@@ -0,0 +1,83 @@
+# base-builder
+> Abstract base image for project builders.
+
+Every project image supports multiple commands that can be invoked through docker after the image is built:
+
+
+docker run --rm -ti gcr.io/oss-fuzz/$project <command> <arguments...>
+
+
+# Supported Commands
+
+| Command | Description |
+|---------|-------------|
+| `compile` (default) | build all fuzz targets
+| `/bin/bash` | drop into shell, execute `compile` script to start build.
+
+# Build Configuration
+
+A single build image can build same set of fuzzers in many configurations.
+The configuration is picked through one or more environment variables.
+
+| Env Variable | Description
+| ------------- | --------
+| `$SANITIZER ("address")` | Specifies predefined sanitizer configuration to use. `address` or `memory` or `undefined`.
+| `$SANITIZER_FLAGS` | Specify compiler sanitizer flags directly. Overrides `$SANITIZER`.
+| `$COVERAGE_FLAGS` | Specify compiler flags to use for fuzzer feedback coverage.
+| `$BUILD_UID` | User id to use while building fuzzers.
+
+## Examples
+
+- *building sqlite3 fuzzer with UBSan (`SANITIZER=undefined`):*
+
+
+
+docker run --rm -ti -e SANITIZER=undefined gcr.io/oss-fuzz/sqlite3
+
+
+
+# Image Files Layout
+
+| Location|Env| Description |
+|---------| -------- | ---------- |
+| `/out/` | `$OUT` | Directory to store build artifacts (fuzz targets, dictionaries, options files, seed corpus archives). |
+| `/src/` | `$SRC` | Directory to checkout source files |
+| `/work/`| `$WORK` | Directory for storing intermediate files |
+| `/usr/lib/libFuzzingEngine.a` | `$LIB_FUZZING_ENGINE` | Location of prebuilt fuzzing engine library (e.g. libFuzzer) that needs to be linked with all fuzz targets.
+
+While files layout is fixed within a container, the environment variables are
+provided to be able to write retargetable scripts.
+
+
+## Compiler Flags
+
+You *must* use special compiler flags to build your project and fuzz targets.
+These flags are provided in following environment variables:
+
+| Env Variable | Description
+| ------------- | --------
+| `$CC` | The C compiler binary.
+| `$CXX`, `$CCC` | The C++ compiler binary.
+| `$CFLAGS` | C compiler flags.
+| `$CXXFLAGS` | C++ compiler flags.
+
+Most well-crafted build scripts will automatically use these variables. If not,
+pass them manually to the build tool.
+
+
+# Child Image Interface
+
+## Sources
+
+Child image has to checkout all sources that it needs to compile fuzz targets into
+`$SRC` directory. When the image is executed, a directory could be mounted on top
+of these with local checkouts using
+`docker run -v $HOME/my_project:/src/my_project ...`.
+
+## Other Required Files
+
+Following files have to be added by child images:
+
+| File Location | Description |
+| ------------- | ----------- |
+| `$SRC/build.sh` | build script to build the project and its fuzz targets |
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/bazel.bazelrc b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/bazel.bazelrc
new file mode 100644
index 0000000000000000000000000000000000000000..a82293d7e8a10f4de481da391c6e64bb8bf32c3f
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/bazel.bazelrc
@@ -0,0 +1,20 @@
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+################################################################################
+
+
+# Pass variables from environment.
+build --action_env=FUZZ_INTROSPECTOR
+build --action_env=FUZZINTRO_OUTDIR
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/bazel_build_fuzz_tests b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/bazel_build_fuzz_tests
new file mode 100644
index 0000000000000000000000000000000000000000..5d52c424839503cd405d7edb83fee5691870fd6e
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/bazel_build_fuzz_tests
@@ -0,0 +1,90 @@
+#!/bin/bash -eu
+#
+# Copyright 2021 Google LLC
+#
+# 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.
+#
+################################################################################
+
+: "${BAZEL_FUZZ_TEST_TAG:=fuzz-test}"
+: "${BAZEL_FUZZ_TEST_EXCLUDE_TAG:=no-oss-fuzz}"
+: "${BAZEL_PACKAGE_SUFFIX:=_oss_fuzz}"
+: "${BAZEL_TOOL:=bazel}"
+: "${BAZEL_EXTRA_BUILD_FLAGS:=}"
+
+if [ "$FUZZING_LANGUAGE" = "jvm" ]; then
+ BAZEL_LANGUAGE=java
+else
+ BAZEL_LANGUAGE=cc
+fi
+
+if [[ -z "${BAZEL_FUZZ_TEST_QUERY:-}" ]]; then
+ BAZEL_FUZZ_TEST_QUERY="
+ let all_fuzz_tests = attr(tags, \"${BAZEL_FUZZ_TEST_TAG}\", \"//...\") in
+ let lang_fuzz_tests = attr(generator_function, \"^${BAZEL_LANGUAGE}_fuzz_test\$\", \$all_fuzz_tests) in
+ \$lang_fuzz_tests - attr(tags, \"${BAZEL_FUZZ_TEST_EXCLUDE_TAG}\", \$lang_fuzz_tests)
+ "
+fi
+
+echo "Using Bazel query to find fuzz targets: ${BAZEL_FUZZ_TEST_QUERY}"
+
+declare -r OSS_FUZZ_TESTS=(
+ $(bazel query "${BAZEL_FUZZ_TEST_QUERY}" | sed "s/$/${BAZEL_PACKAGE_SUFFIX}/")
+)
+
+echo "Found ${#OSS_FUZZ_TESTS[@]} fuzz test packages:"
+for oss_fuzz_test in "${OSS_FUZZ_TESTS[@]}"; do
+ echo " ${oss_fuzz_test}"
+done
+
+declare -r BAZEL_BUILD_FLAGS=(
+ "--@rules_fuzzing//fuzzing:cc_engine=@rules_fuzzing_oss_fuzz//:oss_fuzz_engine" \
+ "--@rules_fuzzing//fuzzing:java_engine=@rules_fuzzing_oss_fuzz//:oss_fuzz_java_engine" \
+ "--@rules_fuzzing//fuzzing:cc_engine_instrumentation=oss-fuzz" \
+ "--@rules_fuzzing//fuzzing:cc_engine_sanitizer=none" \
+ "--cxxopt=-stdlib=libc++" \
+ "--linkopt=-lc++" \
+ "--verbose_failures" \
+ "--spawn_strategy=standalone" \
+ "--action_env=CC=${CC}" "--action_env=CXX=${CXX}" \
+ ${BAZEL_EXTRA_BUILD_FLAGS[*]}
+)
+
+echo "Building the fuzz tests with the following Bazel options:"
+echo " ${BAZEL_BUILD_FLAGS[@]}"
+
+${BAZEL_TOOL} build "${BAZEL_BUILD_FLAGS[@]}" "${OSS_FUZZ_TESTS[@]}"
+
+echo "Extracting the fuzz test packages in the output directory."
+for oss_fuzz_archive in $(find bazel-bin/ -name "*${BAZEL_PACKAGE_SUFFIX}.tar"); do
+ tar --no-same-owner -xvf "${oss_fuzz_archive}" -C "${OUT}"
+done
+
+if [ "$SANITIZER" = "coverage" ]; then
+ echo "Collecting the repository source files for coverage tracking."
+ declare -r COVERAGE_SOURCES="${OUT}/proc/self/cwd"
+ mkdir -p "${COVERAGE_SOURCES}"
+ declare -r RSYNC_FILTER_ARGS=(
+ "--include" "*.h"
+ "--include" "*.cc"
+ "--include" "*.hpp"
+ "--include" "*.cpp"
+ "--include" "*.c"
+ "--include" "*.inc"
+ "--include" "*/"
+ "--exclude" "*"
+ )
+ rsync -avLk "${RSYNC_FILTER_ARGS[@]}" \
+ "$(bazel info execution_root)/" \
+ "${COVERAGE_SOURCES}/"
+fi
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/bisect_clang.py b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/bisect_clang.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e2c0e49abb189d9dc1837ea193d0704dd486b51
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/bisect_clang.py
@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+# Copyright 2019 Google Inc.
+#
+# 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.
+#
+################################################################################
+"""Use git bisect to find the Clang/LLVM commit causing a regression."""
+
+import logging
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+
+def execute(command, *args, expect_zero=True, **kwargs):
+ """Execute |command| and return the returncode, stdout and stderr."""
+ kwargs['stdout'] = subprocess.PIPE
+ kwargs['stderr'] = subprocess.PIPE
+ logging.debug('Running command: "%s"', str(command))
+ process = subprocess.Popen(command, *args, **kwargs)
+ stdout, stderr = process.communicate()
+ stdout = stdout.decode('utf-8')
+ stderr = stderr.decode('utf-8')
+ retcode = process.returncode
+ logging.info('Command: "%s" returned: %d.\nStdout: %s.\nStderr: %s',
+ str(command), retcode, stdout, stderr)
+ if expect_zero and retcode != 0:
+ raise subprocess.CalledProcessError(retcode, command)
+ return retcode, stdout, stderr
+
+
+def search_bisect_output(output):
+ """Search |output| for a message indicating the culprit commit has been
+ found."""
+ # TODO(metzman): Is it necessary to look for "good"?
+ culprit_regex = re.compile('([a-z0-9]{40}) is the first (good|bad) commit')
+ match = re.match(culprit_regex, output)
+ return match.group(1) if match is not None else None
+
+
+class GitRepo:
+ """Class for executing commmands on a git repo."""
+
+ def __init__(self, repo_dir):
+ self.repo_dir = repo_dir
+
+ def do_command(self, git_subcommand):
+ """Execute a |git_subcommand| (a list of strings)."""
+ command = ['git', '-C', self.repo_dir] + git_subcommand
+ return execute(command)
+
+ def test_commit(self, test_command):
+ """Build LLVM at the currently checkedout commit, then run |test_command|.
+ If returncode is 0 run 'git bisect good' otherwise return 'git bisect bad'.
+ Return None if bisect didn't finish yet. Return the culprit commit if it
+ does."""
+ build_clang(self.repo_dir)
+ retcode, _, _ = execute(test_command, shell=True, expect_zero=False)
+ if retcode == 0:
+ retcode, stdout, _ = self.do_bisect_command('good')
+ else:
+ retcode, stdout, _ = self.do_bisect_command('bad')
+ return search_bisect_output(stdout)
+
+ def bisect(self, good_commit, bad_commit, test_command):
+ """Do git bisect assuming |good_commit| is good, |bad_commit| is bad and
+ |test_command| is an oracle. Return the culprit commit."""
+ self.bisect_start(good_commit, bad_commit, test_command)
+ result = self.test_commit(test_command)
+ while result is None:
+ result = self.test_commit(test_command)
+ return result
+
+ def bisect_start(self, good_commit, bad_commit, test_command):
+ """Start doing git bisect."""
+ self.do_bisect_command('start')
+ # Do bad commit first since it is more likely to be recent.
+ self.test_start_commit(bad_commit, 'bad', test_command)
+ self.test_start_commit(good_commit, 'good', test_command)
+
+ def do_bisect_command(self, subcommand):
+ """Execute a git bisect |subcommand| (string) and return the result."""
+ return self.do_command(['bisect', subcommand])
+
+ def test_start_commit(self, commit, label, test_command):
+ """Use |test_command| to test the first good or bad |commit| (depending on
+ |label|)."""
+ assert label in ('good', 'bad'), label
+ self.do_command(['checkout', commit])
+ build_clang(self.repo_dir)
+ retcode, _, _ = execute(test_command, shell=True, expect_zero=False)
+ if label == 'good' and retcode != 0:
+ raise BisectError('Test command "%s" returns %d on first good commit %s' %
+ (test_command, retcode, commit))
+ if label == 'bad' and retcode == 0:
+ raise BisectError('Test command "%s" returns %d on first bad commit %s' %
+ (test_command, retcode, commit))
+
+ self.do_bisect_command(label)
+
+
+class BisectError(Exception):
+ """Error that was encountered during bisection."""
+
+
+def get_clang_build_env():
+ """Get an environment for building Clang."""
+ env = os.environ.copy()
+ for variable in ['CXXFLAGS', 'CFLAGS']:
+ if variable in env:
+ del env[variable]
+ return env
+
+
+def install_clang_build_deps():
+ """Instal dependencies necessary to build clang."""
+ execute([
+ 'apt-get', 'install', '-y', 'build-essential', 'make', 'cmake',
+ 'ninja-build', 'git', 'subversion', 'g++-multilib'
+ ])
+
+
+def clone_with_retries(repo, local_path, num_retries=10):
+ """Clone |repo| to |local_path| if it doesn't exist already. Try up to
+ |num_retries| times. Return False if unable to checkout."""
+ if os.path.isdir(local_path):
+ return
+ for _ in range(num_retries):
+ if os.path.isdir(local_path):
+ shutil.rmtree(local_path)
+ retcode, _, _ = execute(['git', 'clone', repo, local_path],
+ expect_zero=False)
+ if retcode == 0:
+ return
+ raise Exception('Could not checkout %s.' % repo)
+
+
+def get_clang_target_arch():
+ """Get target architecture we want clang to target when we build it."""
+ _, arch, _ = execute(['uname', '-m'])
+ if 'x86_64' in arch:
+ return 'X86'
+ if 'aarch64' in arch:
+ return 'AArch64'
+ raise Exception('Unsupported target: %s.' % arch)
+
+
+def prepare_build(llvm_project_path):
+ """Prepare to build clang."""
+ llvm_build_dir = os.path.join(os.getenv('WORK'), 'llvm-build')
+ if not os.path.exists(llvm_build_dir):
+ os.mkdir(llvm_build_dir)
+ execute([
+ 'cmake', '-G', 'Ninja', '-DLIBCXX_ENABLE_SHARED=OFF',
+ '-DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON', '-DLIBCXXABI_ENABLE_SHARED=OFF',
+ '-DCMAKE_BUILD_TYPE=Release',
+ '-DLLVM_ENABLE_PROJECTS=libcxx;libcxxabi;compiler-rt;clang',
+ '-DLLVM_TARGETS_TO_BUILD=' + get_clang_target_arch(),
+ os.path.join(llvm_project_path, 'llvm')
+ ],
+ env=get_clang_build_env(),
+ cwd=llvm_build_dir)
+ return llvm_build_dir
+
+
+def build_clang(llvm_project_path):
+ """Checkout, build and install Clang."""
+ # TODO(metzman): Merge Python checkout and build code with
+ # checkout_build_install_llvm.sh.
+ # TODO(metzman): Look into speeding this process using ccache.
+ # TODO(metzman): Make this program capable of handling MSAN and i386 Clang
+ # regressions.
+ llvm_build_dir = prepare_build(llvm_project_path)
+ execute(['ninja', '-C', llvm_build_dir, 'install'], env=get_clang_build_env())
+
+
+def find_culprit_commit(test_command, good_commit, bad_commit):
+ """Returns the culprit LLVM commit that introduced a bug revealed by running
+ |test_command|. Uses git bisect and treats |good_commit| as the first latest
+ known good commit and |bad_commit| as the first known bad commit."""
+ llvm_project_path = os.path.join(os.getenv('SRC'), 'llvm-project')
+ clone_with_retries('https://github.com/llvm/llvm-project.git',
+ llvm_project_path)
+ git_repo = GitRepo(llvm_project_path)
+ result = git_repo.bisect(good_commit, bad_commit, test_command)
+ print('Culprit commit', result)
+ return result
+
+
+def main():
+ # pylint: disable=line-too-long
+ """Finds the culprit LLVM commit that introduced a clang regression.
+ Can be tested using this command in a libsodium shell:
+ python3 bisect_clang.py "cd /src/libsodium; make clean; cd -; compile && /out/secret_key_auth_fuzzer -runs=100" \
+ f7e52fbdb5a7af8ea0808e98458b497125a5eca1 \
+ 8288453f6aac05080b751b680455349e09d49825
+ """
+ # pylint: enable=line-too-long
+ # TODO(metzman): Check CFLAGS for things like -fsanitize=fuzzer-no-link.
+ # TODO(metzman): Allow test_command to be optional and for just build.sh to be
+ # used instead.
+ test_command = sys.argv[1]
+ # TODO(metzman): Add in more automation so that the script can automatically
+ # determine the commits used in last Clang roll.
+ good_commit = sys.argv[2]
+ bad_commit = sys.argv[3]
+ # TODO(metzman): Make verbosity configurable.
+ logging.getLogger().setLevel(logging.DEBUG)
+ install_clang_build_deps()
+ find_culprit_commit(test_command, good_commit, bad_commit)
+ return 0
+
+
+if __name__ == '__main__':
+ sys.exit(main())
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/cargo b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/cargo
new file mode 100644
index 0000000000000000000000000000000000000000..4376cfa5d4a339e1ec59193c1af58061e772fa96
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/cargo
@@ -0,0 +1,55 @@
+#!/bin/bash -eu
+# Copyright 2020 Google Inc.
+#
+# 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.
+#
+# This is a wrapper around calling cargo
+# This just expands RUSTFLAGS in case of a coverage build
+# We need this until https://github.com/rust-lang/cargo/issues/5450 is merged
+# because cargo uses relative paths for the current crate
+# and absolute paths for its dependencies
+#
+################################################################################
+
+if [ "$SANITIZER" = "coverage" ] && [ $1 = "build" ]
+then
+ crate_src_abspath=`cargo metadata --no-deps --format-version 1 | jq -r '.workspace_root'`
+ export RUSTFLAGS="$RUSTFLAGS --remap-path-prefix src=$crate_src_abspath/src"
+fi
+
+if [ "$SANITIZER" = "coverage" ] && [ $1 = "fuzz" ] && [ $2 = "build" ]
+then
+ # hack to turn cargo fuzz build into cargo build so as to get coverage
+ # cargo fuzz adds "--target" "x86_64-unknown-linux-gnu"
+ (
+ # go into fuzz directory if not already the case
+ cd fuzz || true
+ fuzz_src_abspath=`pwd`
+ # Default directory is fuzz_targets, but some projects like image-rs use fuzzers.
+ while read i; do
+ export RUSTFLAGS="$RUSTFLAGS --remap-path-prefix $i=$fuzz_src_abspath/$i"
+ # Bash while syntax so that we modify RUSTFLAGS in main shell instead of a subshell.
+ done <<< "$(find . -name "*.rs" | cut -d/ -f2 | uniq)"
+ # we do not want to trigger debug assertions and stops
+ export RUSTFLAGS="$RUSTFLAGS -C debug-assertions=no"
+ # do not optimize with --release, leading to Malformed instrumentation profile data
+ cargo build --bins
+ # copies the build output in the expected target directory
+ cd `cargo metadata --format-version 1 --no-deps | jq -r '.target_directory'`
+ mkdir -p x86_64-unknown-linux-gnu/release
+ cp -r debug/* x86_64-unknown-linux-gnu/release/
+ )
+ exit 0
+fi
+
+/rust/bin/cargo "$@"
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile
new file mode 100644
index 0000000000000000000000000000000000000000..8aa6580bc3d393ca5b75499c5fc0064bed1ee80f
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile
@@ -0,0 +1,420 @@
+#!/bin/bash -eu
+# Copyright 2016 Google Inc.
+#
+# 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.
+#
+################################################################################
+
+echo "---------------------------------------------------------------"
+
+sysctl -w vm.mmap_rnd_bits=28
+
+OSS_FUZZ_ON_DEMAND="${OSS_FUZZ_ON_DEMAND:-0}"
+
+# Used for Rust introspector builds
+RUST_SANITIZER=$SANITIZER
+
+if [ "$FUZZING_LANGUAGE" = "jvm" ]; then
+ if [ "$FUZZING_ENGINE" != "libfuzzer" ] && [ "$FUZZING_ENGINE" != "wycheproof" ]; then
+ echo "ERROR: JVM projects can be fuzzed with libFuzzer or tested with wycheproof engines only."
+ exit 1
+ fi
+ if [ "$SANITIZER" != "address" ] && [ "$SANITIZER" != "coverage" ] && [ "$SANITIZER" != "undefined" ] && [ "$SANITIZER" != "none" ] && [ "$SANITIZER" != "introspector" ]; then
+ echo "ERROR: JVM projects can be fuzzed with AddressSanitizer or UndefinedBehaviorSanitizer or Introspector only."
+ exit 1
+ fi
+ if [ "$ARCHITECTURE" != "x86_64" ]; then
+ echo "ERROR: JVM projects can be fuzzed on x86_64 architecture only."
+ exit 1
+ fi
+fi
+
+if [ "$FUZZING_LANGUAGE" = "rust" ]; then
+ if [ "$SANITIZER" = "introspector" ]; then
+ # introspector sanitizer flag will cause cargo build to fail. Rremove it
+ # temporarily, RUST_SANITIZER will hold the original sanitizer.
+ export SANITIZER=address
+ fi
+fi
+
+
+if [ "$FUZZING_LANGUAGE" = "javascript" ]; then
+ if [ "$FUZZING_ENGINE" != "libfuzzer" ]; then
+ echo "ERROR: JavaScript projects can be fuzzed with libFuzzer engine only."
+ exit 1
+ fi
+ if [ "$SANITIZER" != "coverage" ] && [ "$SANITIZER" != "none" ]; then
+ echo "ERROR: JavaScript projects cannot be fuzzed with sanitizers."
+ exit 1
+ fi
+ if [ "$ARCHITECTURE" != "x86_64" ]; then
+ echo "ERROR: JavaScript projects can be fuzzed on x86_64 architecture only."
+ exit 1
+ fi
+fi
+
+if [ "$FUZZING_LANGUAGE" = "python" ]; then
+ if [ "$FUZZING_ENGINE" != "libfuzzer" ]; then
+ echo "ERROR: Python projects can be fuzzed with libFuzzer engine only."
+ exit 1
+ fi
+ if [ "$SANITIZER" != "address" ] && [ "$SANITIZER" != "undefined" ] && [ "$SANITIZER" != "coverage" ] && [ "$SANITIZER" != "introspector" ]; then
+ echo "ERROR: Python projects can be fuzzed with AddressSanitizer or UndefinedBehaviorSanitizer or Coverage or Fuzz Introspector only."
+ exit 1
+ fi
+ if [ "$ARCHITECTURE" != "x86_64" ]; then
+ echo "ERROR: Python projects can be fuzzed on x86_64 architecture only."
+ exit 1
+ fi
+fi
+
+if [ -z "${SANITIZER_FLAGS-}" ]; then
+ FLAGS_VAR="SANITIZER_FLAGS_${SANITIZER}"
+ export SANITIZER_FLAGS=${!FLAGS_VAR-}
+fi
+
+if [[ $ARCHITECTURE == "i386" ]]; then
+ export CFLAGS="-m32 $CFLAGS"
+ cp -R /usr/i386/lib/* /usr/local/lib
+ cp -R /usr/i386/include/* /usr/local/include
+fi
+
+# Don't use a fuzzing engine with Jazzer which has libFuzzer built-in or with
+# FuzzBench which will provide the fuzzing engine.
+if [[ $FUZZING_ENGINE != "none" ]] && [[ $FUZZING_LANGUAGE != "jvm" ]] && [[ "${OSS_FUZZ_ON_DEMAND}" == "0" ]] ; then
+ # compile script might override environment, use . to call it.
+ . compile_${FUZZING_ENGINE}
+fi
+
+if [[ $SANITIZER_FLAGS = *sanitize=memory* ]]
+then
+ # Take all libraries from lib/msan
+ # export CXXFLAGS_EXTRA="-L/usr/msan/lib $CXXFLAGS_EXTRA"
+ cp -R /usr/msan/lib/* /usr/local/lib/x86_64-unknown-linux-gnu/
+ cp -R /usr/msan/include/* /usr/local/include
+
+ echo 'Building without MSan instrumented libraries.'
+fi
+
+# Coverage flag overrides.
+COVERAGE_FLAGS_VAR="COVERAGE_FLAGS_${SANITIZER}"
+if [[ -n ${!COVERAGE_FLAGS_VAR+x} ]]
+then
+ export COVERAGE_FLAGS="${!COVERAGE_FLAGS_VAR}"
+fi
+
+# Only need the default coverage instrumentation for libFuzzer or honggfuzz.
+# Other engines bring their own.
+if [ $FUZZING_ENGINE = "none" ] || [ $FUZZING_ENGINE = "afl" ] || [ $FUZZING_ENGINE = "centipede" ] || [ "${OSS_FUZZ_ON_DEMAND}" != "0" ]; then
+ export COVERAGE_FLAGS=
+fi
+
+# Rust does not support sanitizers and coverage flags via CFLAGS/CXXFLAGS, so
+# use RUSTFLAGS.
+# FIXME: Support code coverage once support is in.
+# See https://github.com/rust-lang/rust/issues/34701.
+if [ "$RUST_SANITIZER" == "introspector" ]; then
+ export RUSTFLAGS="-Cdebuginfo=2 -Cforce-frame-pointers"
+elif [ "$SANITIZER" != "undefined" ] && [ "$SANITIZER" != "coverage" ] && [ "$SANITIZER" != "none" ] && [ "$ARCHITECTURE" != 'i386' ]; then
+ export RUSTFLAGS="--cfg fuzzing -Zsanitizer=${SANITIZER} -Cdebuginfo=1 -Cforce-frame-pointers"
+else
+ export RUSTFLAGS="--cfg fuzzing -Cdebuginfo=1 -Cforce-frame-pointers"
+fi
+if [ "$SANITIZER" = "coverage" ]
+then
+ # link to C++ from comment in f5098035eb1a14aa966c8651d88ea3d64323823d
+ export RUSTFLAGS="$RUSTFLAGS -Cinstrument-coverage -C link-arg=-lc++"
+fi
+
+# Add Rust libfuzzer flags.
+# See https://github.com/rust-fuzz/libfuzzer/blob/master/build.rs#L12.
+export CUSTOM_LIBFUZZER_PATH="$LIB_FUZZING_ENGINE_DEPRECATED"
+export CUSTOM_LIBFUZZER_STD_CXX=c++
+
+export CFLAGS="$CFLAGS $SANITIZER_FLAGS $COVERAGE_FLAGS"
+export CXXFLAGS="$CFLAGS $CXXFLAGS_EXTRA"
+
+if [ "$SANITIZER" = "undefined" ]; then
+ # Disable "function" sanitizer for C code for now, because many projects,
+ # possibly via legacy C code are affected.
+ # The projects should be fixed and this workaround be removed in the future.
+ # TODO(#11778):
+ # https://github.com/google/oss-fuzz/issues/11778
+ export CFLAGS="$CFLAGS -fno-sanitize=function"
+fi
+
+if [ "$FUZZING_LANGUAGE" = "go" ]; then
+ # required by Go 1.20
+ export CXX="${CXX} -lresolv"
+fi
+
+if [ "$FUZZING_LANGUAGE" = "python" ]; then
+ sanitizer_with_fuzzer_lib_dir=`python3 -c "import atheris; import os; print(atheris.path())"`
+ sanitizer_with_fuzzer_output_lib=$OUT/sanitizer_with_fuzzer.so
+ if [ "$SANITIZER" = "address" ]; then
+ cp $sanitizer_with_fuzzer_lib_dir/asan_with_fuzzer.so $sanitizer_with_fuzzer_output_lib
+ elif [ "$SANITIZER" = "undefined" ]; then
+ cp $sanitizer_with_fuzzer_lib_dir/ubsan_with_fuzzer.so $sanitizer_with_fuzzer_output_lib
+ fi
+
+ # Disable leak checking as it is unsupported.
+ export CFLAGS="$CFLAGS -fno-sanitize=function,leak,vptr,"
+ export CXXFLAGS="$CXXFLAGS -fno-sanitize=function,leak,vptr"
+fi
+
+# Copy latest llvm-symbolizer in $OUT for stack symbolization.
+cp $(which llvm-symbolizer) $OUT/
+
+# Copy Jazzer to $OUT if needed.
+if [ "$FUZZING_LANGUAGE" = "jvm" ]; then
+ cp $(which jazzer_agent_deploy.jar) $(which jazzer_driver) $(which jazzer_junit.jar) $OUT/
+ jazzer_driver_with_sanitizer=$OUT/jazzer_driver_with_sanitizer
+ if [ "$SANITIZER" = "address" ]; then
+ cat > $jazzer_driver_with_sanitizer << 'EOF'
+#!/bin/bash
+this_dir=$(dirname "$0")
+"$this_dir/jazzer_driver" --asan "$@"
+EOF
+ elif [ "$SANITIZER" = "undefined" ]; then
+ cat > $jazzer_driver_with_sanitizer << 'EOF'
+#!/bin/bash
+this_dir=$(dirname "$0")
+"$this_dir/jazzer_driver" --ubsan "$@"
+EOF
+ elif [ "$SANITIZER" = "coverage" ] || [ "$SANITIZER" = "introspector" ]; then
+ # Coverage & introspector builds require no instrumentation.
+ cp $(which jazzer_driver) $jazzer_driver_with_sanitizer
+ fi
+ chmod +x $jazzer_driver_with_sanitizer
+
+ # Disable leak checking since the JVM triggers too many false positives.
+ export CFLAGS="$CFLAGS -fno-sanitize=leak"
+ export CXXFLAGS="$CXXFLAGS -fno-sanitize=leak"
+fi
+
+if [ "$SANITIZER" = "introspector" ] || [ "$RUST_SANITIZER" = "introspector" ]; then
+ export AR=llvm-ar
+ export NM=llvm-nm
+ export RANLIB=llvm-ranlib
+
+ export CFLAGS="$CFLAGS -g"
+ export CXXFLAGS="$CXXFLAGS -g"
+ export FI_BRANCH_PROFILE=1
+ export FUZZ_INTROSPECTOR=1
+ export FUZZ_INTROSPECTOR_AUTO_FUZZ=1
+
+ # Move ar and ranlib
+ mv /usr/bin/ar /usr/bin/old-ar
+ mv /usr/bin/nm /usr/bin/old-nm
+ mv /usr/bin/ranlib /usr/bin/old-ranlib
+
+ ln -sf /usr/local/bin/llvm-ar /usr/bin/ar
+ ln -sf /usr/local/bin/llvm-nm /usr/bin/nm
+ ln -sf /usr/local/bin/llvm-ranlib /usr/bin/ranlib
+
+ apt-get install -y libjpeg-dev zlib1g-dev libyaml-dev
+ python3 -m pip install --upgrade pip setuptools
+ python3 -m pip install cxxfilt pyyaml beautifulsoup4 lxml soupsieve rust-demangler
+ python3 -m pip install --prefer-binary matplotlib
+
+ # Install Fuzz-Introspector
+ pushd /fuzz-introspector/src
+ python3 -m pip install -e .
+ popd
+
+ if [ "$FUZZING_LANGUAGE" = "python" ]; then
+ python3 /fuzz-introspector/src/main.py light --language=python
+ cp -rf $SRC/inspector/ /tmp/inspector-saved
+ elif [ "$FUZZING_LANGUAGE" = "jvm" ]; then
+ python3 /fuzz-introspector/src/main.py light --language=jvm
+ cp -rf $SRC/inspector/ /tmp/inspector-saved
+ elif [ "$FUZZING_LANGUAGE" = "rust" ]; then
+ python3 /fuzz-introspector/src/main.py light --language=rust
+ cp -rf $SRC/inspector/ /tmp/inspector-saved
+ else
+ python3 /fuzz-introspector/src/main.py light
+
+ # Make a copy of the light. This is needed because we run two versions of
+ # introspector: one based on pure statis analysis and one based on
+ # regular LTO.
+ cp -rf $SRC/inspector/ /tmp/inspector-saved
+
+
+ # Move coverage report.
+ if [ -d "$OUT/textcov_reports" ]
+ then
+ find $OUT/textcov_reports/ -name "*.covreport" -exec cp {} $SRC/inspector/ \;
+ find $OUT/textcov_reports/ -name "*.json" -exec cp {} $SRC/inspector/ \;
+ fi
+
+ # Make fuzz-introspector HTML report using light approach.
+ REPORT_ARGS="--name=$PROJECT_NAME"
+
+ # Only pass coverage_url when COVERAGE_URL is set (in cloud builds)
+ if [[ ! -z "${COVERAGE_URL+x}" ]]; then
+ REPORT_ARGS="$REPORT_ARGS --coverage-url=${COVERAGE_URL}"
+ fi
+
+ # Run pure static analysis fuzz introspector
+ fuzz-introspector full --target-dir=$SRC \
+ --language=${FUZZING_LANGUAGE} \
+ --out-dir=$SRC/inspector \
+ ${REPORT_ARGS}
+ fi
+
+ rsync -avu --delete "$SRC/inspector/" "$OUT/inspector"
+fi
+
+echo "---------------------------------------------------------------"
+echo "CC=$CC"
+echo "CXX=$CXX"
+echo "CFLAGS=$CFLAGS"
+echo "CXXFLAGS=$CXXFLAGS"
+echo "RUSTFLAGS=$RUSTFLAGS"
+echo "---------------------------------------------------------------"
+
+if [ "${OSS_FUZZ_ON_DEMAND}" != "0" ]; then
+ fuzzbench_build
+ cp $(which llvm-symbolizer) $OUT/
+ exit 0
+fi
+
+
+if [[ ! -z "${CAPTURE_REPLAY_SCRIPT-}" ]]; then
+ # Capture a replaying build script which can be used for replaying the build
+ # after a vanilla build. This script is meant to be used in a cached
+ # container.
+ python3 -m pip install bashlex
+ python3 /usr/local/bin/bash_parser.py $SRC/build.sh
+fi
+
+# Prepare the build command to run the project's build script.
+if [[ ! -z "${REPLAY_ENABLED-}" ]]; then
+ # If this is a replay, then use replay_build.sh. This is expected to be
+ # running in a cached container where a build has already happened prior.
+ BUILD_CMD="bash -eux $SRC/replay_build.sh"
+else
+ BUILD_CMD="bash -eux $SRC/build.sh"
+fi
+
+# Set +u temporarily to continue even if GOPATH and OSSFUZZ_RUSTPATH are undefined.
+set +u
+# We need to preserve source code files for generating a code coverage report.
+# We need exact files that were compiled, so copy both $SRC and $WORK dirs.
+COPY_SOURCES_CMD="cp -rL --parents $SRC $WORK /usr/include /usr/local/include $GOPATH $OSSFUZZ_RUSTPATH /rustc $OUT"
+set -u
+
+if [ "$FUZZING_LANGUAGE" = "rust" ]; then
+ # Copy rust std lib to its path with a hash.
+ export rustch=`rustc --version --verbose | grep commit-hash | cut -d' ' -f2`
+ mkdir -p /rustc/$rustch/
+ export rustdef=`rustup toolchain list | grep default | cut -d' ' -f1`
+ cp -r /rust/rustup/toolchains/$rustdef/lib/rustlib/src/rust/library/ /rustc/$rustch/
+fi
+
+if [ "${BUILD_UID-0}" -ne "0" ]; then
+ adduser -u $BUILD_UID --disabled-password --gecos '' builder
+ chown -R builder $SRC $OUT $WORK
+ su -c "$BUILD_CMD" builder
+ if [ "$SANITIZER" = "coverage" ]; then
+ # Some directories have broken symlinks (e.g. honggfuzz), ignore the errors.
+ su -c "$COPY_SOURCES_CMD" builder 2>/dev/null || true
+ fi
+else
+ $BUILD_CMD
+ if [ "$SANITIZER" = "coverage" ]; then
+ # Some directories have broken symlinks (e.g. honggfuzz), ignore the errors.
+ $COPY_SOURCES_CMD 2>/dev/null || true
+ fi
+fi
+
+if [ "$SANITIZER" = "introspector" ] || [ "$RUST_SANITIZER" = "introspector" ]; then
+ unset CXXFLAGS
+ unset CFLAGS
+ export G_ANALYTICS_TAG="G-8WTFM1Y62J"
+
+ # If we get to here, it means the e.g. LTO had no problems and succeeded.
+ # TO this end, we wlil restore the original light analysis and used the
+ # LTO processing itself.
+ rm -rf $SRC/inspector
+ cp -rf /tmp/inspector-saved $SRC/inspector
+
+ cd /fuzz-introspector/src
+ python3 -m pip install -e .
+ cd /src/
+
+ if [ "$FUZZING_LANGUAGE" = "rust" ]; then
+ # Restore the sanitizer flag for rust
+ export SANITIZER="introspector"
+ fi
+
+ mkdir -p $SRC/inspector
+ find $SRC/ -name "fuzzerLogFile-*.data" -exec cp {} $SRC/inspector/ \;
+ find $SRC/ -name "fuzzerLogFile-*.data.yaml" -exec cp {} $SRC/inspector/ \;
+ find $SRC/ -name "fuzzerLogFile-*.data.debug_*" -exec cp {} $SRC/inspector/ \;
+ find $SRC/ -name "allFunctionsWithMain-*.yaml" -exec cp {} $SRC/inspector/ \;
+
+ # Move coverage report.
+ if [ -d "$OUT/textcov_reports" ]
+ then
+ find $OUT/textcov_reports/ -name "*.covreport" -exec cp {} $SRC/inspector/ \;
+ find $OUT/textcov_reports/ -name "*.json" -exec cp {} $SRC/inspector/ \;
+ fi
+
+ cd $SRC/inspector
+
+ # Make fuzz-introspector HTML report.
+ REPORT_ARGS="--name=$PROJECT_NAME"
+ # Only pass coverage_url when COVERAGE_URL is set (in cloud builds)
+ if [[ ! -z "${COVERAGE_URL+x}" ]]; then
+ REPORT_ARGS="$REPORT_ARGS --coverage-url=${COVERAGE_URL}"
+ fi
+
+ # Do different things depending on languages
+ if [ "$FUZZING_LANGUAGE" = "python" ]; then
+ echo "GOING python route"
+ set -x
+ REPORT_ARGS="$REPORT_ARGS --target-dir=$SRC/inspector"
+ REPORT_ARGS="$REPORT_ARGS --language=python"
+ fuzz-introspector report $REPORT_ARGS
+ rsync -avu --delete "$SRC/inspector/" "$OUT/inspector"
+ elif [ "$FUZZING_LANGUAGE" = "jvm" ]; then
+ echo "GOING jvm route"
+ set -x
+ find $OUT/ -name "jacoco.xml" -exec cp {} $SRC/inspector/ \;
+ REPORT_ARGS="$REPORT_ARGS --target-dir=$SRC --out-dir=$SRC/inspector"
+ REPORT_ARGS="$REPORT_ARGS --language=jvm"
+ fuzz-introspector full $REPORT_ARGS
+ rsync -avu --delete "$SRC/inspector/" "$OUT/inspector"
+ elif [ "$FUZZING_LANGUAGE" = "rust" ]; then
+ echo "GOING rust route"
+ REPORT_ARGS="$REPORT_ARGS --target-dir=$SRC --out-dir=$SRC/inspector"
+ REPORT_ARGS="$REPORT_ARGS --language=rust"
+ fuzz-introspector full $REPORT_ARGS
+ rsync -avu --delete "$SRC/inspector/" "$OUT/inspector"
+ else
+ # C/C++
+ mkdir -p $SRC/inspector
+ # Correlate fuzzer binaries to fuzz-introspector's raw data
+ fuzz-introspector correlate --binaries-dir=$OUT/
+
+ # Generate fuzz-introspector HTML report, this generates
+ # the file exe_to_fuzz_introspector_logs.yaml
+ REPORT_ARGS="$REPORT_ARGS --target-dir=$SRC/inspector"
+ # Use the just-generated correlation file
+ REPORT_ARGS="$REPORT_ARGS --correlation-file=exe_to_fuzz_introspector_logs.yaml"
+ fuzz-introspector report $REPORT_ARGS
+
+ rsync -avu --delete "$SRC/inspector/" "$OUT/inspector"
+ fi
+fi
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_afl b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_afl
new file mode 100644
index 0000000000000000000000000000000000000000..484d4668c86648d042081a8a1e254dd6a5c36256
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_afl
@@ -0,0 +1,53 @@
+#!/bin/bash -eu
+# Copyright 2016 Google Inc.
+#
+# 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.
+#
+################################################################################
+
+# If LLVM once again does weird changes then enable this:
+#export AFL_LLVM_INSTRUMENT=LLVM-NATIVE
+
+# AFL++ setup
+echo "Copying precompiled AFL++"
+
+# Copy AFL++ tools necessary for fuzzing.
+pushd $SRC/aflplusplus > /dev/null
+
+cp -f libAFLDriver.a $LIB_FUZZING_ENGINE
+
+# Some important projects include libraries, copy those even when they don't
+# start with "afl-". Use "sort -u" to avoid a warning about duplicates.
+ls afl-* *.txt *.a *.o *.so | sort -u | xargs cp -t $OUT
+export CC="$SRC/aflplusplus/afl-clang-fast"
+export CXX="$SRC/aflplusplus/afl-clang-fast++"
+
+# Set sane AFL++ environment defaults:
+# Be quiet, otherwise this can break some builds.
+export AFL_QUIET=1
+# No leak errors during builds.
+export ASAN_OPTIONS="detect_leaks=0:symbolize=0:detect_odr_violation=0:abort_on_error=1"
+# Do not abort on any problems (because this is during build where it is ok)
+export AFL_IGNORE_PROBLEMS=1
+# No complain on unknown AFL environment variables
+export AFL_IGNORE_UNKNOWN_ENVS=1
+
+# Provide a way to document the AFL++ options used in this build:
+echo
+echo AFL++ target compilation setup:
+env | egrep '^AFL_' | tee "$OUT/afl_options.txt"
+echo
+
+popd > /dev/null
+
+echo " done."
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_centipede b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_centipede
new file mode 100644
index 0000000000000000000000000000000000000000..dee31e2e641f2d6e342ec13f6ff176ca53d6726d
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_centipede
@@ -0,0 +1,32 @@
+#!/bin/bash -eu
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+################################################################################
+
+echo "Skipping compilation; using precompiled centipede"
+
+if [[ "$SANITIZER" == 'none' ]]; then
+ cp "$CENTIPEDE_BIN_DIR/centipede" "$OUT"
+fi
+
+cp "$CENTIPEDE_BIN_DIR/libcentipede_runner.pic.a" "$LIB_FUZZING_ENGINE"
+
+export CENTIPEDE_FLAGS=`cat "$SRC/fuzztest/centipede/clang-flags.txt" | tr '\n' ' '`
+export LIBRARIES_FLAGS="-Wno-unused-command-line-argument -Wl,-ldl -Wl,-lrt -Wl,-lpthread -Wl,$SRC/fuzztest/centipede/weak.o"
+
+export CFLAGS="$CFLAGS $CENTIPEDE_FLAGS $LIBRARIES_FLAGS"
+export CXXFLAGS="$CXXFLAGS $CENTIPEDE_FLAGS $LIBRARIES_FLAGS"
+
+echo 'done.'
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_honggfuzz b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_honggfuzz
new file mode 100644
index 0000000000000000000000000000000000000000..cf206e46a4686462e1af5acc354efa13b8538976
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_honggfuzz
@@ -0,0 +1,33 @@
+#!/bin/bash -eu
+# Copyright 2016 Google Inc.
+#
+# 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.
+#
+################################################################################
+
+echo "Skipping compilation; using precompiled honggfuzz"
+
+cp $SRC/honggfuzz/honggfuzz.a $LIB_FUZZING_ENGINE
+cp $SRC/honggfuzz/honggfuzz $OUT/
+
+# Set flags necessary for netdriver compilation.
+export LIB_HFND="-Wl,-u,LIBHFNETDRIVER_module_netdriver -Wl,--start-group $SRC/honggfuzz/libhfnetdriver/libhfnetdriver.a $SRC/honggfuzz/libhfcommon/libhfcommon.a -Wl,--end-group"
+
+export HFND_CXXFLAGS='-DHFND_FUZZING_ENTRY_FUNCTION_CXX(x,y)=extern const char* LIBHFNETDRIVER_module_netdriver;const char** LIBHFNETDRIVER_tmp1 = &LIBHFNETDRIVER_module_netdriver;extern "C" int HonggfuzzNetDriver_main(x,y);int HonggfuzzNetDriver_main(x,y)'
+export HFND_CFLAGS='-DHFND_FUZZING_ENTRY_FUNCTION(x,y)=extern const char* LIBHFNETDRIVER_module_netdriver;const char** LIBHFNETDRIVER_tmp1 = &LIBHFNETDRIVER_module_netdriver;int HonggfuzzNetDriver_main(x,y);int HonggfuzzNetDriver_main(x,y)'
+
+# Custom coverage flags, roughly in sync with:
+# https://github.com/google/honggfuzz/blob/oss-fuzz/hfuzz_cc/hfuzz-cc.c
+export COVERAGE_FLAGS="-fsanitize-coverage=trace-pc-guard,indirect-calls,trace-cmp"
+
+echo " done."
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_javascript_fuzzer b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_javascript_fuzzer
new file mode 100644
index 0000000000000000000000000000000000000000..83ece10aa814e7e8ee3440583ff124c4fa03764e
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_javascript_fuzzer
@@ -0,0 +1,37 @@
+#!/bin/bash -eu
+# Copyright 2023 Google LLC
+#
+# 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.
+#
+################################################################################
+
+project=$1
+# Path the fuzz target source file relative to the project's root.
+fuzz_target=$2
+# Arguments to pass to Jazzer.js
+jazzerjs_args=${@:3}
+
+# Copy source code into the $OUT directory and install Jazzer.js into the project.
+if [ ! -d $OUT/$project ]; then
+ cp -r $SRC/$project $OUT/$project
+fi
+
+fuzzer_basename=$(basename -s .js $fuzz_target)
+
+# Create an execution wrapper that executes Jazzer.js with the correct arguments.
+echo "#!/bin/bash
+# LLVMFuzzerTestOneInput so that the wrapper script is recognized as a fuzz target for 'check_build'.
+project_dir=\$(dirname \"\$0\")/$project
+\$project_dir/node_modules/@jazzer.js/core/dist/cli.js \$project_dir/$fuzz_target $jazzerjs_args \$JAZZERJS_EXTRA_ARGS -- \$@" > $OUT/$fuzzer_basename
+
+chmod +x $OUT/$fuzzer_basename
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_libfuzzer b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_libfuzzer
new file mode 100644
index 0000000000000000000000000000000000000000..9acd0ccb64256e2b91e008df7ce1f1ee06ebd865
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_libfuzzer
@@ -0,0 +1,25 @@
+#!/bin/bash -eu
+# Copyright 2016 Google Inc.
+#
+# 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.
+#
+################################################################################
+
+echo -n "Compiling libFuzzer to $LIB_FUZZING_ENGINE... "
+export LIB_FUZZING_ENGINE="-fsanitize=fuzzer"
+if [ "$FUZZING_LANGUAGE" = "go" ]; then
+ export LIB_FUZZING_ENGINE="$LIB_FUZZING_ENGINE $GOPATH/gosigfuzz/gosigfuzz.o"
+fi
+
+cp /usr/local/lib/clang/*/lib/$ARCHITECTURE-unknown-linux-gnu/libclang_rt.fuzzer.a $LIB_FUZZING_ENGINE_DEPRECATED
+echo " done."
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_python_fuzzer b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_python_fuzzer
new file mode 100644
index 0000000000000000000000000000000000000000..a36c05f3d1a2b2abb3ca492cf26022486cf33ebf
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/compile_python_fuzzer
@@ -0,0 +1,128 @@
+#!/bin/bash -eux
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+################################################################################
+
+# In order to enable PySecSan for a given module, set the environment
+# variable ENABLE_PYSECSAN="YES"
+
+fuzzer_path=$1
+shift 1
+
+fuzzer_basename=$(basename -s .py $fuzzer_path)
+fuzzer_package=${fuzzer_basename}.pkg
+
+PYFUZZ_WORKPATH=$SRC/pyfuzzworkdir/
+FUZZ_WORKPATH=$PYFUZZ_WORKPATH/$fuzzer_basename
+
+if [[ $SANITIZER = *introspector* ]]; then
+ # Extract the source package the fuzzer targets. This must happen before
+ # we enter the virtual environment in the following lines because we need
+ # to use the same python environment that installed the fuzzer dependencies.
+ python3 /fuzz-introspector/frontends/python/prepare_fuzz_imports.py $fuzzer_path isossfuzz
+
+ # We must ensure python3.9, this is because we use certain
+ # AST logic from there.
+ # The below should probably be refined
+ apt-get install -y python3.9
+ apt-get update
+ apt-get install -y python3-pip
+ python3.9 -m pip install virtualenv
+ python3.9 -m virtualenv .venv
+ . .venv/bin/activate
+ pip3 install pyyaml
+ export PYTHONPATH="/fuzz-introspector/frontends/python/PyCG"
+
+ ARGS="--fuzzer $fuzzer_path"
+ if [ -n "${PYFUZZPACKAGE-}" ]; then
+ ARGS="$ARGS --package=${PYFUZZPACKAGE}"
+ fi
+ python /fuzz-introspector/frontends/python/main.py $ARGS
+ ls -la ./
+ exit 0
+fi
+
+# In coverage mode prepend coverage logic to the fuzzer source
+if [[ $SANITIZER = *coverage* ]]; then
+ cat < coverage_wrapper.py
+###### Coverage stub
+import atexit
+import coverage
+cov = coverage.coverage(data_file='.coverage', cover_pylib=True)
+cov.start()
+# Register an exist handler that will print coverage
+def exit_handler():
+ cov.stop()
+ cov.save()
+atexit.register(exit_handler)
+####### End of coverage stub
+EOF
+
+ # Prepend stub and create tmp file
+ cat coverage_wrapper.py $fuzzer_path > tmp_fuzzer_coverage.py
+
+ # Overwrite existing fuzzer with new fuzzer that has stub
+ mv tmp_fuzzer_coverage.py $fuzzer_path
+fi
+
+# If PYSECSAN is enabled, ensure that we can build with it.
+if [[ ${ENABLE_PYSECSAN:-"0"} != "0" ]];
+then
+ # Make sure pysecsan is installed
+ if [[ ! -d "/pysecsan" ]];
+ then
+ pushd /usr/local/lib/sanitizers/pysecsan
+ python3 -m pip install .
+ popd
+ fi
+
+ cat < pysecsan_wrapper.py
+import pysecsan; pysecsan.add_hooks();
+EOF
+
+ # Prepend stub and create tmp file
+ cat pysecsan_wrapper.py $fuzzer_path > tmp_fuzzer_pysecsan.py
+
+ # Overwrite existing fuzzer with new fuzzer that has stub
+ mv tmp_fuzzer_pysecsan.py $fuzzer_path
+fi
+
+rm -rf $PYFUZZ_WORKPATH
+mkdir $PYFUZZ_WORKPATH $FUZZ_WORKPATH
+
+pyinstaller --distpath $OUT --workpath=$FUZZ_WORKPATH --onefile --name $fuzzer_package "$@" $fuzzer_path
+
+# Disable executable bit from package as OSS-Fuzz uses executable bits to
+# identify fuzz targets. We re-enable the executable bit in wrapper script
+# below.
+chmod -x $OUT/$fuzzer_package
+
+# In coverage mode save source files of dependencies in pyinstalled binary
+if [[ $SANITIZER = *coverage* ]]; then
+ rm -rf /medio/
+ python3 /usr/local/bin/python_coverage_helper.py $FUZZ_WORKPATH "/medio"
+ zip -r $fuzzer_package.deps.zip /medio
+ mv $fuzzer_package.deps.zip $OUT/
+fi
+
+# Create execution wrapper.
+echo "#!/bin/sh
+# LLVMFuzzerTestOneInput for fuzzer detection.
+this_dir=\$(dirname \"\$0\")
+chmod +x \$this_dir/$fuzzer_package
+LD_PRELOAD=\$this_dir/sanitizer_with_fuzzer.so \
+ASAN_OPTIONS=\$ASAN_OPTIONS:symbolize=1:external_symbolizer_path=\$this_dir/llvm-symbolizer:detect_leaks=0 \
+\$this_dir/$fuzzer_package \$@" > $OUT/$fuzzer_basename
+chmod +x $OUT/$fuzzer_basename
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/detect_repo.py b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/detect_repo.py
new file mode 100644
index 0000000000000000000000000000000000000000..e677e102329f2c7b3efb49eb77df19f83b46ce9f
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/detect_repo.py
@@ -0,0 +1,182 @@
+# Copyright 2019 Google LLC
+#
+# 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.
+"""Module to get the the name of a git repo containing a specific commit
+inside of an OSS-Fuzz project.
+
+Example Usage:
+
+ python detect_repo.py --src_dir /src --example_commit
+ b534f03eecd8a109db2b085ab24d419b6486de97
+
+Prints the location of the git remote repo as well as the repo's name
+seperated by a space.
+
+ https://github.com/VirusTotal/yara.git yara
+
+"""
+import argparse
+import logging
+import os
+import subprocess
+
+GO_PATH = '/root/go/src/'
+
+
+def main():
+ """Function to get a git repo's url and name referenced by OSS-Fuzz
+ Dockerfile.
+
+ Raises:
+ ValueError when a commit or a ref is not provided.
+ """
+ parser = argparse.ArgumentParser(
+ description=
+ 'Finds a specific git repo in an oss-fuzz project\'s docker file.')
+ parser.add_argument('--repo_name', help='The name of the git repo.')
+ parser.add_argument('--src_dir', help='The location of the possible repo.')
+ parser.add_argument('--example_commit',
+ help='A commit SHA referencing the project\'s main repo.')
+
+ args = parser.parse_args()
+ if not args.repo_name and not args.example_commit:
+ raise ValueError(
+ 'Requires an example commit or a repo name to find repo location.')
+ if args.src_dir:
+ src_dir = args.src_dir
+ else:
+ src_dir = os.environ.get('SRC', '/src')
+
+ for single_dir in get_dirs_to_search(src_dir, args.repo_name):
+ full_path = os.path.join(src_dir, single_dir)
+ if not os.path.isdir(full_path):
+ continue
+ if args.example_commit and check_for_commit(full_path, args.example_commit):
+ print('Detected repo:', get_repo(full_path), full_path)
+ return
+ if args.repo_name and check_for_repo_name(full_path, args.repo_name):
+ print('Detected repo:', get_repo(full_path), full_path)
+ return
+ logging.error('No git repos with specific commit: %s found in %s',
+ args.example_commit, src_dir)
+
+
+def get_dirs_to_search(src_dir, repo_name):
+ """Gets a list of directories to search for the main git repo.
+
+ Args:
+ src_dir: The location set for the projects SRC.
+ repo_name: The name of the repo you are searching for.
+
+ Returns:
+ A list of directorys to search.
+ """
+ dirs_to_search = os.listdir(src_dir)
+ if os.path.exists(GO_PATH) and repo_name:
+ for root, dirs, _ in os.walk(GO_PATH):
+ for test_dir in dirs:
+ if repo_name in test_dir:
+ dirs_to_search.append(os.path.join(root, test_dir))
+ return dirs_to_search
+
+
+def get_repo(repo_path):
+ """Gets a git repo link from a specific directory in a docker image.
+
+ Args:
+ repo_path: The directory on the image where the git repo exists.
+
+ Returns:
+ The repo location or None.
+ """
+ output, return_code = execute(['git', 'config', '--get', 'remote.origin.url'],
+ location=repo_path,
+ check_result=True)
+ if return_code == 0 and output:
+ return output.rstrip()
+ return None
+
+
+def check_for_repo_name(repo_path, expected_repo_name):
+ """Returns True if the repo at |repo_path| repo_name matches
+ |expected_repo_name|.
+
+ Args:
+ repo_path: The directory of a git repo.
+ expected_repo_name: The name of the target git repo.
+ """
+ if not os.path.exists(os.path.join(repo_path, '.git')):
+ return False
+
+ repo_url, _ = execute(['git', 'config', '--get', 'remote.origin.url'],
+ location=repo_path)
+ # Handle two common cases:
+ # https://github.com/google/syzkaller/
+ # https://github.com/google/syzkaller.git
+ repo_url = repo_url.replace('.git', '').rstrip().rstrip('/')
+ actual_repo_name = repo_url.split('/')[-1]
+ return actual_repo_name == expected_repo_name
+
+
+def check_for_commit(repo_path, commit):
+ """Checks a directory for a specific commit.
+
+ Args:
+ repo_path: The name of the directory to test for the commit.
+ commit: The commit SHA to check for.
+
+ Returns:
+ True if directory contains that commit.
+ """
+
+ # Check if valid git repo.
+ if not os.path.exists(os.path.join(repo_path, '.git')):
+ return False
+
+ # Check if history fetch is needed.
+ if os.path.exists(os.path.join(repo_path, '.git', 'shallow')):
+ execute(['git', 'fetch', '--unshallow'], location=repo_path)
+
+ # Check if commit is in history.
+ _, return_code = execute(['git', 'cat-file', '-e', commit],
+ location=repo_path)
+ return return_code == 0
+
+
+def execute(command, location, check_result=False):
+ """Runs a shell command in the specified directory location.
+
+ Args:
+ command: The command as a list to be run.
+ location: The directory the command is run in.
+ check_result: Should an exception be thrown on failed command.
+
+ Returns:
+ The stdout of the command, the error code.
+
+ Raises:
+ RuntimeError: running a command resulted in an error.
+ """
+ process = subprocess.Popen(command, stdout=subprocess.PIPE, cwd=location)
+ output, err = process.communicate()
+ if check_result and (process.returncode or err):
+ raise RuntimeError(
+ 'Error: %s\n running command: %s\n return code: %s\n out %s\n' %
+ (err, command, process.returncode, output))
+ if output is not None:
+ output = output.decode('ascii')
+ return output, process.returncode
+
+
+if __name__ == '__main__':
+ main()
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/install_javascript.sh b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/install_javascript.sh
new file mode 100644
index 0000000000000000000000000000000000000000..232658b0484dc67202352a2bc9025168fd8e4aa0
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/install_javascript.sh
@@ -0,0 +1,27 @@
+#!/bin/bash -eux
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+################################################################################
+# see installation instructions: https://github.com/nodesource/distributions#available-architectures
+apt-get update
+apt-get install -y ca-certificates curl gnupg
+mkdir -p /etc/apt/keyrings
+curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
+
+NODE_MAJOR=20
+echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
+
+apt-get update
+apt-get install nodejs -y
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/install_python.sh b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/install_python.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0d5fcb96450a9e402d1c8a5af30e09bc42bd36ff
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/install_python.sh
@@ -0,0 +1,23 @@
+#!/bin/bash -eux
+# Copyright 2021 Google LLC
+#
+# 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.
+#
+################################################################################
+
+echo "ATHERIS INSTALL"
+unset CFLAGS CXXFLAGS
+# PYI_STATIC_ZLIB=1 is needed for installing pyinstaller 5.0
+export PYI_STATIC_ZLIB=1
+LIBFUZZER_LIB=$( echo /usr/local/lib/clang/*/lib/x86_64-unknown-linux-gnu/libclang_rt.fuzzer_no_main.a ) pip3 install -v --no-cache-dir "atheris>=2.3.0" "pyinstaller==6.10.0" "setuptools==72.1.0" "coverage==6.3.2"
+rm -rf /tmp/*
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/build_jcc.bash b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/build_jcc.bash
new file mode 100644
index 0000000000000000000000000000000000000000..6a62c22890f0edbb24ccdd73d5a8d089f44e7632
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/build_jcc.bash
@@ -0,0 +1,25 @@
+#!/bin/bash -eu
+#
+# Copyright 2023 Google LLC
+#
+# 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.
+#
+################################################################################
+
+go build jcc.go
+go build jcc2.go
+gsutil cp jcc gs://clusterfuzz-builds/jcc/clang++-jcc
+gsutil cp jcc gs://clusterfuzz-builds/jcc/clang-jcc
+
+gsutil cp jcc2 gs://clusterfuzz-builds/jcc/clang++-jcc2
+gsutil cp jcc2 gs://clusterfuzz-builds/jcc/clang-jcc2
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/go.mod b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/go.mod
new file mode 100644
index 0000000000000000000000000000000000000000..c32967d291b649cbe030aae34d0121b02a971647
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/go.mod
@@ -0,0 +1,3 @@
+module github.com/google/jcc
+
+go 1.21
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/jcc.go b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/jcc.go
new file mode 100644
index 0000000000000000000000000000000000000000..7eda88dd8a309908d475245261d76199817223f2
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/jcc.go
@@ -0,0 +1,88 @@
+// Copyright 2023 Google LLC
+//
+// 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.
+
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "log"
+ "os"
+ "os/exec"
+ "path/filepath"
+)
+
+func ExecBuildCommand(bin string, args []string) (int, string, string) {
+ // Executes the original command.
+ cmd := exec.Command(bin, args...)
+ var outb, errb bytes.Buffer
+ cmd.Stdout = &outb
+ cmd.Stderr = &errb
+ cmd.Stdin = os.Stdin
+ cmd.Run()
+ return cmd.ProcessState.ExitCode(), outb.String(), errb.String()
+}
+
+func Compile(bin string, args []string) (int, string, string) {
+ // Run the actual command.
+ return ExecBuildCommand(bin, args)
+}
+
+func AppendStringToFile(filepath, new_content string) error {
+ // Appends |new_content| to the content of |filepath|.
+ file, err := os.OpenFile(filepath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+ if err != nil {
+ return err
+ }
+ defer file.Close()
+
+ _, err = file.WriteString(new_content)
+ return err
+}
+
+func WriteStdErrOut(args []string, outstr string, errstr string) {
+ // Prints |outstr| to stdout, prints |errstr| to stderr, and saves |errstr| to err.log.
+ fmt.Print(outstr)
+ fmt.Fprint(os.Stderr, errstr)
+ // Record what compile args produced the error and the error itself in log file.
+ AppendStringToFile("/tmp/err.log", fmt.Sprintf("%s\n", args)+errstr)
+}
+
+func main() {
+ f, err := os.OpenFile("/tmp/jcc.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+
+ if err != nil {
+ log.Println(err)
+ }
+ defer f.Close()
+ if _, err := f.WriteString(fmt.Sprintf("%s\n", os.Args)); err != nil {
+ log.Println(err)
+ }
+
+ args := os.Args[1:]
+ basename := filepath.Base(os.Args[0])
+ isCPP := basename == "clang++-jcc"
+ newArgs := args
+
+ var bin string
+ if isCPP {
+ bin = "clang++"
+ } else {
+ bin = "clang"
+ }
+ fullCmdArgs := append([]string{bin}, newArgs...)
+ retcode, out, errstr := Compile(bin, newArgs)
+ WriteStdErrOut(fullCmdArgs, out, errstr)
+ os.Exit(retcode)
+}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/jcc2.go b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/jcc2.go
new file mode 100644
index 0000000000000000000000000000000000000000..a2d9e73ea2f58c2b1ed3279fe19ac4d6a43e8126
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/jcc2.go
@@ -0,0 +1,401 @@
+// Copyright 2024 Google LLC
+//
+// 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.
+
+package main
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io/fs"
+ "io/ioutil"
+ "log"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "regexp"
+ "strings"
+)
+
+var MaxMissingHeaderFiles = 10
+var CppifyHeadersMagicString = "\n/* JCCCppifyHeadersMagicString */\n"
+
+func CopyFile(src string, dst string) {
+ contents, err := ioutil.ReadFile(src)
+ if err != nil {
+ panic(err)
+ }
+ err = ioutil.WriteFile(dst, contents, 0644)
+ if err != nil {
+ panic(err)
+ }
+}
+
+func TryFixCCompilation(cmdline []string) ([]string, int, string, string) {
+ var newFile string = ""
+ for i, arg := range cmdline {
+ if !strings.HasSuffix(arg, ".c") {
+ continue
+ }
+ if _, err := os.Stat(arg); errors.Is(err, os.ErrNotExist) {
+ continue
+ }
+ newFile = strings.TrimSuffix(arg, ".c")
+ newFile += ".cpp"
+ CopyFile(arg, newFile)
+ CppifyHeaderIncludesFromFile(newFile)
+ cmdline[i] = newFile
+ break
+ }
+ if newFile == "" {
+ return []string{}, 1, "", ""
+ }
+ cppBin := "clang++"
+ newCmdline := []string{"-stdlib=libc++"}
+ newCmdline = append(cmdline, newCmdline...)
+ newFullArgs := append([]string{cppBin}, newCmdline...)
+
+ retcode, out, err := Compile(cppBin, newCmdline)
+ if retcode == 0 {
+ return newFullArgs, retcode, out, err
+ }
+ correctedCmdline, corrected, _ := CorrectMissingHeaders(cppBin, newCmdline)
+ if corrected {
+ return append([]string{cppBin}, correctedCmdline...), 0, "", ""
+ }
+ return newFullArgs, retcode, out, err
+}
+
+func ExtractMissingHeader(compilerOutput string) (string, bool) {
+ r := regexp.MustCompile(`fatal error: ['|<](?P[a-zA-z0-9\/\.]+)['|>] file not found`)
+ matches := r.FindStringSubmatch(compilerOutput)
+ if len(matches) == 0 {
+ return "", false
+ }
+ return matches[1], true
+}
+
+func ReplaceMissingHeaderInFile(srcFilename, curHeader, replacementHeader string) error {
+ srcFile, err := os.Open(srcFilename)
+ if err != nil {
+ return err
+ }
+ srcBytes, err := ioutil.ReadAll(srcFile)
+ if err != nil {
+ return err
+ }
+ src := string(srcBytes)
+ newSrc := ReplaceMissingHeader(src, curHeader, replacementHeader)
+ b := []byte(newSrc)
+ err = ioutil.WriteFile(srcFilename, b, 0644)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+func ReplaceMissingHeader(src, curHeader, replacementHeader string) string {
+ re := regexp.MustCompile(`#include ["|<]` + curHeader + `["|>]\n`)
+ replacement := "#include \"" + replacementHeader + "\"\n"
+ return re.ReplaceAllString(src, replacement)
+}
+
+func GetHeaderCorrectedFilename(compilerErr string) (string, string, bool) {
+ re := regexp.MustCompile(`(?P[a-z\/\-\_0-9A-z\.]+):.* fatal error: .* file not found`)
+ matches := re.FindStringSubmatch(compilerErr)
+ if len(matches) < 2 {
+ return "", "", false
+ }
+ oldFilename := matches[1]
+ base := filepath.Base(oldFilename)
+ root := filepath.Dir(oldFilename)
+ newFilename := root + "/jcc-corrected-" + base
+ return oldFilename, newFilename, true
+}
+
+func GetHeaderCorrectedCmd(cmd []string, compilerErr string) ([]string, string, error) {
+ oldFilename, newFilename, success := GetHeaderCorrectedFilename(compilerErr)
+ if !success {
+ return cmd, "", errors.New("Couldn't find buggy file")
+ }
+ // Make new cmd.
+ newCmd := make([]string, len(cmd))
+ for i, part := range cmd {
+ newCmd[i] = part
+ }
+ found := false
+ for i, filename := range newCmd {
+ if filename == oldFilename {
+ newCmd[i] = newFilename
+ found = true
+ break
+ }
+ }
+ CopyFile(oldFilename, newFilename)
+ if found {
+ return newCmd, newFilename, nil
+ }
+ return cmd, "", errors.New("Couldn't find file")
+}
+
+func CorrectMissingHeaders(bin string, cmd []string) ([]string, bool, error) {
+
+ _, _, stderr := Compile(bin, cmd)
+ cmd, correctedFilename, err := GetHeaderCorrectedCmd(cmd, stderr)
+ if err != nil {
+ return cmd, false, err
+ }
+ for i := 0; i < MaxMissingHeaderFiles; i++ {
+ fixed, hasBrokenHeaders := TryCompileAndFixHeadersOnce(bin, cmd, correctedFilename)
+ if fixed {
+ return cmd, true, nil
+ }
+ if !hasBrokenHeaders {
+ return cmd, false, nil
+ }
+ }
+ return cmd, false, nil
+}
+
+func ExecBuildCommand(bin string, args []string) (int, string, string) {
+ // Executes the original command.
+ cmd := exec.Command(bin, args...)
+ var outb, errb bytes.Buffer
+ cmd.Stdout = &outb
+ cmd.Stderr = &errb
+ cmd.Stdin = os.Stdin
+ cmd.Run()
+ return cmd.ProcessState.ExitCode(), outb.String(), errb.String()
+}
+
+func Compile(bin string, args []string) (int, string, string) {
+ // Run the actual command.
+ return ExecBuildCommand(bin, args)
+}
+
+func TryCompileAndFixHeadersOnce(bin string, cmd []string, filename string) (fixed, hasBrokenHeaders bool) {
+ retcode, _, err := Compile(bin, cmd)
+ if retcode == 0 {
+ fixed = true
+ hasBrokenHeaders = false
+ return
+ }
+ missingHeader, isMissing := ExtractMissingHeader(err)
+ if !isMissing {
+ fixed = false
+ hasBrokenHeaders = false
+ return
+ }
+
+ newHeaderPath, found := FindMissingHeader(missingHeader)
+ if !found {
+ fixed = false
+ hasBrokenHeaders = true
+ return false, true
+ }
+ ReplaceMissingHeaderInFile(filename, missingHeader, newHeaderPath)
+ return false, true
+}
+
+func FindMissingHeader(missingHeader string) (string, bool) {
+ envVar := "JCC_MISSING_HEADER_SEARCH_PATH"
+ var searchPath string
+ searchPath, exists := os.LookupEnv(envVar)
+ if !exists {
+ searchPath = "/src"
+ }
+ searchPath, _ = filepath.Abs(searchPath)
+ var headerLocation string
+ missingHeader = "/" + missingHeader
+ find := func(path string, d fs.DirEntry, err error) error {
+ if err != nil {
+ return err
+ }
+ if d.IsDir() {
+ return nil
+ }
+ if strings.HasSuffix(path, missingHeader) {
+ headerLocation = path
+ return nil
+ }
+ return nil
+ }
+ filepath.WalkDir(searchPath, find)
+ if headerLocation == "" {
+ return "", false
+ }
+ return headerLocation, true
+}
+
+func CppifyHeaderIncludesFromFile(srcFile string) error {
+ contentsBytes, err := ioutil.ReadFile(srcFile)
+ if err != nil {
+ return err
+ }
+ contents := string(contentsBytes[:])
+ contents, err = CppifyHeaderIncludes(contents)
+ if err != nil {
+ return err
+ }
+ b := []byte(contents)
+ err = ioutil.WriteFile(srcFile, b, 0644)
+ return err
+}
+
+func CppifyHeaderIncludes(contents string) (string, error) {
+ shouldCppify, exists := os.LookupEnv("JCC_CPPIFY_PROJECT_HEADERS")
+ if !exists || strings.Compare(shouldCppify, "0") == 0 {
+ return contents, nil
+ }
+ if strings.Contains(contents, CppifyHeadersMagicString) {
+ return contents, nil
+ }
+ re := regexp.MustCompile(`\#include \"(?P.+)\"\n`)
+ matches := re.FindAllStringSubmatch(contents, -1)
+ if len(matches) == 0 {
+ return "", nil // !!!
+ }
+ for i, match := range matches {
+ if i == 0 {
+ // So we don't cppify twice.
+ contents += CppifyHeadersMagicString
+ }
+ oldStr := match[0]
+ replacement := "extern \"C\" {\n#include \"" + match[1] + "\"\n}\n"
+ contents = strings.Replace(contents, oldStr, replacement, 1)
+ if strings.Compare(contents, "") == 0 {
+ panic("Failed to replace")
+ }
+ }
+ return contents, nil
+}
+
+func AppendStringToFile(filepath, new_content string) error {
+ // Appends |new_content| to the content of |filepath|.
+ file, err := os.OpenFile(filepath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+ if err != nil {
+ return err
+ }
+ defer file.Close()
+
+ _, err = file.WriteString(new_content)
+ return err
+}
+
+func WriteStdErrOut(args []string, outstr string, errstr string) {
+ // Prints |outstr| to stdout, prints |errstr| to stderr, and saves |errstr| to err.log.
+ fmt.Print(outstr)
+ fmt.Fprint(os.Stderr, errstr)
+ // Record what compile args produced the error and the error itself in log file.
+ AppendStringToFile("/workspace/err.log", fmt.Sprintf("%s\n", args)+errstr)
+}
+
+func main() {
+ f, err := os.OpenFile("/tmp/jcc.log", os.O_CREATE|os.O_WRONLY, 0644)
+ if err != nil {
+ log.Println(err)
+ }
+ defer f.Close()
+ if _, err := f.WriteString(fmt.Sprintf("%s\n", os.Args)); err != nil {
+ log.Println(err)
+ }
+
+ args := os.Args[1:]
+ if args[0] == "unfreeze" {
+ fmt.Println("unfreeze")
+ unfreeze()
+ }
+ basename := filepath.Base(os.Args[0])
+ isCPP := basename == "clang++-jcc"
+ newArgs := append(args, "-w")
+
+ var bin string
+ if isCPP {
+ bin = "clang++"
+ newArgs = append(args, "-stdlib=libc++")
+ } else {
+ bin = "clang"
+ }
+ fullCmdArgs := append([]string{bin}, newArgs...)
+ if IsCompilingTarget(fullCmdArgs) {
+ WriteTargetArgsAndCommitImage(fullCmdArgs)
+ os.Exit(0)
+ }
+ retcode, out, errstr := Compile(bin, newArgs)
+ WriteStdErrOut(fullCmdArgs, out, errstr)
+ os.Exit(retcode)
+}
+
+type BuildCommand struct {
+ CWD string `json:"CWD"`
+ CMD []string `json:"CMD"`
+}
+
+func WriteTargetArgsAndCommitImage(cmdline []string) {
+ log.Println("WRITE COMMAND")
+ f, _ := os.OpenFile("/out/statefile.json", os.O_CREATE|os.O_WRONLY, 0644)
+ wd, _ := os.Getwd()
+ buildcmd := BuildCommand{
+ CWD: wd,
+ CMD: cmdline,
+ }
+ jsonData, _ := json.Marshal(buildcmd)
+ f.Write(jsonData)
+ f.Close()
+ hostname, _ := os.Hostname()
+ dockerArgs := []string{"commit", hostname, "frozen"}
+ cmd := exec.Command("docker", dockerArgs...)
+ var outb, errb bytes.Buffer
+ cmd.Stdout = &outb
+ cmd.Stderr = &errb
+ cmd.Stdin = os.Stdin
+ cmd.Run()
+ fmt.Println(outb.String(), errb.String())
+ fmt.Println("COMMIT IMAGE")
+}
+
+func IsCompilingTarget(cmdline []string) bool {
+ for _, arg := range cmdline {
+ // This can fail if people do crazy things they aren't supposed
+ // to such as using some other means to link in libFuzzer.
+ if arg == "-fsanitize=fuzzer" {
+ return true
+ }
+ if arg == "-lFuzzingEngine" {
+ return true
+ }
+ }
+ return false
+}
+
+func parseCommand(command string) (string, []string) {
+ args := strings.Fields(command)
+ commandBin := args[0]
+ commandArgs := args[1:]
+ return commandBin, commandArgs
+}
+
+func unfreeze() {
+ content, err := ioutil.ReadFile("/out/statefile.json")
+ if err != nil {
+ log.Fatal(err)
+ }
+ var command BuildCommand
+ json.Unmarshal(content, &command)
+ bin, args := parseCommand(strings.Join(command.CMD, " "))
+ os.Chdir(command.CWD)
+ ExecBuildCommand(bin, args)
+ os.Exit(0)
+}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/jcc_test.go b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/jcc_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..bc76cb263f11969de5c15d19ebfe742a8e0f5f33
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/jcc_test.go
@@ -0,0 +1,186 @@
+package main
+
+import (
+ "fmt"
+ "os"
+ "strings"
+ "testing"
+)
+
+func TestExtractMissingHeader(t *testing.T) {
+ missingHeaderMessage := `path/to/file.cpp:8:10: fatal error: 'missingheader.h' file not found
+
+ #include "missingheader.h"
+
+ ^~~~~~~~~~~~
+
+ 1 error generated.
+ `
+
+ res, _ := ExtractMissingHeader(missingHeaderMessage)
+ expected := "missingheader.h"
+ if strings.Compare(res, expected) != 0 {
+ t.Errorf("Got: %s. Expected: %s.", res, expected)
+ }
+}
+
+func TestGetHeaderCorrectedFilename(t *testing.T) {
+ missingHeaderMessage := `path/to/file.cpp:8:10: fatal error: 'missingheader.h' file not found
+
+ #include "missingheader.h"
+
+ ^~~~~~~~~~~~
+
+ 1 error generated.
+ `
+ _, correctedFilename, _ := GetHeaderCorrectedFilename(missingHeaderMessage)
+ expected := "path/to/jcc-corrected-file.cpp"
+ if strings.Compare(correctedFilename, expected) != 0 {
+ t.Errorf("Got: %s. Expected: %s.", correctedFilename, expected)
+ }
+}
+
+func TestFindMissingHeader(t *testing.T) {
+ pwd, _ := os.Getwd()
+ t.Setenv("JCC_MISSING_HEADER_SEARCH_PATH", pwd)
+
+ location, _ := FindMissingHeader("header.h")
+ expected := pwd + "/testdata/path/to/header.h"
+ if strings.Compare(location, expected) != 0 {
+ t.Errorf("Got: %s. Expected: %s.", location, expected)
+ }
+}
+
+func TestCorrectMissingHeaders(t *testing.T) {
+ pwd, _ := os.Getwd()
+ t.Setenv("JCC_MISSING_HEADER_SEARCH_PATH", pwd)
+ cfile := pwd + "/testdata/cfile.c"
+ cmd := [4]string{"-fsanitize=address", cfile, "-o", "/tmp/blah"}
+ res, err := CorrectMissingHeaders("clang", cmd[:])
+ if !res {
+ fmt.Println(err)
+ t.Errorf("Expected successful compilation")
+ }
+}
+
+func TestGetHeaderCorrectedCmd(t *testing.T) {
+ compilerErr := `testdata/cpp.cc:8:10: fatal error: 'missingheader.h' file not found
+
+ #include "missingheader.h"
+
+ ^~~~~~~~~~~~
+
+ 1 error generated.
+ `
+
+ cmd := [3]string{"-fsanitize=address", "file.cpp", "path/to/cpp.cc"}
+ expectedFixedCmd := [3]string{"-fanitize=address", "file.cpp", "path/to/jcc-corrected-cpp.cc"}
+ fixedCmd, _, _ := GetHeaderCorrectedCmd(cmd[:], compilerErr)
+ if strings.Compare(fixedCmd[1], expectedFixedCmd[1]) != 0 {
+ t.Errorf("Expected %s, got: %s", expectedFixedCmd, fixedCmd)
+ }
+}
+
+func TestCppifyHeaderIncludes(t *testing.T) {
+ t.Setenv("JCC_CPPIFY_PROJECT_HEADERS", "1")
+ src := `// Copyright blah
+#include
+
+#include "fuzz.h"
+#include "x/y.h"
+extern "C" LLVMFuzzerTestOneInput(uint8_t* data, size_t sz) {
+ return 0;
+}`
+ newFile, _ := CppifyHeaderIncludes(src)
+ expected := `// Copyright blah
+#include
+
+extern "C" {
+#include "fuzz.h"
+}
+extern "C" {
+#include "x/y.h"
+}
+extern "C" LLVMFuzzerTestOneInput(uint8_t* data, size_t sz) {
+ return 0;
+}
+/* JCCCppifyHeadersMagicString */
+`
+ if strings.Compare(newFile, expected) != 0 {
+ t.Errorf("Expected: %s, got: %s", expected, newFile)
+ }
+}
+
+func TestCppifyHeaderIncludesShouldnt(t *testing.T) {
+ src := `// Copyright blah
+#include
+
+#include "fuzz.h"
+#include "x/y.h"
+extern "C" LLVMFuzzerTestOneInput(uint8_t* data, size_t sz) {
+ return 0;
+}`
+ newFile, _ := CppifyHeaderIncludes(src)
+ if strings.Compare(newFile, src) != 0 {
+ t.Errorf("Expected: %s. Got: %s", src, newFile)
+ }
+}
+
+func TestCppifyHeaderIncludesAlready(t *testing.T) {
+ src := `// Copyright blah
+#include
+
+#include "fuzz.h"
+#include "x/y.h"
+extern "C" LLVMFuzzerTestOneInput(uint8_t* data, size_t sz) {
+ return 0;
+}
+/* JCCCppifyHeadersMagicString */
+`
+ newFile, _ := CppifyHeaderIncludes(src)
+ if strings.Compare(newFile, src) != 0 {
+ t.Errorf("Expected %s, got: %s", src, newFile)
+ }
+}
+
+func TestExtractMissingHeaderNonHeaderFailure(t *testing.T) {
+ missingHeaderMessage := `clang: error: no such file or directory: 'x'
+clang: error: no input files`
+
+ header, res := ExtractMissingHeader(missingHeaderMessage)
+ if res {
+ t.Errorf("Expected no match, got: %s", header)
+ }
+}
+
+func TestReplaceMissingHeader(t *testing.T) {
+ cfile := `// Copyright 2035 Robots
+#include
+
+#include
+
+// Some libraries like OpenSSL will use brackets for their own headers.
+#include
+
+int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) {
+ return 0;
+}
+`
+
+ res := ReplaceMissingHeader(cfile, "missingheader.h", "path/to/includes/missingheader.h")
+ expected := `// Copyright 2035 Robots
+#include
+
+#include
+
+// Some libraries like OpenSSL will use brackets for their own headers.
+#include "path/to/includes/missingheader.h"
+
+int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) {
+ return 0;
+}
+`
+ if strings.Compare(res, expected) != 0 {
+ t.Errorf("Got: %s. Expected: %s.", res, expected)
+ }
+}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/.gitignore b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..ea1fd92c507fc7d30a9fb1cd71f0a03d42cfca1d
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/.gitignore
@@ -0,0 +1,2 @@
+jcc-corrected-cfile.c
+jcc-corrected-cfile.cpp
\ No newline at end of file
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/cfile.c b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/cfile.c
new file mode 100644
index 0000000000000000000000000000000000000000..e18c414d13060ac339cf2aafe5e782a8e55e9cc3
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/cfile.c
@@ -0,0 +1,18 @@
+// Copyright 2023 Google LLC
+//
+// 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 "header.h"
+int main() {
+ return 0;
+}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/cpp.cc b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/cpp.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e18c414d13060ac339cf2aafe5e782a8e55e9cc3
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/cpp.cc
@@ -0,0 +1,18 @@
+// Copyright 2023 Google LLC
+//
+// 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 "header.h"
+int main() {
+ return 0;
+}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/path/to/header.h b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/path/to/header.h
new file mode 100644
index 0000000000000000000000000000000000000000..f4d3e90abd55b52ed6e8a02f23393165ccbf34ab
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/path/to/header.h
@@ -0,0 +1,15 @@
+// Copyright 2023 Google LLC
+//
+// 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.
+
+int xhg(void);
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/llvmsymbol.diff b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/llvmsymbol.diff
new file mode 100644
index 0000000000000000000000000000000000000000..70181bf3997985bbd8ac568f3227e18ef423f6f2
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/llvmsymbol.diff
@@ -0,0 +1,50 @@
+diff --git a/llvm/lib/DebugInfo/Symbolize/CMakeLists.txt b/llvm/lib/DebugInfo/Symbolize/CMakeLists.txt
+index acfb3bd0e..a499ee2e0 100644
+--- a/llvm/lib/DebugInfo/Symbolize/CMakeLists.txt
++++ b/llvm/lib/DebugInfo/Symbolize/CMakeLists.txt
+@@ -12,4 +12,11 @@ add_llvm_component_library(LLVMSymbolize
+ Object
+ Support
+ Demangle
+- )
++
++ LINK_LIBS
++ /usr/lib/swift_static/linux/libswiftCore.a
++ /usr/lib/swift_static/linux/libicui18nswift.a
++ /usr/lib/swift_static/linux/libicuucswift.a
++ /usr/lib/swift_static/linux/libicudataswift.a
++ /usr/lib/x86_64-linux-gnu/libstdc++.so.6
++)
+diff --git a/llvm/lib/DebugInfo/Symbolize/Symbolize.cpp b/llvm/lib/DebugInfo/Symbolize/Symbolize.cpp
+index fb4875f79..0030769ee 100644
+--- a/llvm/lib/DebugInfo/Symbolize/Symbolize.cpp
++++ b/llvm/lib/DebugInfo/Symbolize/Symbolize.cpp
+@@ -36,6 +36,13 @@
+ #include
+ #include
+
++
++extern "C" char *swift_demangle(const char *mangledName,
++ size_t mangledNameLength,
++ char *outputBuffer,
++ size_t *outputBufferSize,
++ uint32_t flags);
++
+ namespace llvm {
+ namespace symbolize {
+
+@@ -678,6 +685,14 @@ LLVMSymbolizer::DemangleName(const std::string &Name,
+ free(DemangledName);
+ return Result;
+ }
++ if (!Name.empty() && Name.front() == '$') {
++ char *DemangledName = swift_demangle(Name.c_str(), Name.length(), 0, 0, 0);
++ if (DemangledName) {
++ std::string Result = DemangledName;
++ free(DemangledName);
++ return Result;
++ }
++ }
+
+ if (DbiModuleDescriptor && DbiModuleDescriptor->isWin32Module())
+ return std::string(demanglePE32ExternCFunc(Name));
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/ossfuzz_coverage_runner.go b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/ossfuzz_coverage_runner.go
new file mode 100644
index 0000000000000000000000000000000000000000..d433da24638c96dbe58c77bf00a964f8834edd18
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/ossfuzz_coverage_runner.go
@@ -0,0 +1,69 @@
+// Copyright 2020 Google LLC
+//
+// 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.
+
+package mypackagebeingfuzzed
+
+import (
+ "io/ioutil"
+ "os"
+ "runtime/pprof"
+ "testing"
+)
+
+func TestFuzzCorpus(t *testing.T) {
+ dir := os.Getenv("FUZZ_CORPUS_DIR")
+ if dir == "" {
+ t.Logf("No fuzzing corpus directory set")
+ return
+ }
+ infos, err := ioutil.ReadDir(dir)
+ if err != nil {
+ t.Logf("Not fuzzing corpus directory %s", err)
+ return
+ }
+ filename := ""
+ defer func() {
+ if r := recover(); r != nil {
+ t.Error("Fuzz panicked in "+filename, r)
+ }
+ }()
+ profname := os.Getenv("FUZZ_PROFILE_NAME")
+ if profname != "" {
+ f, err := os.Create(profname + ".cpu.prof")
+ if err != nil {
+ t.Logf("error creating profile file %s\n", err)
+ } else {
+ _ = pprof.StartCPUProfile(f)
+ }
+ }
+ for i := range infos {
+ filename = dir + infos[i].Name()
+ data, err := ioutil.ReadFile(filename)
+ if err != nil {
+ t.Error("Failed to read corpus file", err)
+ }
+ FuzzFunction(data)
+ }
+ if profname != "" {
+ pprof.StopCPUProfile()
+ f, err := os.Create(profname + ".heap.prof")
+ if err != nil {
+ t.Logf("error creating heap profile file %s\n", err)
+ }
+ if err = pprof.WriteHeapProfile(f); err != nil {
+ t.Logf("error writing heap profile file %s\n", err)
+ }
+ f.Close()
+ }
+}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/LICENSE b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..6d6d1266c329fd60129d68b2a80179e0102633e0
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/LICENSE
@@ -0,0 +1,13 @@
+# Copyright 2022 Google LLC
+#
+# 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.
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/README.md b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cbb07c1f1de011555b07e9ddc57c01fac34deba4
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/README.md
@@ -0,0 +1,3 @@
+# pysecsan
+
+Security sanitizers for vulnerability detection during runtime.
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pyproject.toml b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..636f93d09324148c5c33b90b2cfcde4feb948207
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pyproject.toml
@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pysecsan"
+version = "0.1.0"
+authors = [
+ { name="David Korczynski", email="david@adalogics.com" },
+]
+description = "Sanitizers to detect security vulnerabilities at runtime."
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+ "Programming Language :: Python :: 3",
+ "License :: OSI Approved :: Apache Software License",
+ "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/google/oss-fuzz/tree/master/infra/sanitizers/pysecsan"
+"Bug Tracker" = "https://github.com/google/oss-fuzz/issues"
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/__init__.py b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..606ff453358402b2ef653ccae9944dd0481000ea
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/__init__.py
@@ -0,0 +1,20 @@
+# Copyright 2022 Google LLC
+#
+# 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.
+"""Glue for pysecsan library."""
+
+# Import sanlib and expose only needs functionality by way of __all__
+from .sanlib import *
+
+# pylint: disable=undefined-all-variable
+__all__ = ['add_hooks']
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/command_injection.py b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/command_injection.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d010047588f04ad66dba55173f0a13284fbc21e
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/command_injection.py
@@ -0,0 +1,106 @@
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+################################################################################
+"""Sanitizers for capturing code injections."""
+
+from typing import Optional
+from pysecsan import sanlib
+
+
+def get_all_substr_prefixes(main_str, sub_str):
+ """Yields all strings prefixed with sub_str in main_str."""
+ idx = 0
+ while True:
+ idx = main_str.find(sub_str, idx)
+ if idx == -1:
+ return
+ yield main_str[0:idx]
+ # Increase idx the length of the substring from the current position
+ # where an occurence of the substring was found.
+ idx += len(sub_str)
+
+
+# pylint: disable=unsubscriptable-object
+def check_code_injection_match(elem, check_unquoted=False) -> Optional[str]:
+ """identify if elem is an injection match."""
+ # Check exact match
+ if elem == 'exec-sanitizer':
+ return 'Explicit command injection found.'
+
+ # Check potential for injecting into a string
+ if 'FROMFUZZ' in elem:
+ if check_unquoted:
+ # return true if any index is unquoted
+ for sub_str in get_all_substr_prefixes(elem, 'FROMFUZZ'):
+ if sub_str.count('\"') % 2 == 0:
+ return 'Fuzzer controlled content in data. Code injection potential.'
+
+ # Return None if all fuzzer taints were quoted
+ return None
+ return 'Fuzzer-controlled data in command string. Injection potential.'
+ return None
+
+
+# pylint: disable=invalid-name
+def hook_pre_exec_subprocess_Popen(cmd, **kwargs):
+ """Hook for subprocess.Popen."""
+
+ arg_shell = 'shell' in kwargs and kwargs['shell']
+
+ # Command injections depend on whether the first argument is a list of
+ # strings or a string. Handle this now.
+ # Example: tests/poe/ansible-runner-cve-2021-4041
+ if isinstance(cmd, str):
+ res = check_code_injection_match(cmd, check_unquoted=True)
+ if res is not None:
+ # if shell arg is true and string is tainted and unquoted that's a
+ # definite code injection.
+ if arg_shell is True:
+ sanlib.abort_with_issue('Code injection in Popen', 'Command injection')
+
+ # It's a maybe: will not report this to avoid false positives.
+ # TODO: add more precise detection here.
+
+ # Check for hg command injection
+ # Example: tests/poe/libvcs-cve-2022-21187
+ if cmd[0] == 'hg':
+ # Check if the arguments are controlled by the fuzzer, and this given
+ # arg is not preceded by --
+ found_dashes = False
+ for idx in range(1, len(cmd)):
+ if cmd[0] == '--':
+ found_dashes = True
+ if not found_dashes and check_code_injection_match(cmd[idx]):
+ sanlib.abort_with_issue(
+ 'command injection likely by way of mercurial. The following'
+ f'command {str(cmd)} is executed, and if you substitute {cmd[idx]} '
+ 'with \"--config=alias.init=!touch HELLO_PY\" then you will '
+ 'create HELLO_PY', 'Command injection')
+
+
+def hook_pre_exec_os_system(cmd):
+ """Hook for os.system."""
+ res = check_code_injection_match(cmd)
+ if res is not None:
+ sanlib.abort_with_issue(f'code injection by way of os.system\n{res}',
+ 'Command injection')
+
+
+def hook_pre_exec_eval(cmd, *args, **kwargs):
+ """Hook for eval. Experimental atm."""
+ res = check_code_injection_match(cmd, check_unquoted=True)
+ if res is not None:
+ sanlib.abort_with_issue(f'Potential code injection by way of eval\n{res}',
+ 'Command injection')
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/yaml_deserialization.py b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/yaml_deserialization.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba7179d37e8cd938b35277fe613afca0c375143a
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/yaml_deserialization.py
@@ -0,0 +1,42 @@
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+################################################################################
+"""Catches vulnerable yaml desrializations that can potentially lead to
+arbitrary code execution."""
+from pysecsan import sanlib
+
+try:
+ import yaml
+# pylint: disable=broad-except
+except Exception:
+ pass
+
+
+def hook_pre_exec_pyyaml_load(stream, loader):
+ """Hook for pyyaml.load_yaml.
+
+ Exits if the loader is unsafe or vanilla loader and the stream passed
+ to the loader is controlled by the fuzz data
+ """
+ # Ensure loader is the unsafe loader or vanilla loader
+ if loader not in (yaml.loader.Loader, yaml.loader.UnsafeLoader):
+ return
+
+ # Check for exact taint in stream
+ if sanlib.is_exact_taint(stream):
+ msg = (
+ 'Yaml deserialization issue.\n'
+ 'Unsafe deserialization can be used to execute arbitrary commands.\n')
+ sanlib.abort_with_issue(msg, 'Yaml deserialisation')
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/setup.py b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..d54eeb94c4af3ee12d1ca47e994892566c65a3b0
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/setup.py
@@ -0,0 +1,21 @@
+# Copyright 2022 Google LLC
+#
+# 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.
+"""Config for installing python as package."""
+from setuptools import setup, find_packages
+
+setup(name='pysecsan',
+ version='0.1',
+ author='David Korczynski',
+ author_email='david@adalogics.com',
+ packages=find_packages(exclude='tests'))
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/yaml_deserialization_general.py b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/yaml_deserialization_general.py
new file mode 100644
index 0000000000000000000000000000000000000000..6581acede3f00ee595c4c849c69791b489e1e3b5
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/yaml_deserialization_general.py
@@ -0,0 +1,47 @@
+#!/usr/bin/python3
+# Copyright 2022 Google LLC
+#
+# 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.
+"""Fuzzer for insecure yaml deserialization."""
+
+import sys
+import yaml
+import atheris
+import pysecsan
+
+
+def serialize_with_tainted_data(param):
+ """Hit insecure yaml function."""
+ try:
+ yaml.load(param, yaml.Loader)
+ except yaml.YAMLError:
+ pass
+
+
+def test_one_input(data):
+ """Fuzzer routine."""
+ fdp = atheris.FuzzedDataProvider(data)
+ serialize_with_tainted_data(fdp.ConsumeUnicodeNoSurrogates(32))
+
+
+def main():
+ """Set up and start fuzzing."""
+ pysecsan.add_hooks()
+
+ atheris.instrument_all()
+ atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+ atheris.Fuzz()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-clang/Dockerfile b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-clang/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..959b4d430de1e2db53c6f181ee519ce84c1d126c
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-clang/Dockerfile
@@ -0,0 +1,79 @@
+# Copyright 2016 Google Inc.
+#
+# 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.
+#
+################################################################################
+
+# Docker image with clang installed.
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-image:${IMG_TAG}
+
+ARG arch=x86_64
+
+ENV FUZZINTRO_OUTDIR=$SRC
+
+# Install newer cmake.
+# Many projects, as well as recent clang versions, need a newer cmake.
+ENV CMAKE_VERSION 3.29.2
+RUN apt-get update && apt-get install -y wget sudo && \
+ wget -q https://github.com/Kitware/CMake/releases/download/v$CMAKE_VERSION/cmake-$CMAKE_VERSION-Linux-$arch.sh && \
+ chmod +x cmake-$CMAKE_VERSION-Linux-$arch.sh && \
+ ./cmake-$CMAKE_VERSION-Linux-$arch.sh --skip-license --prefix="/usr/local" && \
+ rm cmake-$CMAKE_VERSION-Linux-$arch.sh && \
+ SUDO_FORCE_REMOVE=yes apt-get autoremove --purge -y wget sudo && \
+ rm -rf /usr/local/doc/cmake /usr/local/bin/cmake-gui
+
+RUN apt-get update && apt-get install -y git && \
+ git clone https://github.com/ossf/fuzz-introspector.git fuzz-introspector && \
+ cd fuzz-introspector && \
+ git checkout f9bcb8824a18d60d57e2430c5b43f525d811cae8 && \
+ git submodule init && \
+ git submodule update && \
+ apt-get autoremove --purge -y git && \
+ rm -rf .git
+
+COPY checkout_build_install_llvm.sh /root/
+# Keep all steps in the same script to decrease the number of intermediate
+# layes in docker file.
+RUN /root/checkout_build_install_llvm.sh
+RUN rm /root/checkout_build_install_llvm.sh
+
+# Setup the environment.
+ENV CC "clang"
+ENV CXX "clang++"
+ENV CCC "clang++"
+
+# FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION is described at
+# https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode
+
+# The implicit-function-declaration and implicit-int errors are downgraded to a
+# warning, to allow compiling legacy code.
+# See https://releases.llvm.org/16.0.0/tools/clang/docs/ReleaseNotes.html#potentially-breaking-changes
+# Same for deprecated-declarations, int-conversion,
+# incompatible-function-pointer-types, enum-constexpr-conversion,
+# vla-cxx-extension
+
+ENV CFLAGS -O1 \
+ -fno-omit-frame-pointer \
+ -gline-tables-only \
+ -Wno-error=enum-constexpr-conversion \
+ -Wno-error=incompatible-function-pointer-types \
+ -Wno-error=int-conversion \
+ -Wno-error=deprecated-declarations \
+ -Wno-error=implicit-function-declaration \
+ -Wno-error=implicit-int \
+ -Wno-error=vla-cxx-extension \
+ -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+ENV CXXFLAGS_EXTRA "-stdlib=libc++"
+ENV CXXFLAGS "$CFLAGS $CXXFLAGS_EXTRA"
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-clang/checkout_build_install_llvm.sh b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-clang/checkout_build_install_llvm.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e5ab30d04a4c38a29855785b83a2f03be56c897f
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-clang/checkout_build_install_llvm.sh
@@ -0,0 +1,246 @@
+#!/bin/bash -eux
+# Copyright 2016 Google Inc.
+#
+# 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.
+#
+################################################################################
+
+NPROC=$(nproc)
+
+TARGET_TO_BUILD=
+case $(uname -m) in
+ x86_64)
+ TARGET_TO_BUILD=X86
+ ARCHITECTURE_DEPS="g++-multilib"
+ # Use chromium's clang revision.
+ export CC=$WORK/llvm-stage1/bin/clang
+ export CXX=$WORK/llvm-stage1/bin/clang++
+ ;;
+ aarch64)
+ TARGET_TO_BUILD=AArch64
+ # g++ multilib is not needed on AArch64 because we don't care about i386.
+ # We need to install clang and lld using apt because the binary downloaded
+ # from Chrome's developer tools doesn't support AArch64.
+ # TODO(metzman): Make x86_64 use the distro's clang for consistency once
+ # we support AArch64 fully.
+ ARCHITECTURE_DEPS="clang lld g++"
+ export CC=clang
+ export CXX=clang++
+ ;;
+ *)
+ echo "Error: unsupported target $(uname -m)"
+ exit 1
+ ;;
+esac
+
+INTROSPECTOR_DEP_PACKAGES="texinfo bison flex"
+# zlib1g-dev is needed for llvm-profdata to handle coverage data from rust compiler
+LLVM_DEP_PACKAGES="build-essential make ninja-build git python3 python3-distutils binutils-dev zlib1g-dev $ARCHITECTURE_DEPS $INTROSPECTOR_DEP_PACKAGES"
+
+apt-get update && apt-get install -y $LLVM_DEP_PACKAGES --no-install-recommends
+
+# For manual bumping.
+# On each bump a full trial run for everything (fuzzing engines, sanitizers,
+# languages, projects, ...) is needed.
+# Check CMAKE_VERSION infra/base-images/base-clang/Dockerfile was released
+# recently enough to fully support this clang version.
+OUR_LLVM_REVISION=llvmorg-18.1.8
+
+mkdir $SRC/chromium_tools
+cd $SRC/chromium_tools
+git clone https://chromium.googlesource.com/chromium/src/tools/clang
+cd clang
+# Pin clang script due to https://github.com/google/oss-fuzz/issues/7617
+git checkout 9eb79319239629c1b23cf7a59e5ebb2bab319a34
+
+LLVM_SRC=$SRC/llvm-project
+# Checkout
+CHECKOUT_RETRIES=10
+function clone_with_retries {
+ REPOSITORY=$1
+ LOCAL_PATH=$2
+ CHECKOUT_RETURN_CODE=1
+
+ # Disable exit on error since we might encounter some failures while retrying.
+ set +e
+ for i in $(seq 1 $CHECKOUT_RETRIES); do
+ rm -rf $LOCAL_PATH
+ git clone $REPOSITORY $LOCAL_PATH
+ CHECKOUT_RETURN_CODE=$?
+ if [ $CHECKOUT_RETURN_CODE -eq 0 ]; then
+ break
+ fi
+ done
+
+ # Re-enable exit on error. If checkout failed, script will exit.
+ set -e
+ return $CHECKOUT_RETURN_CODE
+}
+clone_with_retries https://github.com/llvm/llvm-project.git $LLVM_SRC
+
+git -C $LLVM_SRC checkout $OUR_LLVM_REVISION
+echo "Using LLVM revision: $OUR_LLVM_REVISION"
+
+# For fuzz introspector.
+echo "Applying introspector changes"
+OLD_WORKING_DIR=$PWD
+cd $LLVM_SRC
+cp -rf /fuzz-introspector/frontends/llvm/include/llvm/Transforms/FuzzIntrospector/ ./llvm/include/llvm/Transforms/FuzzIntrospector
+cp -rf /fuzz-introspector/frontends/llvm/lib/Transforms/FuzzIntrospector ./llvm/lib/Transforms/FuzzIntrospector
+
+# LLVM currently does not support dynamically loading LTO passes. Thus, we
+# hardcode it into Clang instead. Ref: https://reviews.llvm.org/D77704
+/fuzz-introspector/frontends/llvm/patch-llvm.sh
+cd $OLD_WORKING_DIR
+
+mkdir -p $WORK/llvm-stage2 $WORK/llvm-stage1
+python3 $SRC/chromium_tools/clang/scripts/update.py --output-dir $WORK/llvm-stage1
+
+cd $WORK/llvm-stage2
+cmake -G "Ninja" \
+ -DLIBCXX_ENABLE_SHARED=OFF \
+ -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON \
+ -DLIBCXXABI_ENABLE_SHARED=OFF \
+ -DCMAKE_BUILD_TYPE=Release \
+ -DLLVM_ENABLE_RUNTIMES="compiler-rt;libcxx;libcxxabi" \
+ -DLLVM_TARGETS_TO_BUILD="$TARGET_TO_BUILD" \
+ -DLLVM_ENABLE_PROJECTS="clang;lld" \
+ -DLLVM_BINUTILS_INCDIR="/usr/include/" \
+ -DLIBCXXABI_USE_LLVM_UNWINDER=OFF \
+ $LLVM_SRC/llvm
+
+ninja -j $NPROC
+ninja install
+rm -rf $WORK/llvm-stage1 $WORK/llvm-stage2
+
+# libFuzzer sources.
+cp -r $LLVM_SRC/compiler-rt/lib/fuzzer $SRC/libfuzzer
+
+# Use the clang we just built from now on.
+export CC=clang
+export CXX=clang++
+
+function free_disk_space {
+ rm -rf $LLVM_SRC $SRC/chromium_tools
+ apt-get autoremove --purge -y $LLVM_DEP_PACKAGES
+ # Delete unneeded parts of LLVM to reduce image size.
+ # See https://github.com/google/oss-fuzz/issues/5170
+ LLVM_TOOLS_TMPDIR=/tmp/llvm-tools
+ mkdir $LLVM_TOOLS_TMPDIR
+ # Move binaries with llvm- prefix that we want into LLVM_TOOLS_TMPDIR.
+ mv \
+ /usr/local/bin/llvm-ar \
+ /usr/local/bin/llvm-as \
+ /usr/local/bin/llvm-config \
+ /usr/local/bin/llvm-cov \
+ /usr/local/bin/llvm-objcopy \
+ /usr/local/bin/llvm-nm \
+ /usr/local/bin/llvm-profdata \
+ /usr/local/bin/llvm-ranlib \
+ /usr/local/bin/llvm-symbolizer \
+ /usr/local/bin/llvm-undname \
+ $LLVM_TOOLS_TMPDIR
+
+ # Delete remaining llvm- binaries.
+ rm -rf /usr/local/bin/llvm-*
+
+ # Restore the llvm- binaries we want to keep.
+ mv $LLVM_TOOLS_TMPDIR/* /usr/local/bin/
+ rm -rf $LLVM_TOOLS_TMPDIR
+
+ # Remove binaries from LLVM build that we don't need.
+ rm -f \
+ /usr/local/bin/bugpoint \
+ /usr/local/bin/llc \
+ /usr/local/bin/lli \
+ /usr/local/bin/clang-check \
+ /usr/local/bin/clang-refactor \
+ /usr/local/bin/clang-offload-wrapper \
+ /usr/local/bin/clang-offload-bundler \
+ /usr/local/bin/clang-repl \
+ /usr/local/bin/clang-check \
+ /usr/local/bin/clang-refactor \
+ /usr/local/bin/c-index-test \
+ /usr/local/bin/clang-rename \
+ /usr/local/bin/clang-scan-deps \
+ /usr/local/bin/clang-extdef-mapping \
+ /usr/local/bin/diagtool \
+ /usr/local/bin/sanstats \
+ /usr/local/bin/dsymutil \
+ /usr/local/bin/verify-uselistorder \
+ /usr/local/bin/clang-format
+
+ # Remove unneeded clang libs, CMake files from LLVM build, lld libs, and the
+ # libraries.
+ # Note: we need fuzzer_no_main libraries for atheris. Don't delete.
+ rm -rf \
+ /usr/local/lib/libclang* \
+ /usr/local/lib/liblld* \
+ /usr/local/lib/cmake/
+}
+
+if [ "$TARGET_TO_BUILD" == "AArch64" ]
+then
+ free_disk_space
+ # Exit now on AArch64. We don't need to rebuild libc++ because on AArch64 we
+ # do not support MSAN nor do we care about i386.
+ exit 0
+fi
+
+function cmake_libcxx {
+ extra_args="$@"
+ cmake -G "Ninja" \
+ -DLIBCXX_ENABLE_SHARED=OFF \
+ -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON \
+ -DLIBCXXABI_ENABLE_SHARED=OFF \
+ -DLIBCXXABI_USE_LLVM_UNWINDER=OFF \
+ -DCMAKE_BUILD_TYPE=Release \
+ -DLLVM_ENABLE_PIC=ON \
+ -DLLVM_TARGETS_TO_BUILD="$TARGET_TO_BUILD" \
+ -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi" \
+ -DLLVM_BINUTILS_INCDIR="/usr/include/" \
+ $extra_args \
+ -S $LLVM_SRC/runtimes
+}
+
+# 32-bit libraries.
+mkdir -p $WORK/i386
+cd $WORK/i386
+cmake_libcxx \
+ -DCMAKE_INSTALL_PREFIX=/usr/i386/ \
+ -DCMAKE_C_FLAGS="-m32" \
+ -DCMAKE_CXX_FLAGS="-m32"
+
+ninja -j $NPROC cxx
+ninja install-cxx
+rm -rf $WORK/i386
+
+# MemorySanitizer instrumented libraries.
+mkdir -p $WORK/msan
+cd $WORK/msan
+
+# https://github.com/google/oss-fuzz/issues/1099
+cat < $WORK/msan/ignorelist.txt
+fun:__gxx_personality_*
+EOF
+
+cmake_libcxx \
+ -DLLVM_USE_SANITIZER=Memory \
+ -DCMAKE_INSTALL_PREFIX=/usr/msan/ \
+ -DCMAKE_CXX_FLAGS="-fsanitize-ignorelist=$WORK/msan/ignorelist.txt"
+
+ninja -j $NPROC cxx
+ninja install-cxx
+rm -rf $WORK/msan
+
+free_disk_space
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/actions/build_fuzzers/action.yml b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/actions/build_fuzzers/action.yml
new file mode 100644
index 0000000000000000000000000000000000000000..164c890e91849dc1374c71f0320896f098c5ad97
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/actions/build_fuzzers/action.yml
@@ -0,0 +1,55 @@
+# action.yml
+name: 'build-fuzzers'
+description: "Builds an OSS-Fuzz project's fuzzers."
+inputs:
+ oss-fuzz-project-name:
+ description: 'Name of the corresponding OSS-Fuzz project.'
+ required: true
+ language:
+ description: 'Programming language project is written in.'
+ required: false
+ default: 'c++'
+ dry-run:
+ description: 'If set, run the action without actually reporting a failure.'
+ default: false
+ allowed-broken-targets-percentage:
+ description: 'The percentage of broken targets allowed in bad_build_check.'
+ required: false
+ sanitizer:
+ description: 'The sanitizer to build the fuzzers with.'
+ default: 'address'
+ architecture:
+ description: 'The architecture used to build the fuzzers.'
+ default: 'x86_64'
+ project-src-path:
+ description: "The path to the project's source code checkout."
+ required: false
+ bad-build-check:
+ description: "Whether or not OSS-Fuzz's check for bad builds should be done."
+ required: false
+ default: true
+ keep-unaffected-fuzz-targets:
+ description: "Whether to keep unaffected fuzzers or delete them."
+ required: false
+ default: false
+ output-sarif:
+ description: "Whether to output fuzzing results to SARIF."
+ required: false
+ default: false
+runs:
+ using: 'docker'
+ image: '../../../build_fuzzers.Dockerfile'
+ env:
+ OSS_FUZZ_PROJECT_NAME: ${{ inputs.oss-fuzz-project-name }}
+ LANGUAGE: ${{ inputs.language }}
+ DRY_RUN: ${{ inputs.dry-run}}
+ ALLOWED_BROKEN_TARGETS_PERCENTAGE: ${{ inputs.allowed-broken-targets-percentage}}
+ SANITIZER: ${{ inputs.sanitizer }}
+ ARCHITECTURE: ${{ inputs.architecture }}
+ PROJECT_SRC_PATH: ${{ inputs.project-src-path }}
+ LOW_DISK_SPACE: 'True'
+ BAD_BUILD_CHECK: ${{ inputs.bad-build-check }}
+ CIFUZZ_DEBUG: 'True'
+ CFL_PLATFORM: 'github'
+ KEEP_UNAFFECTED_FUZZ_TARGETS: ${{ inputs.keep-unaffected-fuzz-targets }}
+ OUTPUT_SARIF: ${{ inputs.output-sarif }}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/cifuzz-base/Dockerfile b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/cifuzz-base/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..6f3ada4f2762c6e6ddf058b6be9a67b31c154594
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/cifuzz-base/Dockerfile
@@ -0,0 +1,44 @@
+# Copyright 2020 Google LLC
+#
+# 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.
+#
+################################################################################
+
+FROM ghcr.io/aixcc-finals/base-runner
+
+RUN apt-get update && \
+ apt-get install -y systemd && \
+ wget https://download.docker.com/linux/ubuntu/dists/focal/pool/stable/amd64/docker-ce-cli_20.10.8~3-0~ubuntu-focal_amd64.deb -O /tmp/docker-ce.deb && \
+ dpkg -i /tmp/docker-ce.deb && \
+ rm /tmp/docker-ce.deb
+
+ENV PATH=/opt/gcloud/google-cloud-sdk/bin/:$PATH
+ENV OSS_FUZZ_ROOT=/opt/oss-fuzz
+
+# Do this step before copying to make rebuilding faster when developing.
+COPY ./infra/cifuzz/requirements.txt /tmp/requirements.txt
+RUN python3 -m pip install -r /tmp/requirements.txt && rm /tmp/requirements.txt
+
+ADD . ${OSS_FUZZ_ROOT}
+# Don't use the default npm location since jazzer.js can break us.
+# This means javascript needed by cifuzz/clusterfuzzlite must be executed in
+# OSS_FUZZ_ROOT.
+RUN cd ${OSS_FUZZ_ROOT} && npm install ${OSS_FUZZ_ROOT}/infra/cifuzz
+
+
+ENV PYTHONUNBUFFERED=1
+
+# Python file to execute when the docker container starts up.
+# We can't use the env var $OSS_FUZZ_ROOT here. Since it's a constant env var,
+# just expand to '/opt/oss-fuzz'.
+ENTRYPOINT ["python3", "/opt/oss-fuzz/infra/cifuzz/cifuzz_combined_entrypoint.py"]
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/cloudbuild.yaml b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/cloudbuild.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..03b1961e50ff9c701133753e918179177323726e
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/cloudbuild.yaml
@@ -0,0 +1,52 @@
+# TODO(metzman): Get rid of cifuzz-build-fuzzers and cifuzz-run-fuzzers.
+steps:
+- name: 'gcr.io/cloud-builders/docker'
+ args:
+ - build
+ - '-t'
+ - ghcr.io/aixcc-finals/cifuzz-base
+ - '-t'
+ - ghcr.io/aixcc-finals/cifuzz-base:v1
+ - '-f'
+ - infra/cifuzz/cifuzz-base/Dockerfile
+ - .
+- name: 'gcr.io/cloud-builders/docker'
+ args:
+ - build
+ - '-t'
+ - ghcr.io/aixcc-finals/cifuzz-build-fuzzers
+ - '-t'
+ - ghcr.io/aixcc-finals/cifuzz-build-fuzzers:v1
+ - '-t'
+ - ghcr.io/aixcc-finals/clusterfuzzlite-build-fuzzers
+ - '-t'
+ - ghcr.io/aixcc-finals/clusterfuzzlite-build-fuzzers:v1
+ - '-f'
+ - infra/build_fuzzers.Dockerfile
+ - infra
+- name: 'gcr.io/cloud-builders/docker'
+ args:
+ - build
+ - '-t'
+ - ghcr.io/aixcc-finals/cifuzz-run-fuzzers
+ - '-t'
+ - ghcr.io/aixcc-finals/cifuzz-run-fuzzers:v1
+ - '-t'
+ - ghcr.io/aixcc-finals/clusterfuzzlite-run-fuzzers
+ - '-t'
+ - ghcr.io/aixcc-finals/clusterfuzzlite-run-fuzzers:v1
+ - '-f'
+ - infra/run_fuzzers.Dockerfile
+ - infra
+images:
+- ghcr.io/aixcc-finals/cifuzz-base
+- ghcr.io/aixcc-finals/cifuzz-base:v1
+- ghcr.io/aixcc-finals/cifuzz-run-fuzzers
+- ghcr.io/aixcc-finals/cifuzz-run-fuzzers:v1
+- ghcr.io/aixcc-finals/cifuzz-build-fuzzers
+- ghcr.io/aixcc-finals/cifuzz-build-fuzzers:v1
+- ghcr.io/aixcc-finals/clusterfuzzlite-build-fuzzers
+- ghcr.io/aixcc-finals/clusterfuzzlite-build-fuzzers:v1
+- ghcr.io/aixcc-finals/clusterfuzzlite-run-fuzzers
+- ghcr.io/aixcc-finals/clusterfuzzlite-run-fuzzers:v1
+timeout: 1800s
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/clusterfuzz_deployment_test.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/clusterfuzz_deployment_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..31c7b03ecb82dbaed32681ba8a94c61044a67e28
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/clusterfuzz_deployment_test.py
@@ -0,0 +1,268 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Tests for clusterfuzz_deployment.py"""
+
+import os
+import unittest
+from unittest import mock
+
+import parameterized
+from pyfakefs import fake_filesystem_unittest
+
+import clusterfuzz_deployment
+import config_utils
+import test_helpers
+import workspace_utils
+
+# NOTE: This integration test relies on
+# https://github.com/google/oss-fuzz/tree/master/projects/example project.
+EXAMPLE_PROJECT = 'example'
+
+# An example fuzzer that triggers an error.
+EXAMPLE_FUZZER = 'example_crash_fuzzer'
+
+WORKSPACE = '/workspace'
+EXPECTED_LATEST_BUILD_PATH = os.path.join(WORKSPACE, 'cifuzz-prev-build')
+
+# pylint: disable=unused-argument
+
+
+def _create_config(**kwargs):
+ """Creates a config object and then sets every attribute that is a key in
+ |kwargs| to the corresponding value. Asserts that each key in |kwargs| is an
+ attribute of Config."""
+ defaults = {
+ 'cfl_platform': 'github',
+ 'oss_fuzz_project_name': EXAMPLE_PROJECT,
+ 'workspace': WORKSPACE,
+ }
+ for default_key, default_value in defaults.items():
+ if default_key not in kwargs:
+ kwargs[default_key] = default_value
+
+ return test_helpers.create_run_config(**kwargs)
+
+
+def _create_deployment(**kwargs):
+ config = _create_config(**kwargs)
+ workspace = workspace_utils.Workspace(config)
+ return clusterfuzz_deployment.get_clusterfuzz_deployment(config, workspace)
+
+
+class OSSFuzzTest(fake_filesystem_unittest.TestCase):
+ """Tests OSSFuzz."""
+
+ def setUp(self):
+ self.setUpPyfakefs()
+ self.deployment = _create_deployment()
+ self.corpus_dir = os.path.join(self.deployment.workspace.corpora,
+ EXAMPLE_FUZZER)
+
+ @mock.patch('http_utils.download_and_unpack_zip', return_value=True)
+ def test_download_corpus(self, mock_download_and_unpack_zip):
+ """Tests that we can download a corpus for a valid project."""
+ self.deployment.download_corpus(EXAMPLE_FUZZER, self.corpus_dir)
+ expected_url = ('https://storage.googleapis.com/example-backup.'
+ 'clusterfuzz-external.appspot.com/corpus/libFuzzer/'
+ 'example_crash_fuzzer/public.zip')
+ call_args, _ = mock_download_and_unpack_zip.call_args
+ self.assertEqual(call_args, (expected_url, self.corpus_dir))
+ self.assertTrue(os.path.exists(self.corpus_dir))
+
+ @mock.patch('http_utils.download_and_unpack_zip', return_value=False)
+ def test_download_corpus_fail(self, _):
+ """Tests that when downloading fails, an empty corpus directory is still
+ returned."""
+ self.deployment.download_corpus(EXAMPLE_FUZZER, self.corpus_dir)
+ self.assertEqual(os.listdir(self.corpus_dir), [])
+
+ def test_get_latest_build_name(self):
+ """Tests that the latest build name can be retrieved from GCS."""
+ latest_build_name = self.deployment.get_latest_build_name()
+ self.assertTrue(latest_build_name.endswith('.zip'))
+ self.assertTrue('address' in latest_build_name)
+
+ @parameterized.parameterized.expand([
+ ('upload_build', ('commit',),
+ 'Not uploading latest build because on OSS-Fuzz.'),
+ ('upload_corpus', ('target', 'corpus-dir'),
+ 'Not uploading corpus because on OSS-Fuzz.'),
+ ('upload_crashes', tuple(), 'Not uploading crashes because on OSS-Fuzz.'),
+ ])
+ def test_noop_methods(self, method, method_args, expected_message):
+ """Tests that certain methods are noops for OSS-Fuzz."""
+ with mock.patch('logging.info') as mock_info:
+ method = getattr(self.deployment, method)
+ self.assertIsNone(method(*method_args))
+ mock_info.assert_called_with(expected_message)
+
+ @mock.patch('http_utils.download_and_unpack_zip', return_value=True)
+ def test_download_latest_build(self, mock_download_and_unpack_zip):
+ """Tests that downloading the latest build works as intended under normal
+ circumstances."""
+ self.assertEqual(self.deployment.download_latest_build(),
+ EXPECTED_LATEST_BUILD_PATH)
+ expected_url = ('https://storage.googleapis.com/clusterfuzz-builds/example/'
+ 'example-address-202008030600.zip')
+ mock_download_and_unpack_zip.assert_called_with(expected_url,
+ EXPECTED_LATEST_BUILD_PATH)
+
+ @mock.patch('http_utils.download_and_unpack_zip', return_value=False)
+ def test_download_latest_build_fail(self, _):
+ """Tests that download_latest_build returns None when it fails to download a
+ build."""
+ self.assertIsNone(self.deployment.download_latest_build())
+
+
+class ClusterFuzzLiteTest(fake_filesystem_unittest.TestCase):
+ """Tests for ClusterFuzzLite."""
+
+ def setUp(self):
+ self.setUpPyfakefs()
+ self.deployment = _create_deployment(mode='batch',
+ oss_fuzz_project_name='',
+ cloud_bucket='gs://bucket')
+ self.corpus_dir = os.path.join(self.deployment.workspace.corpora,
+ EXAMPLE_FUZZER)
+
+ @mock.patch('filestore.github_actions.GithubActionsFilestore.download_corpus',
+ return_value=True)
+ def test_download_corpus(self, mock_download_corpus):
+ """Tests that download_corpus works for a valid project."""
+ self.deployment.download_corpus(EXAMPLE_FUZZER, self.corpus_dir)
+ mock_download_corpus.assert_called_with('example_crash_fuzzer',
+ self.corpus_dir)
+ self.assertTrue(os.path.exists(self.corpus_dir))
+
+ @mock.patch('filestore.github_actions.GithubActionsFilestore.download_corpus',
+ side_effect=Exception)
+ def test_download_corpus_fail(self, _):
+ """Tests that when downloading fails, an empty corpus directory is still
+ returned."""
+ self.deployment.download_corpus(EXAMPLE_FUZZER, self.corpus_dir)
+ self.assertEqual(os.listdir(self.corpus_dir), [])
+
+ @mock.patch('filestore.github_actions.GithubActionsFilestore.download_build',
+ side_effect=[False, True])
+ @mock.patch('repo_manager.RepoManager.get_commit_list',
+ return_value=['commit1', 'commit2'])
+ @mock.patch('continuous_integration.GithubCiMixin.repo_dir',
+ return_value='/path/to/repo')
+ def test_download_latest_build(self, mock_repo_dir, mock_get_commit_list,
+ mock_download_build):
+ """Tests that downloading the latest build works as intended under normal
+ circumstances."""
+ self.assertEqual(self.deployment.download_latest_build(),
+ EXPECTED_LATEST_BUILD_PATH)
+ expected_artifact_name = 'address-commit2'
+ mock_download_build.assert_called_with(expected_artifact_name,
+ EXPECTED_LATEST_BUILD_PATH)
+
+ @mock.patch('filestore.github_actions.GithubActionsFilestore.download_build',
+ side_effect=Exception)
+ @mock.patch('repo_manager.RepoManager.get_commit_list',
+ return_value=['commit1', 'commit2'])
+ @mock.patch('continuous_integration.GithubCiMixin.repo_dir',
+ return_value='/path/to/repo')
+ def test_download_latest_build_fail(self, mock_repo_dir, mock_get_commit_list,
+ _):
+ """Tests that download_latest_build returns None when it fails to download a
+ build."""
+ self.assertIsNone(self.deployment.download_latest_build())
+
+ @mock.patch('filestore.github_actions.GithubActionsFilestore.upload_build')
+ def test_upload_build(self, mock_upload_build):
+ """Tests that upload_build works as intended."""
+ self.deployment.upload_build('commit')
+ mock_upload_build.assert_called_with('address-commit',
+ '/workspace/build-out')
+
+
+class NoClusterFuzzDeploymentTest(fake_filesystem_unittest.TestCase):
+ """Tests for NoClusterFuzzDeployment."""
+
+ def setUp(self):
+ self.setUpPyfakefs()
+ config = test_helpers.create_run_config(workspace=WORKSPACE,
+ cfl_platform='other',
+ filestore='no_filestore',
+ no_clusterfuzz_deployment=True)
+ workspace = workspace_utils.Workspace(config)
+ self.deployment = clusterfuzz_deployment.get_clusterfuzz_deployment(
+ config, workspace)
+
+ self.corpus_dir = os.path.join(workspace.corpora, EXAMPLE_FUZZER)
+
+ @mock.patch('logging.info')
+ def test_download_corpus(self, mock_info):
+ """Tests that download corpus returns the path to the empty corpus
+ directory."""
+ self.deployment.download_corpus(EXAMPLE_FUZZER, self.corpus_dir)
+ mock_info.assert_called_with(
+ 'Not downloading corpus because no ClusterFuzz deployment.')
+ self.assertTrue(os.path.exists(self.corpus_dir))
+
+ @parameterized.parameterized.expand([
+ ('upload_build', ('commit',),
+ 'Not uploading latest build because no ClusterFuzz deployment.'),
+ ('upload_corpus', ('target', 'corpus-dir'),
+ 'Not uploading corpus because no ClusterFuzz deployment.'),
+ ('upload_crashes', tuple(),
+ 'Not uploading crashes because no ClusterFuzz deployment.'),
+ ('download_latest_build', tuple(),
+ 'Not downloading latest build because no ClusterFuzz deployment.')
+ ])
+ def test_noop_methods(self, method, method_args, expected_message):
+ """Tests that certain methods are noops for NoClusterFuzzDeployment."""
+ with mock.patch('logging.info') as mock_info:
+ method = getattr(self.deployment, method)
+ self.assertIsNone(method(*method_args))
+ mock_info.assert_called_with(expected_message)
+
+
+class GetClusterFuzzDeploymentTest(unittest.TestCase):
+ """Tests for get_clusterfuzz_deployment."""
+
+ def setUp(self):
+ test_helpers.patch_environ(self)
+ os.environ['GITHUB_REPOSITORY'] = 'owner/myproject'
+
+ @parameterized.parameterized.expand([
+ (config_utils.BaseConfig.Platform.INTERNAL_GENERIC_CI,
+ clusterfuzz_deployment.OSSFuzz),
+ (config_utils.BaseConfig.Platform.INTERNAL_GITHUB,
+ clusterfuzz_deployment.OSSFuzz),
+ (config_utils.BaseConfig.Platform.EXTERNAL_GENERIC_CI,
+ clusterfuzz_deployment.ClusterFuzzLite),
+ (config_utils.BaseConfig.Platform.EXTERNAL_GITHUB,
+ clusterfuzz_deployment.ClusterFuzzLite),
+ ])
+ def test_get_clusterfuzz_deployment(self, platform, expected_deployment_cls):
+ """Tests that get_clusterfuzz_deployment returns the correct value."""
+ with mock.patch('config_utils.BaseConfig.platform',
+ return_value=platform,
+ new_callable=mock.PropertyMock):
+ with mock.patch('filestore_utils.get_filestore', return_value=None):
+ with mock.patch('platform_config.github._get_event_data',
+ return_value={}):
+ config = _create_config()
+ workspace = workspace_utils.Workspace(config)
+
+ self.assertIsInstance(
+ clusterfuzz_deployment.get_clusterfuzz_deployment(
+ config, workspace), expected_deployment_cls)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/config_utils.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/config_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4a3cb8f7ad9265f3eaaac9af4a810d412e3fc00
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/config_utils.py
@@ -0,0 +1,283 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Module for getting the configuration CIFuzz needs to run."""
+
+import enum
+import importlib
+import logging
+import os
+import sys
+
+import environment
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import platform_config
+import constants
+
+SANITIZERS = ['address', 'memory', 'undefined', 'coverage']
+
+# TODO(metzman): Set these on config objects so there's one source of truth.
+DEFAULT_ENGINE = 'libfuzzer'
+
+# This module deals a lot with env variables. Many of these will be set by users
+# and others beyond CIFuzz's control. Thus, you should be careful about using
+# the environment.py helpers for getting env vars, since it can cause values
+# that should be interpreted as strings to be returned as other types (bools or
+# ints for example). The environment.py helpers should not be used for values
+# that are supposed to be strings.
+
+
+def _get_sanitizer():
+ return os.getenv('SANITIZER', constants.DEFAULT_SANITIZER).lower()
+
+
+def _get_architecture():
+ return os.getenv('ARCHITECTURE', constants.DEFAULT_ARCHITECTURE).lower()
+
+
+def _is_dry_run():
+ """Returns True if configured to do a dry run."""
+ return environment.get_bool('DRY_RUN', False)
+
+
+def _get_language():
+ """Returns the project language."""
+ # Get language from environment. We took this approach because the convenience
+ # given to OSS-Fuzz users by not making them specify the language again (and
+ # getting it from the project.yaml) is outweighed by the complexity in
+ # implementing this. A lot of the complexity comes from our unittests not
+ # setting a proper projet at this point.
+ return os.getenv('LANGUAGE', constants.DEFAULT_LANGUAGE)
+
+
+def _get_extra_environment_variables():
+ """Gets extra environment variables specified by the user with
+ CFL_EXTRA_$NAME=$VALUE."""
+ return [key for key in os.environ if key.startswith('CFL_EXTRA_')]
+
+
+# pylint: disable=too-many-instance-attributes
+
+
+class ConfigError(Exception):
+ """Error for invalid configuration."""
+
+
+class BaseConfig:
+ """Object containing constant configuration for CIFuzz."""
+
+ class Platform(enum.Enum):
+ """Enum representing the different platforms CIFuzz runs on."""
+ EXTERNAL_GITHUB = 0 # Non-OSS-Fuzz on GitHub actions.
+ INTERNAL_GITHUB = 1 # OSS-Fuzz on GitHub actions.
+ INTERNAL_GENERIC_CI = 2 # OSS-Fuzz on any CI.
+ EXTERNAL_GENERIC_CI = 3 # Non-OSS-Fuzz on any CI.
+
+ @property
+ def is_github(self):
+ """Returns True if running on GitHub."""
+ return self.cfl_platform == 'github'
+
+ def __init__(self):
+ # Need to set these before calling self.platform.
+ self.oss_fuzz_project_name = os.getenv('OSS_FUZZ_PROJECT_NAME')
+ self.cfl_platform = os.getenv('CFL_PLATFORM')
+ logging.debug('Is github: %s.', self.is_github)
+
+ self.platform_conf = _get_platform_config(self.cfl_platform)
+ self.base_commit = self.platform_conf.base_commit
+ self.base_ref = self.platform_conf.base_ref
+ self.pr_ref = self.platform_conf.pr_ref
+ self.workspace = self.platform_conf.workspace
+ self.project_src_path = self.platform_conf.project_src_path
+ self.actor = self.platform_conf.actor
+ self.token = self.platform_conf.token
+ self.project_repo_owner = self.platform_conf.project_repo_owner
+ self.project_repo_name = self.platform_conf.project_repo_name
+ self.filestore = self.platform_conf.filestore
+
+ # This determines if builds are done using docker in docker
+ # rather than the normal method which is sibling containers.
+ self.docker_in_docker = self.platform_conf.docker_in_docker
+
+ self.dry_run = _is_dry_run() # Check if failures should not be reported.
+ self.sanitizer = _get_sanitizer()
+ self.architecture = _get_architecture()
+ self.language = _get_language()
+ self.low_disk_space = environment.get_bool('LOW_DISK_SPACE', False)
+
+ self.git_store_repo = os.environ.get('GIT_STORE_REPO')
+ self.git_store_branch = os.environ.get('GIT_STORE_BRANCH')
+ self.git_store_branch_coverage = os.environ.get('GIT_STORE_BRANCH_COVERAGE',
+ self.git_store_branch)
+ self.cloud_bucket = os.environ.get('CLOUD_BUCKET')
+ self.no_clusterfuzz_deployment = environment.get_bool(
+ 'NO_CLUSTERFUZZ_DEPLOYMENT', False)
+ self.build_integration_path = (
+ constants.DEFAULT_EXTERNAL_BUILD_INTEGRATION_PATH)
+
+ self.parallel_fuzzing = environment.get_bool('PARALLEL_FUZZING', False)
+ self.extra_environment_variables = _get_extra_environment_variables()
+ self.output_sarif = environment.get_bool('OUTPUT_SARIF', False)
+
+ # TODO(metzman): Fix tests to create valid configurations and get rid of
+ # CIFUZZ_TEST here and in presubmit.py.
+ if not os.getenv('CIFUZZ_TEST') and not self.validate():
+ raise ConfigError('Invalid Configuration.')
+
+ def validate(self):
+ """Returns False if the configuration is invalid."""
+ # Do validation here so that unittests don't need to make a fully-valid
+ # config.
+ # pylint: disable=too-many-return-statements
+ if not self.workspace:
+ logging.error('Must set WORKSPACE.')
+ return False
+
+ if self.sanitizer not in SANITIZERS:
+ logging.error('Invalid SANITIZER: %s. Must be one of: %s.',
+ self.sanitizer, SANITIZERS)
+ return False
+
+ if self.architecture not in constants.ARCHITECTURES:
+ logging.error('Invalid ARCHITECTURE: %s. Must be one of: %s.',
+ self.architecture, constants.ARCHITECTURES)
+ return False
+
+ if self.architecture == 'i386' and self.sanitizer != 'address':
+ logging.error(
+ 'ARCHITECTURE=i386 can be used with SANITIZER=address only.')
+ return False
+
+ if self.language not in constants.LANGUAGES:
+ logging.error('Invalid LANGUAGE: %s. Must be one of: %s.', self.language,
+ constants.LANGUAGES)
+ return False
+
+ if not self.project_repo_name:
+ logging.error('Must set REPOSITORY.')
+ return False
+
+ return True
+
+ @property
+ def is_internal(self):
+ """Returns True if this is an OSS-Fuzz project."""
+ return bool(self.oss_fuzz_project_name)
+
+ @property
+ def platform(self):
+ """Returns the platform CIFuzz is runnning on."""
+ if not self.is_internal:
+ if not self.is_github:
+ return self.Platform.EXTERNAL_GENERIC_CI
+ return self.Platform.EXTERNAL_GITHUB
+
+ if self.is_github:
+ return self.Platform.INTERNAL_GITHUB
+ return self.Platform.INTERNAL_GENERIC_CI
+
+ @property
+ def is_coverage(self):
+ """Returns True if this CIFuzz run (building fuzzers and running them) for
+ generating a coverage report."""
+ return self.sanitizer == 'coverage'
+
+
+def _get_platform_config(cfl_platform):
+ """Returns the CI environment object for |cfl_platform|."""
+ module_name = f'platform_config.{cfl_platform}'
+ try:
+ cls = importlib.import_module(module_name).PlatformConfig
+ except ImportError:
+ cls = platform_config.BasePlatformConfig
+ return cls()
+
+
+class RunFuzzersConfig(BaseConfig):
+ """Class containing constant configuration for running fuzzers in CIFuzz."""
+
+ MODES = ['batch', 'code-change', 'coverage', 'prune']
+
+ def __init__(self):
+ super().__init__()
+ # TODO(metzman): Pick a better default for pruning.
+ self.fuzz_seconds = int(os.environ.get('FUZZ_SECONDS', 600))
+ self.mode = os.environ.get('MODE', 'code-change').lower()
+ if self.is_coverage:
+ self.mode = 'coverage'
+
+ self.report_unreproducible_crashes = environment.get_bool(
+ 'REPORT_UNREPRODUCIBLE_CRASHES', False)
+
+ self.minimize_crashes = environment.get_bool('MINIMIZE_CRASHES', False)
+ if self.mode == 'batch':
+ logging.warning(
+ 'Minimizing crashes reduces fuzzing time in batch fuzzing.')
+ self.report_timeouts = environment.get_bool('REPORT_TIMEOUTS', False)
+ self.report_ooms = environment.get_bool('REPORT_OOMS', True)
+ self.upload_all_crashes = environment.get_bool('UPLOAD_ALL_CRASHES', False)
+
+ # TODO(metzman): Fix tests to create valid configurations and get rid of
+ # CIFUZZ_TEST here and in presubmit.py.
+ if not os.getenv('CIFUZZ_TEST') and not self._run_config_validate():
+ raise ConfigError('Invalid Run Configuration.')
+
+ def _run_config_validate(self):
+ """Do extra validation on RunFuzzersConfig.__init__(). Do not name this
+ validate or else it will be called when using the parent's __init__ and will
+ fail. Returns True if valid."""
+ if self.mode not in self.MODES:
+ logging.error('Invalid MODE: %s. Must be one of %s.', self.mode,
+ self.MODES)
+ return False
+
+ return True
+
+
+class BuildFuzzersConfig(BaseConfig):
+ """Class containing constant configuration for building fuzzers in CIFuzz."""
+
+ def __init__(self):
+ """Get the configuration from CIFuzz from the environment. These variables
+ are set by GitHub or the user."""
+ super().__init__()
+ self.git_sha = self.platform_conf.git_sha
+ self.git_url = self.platform_conf.git_url
+
+ self.allowed_broken_targets_percentage = os.getenv(
+ 'ALLOWED_BROKEN_TARGETS_PERCENTAGE')
+ self.bad_build_check = environment.get_bool('BAD_BUILD_CHECK', True)
+
+ self.keep_unaffected_fuzz_targets = environment.get_bool(
+ 'KEEP_UNAFFECTED_FUZZ_TARGETS')
+
+ self.upload_build = environment.get_bool('UPLOAD_BUILD', False)
+ if not self.keep_unaffected_fuzz_targets:
+ has_base_for_diff = (self.base_ref or self.base_commit)
+ if not has_base_for_diff:
+ logging.info(
+ 'Keeping all fuzzers because there is nothing to diff against.')
+ self.keep_unaffected_fuzz_targets = True
+ elif self.upload_build:
+ logging.info('Keeping all fuzzers because we are uploading build.')
+ self.keep_unaffected_fuzz_targets = True
+ elif self.sanitizer == 'coverage':
+ logging.info('Keeping all fuzzers because we are doing coverage.')
+ self.keep_unaffected_fuzz_targets = True
+
+ if self.sanitizer == 'coverage':
+ self.bad_build_check = False
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/external-actions/run_fuzzers/action.yml b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/external-actions/run_fuzzers/action.yml
new file mode 100644
index 0000000000000000000000000000000000000000..9ca11e448a0d86d74112eac5133783b57dbe55c0
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/external-actions/run_fuzzers/action.yml
@@ -0,0 +1,97 @@
+# action.yml
+name: 'run-fuzzers'
+description: 'Runs fuzz target binaries for a specified length of time.'
+inputs:
+ language:
+ description: 'Programming language project is written in.'
+ required: false
+ default: 'c++'
+ fuzz-seconds:
+ description: 'The total time allotted for fuzzing in seconds.'
+ required: true
+ default: 600
+ dry-run:
+ description: 'If set, run the action without actually reporting a failure.'
+ default: false
+ sanitizer:
+ description: 'The sanitizer to run the fuzzers with.'
+ default: 'address'
+ mode:
+ description: |
+ The mode to run the fuzzers with ("code-change", "batch", "coverage", or "prune").
+ "code-change" is for fuzzing a pull request or commit.
+ "batch" is for non-interactive fuzzing of an entire project.
+ "coverage" is for coverage generation.
+ "prune" is for corpus pruning.
+ required: false
+ default: 'code-change'
+ github-token:
+ description: |
+ Token for GitHub API. WARNING: THIS SHOULD NOT BE USED IN PRODUCTION YET
+ You should use "secrets.GITHUB_TOKEN" in your workflow file, do not
+ hardcode the token.
+ TODO(https://github.com/google/oss-fuzz/pull/5841#discussion_r639393361):
+ Document locking this down.
+ required: true
+ storage-repo:
+ description: |
+ The git repo to use for storing certain artifacts from fuzzing.
+ required: false
+ storage-repo-branch:
+ description: |
+ The branch of the git repo to use for storing certain artifacts from
+ fuzzing.
+ default: main
+ required: false
+ storage-repo-branch-coverage:
+ description: |
+ The branch of the git repo to use for storing coverage reports.
+ default: gh-pages
+ required: false
+ report-unreproducible-crashes:
+ description: 'If True, then unreproducible crashes will be reported.'
+ required: false
+ default: false
+ minimize-crashes:
+ description: 'If True, reportable crashes will be minimized.'
+ required: false
+ default: False
+ parallel-fuzzing:
+ description: "Whether to use all available cores for fuzzing."
+ required: false
+ default: false
+ output-sarif:
+ description: "Whether to output fuzzing results to SARIF."
+ required: false
+ default: false
+ report-timeouts:
+ description: "Whether to report fails due to timeout."
+ required: false
+ default: true
+ report-ooms:
+ description: "Whether to report fails due to OOM."
+ required: false
+ default: true
+runs:
+ using: 'docker'
+ image: '../../../run_fuzzers.Dockerfile'
+ env:
+ OSS_FUZZ_PROJECT_NAME: ${{ inputs.oss-fuzz-project-name }}
+ LANGUAGE: ${{ inputs.language }}
+ FUZZ_SECONDS: ${{ inputs.fuzz-seconds }}
+ DRY_RUN: ${{ inputs.dry-run}}
+ SANITIZER: ${{ inputs.sanitizer }}
+ MODE: ${{ inputs.mode }}
+ GITHUB_TOKEN: ${{ inputs.github-token }}
+ LOW_DISK_SPACE: 'True'
+ GIT_STORE_REPO: ${{ inputs.storage-repo }}
+ GIT_STORE_BRANCH: ${{ inputs.storage-repo-branch }}
+ GIT_STORE_BRANCH_COVERAGE: ${{ inputs.storage-repo-branch-coverage }}
+ REPORT_UNREPRODUCIBLE_CRASHES: ${{ inputs.report-unreproducible-crashes }}
+ MINIMIZE_CRASHES: ${{ inputs.minimize-crashes }}
+ CIFUZZ_DEBUG: 'True'
+ CFL_PLATFORM: 'github'
+ PARALLEL_FUZZING: ${{ inputs.parallel-fuzzing }}
+ OUTPUT_SARIF: ${{ inputs.output-sarif }}
+ REPORT_TIMEOUTS: ${{ inputs.report-timeouts }}
+ REPORT_OOMS: ${{ inputs.report-ooms}}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/__init__.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bce4271ce61303b8567beee2cc6343646be2aeda
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/__init__.py
@@ -0,0 +1,54 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Module for a generic filestore."""
+
+
+class FilestoreError(Exception):
+ """Error using the filestore."""
+
+
+# pylint: disable=unused-argument,no-self-use
+class BaseFilestore:
+ """Base class for a filestore."""
+
+ def __init__(self, config):
+ self.config = config
+
+ def upload_crashes(self, name, directory):
+ """Uploads the crashes at |directory| to |name|."""
+ raise NotImplementedError('Child class must implement method.')
+
+ def upload_corpus(self, name, directory, replace=False):
+ """Uploads the corpus at |directory| to |name|."""
+ raise NotImplementedError('Child class must implement method.')
+
+ def upload_build(self, name, directory):
+ """Uploads the build at |directory| to |name|."""
+ raise NotImplementedError('Child class must implement method.')
+
+ def upload_coverage(self, name, directory):
+ """Uploads the coverage report at |directory| to |name|."""
+ raise NotImplementedError('Child class must implement method.')
+
+ def download_corpus(self, name, dst_directory):
+ """Downloads the corpus located at |name| to |dst_directory|."""
+ raise NotImplementedError('Child class must implement method.')
+
+ def download_build(self, name, dst_directory):
+ """Downloads the build with |name| to |dst_directory|."""
+ raise NotImplementedError('Child class must implement method.')
+
+ def download_coverage(self, name, dst_directory):
+ """Downloads the latest project coverage report."""
+ raise NotImplementedError('Child class must implement method.')
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/git/__init__.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/git/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..636ed693f4357f160ad14e3ccadd6ea07eddb38b
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/git/__init__.py
@@ -0,0 +1,158 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Module for a git based filestore."""
+
+import logging
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+import filestore
+
+# pylint: disable=wrong-import-position
+INFRA_DIR = os.path.dirname(
+ os.path.dirname(os.path.dirname(os.path.dirname(
+ os.path.abspath(__file__)))))
+sys.path.append(INFRA_DIR)
+
+import retry
+
+_PUSH_RETRIES = 3
+_PUSH_BACKOFF = 1
+_GIT_EMAIL = 'cifuzz@clusterfuzz.com'
+_GIT_NAME = 'CIFuzz'
+_CORPUS_DIR = 'corpus'
+_COVERAGE_DIR = 'coverage'
+
+
+def git_runner(repo_path):
+ """Returns a gits runner for the repo_path."""
+
+ def func(*args):
+ return subprocess.check_call(('git', '-C', repo_path) + args)
+
+ return func
+
+
+# pylint: disable=unused-argument,no-self-use
+class GitFilestore(filestore.BaseFilestore):
+ """Generic git filestore. This still relies on another filestore provided by
+ the CI for larger artifacts or artifacts which make sense to be included as
+ the result of a workflow run."""
+
+ def __init__(self, config, ci_filestore):
+ super().__init__(config)
+ self.repo_path = tempfile.mkdtemp()
+ self._git = git_runner(self.repo_path)
+ self._clone(self.config.git_store_repo)
+
+ self._ci_filestore = ci_filestore
+
+ def __del__(self):
+ shutil.rmtree(self.repo_path)
+
+ def _clone(self, repo_url):
+ """Clones repo URL."""
+ self._git('clone', repo_url, '.')
+ self._git('config', '--local', 'user.email', _GIT_EMAIL)
+ self._git('config', '--local', 'user.name', _GIT_NAME)
+
+ def _reset_git(self, branch):
+ """Resets the git repo."""
+ self._git('fetch', 'origin')
+ try:
+ self._git('checkout', '-B', branch, 'origin/' + branch)
+ self._git('reset', '--hard', 'HEAD')
+ except subprocess.CalledProcessError:
+ self._git('checkout', '--orphan', branch)
+
+ self._git('clean', '-fxd')
+
+ # pylint: disable=too-many-arguments
+ @retry.wrap(_PUSH_RETRIES, _PUSH_BACKOFF)
+ def _upload_to_git(self,
+ message,
+ branch,
+ upload_path,
+ local_path,
+ replace=False):
+ """Uploads a directory to git. If `replace` is True, then existing contents
+ in the upload_path is deleted."""
+ self._reset_git(branch)
+
+ full_repo_path = os.path.join(self.repo_path, upload_path)
+ if replace and os.path.exists(full_repo_path):
+ shutil.rmtree(full_repo_path)
+
+ shutil.copytree(local_path, full_repo_path, dirs_exist_ok=True)
+ self._git('add', '.')
+ try:
+ self._git('commit', '-m', message)
+ except subprocess.CalledProcessError:
+ logging.debug('No changes, skipping git push.')
+ return
+
+ self._git('push', 'origin', branch)
+
+ def upload_crashes(self, name, directory):
+ """Uploads the crashes at |directory| to |name|."""
+ return self._ci_filestore.upload_crashes(name, directory)
+
+ def upload_corpus(self, name, directory, replace=False):
+ """Uploads the corpus at |directory| to |name|."""
+ self._upload_to_git('Corpus upload',
+ self.config.git_store_branch,
+ os.path.join(_CORPUS_DIR, name),
+ directory,
+ replace=replace)
+
+ def upload_build(self, name, directory):
+ """Uploads the build at |directory| to |name|."""
+ return self._ci_filestore.upload_build(name, directory)
+
+ def upload_coverage(self, name, directory):
+ """Uploads the coverage report at |directory| to |name|."""
+ self._upload_to_git('Coverage upload',
+ self.config.git_store_branch_coverage,
+ os.path.join(_COVERAGE_DIR, name),
+ directory,
+ replace=True)
+
+ def download_corpus(self, name, dst_directory):
+ """Downloads the corpus located at |name| to |dst_directory|."""
+ self._reset_git(self.config.git_store_branch)
+ path = os.path.join(self.repo_path, _CORPUS_DIR, name)
+ if not os.path.exists(path):
+ logging.debug('Corpus does not exist at %s.', path)
+ return False
+
+ shutil.copytree(path, dst_directory, dirs_exist_ok=True)
+ return True
+
+ def download_build(self, name, dst_directory):
+ """Downloads the build with |name| to |dst_directory|."""
+ return self._ci_filestore.download_build(name, dst_directory)
+
+ def download_coverage(self, name, dst_directory):
+ """Downloads the latest project coverage report."""
+ self._reset_git(self.config.git_store_branch_coverage)
+ path = os.path.join(self.repo_path, _COVERAGE_DIR, name)
+ if not os.path.exists(path):
+ logging.debug('Coverage does not exist at %s.', path)
+ return False
+
+ shutil.copytree(path, dst_directory, dirs_exist_ok=True)
+ return True
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/__init__.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4750a39b9709d49b9f207321480147b1e1d75476
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/__init__.py
@@ -0,0 +1,179 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Implementation of a filestore using Github actions artifacts."""
+import logging
+import os
+import shutil
+import sys
+import tarfile
+import tempfile
+
+# pylint: disable=wrong-import-position,import-error
+INFRA_DIR = os.path.abspath(
+ os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir,
+ os.path.pardir))
+sys.path.append(INFRA_DIR)
+OSS_FUZZ_ROOT_DIR = os.path.dirname(INFRA_DIR)
+
+import utils
+import http_utils
+import filestore
+from filestore.github_actions import github_api
+
+UPLOAD_JS = os.path.join(os.path.dirname(__file__), 'upload.js')
+
+
+def tar_directory(directory, archive_path):
+ """Tars a |directory| and stores archive at |archive_path|. |archive_path|
+ must end in .tar"""
+ assert archive_path.endswith('.tar')
+ # Do this because make_archive will append the extension to archive_path.
+ archive_path = os.path.splitext(archive_path)[0]
+
+ root_directory = os.path.abspath(directory)
+ shutil.make_archive(archive_path,
+ 'tar',
+ root_dir=root_directory,
+ base_dir='./')
+
+
+class GithubActionsFilestore(filestore.BaseFilestore):
+ """Implementation of BaseFilestore using Github actions artifacts. Relies on
+ github_actions_toolkit for using the GitHub actions API and the github_api
+ module for using GitHub's standard API. We need to use both because the GitHub
+ actions API is the only way to upload an artifact but it does not support
+ downloading artifacts from other runs. The standard GitHub API does support
+ this however."""
+
+ ARTIFACT_PREFIX = 'cifuzz-'
+ BUILD_PREFIX = 'build-'
+ CRASHES_PREFIX = 'crashes-'
+ CORPUS_PREFIX = 'corpus-'
+ COVERAGE_PREFIX = 'coverage-'
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.github_api_http_headers = github_api.get_http_auth_headers(config)
+
+ def _get_artifact_name(self, name):
+ """Returns |name| prefixed with |self.ARITFACT_PREFIX| if it isn't already
+ prefixed. Otherwise returns |name|."""
+ if name.startswith(self.ARTIFACT_PREFIX):
+ return name
+ return f'{self.ARTIFACT_PREFIX}{name}'
+
+ def _upload_directory(self, name, directory): # pylint: disable=no-self-use
+ """Uploads |directory| as artifact with |name|."""
+ name = self._get_artifact_name(name)
+ with tempfile.TemporaryDirectory() as temp_dir:
+ archive_path = os.path.join(temp_dir, name + '.tar')
+ tar_directory(directory, archive_path)
+ _raw_upload_directory(name, temp_dir)
+
+ def upload_crashes(self, name, directory):
+ """Uploads the crashes at |directory| to |name|."""
+ return _raw_upload_directory(self.CRASHES_PREFIX + name, directory)
+
+ def upload_corpus(self, name, directory, replace=False):
+ """Uploads the corpus at |directory| to |name|."""
+ # Not applicable as the the entire corpus is uploaded under a single
+ # artifact name.
+ del replace
+ return self._upload_directory(self.CORPUS_PREFIX + name, directory)
+
+ def upload_build(self, name, directory):
+ """Uploads the build at |directory| to |name|."""
+ return self._upload_directory(self.BUILD_PREFIX + name, directory)
+
+ def upload_coverage(self, name, directory):
+ """Uploads the coverage report at |directory| to |name|."""
+ return self._upload_directory(self.COVERAGE_PREFIX + name, directory)
+
+ def download_corpus(self, name, dst_directory): # pylint: disable=unused-argument,no-self-use
+ """Downloads the corpus located at |name| to |dst_directory|."""
+ return self._download_artifact(self.CORPUS_PREFIX + name, dst_directory)
+
+ def _find_artifact(self, name):
+ """Finds an artifact using the GitHub API and returns it."""
+ logging.debug('Listing artifacts.')
+ artifacts = self._list_artifacts()
+ artifact = github_api.find_artifact(name, artifacts)
+ logging.debug('Artifact: %s.', artifact)
+ return artifact
+
+ def _download_artifact(self, name, dst_directory):
+ """Downloads artifact with |name| to |dst_directory|. Returns True on
+ success."""
+ name = self._get_artifact_name(name)
+
+ with tempfile.TemporaryDirectory() as temp_dir:
+ if not self._raw_download_artifact(name, temp_dir):
+ logging.warning('Could not download artifact: %s.', name)
+ return False
+
+ artifact_tarfile_path = os.path.join(temp_dir, name + '.tar')
+ if not os.path.exists(artifact_tarfile_path):
+ logging.error('Artifact zip did not contain a tarfile.')
+ return False
+
+ # TODO(jonathanmetzman): Replace this with archive.unpack from
+ # libClusterFuzz so we can avoid path traversal issues.
+ with tarfile.TarFile(artifact_tarfile_path) as artifact_tarfile:
+ artifact_tarfile.extractall(dst_directory)
+ return True
+
+ def _raw_download_artifact(self, name, dst_directory):
+ """Downloads the artifact with |name| to |dst_directory|. Returns True on
+ success. Does not do any untarring or adding prefix to |name|."""
+ artifact = self._find_artifact(name)
+ if not artifact:
+ logging.warning('Could not find artifact: %s.', name)
+ return False
+ download_url = artifact['archive_download_url']
+ return http_utils.download_and_unpack_zip(
+ download_url, dst_directory, headers=self.github_api_http_headers)
+
+ def _list_artifacts(self):
+ """Returns a list of artifacts."""
+ return github_api.list_artifacts(self.config.project_repo_owner,
+ self.config.project_repo_name,
+ self.github_api_http_headers)
+
+ def download_build(self, name, dst_directory):
+ """Downloads the build with name |name| to |dst_directory|."""
+ return self._download_artifact(self.BUILD_PREFIX + name, dst_directory)
+
+ def download_coverage(self, name, dst_directory):
+ """Downloads the latest project coverage report."""
+ return self._download_artifact(self.COVERAGE_PREFIX + name, dst_directory)
+
+
+def _upload_artifact_with_upload_js(name, artifact_paths, directory):
+ """Uploads the artifacts in |artifact_paths| that are located in |directory|
+ to |name|, using the upload.js script."""
+ command = [UPLOAD_JS, name, directory] + artifact_paths
+ _, _, retcode = utils.execute(command, location=OSS_FUZZ_ROOT_DIR)
+ return retcode == 0
+
+
+def _raw_upload_directory(name, directory):
+ """Uploads the artifacts located in |directory| to |name|. Does not do any
+ tarring or adding prefixes to |name|."""
+ # Get file paths.
+ artifact_paths = []
+ for root, _, curr_file_paths in os.walk(directory):
+ for file_path in curr_file_paths:
+ artifact_paths.append(os.path.join(root, file_path))
+ logging.debug('Artifact paths: %s.', artifact_paths)
+ return _upload_artifact_with_upload_js(name, artifact_paths, directory)
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/github_actions_test.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/github_actions_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..90a0b070db61df690ad0781c2fdd63009d1af6a8
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/github_actions_test.py
@@ -0,0 +1,283 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Tests for github_actions."""
+import os
+import shutil
+import sys
+import tarfile
+import tempfile
+import unittest
+from unittest import mock
+
+from pyfakefs import fake_filesystem_unittest
+
+# pylint: disable=wrong-import-position
+INFRA_DIR = os.path.dirname(
+ os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.append(INFRA_DIR)
+
+from filestore import github_actions
+import test_helpers
+
+# pylint: disable=protected-access,no-self-use
+
+
+class GithubActionsFilestoreTest(fake_filesystem_unittest.TestCase):
+ """Tests for GithubActionsFilestore."""
+
+ @mock.patch('platform_config.github._get_event_data', return_value={})
+ def setUp(self, _): # pylint: disable=arguments-differ
+ test_helpers.patch_environ(self)
+ self.token = 'example githubtoken'
+ self.owner = 'exampleowner'
+ self.repo = 'examplerepo'
+ os.environ['GITHUB_REPOSITORY'] = f'{self.owner}/{self.repo}'
+ os.environ['GITHUB_EVENT_PATH'] = '/fake'
+ os.environ['CFL_PLATFORM'] = 'github'
+ os.environ['GITHUB_WORKSPACE'] = '/workspace'
+ self.config = test_helpers.create_run_config(token=self.token)
+ self.local_dir = '/local-dir'
+ self.testcase = os.path.join(self.local_dir, 'testcase')
+
+ def _get_expected_http_headers(self):
+ return {
+ 'Authorization': f'token {self.token}',
+ 'Accept': 'application/vnd.github.v3+json',
+ }
+
+ @mock.patch('filestore.github_actions.github_api.list_artifacts')
+ def test_list_artifacts(self, mock_list_artifacts):
+ """Tests that _list_artifacts works as intended."""
+ filestore = github_actions.GithubActionsFilestore(self.config)
+ filestore._list_artifacts()
+ mock_list_artifacts.assert_called_with(self.owner, self.repo,
+ self._get_expected_http_headers())
+
+ @mock.patch('logging.warning')
+ @mock.patch('filestore.github_actions.GithubActionsFilestore._list_artifacts',
+ return_value=None)
+ @mock.patch('filestore.github_actions.github_api.find_artifact',
+ return_value=None)
+ def test_download_build_no_artifact(self, _, __, mock_warning):
+ """Tests that download_build returns None and doesn't exception when
+ find_artifact can't find an artifact."""
+ filestore = github_actions.GithubActionsFilestore(self.config)
+ name = 'name'
+ build_dir = 'build-dir'
+ self.assertFalse(filestore.download_build(name, build_dir))
+ mock_warning.assert_called_with('Could not download artifact: %s.',
+ 'cifuzz-build-' + name)
+
+ @mock.patch('logging.warning')
+ @mock.patch('filestore.github_actions.GithubActionsFilestore._list_artifacts',
+ return_value=None)
+ @mock.patch('filestore.github_actions.github_api.find_artifact',
+ return_value=None)
+ def test_download_corpus_no_artifact(self, _, __, mock_warning):
+ """Tests that download_corpus_build returns None and doesn't exception when
+ find_artifact can't find an artifact."""
+ filestore = github_actions.GithubActionsFilestore(self.config)
+ name = 'name'
+ dst_dir = 'local-dir'
+ self.assertFalse(filestore.download_corpus(name, dst_dir))
+ mock_warning.assert_called_with('Could not download artifact: %s.',
+ 'cifuzz-corpus-' + name)
+
+ @mock.patch('filestore.github_actions.tar_directory')
+ @mock.patch('filestore.github_actions._upload_artifact_with_upload_js')
+ def test_upload_corpus(self, mock_upload_artifact, mock_tar_directory):
+ """Test uploading corpus."""
+ self._create_local_dir()
+
+ def mock_tar_directory_impl(_, archive_path):
+ self.fs.create_file(archive_path)
+
+ mock_tar_directory.side_effect = mock_tar_directory_impl
+
+ filestore = github_actions.GithubActionsFilestore(self.config)
+ filestore.upload_corpus('target', self.local_dir)
+ self.assert_upload(mock_upload_artifact, mock_tar_directory,
+ 'corpus-target')
+
+ @mock.patch('filestore.github_actions._upload_artifact_with_upload_js')
+ def test_upload_crashes(self, mock_upload_artifact):
+ """Test uploading crashes."""
+ self._create_local_dir()
+
+ filestore = github_actions.GithubActionsFilestore(self.config)
+ filestore.upload_crashes('current', self.local_dir)
+ mock_upload_artifact.assert_has_calls(
+ [mock.call('crashes-current', ['/local-dir/testcase'], '/local-dir')])
+
+ @mock.patch('filestore.github_actions.tar_directory')
+ @mock.patch('filestore.github_actions._upload_artifact_with_upload_js')
+ def test_upload_build(self, mock_upload_artifact, mock_tar_directory):
+ """Test uploading build."""
+ self._create_local_dir()
+
+ def mock_tar_directory_impl(_, archive_path):
+ self.fs.create_file(archive_path)
+
+ mock_tar_directory.side_effect = mock_tar_directory_impl
+
+ filestore = github_actions.GithubActionsFilestore(self.config)
+ filestore.upload_build('sanitizer', self.local_dir)
+ self.assert_upload(mock_upload_artifact, mock_tar_directory,
+ 'build-sanitizer')
+
+ @mock.patch('filestore.github_actions.tar_directory')
+ @mock.patch('filestore.github_actions._upload_artifact_with_upload_js')
+ def test_upload_coverage(self, mock_upload_artifact, mock_tar_directory):
+ """Test uploading coverage."""
+ self._create_local_dir()
+
+ def mock_tar_directory_impl(_, archive_path):
+ self.fs.create_file(archive_path)
+
+ mock_tar_directory.side_effect = mock_tar_directory_impl
+
+ filestore = github_actions.GithubActionsFilestore(self.config)
+ filestore.upload_coverage('latest', self.local_dir)
+ self.assert_upload(mock_upload_artifact, mock_tar_directory,
+ 'coverage-latest')
+
+ def assert_upload(self, mock_upload_artifact, mock_tar_directory,
+ expected_artifact_name):
+ """Tests that upload_directory invokes tar_directory and
+ artifact_client.upload_artifact properly."""
+ # Don't assert what second argument will be since it's a temporary
+ # directory.
+ self.assertEqual(mock_tar_directory.call_args_list[0][0][0], self.local_dir)
+
+ # Don't assert what second and third arguments will be since they are
+ # temporary directories.
+ expected_artifact_name = 'cifuzz-' + expected_artifact_name
+ self.assertEqual(mock_upload_artifact.call_args_list[0][0][0],
+ expected_artifact_name)
+
+ # Assert artifacts list contains one tarfile.
+ artifacts_list = mock_upload_artifact.call_args_list[0][0][1]
+ self.assertEqual(len(artifacts_list), 1)
+ self.assertEqual(os.path.basename(artifacts_list[0]),
+ expected_artifact_name + '.tar')
+
+ def _create_local_dir(self):
+ """Sets up pyfakefs and creates a corpus directory containing
+ self.testcase."""
+ self.setUpPyfakefs()
+ self.fs.create_file(self.testcase, contents='hi')
+
+ @mock.patch('filestore.github_actions.GithubActionsFilestore._find_artifact')
+ @mock.patch('http_utils.download_and_unpack_zip')
+ def test_download_artifact(self, mock_download_and_unpack_zip,
+ mock_find_artifact):
+ """Tests that _download_artifact works as intended."""
+ artifact_download_url = 'http://example.com/download'
+ artifact_listing = {
+ 'expired': False,
+ 'name': 'corpus',
+ 'archive_download_url': artifact_download_url
+ }
+ mock_find_artifact.return_value = artifact_listing
+
+ self._create_local_dir()
+ with tempfile.TemporaryDirectory() as temp_dir:
+ # Create a tarball.
+ archive_path = os.path.join(temp_dir, 'cifuzz-corpus.tar')
+ github_actions.tar_directory(self.local_dir, archive_path)
+
+ artifact_download_dst_dir = os.path.join(temp_dir, 'dst')
+ os.mkdir(artifact_download_dst_dir)
+
+ def mock_download_and_unpack_zip_impl(url, download_artifact_temp_dir,
+ headers):
+ self.assertEqual(url, artifact_download_url)
+ self.assertEqual(headers, self._get_expected_http_headers())
+ shutil.copy(
+ archive_path,
+ os.path.join(download_artifact_temp_dir,
+ os.path.basename(archive_path)))
+ return True
+
+ mock_download_and_unpack_zip.side_effect = (
+ mock_download_and_unpack_zip_impl)
+ filestore = github_actions.GithubActionsFilestore(self.config)
+ self.assertTrue(
+ filestore._download_artifact('corpus', artifact_download_dst_dir))
+ mock_find_artifact.assert_called_with('cifuzz-corpus')
+ self.assertTrue(
+ os.path.exists(
+ os.path.join(artifact_download_dst_dir,
+ os.path.basename(self.testcase))))
+
+ @mock.patch('filestore.github_actions.github_api.list_artifacts')
+ def test_find_artifact(self, mock_list_artifacts):
+ """Tests that _find_artifact works as intended."""
+ artifact_listing_1 = {
+ 'expired': False,
+ 'name': 'other',
+ 'archive_download_url': 'http://download1'
+ }
+ artifact_listing_2 = {
+ 'expired': False,
+ 'name': 'artifact',
+ 'archive_download_url': 'http://download2'
+ }
+ artifact_listing_3 = {
+ 'expired': True,
+ 'name': 'artifact',
+ 'archive_download_url': 'http://download3'
+ }
+ artifact_listing_4 = {
+ 'expired': False,
+ 'name': 'artifact',
+ 'archive_download_url': 'http://download4'
+ }
+ artifacts = [
+ artifact_listing_1, artifact_listing_2, artifact_listing_3,
+ artifact_listing_4
+ ]
+ mock_list_artifacts.return_value = artifacts
+ filestore = github_actions.GithubActionsFilestore(self.config)
+ # Test that find_artifact will return the most recent unexpired artifact
+ # with the correct name.
+ self.assertEqual(filestore._find_artifact('artifact'), artifact_listing_2)
+ mock_list_artifacts.assert_called_with(self.owner, self.repo,
+ self._get_expected_http_headers())
+
+
+class TarDirectoryTest(unittest.TestCase):
+ """Tests for tar_directory."""
+
+ def test_tar_directory(self):
+ """Tests that tar_directory writes the archive to the correct location and
+ archives properly."""
+ with tempfile.TemporaryDirectory() as temp_dir:
+ archive_path = os.path.join(temp_dir, 'myarchive.tar')
+ archived_dir = os.path.join(temp_dir, 'toarchive')
+ os.mkdir(archived_dir)
+ archived_filename = 'file1'
+ archived_file_path = os.path.join(archived_dir, archived_filename)
+ with open(archived_file_path, 'w') as file_handle:
+ file_handle.write('hi')
+ github_actions.tar_directory(archived_dir, archive_path)
+ self.assertTrue(os.path.exists(archive_path))
+
+ # Now check it archives correctly.
+ unpacked_directory = os.path.join(temp_dir, 'unpacked')
+ with tarfile.TarFile(archive_path) as artifact_tarfile:
+ artifact_tarfile.extractall(unpacked_directory)
+ unpacked_archived_file_path = os.path.join(unpacked_directory,
+ archived_filename)
+ self.assertTrue(os.path.exists(unpacked_archived_file_path))
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/github_api_test.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/github_api_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d6f54e41c8dad942072dc859e42d9c1f8fd82ad
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/github_api_test.py
@@ -0,0 +1,41 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Tests for github_api."""
+import os
+import sys
+import unittest
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(
+ os.path.abspath(
+ os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir,
+ os.path.pardir)))
+
+from filestore.github_actions import github_api
+import test_helpers
+
+
+class GetHttpAuthHeaders(unittest.TestCase):
+ """Tests for get_http_auth_headers."""
+
+ def test_get_http_auth_headers(self):
+ """Tests that get_http_auth_headers returns the correct result."""
+ token = 'example githubtoken'
+ run_config = test_helpers.create_run_config(token=token)
+ expected_headers = {
+ 'Authorization': f'token {token}',
+ 'Accept': 'application/vnd.github.v3+json',
+ }
+ self.assertEqual(expected_headers,
+ github_api.get_http_auth_headers(run_config))
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/upload.js b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/upload.js
new file mode 100644
index 0000000000000000000000000000000000000000..13a805891bf5565ce88e30120a12c0b078c65af5
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/filestore/github_actions/upload.js
@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// Copyright 2021 Google LLC
+//
+// 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.
+// Script for uploading an artifact. Returns 0 on success.
+// Usage: upload.js ...
+
+const fs = require('fs');
+const { DefaultArtifactClient } = require('@actions/artifact');
+
+const artifactClient = new DefaultArtifactClient();
+const artifactName = process.argv[2];
+const rootDirectory = process.argv[3]
+const files = process.argv.slice(4);
+const options = {
+ continueOnError: true
+};
+
+async function uploadArtifact() {
+ try {
+ const uploadResult = await artifactClient.uploadArtifact(artifactName, files, rootDirectory, options);
+ console.log(uploadResult);
+ if (uploadResult.failedItems.length > 0) {
+ return 1;
+ }
+ return 0;
+ } catch (error) {
+ console.error('Error uploading artifact:', error);
+ return 1;
+ }
+}
+
+uploadArtifact().then(exitCode => {
+ process.exit(exitCode);
+});
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/fuzz_target_test.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/fuzz_target_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..e553a25aecacfebc1a15e920fc54f19388d396d6
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/fuzz_target_test.py
@@ -0,0 +1,298 @@
+# Copyright 2020 Google LLC
+#
+# 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.
+"""Tests the functionality of the fuzz_target module."""
+
+import os
+import shutil
+import tempfile
+import unittest
+from unittest import mock
+
+import certifi
+# Importing this later causes import failures with pytest for some reason.
+# TODO(ochang): Figure out why.
+import parameterized
+import google.cloud.ndb # pylint: disable=unused-import
+from pyfakefs import fake_filesystem_unittest
+from clusterfuzz.fuzz import engine
+
+import clusterfuzz_deployment
+import fuzz_target
+import test_helpers
+import workspace_utils
+
+# NOTE: This integration test relies on
+# https://github.com/google/oss-fuzz/tree/master/projects/example project.
+EXAMPLE_PROJECT = 'example'
+
+# An example fuzzer that triggers an error.
+EXAMPLE_FUZZER = 'example_crash_fuzzer'
+
+# Mock return values for engine_impl.reproduce.
+EXECUTE_SUCCESS_RESULT = engine.ReproduceResult([], 0, 0, '')
+EXECUTE_FAILURE_RESULT = engine.ReproduceResult([], 1, 0, '')
+
+TEST_DATA_PATH = os.path.join(os.path.dirname(__file__), 'test_data')
+
+
+def _create_config(**kwargs):
+ """Creates a config object and then sets every attribute that is a key in
+ |kwargs| to the corresponding value. Asserts that each key in |kwargs| is an
+ attribute of Config."""
+ defaults = {
+ 'cfl_platform': 'github',
+ 'oss_fuzz_project_name': EXAMPLE_PROJECT,
+ 'workspace': '/workspace'
+ }
+ for default_key, default_value in defaults.items():
+ if default_key not in kwargs:
+ kwargs[default_key] = default_value
+
+ return test_helpers.create_run_config(**kwargs)
+
+
+def _create_deployment(**kwargs):
+ config = _create_config(**kwargs)
+ workspace = workspace_utils.Workspace(config)
+ return clusterfuzz_deployment.get_clusterfuzz_deployment(config, workspace)
+
+
+@mock.patch('utils.get_container_name', return_value='container')
+class IsReproducibleTest(fake_filesystem_unittest.TestCase):
+ """Tests the is_reproducible method in the fuzz_target.FuzzTarget class."""
+
+ def setUp(self):
+ """Sets up example fuzz target to test is_reproducible method."""
+ self.fuzz_target_name = 'fuzz-target'
+ deployment = _create_deployment()
+ self.config = deployment.config
+ self.workspace = deployment.workspace
+ self.fuzz_target_path = os.path.join(self.workspace.out,
+ self.fuzz_target_name)
+ self.setUpPyfakefs()
+ self.fs.create_file(self.fuzz_target_path)
+ self.testcase_path = '/testcase'
+ self.fs.create_file(self.testcase_path)
+
+ self.target = fuzz_target.FuzzTarget(self.fuzz_target_path,
+ fuzz_target.REPRODUCE_ATTEMPTS,
+ self.workspace, deployment,
+ deployment.config)
+
+ # ClusterFuzz requires ROOT_DIR.
+ root_dir = os.environ['ROOT_DIR']
+ test_helpers.patch_environ(self, empty=True)
+ os.environ['ROOT_DIR'] = root_dir
+
+ # There's an extremely bad issue that happens if this test is run: Other tests
+ # in this file fail in CI with stacktraces using referencing fakefs even if
+ # the tests do not use fakefs.
+ # TODO(metzman): Stop using fakefs.
+ @mock.patch('os.chmod')
+ @unittest.skip('Skip because of weird failures.')
+ def test_repro_timed_out(self, mock_chmod, mock_get_container_name):
+ """Tests that is_reproducible behaves correctly when reproduction times
+ out."""
+ del mock_get_container_name
+ del mock_chmod
+
+ with mock.patch(
+ 'clusterfuzz._internal.bot.fuzzers.libFuzzer.engine.LibFuzzerEngine.'
+ 'reproduce',
+ side_effect=TimeoutError):
+ self.assertFalse(
+ self.target.is_reproducible('/testcase', self.target.target_path, []))
+
+ def test_reproducible(self, _):
+ """Tests that is_reproducible returns True if crash is detected and that
+ is_reproducible uses the correct command to reproduce a crash."""
+ all_repro = [EXECUTE_FAILURE_RESULT] * fuzz_target.REPRODUCE_ATTEMPTS
+ with mock.patch('clusterfuzz.fuzz.get_engine') as mock_get_engine:
+ mock_get_engine().reproduce.side_effect = all_repro
+
+ result = self.target.is_reproducible(self.testcase_path,
+ self.fuzz_target_path, [])
+ mock_get_engine().reproduce.assert_called_once_with(
+ '/workspace/build-out/fuzz-target',
+ '/testcase',
+ arguments=[],
+ max_time=30)
+ self.assertTrue(result)
+ self.assertEqual(1, mock_get_engine().reproduce.call_count)
+
+ def test_flaky(self, _):
+ """Tests that is_reproducible returns True if crash is detected on the last
+ attempt."""
+ last_time_repro = [EXECUTE_SUCCESS_RESULT] * 9 + [EXECUTE_FAILURE_RESULT]
+ with mock.patch('clusterfuzz.fuzz.get_engine') as mock_get_engine:
+ mock_get_engine().reproduce.side_effect = last_time_repro
+ self.assertTrue(
+ self.target.is_reproducible(self.testcase_path, self.fuzz_target_path,
+ []))
+ self.assertEqual(fuzz_target.REPRODUCE_ATTEMPTS,
+ mock_get_engine().reproduce.call_count)
+
+ def test_nonexistent_fuzzer(self, _):
+ """Tests that is_reproducible raises an error if it could not attempt
+ reproduction because the fuzzer doesn't exist."""
+ with self.assertRaises(fuzz_target.ReproduceError):
+ self.target.is_reproducible(self.testcase_path, '/non-existent-path', [])
+
+ def test_unreproducible(self, _):
+ """Tests that is_reproducible returns False for a crash that did not
+ reproduce."""
+ all_unrepro = [EXECUTE_SUCCESS_RESULT] * fuzz_target.REPRODUCE_ATTEMPTS
+ with mock.patch('clusterfuzz.fuzz.get_engine') as mock_get_engine:
+ mock_get_engine().reproduce.side_effect = all_unrepro
+ result = self.target.is_reproducible(self.testcase_path,
+ self.fuzz_target_path, [])
+ self.assertFalse(result)
+
+
+class IsCrashReportableTest(fake_filesystem_unittest.TestCase):
+ """Tests the is_crash_reportable method of FuzzTarget."""
+
+ def setUp(self):
+ """Sets up example fuzz target to test is_crash_reportable method."""
+ self.setUpPyfakefs()
+ self.fuzz_target_path = '/example/do_stuff_fuzzer'
+ deployment = _create_deployment()
+ self.target = fuzz_target.FuzzTarget(self.fuzz_target_path, 100,
+ deployment.workspace, deployment,
+ deployment.config)
+ self.oss_fuzz_build_path = '/oss-fuzz-build'
+ self.fs.create_file(self.fuzz_target_path)
+ self.oss_fuzz_target_path = os.path.join(
+ self.oss_fuzz_build_path, os.path.basename(self.fuzz_target_path))
+ self.fs.create_file(self.oss_fuzz_target_path)
+ self.testcase_path = '/testcase'
+ self.fs.create_file(self.testcase_path, contents='')
+
+ # Do this to prevent pyfakefs from messing with requests.
+ self.fs.add_real_directory(os.path.dirname(certifi.__file__))
+
+ @mock.patch('fuzz_target.FuzzTarget.is_reproducible',
+ side_effect=[True, False])
+ @mock.patch('logging.info')
+ def test_new_reproducible_crash(self, mock_info, _):
+ """Tests that a new reproducible crash returns True."""
+ with tempfile.TemporaryDirectory() as tmp_dir:
+ self.target.out_dir = tmp_dir
+ self.assertTrue(self.target.is_crash_reportable(self.testcase_path, []))
+ mock_info.assert_called_with(
+ 'The crash is not reproducible on previous build. '
+ 'Code change (pr/commit) introduced crash.')
+
+ # yapf: disable
+ @parameterized.parameterized.expand([
+ # Reproducible on PR build, but also reproducible on OSS-Fuzz.
+ ([True, True],),
+
+ # Not reproducible on PR build, but somehow reproducible on OSS-Fuzz.
+ # Unlikely to happen in real world except if test is flaky.
+ ([False, True],),
+
+ # Not reproducible on PR build, and not reproducible on OSS-Fuzz.
+ ([False, False],),
+ ])
+ # yapf: enable
+ def test_invalid_crash(self, is_reproducible_retvals):
+ """Tests that a nonreportable crash causes the method to return False."""
+ with mock.patch('fuzz_target.FuzzTarget.is_reproducible',
+ side_effect=is_reproducible_retvals):
+ with mock.patch('clusterfuzz_deployment.OSSFuzz.download_latest_build',
+ return_value=self.oss_fuzz_build_path):
+ self.assertFalse(self.target.is_crash_reportable(
+ self.testcase_path, []))
+
+ @mock.patch('logging.info')
+ @mock.patch('fuzz_target.FuzzTarget.is_reproducible', return_value=[True])
+ def test_reproducible_no_oss_fuzz_target(self, _, mock_info):
+ """Tests that is_crash_reportable returns True when a crash reproduces on
+ the PR build but the target is not in the OSS-Fuzz build (usually because it
+ is new)."""
+ os.remove(self.oss_fuzz_target_path)
+
+ def is_reproducible_side_effect(testcase, target_path, reproduce_arguments):
+ del testcase
+ del reproduce_arguments
+ if os.path.dirname(target_path) == self.oss_fuzz_build_path:
+ raise fuzz_target.ReproduceError()
+ return True
+
+ with mock.patch(
+ 'fuzz_target.FuzzTarget.is_reproducible',
+ side_effect=is_reproducible_side_effect) as mock_is_reproducible:
+ with mock.patch('clusterfuzz_deployment.OSSFuzz.download_latest_build',
+ return_value=self.oss_fuzz_build_path):
+ self.assertTrue(self.target.is_crash_reportable(self.testcase_path, []))
+ mock_is_reproducible.assert_any_call(self.testcase_path,
+ self.oss_fuzz_target_path, [])
+ mock_info.assert_called_with(
+ 'Could not run previous build of target to determine if this code '
+ 'change (pr/commit) introduced crash. Assuming crash was newly '
+ 'introduced.')
+
+
+class FuzzTest(fake_filesystem_unittest.TestCase):
+ """Fuzz test."""
+
+ def setUp(self):
+ """Sets up example fuzz target."""
+ self.setUpPyfakefs()
+ deployment = _create_deployment()
+ config = deployment.config
+ workspace = deployment.workspace
+ self.fuzz_target = fuzz_target.FuzzTarget('/path/fuzz-target', 10,
+ workspace, deployment, config)
+
+ def test_get_fuzz_target_artifact(self):
+ """Tests that get_fuzz_target_artifact works as intended."""
+ # pylint: disable=protected-access
+ fuzz_target_artifact = self.fuzz_target._target_artifact_path()
+ self.assertEqual('/workspace/out/artifacts/fuzz-target/address',
+ fuzz_target_artifact)
+
+
+class TimeoutIntegrationTest(unittest.TestCase):
+ """Tests handling of fuzzer timeout (timeout crashes reported by
+ libFuzzer)."""
+ TIMEOUT_FUZZER_NAME = 'timeout_fuzzer'
+
+ @parameterized.parameterized.expand([(True, True), (False, False)])
+ def test_timeout_reported(self, report_timeouts, expect_crash):
+ """Tests that timeouts are not reported."""
+ with test_helpers.temp_dir_copy(TEST_DATA_PATH) as temp_dir:
+ fuzz_target_path = os.path.join(temp_dir, 'build-out',
+ self.TIMEOUT_FUZZER_NAME)
+ shutil.copy(os.path.join(temp_dir, self.TIMEOUT_FUZZER_NAME),
+ fuzz_target_path)
+ deployment = _create_deployment(workspace=temp_dir,
+ report_timeouts=report_timeouts)
+ config = deployment.config
+ fuzz_target_obj = fuzz_target.FuzzTarget(fuzz_target_path,
+ fuzz_target.REPRODUCE_ATTEMPTS,
+ deployment.workspace, deployment,
+ config)
+ with mock.patch('clusterfuzz._internal.bot.fuzzers.libfuzzer.'
+ 'fix_timeout_argument_for_reproduction') as _:
+ with mock.patch(
+ 'clusterfuzz._internal.bot.fuzzers.libFuzzer.fuzzer.get_arguments',
+ return_value=['-timeout=1', '-rss_limit_mb=2560']):
+ fuzz_result = fuzz_target_obj.fuzz()
+ self.assertEqual(bool(fuzz_result.testcase), expect_crash)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/http_utils.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/http_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfcef216766cea9ac3c56da6580f512d585af1bd
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/http_utils.py
@@ -0,0 +1,118 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Utility module for HTTP."""
+import json
+import logging
+import os
+import sys
+import tempfile
+import zipfile
+
+import requests
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import retry
+
+_DOWNLOAD_URL_RETRIES = 3
+_DOWNLOAD_URL_BACKOFF = 1
+_HTTP_REQUEST_TIMEOUT = 10
+
+
+def download_and_unpack_zip(url, extract_directory, headers=None):
+ """Downloads and unpacks a zip file from an HTTP URL.
+
+ Args:
+ url: A url to the zip file to be downloaded and unpacked.
+ extract_directory: The path where the zip file should be extracted to.
+ headers: (Optional) HTTP headers to send with the download request.
+
+ Returns:
+ True on success.
+ """
+ if headers is None:
+ headers = {}
+
+ if not os.path.exists(extract_directory):
+ logging.error('Extract directory: %s does not exist.', extract_directory)
+ return False
+
+ # Gives the temporary zip file a unique identifier in the case that
+ # that download_and_unpack_zip is done in parallel.
+ with tempfile.NamedTemporaryFile(suffix='.zip') as tmp_file:
+ if not download_url(url, tmp_file.name, headers=headers):
+ return False
+
+ try:
+ with zipfile.ZipFile(tmp_file.name, 'r') as zip_file:
+ zip_file.extractall(extract_directory)
+ except zipfile.BadZipFile:
+ logging.error('Error unpacking zip from %s. Bad Zipfile.', url)
+ return False
+
+ return True
+
+
+def download_url(*args, **kwargs):
+ """Wrapper around _download_url that returns False if _download_url
+ exceptions."""
+ try:
+ return _download_url(*args, **kwargs)
+ except Exception: # pylint: disable=broad-except
+ return False
+
+
+def get_json_from_url(url):
+ """Gets a json object from a specified HTTP URL.
+
+ Args:
+ url: The url of the json to be downloaded.
+
+ Returns:
+ A dictionary deserialized from JSON or None on failure.
+ """
+ try:
+ return requests.get(url, timeout=_HTTP_REQUEST_TIMEOUT).json()
+ except (ValueError, TypeError, json.JSONDecodeError,
+ requests.exceptions.ReadTimeout) as err:
+ logging.error('Loading json from url %s failed with: %s.', url, str(err))
+ return None
+
+
+@retry.wrap(_DOWNLOAD_URL_RETRIES, _DOWNLOAD_URL_BACKOFF)
+def _download_url(url, filename, headers=None):
+ """Downloads the file located at |url|, using HTTP to |filename|.
+
+ Args:
+ url: A url to a file to download.
+ filename: The path the file should be downloaded to.
+ headers: (Optional) HTTP headers to send with the download request.
+
+ Returns:
+ True on success.
+ """
+ if headers is None:
+ headers = {}
+
+ response = requests.get(url, headers=headers)
+
+ if response.status_code != 200:
+ logging.error('Unable to download from: %s. Code: %d. Content: %s.', url,
+ response.status_code, response.content)
+ return False
+
+ with open(filename, 'wb') as file_handle:
+ file_handle.write(response.content)
+
+ return True
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/__init__.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..219edbe457260f6bb9c3310665d853f2720ffc1d
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/__init__.py
@@ -0,0 +1,124 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Module for getting the configuration CIFuzz needs to run."""
+import logging
+import os
+
+import environment
+
+
+class BasePlatformConfig:
+ """Base class for PlatformConfig subclasses."""
+
+ @property
+ def project_src_path(self):
+ """Returns the manually checked out path of the project's source if
+ specified or None."""
+ path = os.getenv('PROJECT_SRC_PATH')
+ if not path:
+ logging.debug('No PROJECT_SRC_PATH.')
+ return path
+
+ logging.debug('PROJECT_SRC_PATH: %s.', path)
+ return path
+
+ @property
+ def workspace(self):
+ """Returns the workspace."""
+ return os.getenv('WORKSPACE')
+
+ # Optional config variables.
+
+ @property
+ def git_sha(self):
+ """Returns the Git SHA to checkout and fuzz. This is used only by GitHub
+ projects when commit fuzzing. It is not used when PR fuzzing. It is
+ definitely needed by OSS-Fuzz on GitHub since they have no copy of the repo
+ on the host and the repo on the builder image is a clone from main/master.
+ Right now it is needed by external on GitHub because we need to clone a new
+ repo because the copy they give us doesn't work for diffing.
+
+ TODO(metzman): Try to eliminate the need for this by 1. Making the clone
+ from external github projects usable. 2. Forcing OSS-Fuzz on Github to clone
+ before starting CIFuzz."""
+ return None
+
+ @property
+ def base_commit(self):
+ """Returns the base commit to diff against (commit fuzzing)."""
+ # TODO(metzman) Rename base_commit to git_base_commit.
+ return os.getenv('GIT_BASE_COMMIT')
+
+ @property
+ def base_ref(self):
+ """Returns the base branch to diff against (pr fuzzing)."""
+ # TODO(metzman) Rename base_ref to git_base_ref.
+ return os.getenv('GIT_BASE_REF')
+
+ @property
+ def pr_ref(self):
+ """Returns the pull request to checkout and fuzz. This is used only by
+ GitHub projects when PR fuzzing. It is not used when commit fuzzing. It is
+ definitely needed by OSS-Fuzz on GitHub since they have no copy of the repo
+ on the host and the repo on the builder image is a clone from main/master.
+ Right now it is needed by external on GitHub because we need to clone a new
+ repo because the copy they give us doesn't work for diffing.
+
+ TODO(metzman): Try to eliminate the need for this by 1. Making the clone
+ from external github projects usable. 2. Forcing OSS-Fuzz on Github to clone
+ before starting CIFuzz."""
+ return None
+
+ @property
+ def project_repo_owner(self):
+ """Returns the project repo owner (githubism)."""
+ return None
+
+ @property
+ def project_repo_name(self):
+ """Returns the project repo name."""
+ return os.environ.get('REPOSITORY')
+
+ @property
+ def actor(self):
+ """Name of the actor for the CI."""
+ return None
+
+ @property
+ def token(self):
+ """Returns the CI API token."""
+ return None
+
+ @property
+ def docker_in_docker(self):
+ """Returns whether or not CFL is running using Docker in Docker."""
+ return environment.get_bool('DOCKER_IN_DOCKER', False)
+
+ @property
+ def filestore(self):
+ """Returns the filestore used to store persistent data."""
+ return os.environ.get('FILESTORE')
+
+ @property
+ def git_url(self):
+ """Returns the repo URL. This is only used by GitHub users. Right now it is
+ needed by external on GitHub because we need to clone a new repo because the
+ copy they give us doesn't work for diffing. It isn't used by OSS-Fuzz on
+ github users since the Git URL is determined using repo detection.
+
+ TODO(metzman): Try to eliminate the need for this by making the clone
+ from external github projects usable.
+ TODO(metzman): As an easier goal, maybe make OSS-Fuzz GitHub use this too
+ for: 1. Consistency 2. Maybe it will allow use on forks."""
+ return None
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/gcb.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/gcb.py
new file mode 100644
index 0000000000000000000000000000000000000000..59b7e2fab641cc9709cba880b475a9395ae36d98
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/gcb.py
@@ -0,0 +1,40 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Module for getting the configuration CIFuzz needs to run on Github."""
+import logging
+import os
+
+import platform_config
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+ """CI environment for Google Cloud Build."""
+
+ @property
+ def project_src_path(self):
+ """Returns the manually checked out path of the project's source if
+ specified or the default."""
+ project_src_path = os.getenv('PROJECT_SRC_PATH', '/workspace')
+ logging.debug('PROJECT_SRC_PATH: %s.', project_src_path)
+ return project_src_path
+
+ @property
+ def workspace(self):
+ """Returns the workspace."""
+ return os.getenv('WORKSPACE', '/builder/home')
+
+ @property
+ def filestore(self):
+ """Returns the filestore used to store persistent data."""
+ return os.environ.get('FILESTORE', 'gsutil')
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/github.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/github.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc66e495acd02bb3ede6b92e289a02e2216a219c
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/github.py
@@ -0,0 +1,146 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Module for getting the configuration CIFuzz needs to run on Github."""
+import json
+import logging
+import os
+
+import platform_config
+
+
+def _get_github_event_path():
+ return os.getenv('GITHUB_EVENT_PATH')
+
+
+def _get_event_data():
+ """Returns the GitHub event data."""
+ github_event_path = _get_github_event_path()
+ with open(github_event_path, encoding='utf-8') as file_handle:
+ return json.load(file_handle)
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+ """CI environment for GitHub."""
+
+ def __init__(self):
+ self._event_data = _get_event_data()
+ self._event = os.getenv('GITHUB_EVENT_NAME')
+
+ @property
+ def workspace(self):
+ """Returns the workspace."""
+ return os.getenv('GITHUB_WORKSPACE')
+
+ @property
+ def git_sha(self):
+ """Returns the Git SHA to checkout and fuzz. This is used only by GitHub
+ projects when commit fuzzing. It is not used when PR fuzzing. It is
+ definitely needed by OSS-Fuzz on GitHub since they have no copy of the repo
+ on the host and the repo on the builder image is a clone from main/master.
+ Right now it is needed by external on GitHub because we need to clone a new
+ repo because the copy they give us doesn't work for diffing.
+
+ TODO(metzman): Try to eliminate the need for this by 1. Making the clone
+ from external github projects usable. 2. Forcing OSS-Fuzz on Github to clone
+ before starting CIFuzz."""
+ return os.getenv('GITHUB_SHA')
+
+ @property
+ def actor(self):
+ """Name of the actor for the CI."""
+ return os.getenv('GITHUB_ACTOR')
+
+ @property
+ def token(self):
+ """Returns the CI API token."""
+ return os.getenv('GITHUB_TOKEN')
+
+ @property
+ def project_src_path(self):
+ """Returns the manually checked out path of the project's source if
+ specified or None. The path returned is relative to |self.workspace| since
+ on github the checkout will be relative to there."""
+ project_src_path = super().project_src_path
+ if project_src_path is None:
+ # Not set for internal GitHub users.
+ return project_src_path
+ # On GitHub (external users), this path is relative to |workspace|.
+ return os.path.join(self.workspace, project_src_path)
+
+ @property
+ def _project_repo_owner_and_name(self):
+ """Returns a tuple containing the project repo owner and the name of the
+ repo."""
+ # On GitHub this includes owner and repo name.
+ repository = os.getenv('GITHUB_REPOSITORY')
+ # Use os.path.split to split owner from repo.
+ return os.path.split(repository)
+
+ @property
+ def project_repo_owner(self):
+ """Returns the project repo owner (githubism)."""
+ return self._project_repo_owner_and_name[0]
+
+ @property
+ def project_repo_name(self):
+ """Returns the project repo name."""
+ return self._project_repo_owner_and_name[1]
+
+ @property
+ def git_url(self):
+ """Returns the repo URL. This is only used by GitHub users. Right now it is
+ needed by external on GitHub because we need to clone a new repo because the
+ copy they give us doesn't work for diffing. It isn't used by OSS-Fuzz on
+ github users since the Git URL is determined using repo detection.
+
+ TODO(metzman): Try to eliminate the need for this by making the clone
+ from external github projects usable.
+ TODO(metzman): As an easier goal, maybe make OSS-Fuzz GitHub use this too
+ for: 1. Consistency 2. Maybe it will allow use on forks."""
+ repository = os.getenv('GITHUB_REPOSITORY')
+ github_server_url = os.getenv('GITHUB_SERVER_URL', 'https://github.com')
+ # TODO(metzman): Probably need to change this to github.server_url.
+ return os.path.join(github_server_url, repository)
+
+ @property
+ def base_commit(self):
+ """Returns the base commit to diff against (commit fuzzing)."""
+ base_commit = None
+ if self._event == 'push':
+ base_commit = self._event_data['before']
+ logging.debug('base_commit: %s', base_commit)
+ return base_commit
+
+ @property
+ def pr_ref(self):
+ """Returns the pull request to checkout and fuzz. This is used only by
+ GitHub projects when PR fuzzing. It is not used when commit fuzzing. It is
+ definitely needed by OSS-Fuzz on GitHub since they have no copy of the repo
+ on the host and the repo on the builder image is a clone from main/master.
+ Right now it is needed by external on GitHub because we need to clone a new
+ repo because the copy they give us doesn't work for diffing.
+
+ TODO(metzman): Try to eliminate the need for this by 1. Making the clone
+ from external github projects usable. 2. Forcing OSS-Fuzz on Github to clone
+ before starting CIFuzz."""
+ if self._event == 'pull_request':
+ pr_ref = f'refs/pull/{self._event_data["pull_request"]["number"]}/merge'
+ logging.debug('pr_ref: %s', pr_ref)
+ return pr_ref
+ return None
+
+ @property
+ def base_ref(self):
+ """Returns the base branch to diff against (pr fuzzing)."""
+ return os.getenv('GITHUB_BASE_REF')
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/github_test.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/github_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..11cc6866cdffd122bd0a1dbba91c1b87e676cc39
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/github_test.py
@@ -0,0 +1,87 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Tests for platform_config.github."""
+import os
+import unittest
+from unittest import mock
+
+import platform_config.github
+import test_helpers
+
+# pylint: disable=arguments-differ
+
+
+class GetProjectRepoOwnerAndNameTest(unittest.TestCase):
+ """Tests for get_project_repo_owner and get_project_repo_name."""
+
+ @mock.patch('platform_config.github._get_event_data', return_value={})
+ def setUp(self, _):
+ test_helpers.patch_environ(self)
+ self.repo_owner = 'repo-owner'
+ self.repo_name = 'repo-name'
+ os.environ['GITHUB_REPOSITORY'] = f'{self.repo_owner}/{self.repo_name}'
+ self.platform_conf = platform_config.github.PlatformConfig()
+
+ def test_github_repository_owner(self):
+ """Tests that the correct result is returned when repository contains the
+ owner and repo name (as it does on GitHub)."""
+ self.assertEqual(self.platform_conf.project_repo_owner, self.repo_owner)
+
+ def test_github_repository_name(self):
+ """Tests that the correct result is returned when repository contains the
+ owner and repo name (as it does on GitHub)."""
+ os.environ['GITHUB_REPOSITORY'] = f'{self.repo_owner}/{self.repo_name}'
+ self.assertEqual(self.platform_conf.project_repo_name, self.repo_name)
+
+
+class ProjectSrcPathTest(unittest.TestCase):
+ """Tests for project_src_path."""
+
+ def setUp(self):
+ test_helpers.patch_environ(self)
+ self.workspace = '/workspace'
+ os.environ['GITHUB_WORKSPACE'] = self.workspace
+ self.project_src_dir_name = 'project-src'
+
+ @mock.patch('platform_config.github._get_event_data', return_value={})
+ def test_github_unset(self, _):
+ """Tests that project_src_path returns None when no PROJECT_SRC_PATH is
+ set."""
+ github_env = platform_config.github.PlatformConfig()
+ self.assertIsNone(github_env.project_src_path)
+
+ @mock.patch('platform_config.github._get_event_data', return_value={})
+ def test_github(self, _):
+ """Tests that project_src_path returns the correct result on GitHub."""
+ os.environ['PROJECT_SRC_PATH'] = self.project_src_dir_name
+ expected_project_src_path = os.path.join(self.workspace,
+ self.project_src_dir_name)
+ github_env = platform_config.github.PlatformConfig()
+ self.assertEqual(github_env.project_src_path, expected_project_src_path)
+
+
+class GetGitUrlTest(unittest.TestCase):
+ """Tests for GenericPlatformConfig.git_url."""
+
+ @mock.patch('platform_config.github._get_event_data', return_value={})
+ def setUp(self, _):
+ test_helpers.patch_environ(self)
+ self.platform_conf = platform_config.github.PlatformConfig()
+
+ def test_repository(self):
+ """Tests that the correct result is returned when repository contains the
+ owner and repo name (as it does on GitHub)."""
+ os.environ['GITHUB_REPOSITORY'] = 'repo/owner'
+ self.assertEqual('https://github.com/repo/owner',
+ self.platform_conf.git_url)
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/gitlab.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/gitlab.py
new file mode 100644
index 0000000000000000000000000000000000000000..186cbefc4db9d2dc3693e36a20ed4ec40227d748
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/gitlab.py
@@ -0,0 +1,78 @@
+# Copyright 2022 Google LLC
+#
+# 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.
+"""Module for getting the configuration CIFuzz needs to run on GitLab."""
+import logging
+import os
+
+import environment
+import platform_config
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+ """CI environment for GitLab."""
+
+ @property
+ def workspace(self):
+ """Returns the workspace."""
+ return os.path.join(os.getenv('CI_BUILDS_DIR'), os.getenv('CI_JOB_ID'))
+
+ @property
+ def git_sha(self):
+ """Returns the Git SHA to checkout and fuzz."""
+ return os.getenv('CI_COMMIT_SHA')
+
+ @property
+ def project_src_path(self):
+ """Returns the directory with the source of the project"""
+ return os.getenv('CI_PROJECT_DIR')
+
+ @property
+ def token(self):
+ """Returns the job token"""
+ return os.getenv('CI_JOB_TOKEN')
+
+ @property
+ def project_repo_name(self):
+ """Returns the project's name"""
+ return os.getenv('CI_PROJECT_NAME')
+
+ @property
+ def base_commit(self):
+ """Returns the previous commit sha for commit-fuzzing"""
+ base_commit = None
+ if os.getenv('CI_PIPELINE_SOURCE') == 'push':
+ base_commit = os.getenv('CI_COMMIT_BEFORE_SHA')
+ logging.debug('base_commit: %s.', base_commit)
+ return base_commit
+
+ @property
+ def base_ref(self):
+ """Returns the base commit sha for a merge request"""
+ # Could also be CI_MERGE_REQUEST_TARGET_BRANCH_NAME.
+ return os.getenv('CI_MERGE_REQUEST_DIFF_BASE_SHA')
+
+ @property
+ def filestore(self):
+ """Returns the filestore used to store persistent data."""
+ return os.environ.get('FILESTORE', 'gitlab')
+
+ @property
+ def artifacts_dir(self):
+ """Gitlab: returns the directory to put artifacts"""
+ return environment.get('CFL_ARTIFACTS_DIR', 'artifacts')
+
+ @property
+ def cache_dir(self):
+ """Gitlab: returns the directory to use as cache"""
+ return environment.get('CFL_CACHE_DIR', 'cache')
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/prow.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/prow.py
new file mode 100644
index 0000000000000000000000000000000000000000..69c035ae80194e86b3fff7759db0f0f0aca4a64b
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/prow.py
@@ -0,0 +1,64 @@
+# Copyright 2021 Google LLC
+#
+# 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.
+"""Module for getting the configuration CIFuzz needs to run on prow."""
+import logging
+import os
+
+import platform_config
+
+# pylint: disable=too-few-public-methods
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+ """CI environment for Prow."""
+
+ @property
+ def project_src_path(self):
+ """Returns the manually checked out path of the project's source if
+ specified or the current directory if not. Prow will run ClusterfuzzLite
+ at the directory head for the repo."""
+ project_src_path = os.getenv('PROJECT_SRC_PATH', os.getcwd())
+ logging.debug('PROJECT_SRC_PATH: %s.', project_src_path)
+ return project_src_path
+
+ @property
+ def workspace(self):
+ """Returns the workspace."""
+ # Let Prow user override workspace, but default to using artifacts dir
+ return os.getenv('WORKSPACE', os.getenv('ARTIFACTS'))
+
+ @property
+ def base_ref(self):
+ """Returns the base branch to diff against (pr fuzzing)."""
+ return os.getenv('PULL_BASE_REF')
+
+ @property
+ def project_repo_name(self):
+ """Returns the project repo name."""
+ return os.getenv('REPO_NAME')
+
+ @property
+ def base_commit(self):
+ """Returns the base commit to diff against (commit fuzzing)."""
+ return os.getenv('PULL_BASE_SHA')
+
+ @property
+ def docker_in_docker(self):
+ """Returns True if using Docker in Docker."""
+ return True
+
+ @property
+ def filestore(self):
+ """Returns the filestore used to store persistent data."""
+ return os.environ.get('FILESTORE', 'gsutil')
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/standalone.py b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/standalone.py
new file mode 100644
index 0000000000000000000000000000000000000000..1975dfb1b842a28b9f2ceea809ef2f0d4d7a4a49
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/platform_config/standalone.py
@@ -0,0 +1,33 @@
+# Copyright 2022 Google LLC
+#
+# 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.
+"""Module for getting the configuration CIFuzz needs to run standalone."""
+import os
+
+import platform_config
+
+# pylint: disable=too-few-public-methods
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+ """CI environment for Standalone."""
+
+ @property
+ def filestore(self):
+ """Returns the filestore used to store persistent data."""
+ return os.environ.get('FILESTORE', 'filesystem')
+
+ @property
+ def filestore_root_dir(self):
+ """Returns the filestore used to store persistent data."""
+ return os.environ['FILESTORE_ROOT_DIR']
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/TimeoutFuzzer.cpp b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/TimeoutFuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3034d300ed52a6487df3f42a3e83325bae403ad9
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/TimeoutFuzzer.cpp
@@ -0,0 +1,36 @@
+// Copyright 2021 Google LLC
+//
+// 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.
+
+// Example of a standalone runner for "fuzz targets".
+// It reads all files passed as parameters and feeds their contents
+// one by one into the fuzz target (LLVMFuzzerTestOneInput).
+// This runner does not do any fuzzing, but allows us to run the fuzz target
+// on the test corpus (e.g. "do_stuff_test_data") or on a single file,
+// e.g. the one that comes from a bug report.
+
+// This is a fuzz target that times out on every input by infinite looping.
+// This is used for testing.
+// Build instructions:
+// 1. clang++ -fsanitize=fuzzer TimeoutFuzzer.cpp -o timeout_fuzzer
+// 2. strip timeout_fuzzer
+// The binary is stripped to save space in the git repo.
+
+#include
+#include
+
+extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) {
+ while (true)
+ ;
+ return 0;
+}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/example_crash_fuzzer_output.txt b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/example_crash_fuzzer_output.txt
new file mode 100644
index 0000000000000000000000000000000000000000..64cb0af8ceda12d9b7fbbb11a4463cd7b10c476a
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/example_crash_fuzzer_output.txt
@@ -0,0 +1,202 @@
+/github/workspace/build-out/do_stuff_fuzzer -timeout=25 -rss_limit_mb=2560 -dict=/github/workspace/build-out/do_stuff_fuzzer.dict -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmp9p1w4p8r/ -max_total_time=600 -print_final_stats=1 /github/workspace/cifuzz-corpus/do_stuff_fuzzer >fuzz-0.log 2>&1
+================== Job 0 exited with exit code 77 ============
+Dictionary: 3 entries
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 1 modules (86 inline 8-bit counters): 86 [0x6150e0, 0x615136),
+INFO: Loaded 1 PC tables (86 PCs): 86 [0x5c8b08,0x5c9068),
+INFO: 5 files found in /github/workspace/cifuzz-corpus/do_stuff_fuzzer
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
+INFO: seed corpus: files: 5 min: 3b max: 44b total: 64b rss: 31Mb
+#6 INITED cov: 64 ft: 70 corp: 5/64b exec/s: 0 rss: 32Mb
+#9 NEW cov: 64 ft: 72 corp: 6/74b lim: 4096 exec/s: 0 rss: 32Mb L: 10/44 MS: 3 ChangeBit-InsertByte-ManualDict- DE: "foo"-
+#17 NEW cov: 64 ft: 74 corp: 7/86b lim: 4096 exec/s: 0 rss: 32Mb L: 12/44 MS: 3 ChangeBit-ManualDict-PersAutoDict- DE: "ouch"-"foo"-
+#18 NEW cov: 64 ft: 76 corp: 8/100b lim: 4096 exec/s: 0 rss: 32Mb L: 14/44 MS: 1 CrossOver-
+#22 NEW cov: 64 ft: 78 corp: 9/141b lim: 4096 exec/s: 0 rss: 32Mb L: 41/44 MS: 4 InsertRepeatedBytes-CopyPart-ChangeBinInt-ChangeBit-
+#24 NEW cov: 64 ft: 80 corp: 10/151b lim: 4096 exec/s: 0 rss: 32Mb L: 10/44 MS: 2 CrossOver-CopyPart-
+#28 NEW cov: 64 ft: 81 corp: 11/171b lim: 4096 exec/s: 0 rss: 32Mb L: 20/44 MS: 4 InsertByte-PersAutoDict-ShuffleBytes-ManualDict- DE: "foo"-"ouch"-
+#43 NEW cov: 65 ft: 83 corp: 12/175b lim: 4096 exec/s: 0 rss: 32Mb L: 4/44 MS: 5 InsertByte-ChangeBit-ManualDict-ManualDict-EraseBytes- DE: "bar"-"bar"-
+#54 NEW cov: 65 ft: 84 corp: 13/191b lim: 4096 exec/s: 0 rss: 32Mb L: 16/44 MS: 1 CrossOver-
+#64 NEW cov: 65 ft: 86 corp: 14/209b lim: 4096 exec/s: 0 rss: 32Mb L: 18/44 MS: 5 InsertByte-ChangeBinInt-CMP-PersAutoDict-CopyPart- DE: "\000\000"-"foo"-
+#75 REDUCE cov: 65 ft: 86 corp: 14/203b lim: 4096 exec/s: 0 rss: 32Mb L: 35/44 MS: 1 EraseBytes-
+#76 REDUCE cov: 65 ft: 86 corp: 14/195b lim: 4096 exec/s: 0 rss: 32Mb L: 36/36 MS: 1 EraseBytes-
+=================================================================
+==26==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x603000003114 at pc 0x00000056d1db bp 0x7fffd6a72bf0 sp 0x7fffd6a72be8
+READ of size 4 at 0x603000003114 thread T0
+SCARINESS: 17 (4-byte-read-heap-buffer-overflow)
+ #0 0x56d1da in DoStuff(std::__1::basic_string, std::__1::allocator > const&) /src/cifuzz-example/my_api.cpp:26:10
+ #1 0x56c5d6 in LLVMFuzzerTestOneInput /src/cifuzz-example/do_stuff_fuzzer.cpp:15:3
+ #2 0x43de23 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+ #3 0x43d60a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+ #4 0x43ecd9 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:757:19
+ #5 0x43f9a5 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:895:5
+ #6 0x42ed0f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+ #7 0x458362 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #8 0x7fcfaa2aa082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+ #9 0x41f74d in _start (build-out/do_stuff_fuzzer+0x41f74d)
+
+DEDUP_TOKEN: DoStuff(std::__1::basic_string, std::__1::allocator > const&)--LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+0x603000003114 is located 0 bytes to the right of 20-byte region [0x603000003100,0x603000003114)
+allocated by thread T0 here:
+ #0 0x569dfd in operator new(unsigned long) /src/llvm-project/compiler-rt/lib/asan/asan_new_delete.cpp:95:3
+ #1 0x56c9d4 in __libcpp_operator_new /usr/local/bin/../include/c++/v1/new:245:10
+ #2 0x56c9d4 in __libcpp_allocate /usr/local/bin/../include/c++/v1/new:271:10
+ #3 0x56c9d4 in allocate /usr/local/bin/../include/c++/v1/__memory/allocator.h:105:38
+ #4 0x56c9d4 in allocate /usr/local/bin/../include/c++/v1/__memory/allocator_traits.h:262:20
+ #5 0x56c9d4 in __vallocate /usr/local/bin/../include/c++/v1/vector:931:37
+ #6 0x56c9d4 in vector /usr/local/bin/../include/c++/v1/vector:1236:9
+ #7 0x56c9d4 in DoStuff(std::__1::basic_string, std::__1::allocator > const&) /src/cifuzz-example/my_api.cpp:14:20
+ #8 0x56c5d6 in LLVMFuzzerTestOneInput /src/cifuzz-example/do_stuff_fuzzer.cpp:15:3
+ #9 0x43de23 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+ #10 0x43d60a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+ #11 0x43ecd9 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:757:19
+ #12 0x43f9a5 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:895:5
+ #13 0x42ed0f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+ #14 0x458362 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #15 0x7fcfaa2aa082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+
+DEDUP_TOKEN: operator new(unsigned long)--__libcpp_operator_new--__libcpp_allocate
+SUMMARY: AddressSanitizer: heap-buffer-overflow /src/cifuzz-example/my_api.cpp:26:10 in DoStuff(std::__1::basic_string, std::__1::allocator > const&)
+Shadow bytes around the buggy address:
+ 0x0c067fff85d0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff85e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff85f0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff8600: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd
+ 0x0c067fff8610: fd fa fa fa fd fd fd fa fa fa 00 00 00 00 fa fa
+=>0x0c067fff8620: 00 00[04]fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff8630: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff8640: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff8650: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff8660: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff8670: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+Shadow byte legend (one shadow byte represents 8 application bytes):
+ Addressable: 00
+ Partially addressable: 01 02 03 04 05 06 07
+ Heap left redzone: fa
+ Freed heap region: fd
+ Stack left redzone: f1
+ Stack mid redzone: f2
+ Stack right redzone: f3
+ Stack after return: f5
+ Stack use after scope: f8
+ Global redzone: f9
+ Global init order: f6
+ Poisoned by user: f7
+ Container overflow: fc
+ Array cookie: ac
+ Intra object redzone: bb
+ ASan internal: fe
+ Left alloca redzone: ca
+ Right alloca redzone: cb
+==26==ABORTING
+MS: 4 PersAutoDict-ManualDict-CrossOver-PersAutoDict- DE: "foo"-"ouch"-"bar"-; base unit: 1a25c32303e03f997166aee1c665b5ae9f66ec7d
+0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x66,0x6f,0x6f,0xff,0x1,0x62,0x61,0x72,0x63,0x68,0x6f,0x75,0x63,0x68,0x66,0x6f,0x66,0x6e,0x6f,0x6d,0x67,0x6d,
+\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377foo\377\001barchouchfofnomgm
+artifact_prefix='/tmp/tmp9p1w4p8r/'; Test unit written to /tmp/tmp9p1w4p8r/crash-1c750df432fe458b738987ba69cd20a598708775
+Base64: //////////////////////9mb2//AWJhcmNob3VjaGZvZm5vbWdt
+stat::number_of_executed_units: 90
+stat::average_exec_per_sec: 0
+stat::new_units_added: 11
+stat::slowest_unit_time_sec: 0
+stat::peak_rss_mb: 33
+/github/workspace/build-out/do_stuff_fuzzer -timeout=25 -rss_limit_mb=2560 -dict=/github/workspace/build-out/do_stuff_fuzzer.dict -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmp9p1w4p8r/ -max_total_time=600 -print_final_stats=1 /github/workspace/cifuzz-corpus/do_stuff_fuzzer >fuzz-1.log 2>&1
+================== Job 1 exited with exit code 77 ============
+Dictionary: 3 entries
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 1 modules (86 inline 8-bit counters): 86 [0x6150e0, 0x615136),
+INFO: Loaded 1 PC tables (86 PCs): 86 [0x5c8b08,0x5c9068),
+INFO: 15 files found in /github/workspace/cifuzz-corpus/do_stuff_fuzzer
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
+INFO: seed corpus: files: 15 min: 3b max: 44b total: 239b rss: 31Mb
+#16 INITED cov: 65 ft: 86 corp: 13/159b exec/s: 0 rss: 32Mb
+#38 NEW cov: 65 ft: 88 corp: 14/188b lim: 4096 exec/s: 0 rss: 32Mb L: 29/35 MS: 2 InsertByte-CopyPart-
+#43 REDUCE cov: 65 ft: 88 corp: 14/187b lim: 4096 exec/s: 0 rss: 32Mb L: 2/35 MS: 5 InsertByte-ChangeByte-ChangeBinInt-EraseBytes-EraseBytes-
+#64 NEW cov: 66 ft: 89 corp: 15/191b lim: 4096 exec/s: 0 rss: 32Mb L: 4/35 MS: 1 ChangeByte-
+#78 REDUCE cov: 66 ft: 89 corp: 15/190b lim: 4096 exec/s: 0 rss: 32Mb L: 15/35 MS: 4 ChangeBinInt-CopyPart-EraseBytes-EraseBytes-
+#95 REDUCE cov: 66 ft: 89 corp: 15/188b lim: 4096 exec/s: 0 rss: 32Mb L: 16/35 MS: 2 ChangeBinInt-EraseBytes-
+#110 REDUCE cov: 66 ft: 89 corp: 15/184b lim: 4096 exec/s: 0 rss: 32Mb L: 31/31 MS: 5 CrossOver-ChangeByte-ShuffleBytes-InsertByte-EraseBytes-
+#146 REDUCE cov: 66 ft: 89 corp: 15/183b lim: 4096 exec/s: 0 rss: 32Mb L: 1/31 MS: 1 EraseBytes-
+#157 NEW cov: 66 ft: 90 corp: 16/210b lim: 4096 exec/s: 0 rss: 32Mb L: 27/31 MS: 1 CrossOver-
+#230 REDUCE cov: 66 ft: 92 corp: 17/318b lim: 4096 exec/s: 0 rss: 32Mb L: 108/108 MS: 3 CopyPart-InsertRepeatedBytes-CrossOver-
+#277 NEW cov: 66 ft: 94 corp: 18/429b lim: 4096 exec/s: 0 rss: 32Mb L: 111/111 MS: 2 ManualDict-CMP- DE: "bar"-"\000\000\000\000"-
+#337 NEW cov: 67 ft: 95 corp: 19/439b lim: 4096 exec/s: 0 rss: 32Mb L: 10/111 MS: 5 ChangeByte-ChangeBit-ManualDict-CopyPart-EraseBytes- DE: "bar"-
+=================================================================
+==30==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x603000007d94 at pc 0x00000056d1db bp 0x7ffdb9da4b50 sp 0x7ffdb9da4b48
+READ of size 4 at 0x603000007d94 thread T0
+SCARINESS: 17 (4-byte-read-heap-buffer-overflow)
+ #0 0x56d1da in DoStuff(std::__1::basic_string, std::__1::allocator > const&) /src/cifuzz-example/my_api.cpp:26:10
+ #1 0x56c5d6 in LLVMFuzzerTestOneInput /src/cifuzz-example/do_stuff_fuzzer.cpp:15:3
+ #2 0x43de23 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+ #3 0x43d60a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+ #4 0x43ecd9 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:757:19
+ #5 0x43f9a5 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:895:5
+ #6 0x42ed0f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+ #7 0x458362 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #8 0x7fc2c6bd3082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+ #9 0x41f74d in _start (build-out/do_stuff_fuzzer+0x41f74d)
+
+DEDUP_TOKEN: DoStuff(std::__1::basic_string, std::__1::allocator > const&)--LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+0x603000007d94 is located 0 bytes to the right of 20-byte region [0x603000007d80,0x603000007d94)
+allocated by thread T0 here:
+ #0 0x569dfd in operator new(unsigned long) /src/llvm-project/compiler-rt/lib/asan/asan_new_delete.cpp:95:3
+ #1 0x56c9d4 in __libcpp_operator_new /usr/local/bin/../include/c++/v1/new:245:10
+ #2 0x56c9d4 in __libcpp_allocate /usr/local/bin/../include/c++/v1/new:271:10
+ #3 0x56c9d4 in allocate /usr/local/bin/../include/c++/v1/__memory/allocator.h:105:38
+ #4 0x56c9d4 in allocate /usr/local/bin/../include/c++/v1/__memory/allocator_traits.h:262:20
+ #5 0x56c9d4 in __vallocate /usr/local/bin/../include/c++/v1/vector:931:37
+ #6 0x56c9d4 in vector /usr/local/bin/../include/c++/v1/vector:1236:9
+ #7 0x56c9d4 in DoStuff(std::__1::basic_string, std::__1::allocator > const&) /src/cifuzz-example/my_api.cpp:14:20
+ #8 0x56c5d6 in LLVMFuzzerTestOneInput /src/cifuzz-example/do_stuff_fuzzer.cpp:15:3
+ #9 0x43de23 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+ #10 0x43d60a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+ #11 0x43ecd9 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:757:19
+ #12 0x43f9a5 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:895:5
+ #13 0x42ed0f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+ #14 0x458362 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #15 0x7fc2c6bd3082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+
+DEDUP_TOKEN: operator new(unsigned long)--__libcpp_operator_new--__libcpp_allocate
+SUMMARY: AddressSanitizer: heap-buffer-overflow /src/cifuzz-example/my_api.cpp:26:10 in DoStuff(std::__1::basic_string, std::__1::allocator > const&)
+Shadow bytes around the buggy address:
+ 0x0c067fff8f60: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd
+ 0x0c067fff8f70: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa fa
+ 0x0c067fff8f80: fd fd fd fa fa fa fd fd fd fa fa fa fd fd fd fa
+ 0x0c067fff8f90: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd
+ 0x0c067fff8fa0: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa fa
+=>0x0c067fff8fb0: 00 00[04]fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff8fc0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff8fd0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff8fe0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff8ff0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c067fff9000: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+Shadow byte legend (one shadow byte represents 8 application bytes):
+ Addressable: 00
+ Partially addressable: 01 02 03 04 05 06 07
+ Heap left redzone: fa
+ Freed heap region: fd
+ Stack left redzone: f1
+ Stack mid redzone: f2
+ Stack right redzone: f3
+ Stack after return: f5
+ Stack use after scope: f8
+ Global redzone: f9
+ Global init order: f6
+ Poisoned by user: f7
+ Container overflow: fc
+ Array cookie: ac
+ Intra object redzone: bb
+ ASan internal: fe
+ Left alloca redzone: ca
+ Right alloca redzone: cb
+==30==ABORTING
+MS: 4 ShuffleBytes-ManualDict-CrossOver-PersAutoDict- DE: "foo"-"bar"-; base unit: 8fc7da8d952ed1aa5c7415e21b3d52b42402973d
+0x66,0x6f,0x6f,0x63,0x6f,0x75,0x6f,0x75,0x63,0x68,0x63,0x68,0x66,0x62,0x61,0x72,0x6f,0x6f,0x6d,0x67,0x66,0x6f,0x6f,0x2f,0x99,0x6f,0x6f,0x90,0x6f,0x6f,0x6d,0x0,0x0,0x67,0x2f,
+foocououchchfbaroomgfoo/\231oo\220oom\000\000g/
+artifact_prefix='/tmp/tmp9p1w4p8r/'; Test unit written to /tmp/tmp9p1w4p8r/crash-f8a2a1e84f58a2d676e5ad8078119a39b78df901
+Base64: Zm9vY291b3VjaGNoZmJhcm9vbWdmb28vmW9vkG9vbQAAZy8=
+stat::number_of_executed_units: 366
+stat::average_exec_per_sec: 0
+stat::new_units_added: 11
+stat::slowest_unit_time_sec: 0
+stat::peak_rss_mb: 33
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/external-project/do_stuff_fuzzer.cpp b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/external-project/do_stuff_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eaf70137c3b8aa58a6c09f89eecdba7f5ebbd010
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/external-project/do_stuff_fuzzer.cpp
@@ -0,0 +1,24 @@
+// Copyright 2020 Google LLC
+//
+// 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 "my_api.h"
+
+#include
+
+// Simple fuzz target for DoStuff().
+// See https://llvm.org/docs/LibFuzzer.html for details.
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+ std::string str(reinterpret_cast(data), size);
+ DoStuff(str); // Disregard the output.
+ return 0;
+}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/msan_crash_fuzzer_bug_summary.txt b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/msan_crash_fuzzer_bug_summary.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b55e9c6b73b5d645ca7fba6a196f2485bd423b24
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/msan_crash_fuzzer_bug_summary.txt
@@ -0,0 +1,22 @@
+MemorySanitizer: use-of-uninitialized-value
+#0 0x52675f in LLVMFuzzerTestOneInput /src/cifuzz-example/do_stuff_fuzzer.cpp:13:7
+#1 0x45a431 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:599:15
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+#7 0x41eab8 in _start (out/do_stuff_fuzzer+0x41eab8)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&)
+Uninitialized value was created by a heap allocation
+#0 0x4d57ad in malloc /src/llvm-project/compiler-rt/lib/msan/msan_interceptors.cpp:901:3
+#1 0x437c07 in operator new(unsigned long) (out/do_stuff_fuzzer+0x437c07)
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+DEDUP_TOKEN: malloc--operator new(unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&)
+
+SUMMARY:
\ No newline at end of file
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/msan_crash_fuzzer_output.txt b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/msan_crash_fuzzer_output.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c803bfb1c928e7613baa0f7dfd39238e59ecc9b4
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/msan_crash_fuzzer_output.txt
@@ -0,0 +1,39 @@
+Dictionary: 3 entries
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 1 modules (184 inline 8-bit counters): 184 [0x829300, 0x8293b8),
+INFO: Loaded 1 PC tables (184 PCs): 184 [0x5dc910,0x5dd490),
+INFO: 5 files found in /tmp/do_stuff_fuzzer_corpus
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
+==13==WARNING: MemorySanitizer: use-of-uninitialized-value
+#0 0x52675f in LLVMFuzzerTestOneInput /src/cifuzz-example/do_stuff_fuzzer.cpp:13:7
+#1 0x45a431 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:599:15
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+#7 0x41eab8 in _start (out/do_stuff_fuzzer+0x41eab8)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&)
+Uninitialized value was created by a heap allocation
+#0 0x4d57ad in malloc /src/llvm-project/compiler-rt/lib/msan/msan_interceptors.cpp:901:3
+#1 0x437c07 in operator new(unsigned long) (out/do_stuff_fuzzer+0x437c07)
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+DEDUP_TOKEN: malloc--operator new(unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&)
+
+SUMMARY: MemorySanitizer: use-of-uninitialized-value /src/cifuzz-example/do_stuff_fuzzer.cpp:13:7 in LLVMFuzzerTestOneInput
+Unique heap origins: 65
+Stack depot allocated bytes: 4424
+Unique origin histories: 29
+History depot allocated bytes: 696
+Exiting
+MS: 0 ; base unit: 0000000000000000000000000000000000000000
+
+
+artifact_prefix='./'; Test unit written to ./crash-da39a3ee5e6b4b0d3255bfef95601890afd80709
+Base64:
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/sarif_utils_msan_stack.txt b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/sarif_utils_msan_stack.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9214d8f81f9c77c12b77b6da46db80473941f9fd
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/sarif_utils_msan_stack.txt
@@ -0,0 +1,62 @@
+Dictionary: 3 entries
+2024-05-07 18:49:02,343 - root - INFO - Fuzzer: do_stuff_fuzzer. Detected bug.
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 1 modules (83 inline 8-bit counters): 83 [0x563ff0e03e98, 0x563ff0e03eeb),
+INFO: Loaded 1 PC tables (83 PCs): 83 [0x563ff0e03ef0,0x563ff0e04420),
+INFO: 0 files found in /github/workspace/cifuzz-corpus/do_stuff_fuzzer
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
+INFO: A corpus is not provided, starting from an empty corpus
+#2 INITED cov: 2 ft: 2 corp: 1/1b exec/s: 0 rss: 69Mb
+#4 NEW cov: 3 ft: 3 corp: 2/3b lim: 4096 exec/s: 0 rss: 69Mb L: 2/2 MS: 2 ChangeBit-InsertByte-
+==23==WARNING: MemorySanitizer: use-of-uninitialized-value
+ #0 0x563ff0d278f0 in LLVMFuzzerTestOneInput /src/cifuzz-external-example/do_stuff_fuzzer.cpp:24:1
+ #1 0x563ff0c24340 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:614:13
+ #2 0x563ff0c23b65 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:516:7
+ #3 0x563ff0c25335 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:760:19
+ #4 0x563ff0c26125 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector>&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:905:5
+ #5 0x563ff0c14436 in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:914:6
+ #6 0x563ff0c40962 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #7 0x7f4c156ed082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 87b331c034a6458c64ce09c03939e947212e18ce)
+ #8 0x563ff0c055ad in _start (build-out/do_stuff_fuzzer+0x4a5ad)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*)
+ Uninitialized value was stored to memory at
+ #0 0x563ff0d278e9 in LLVMFuzzerTestOneInput /src/cifuzz-external-example/do_stuff_fuzzer.cpp
+ #1 0x563ff0c24340 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:614:13
+ #2 0x563ff0c23b65 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:516:7
+ #3 0x563ff0c25335 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:760:19
+ #4 0x563ff0c26125 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector>&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:905:5
+ #5 0x563ff0c14436 in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:914:6
+ #6 0x563ff0c40962 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #7 0x7f4c156ed082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 87b331c034a6458c64ce09c03939e947212e18ce)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*)
+ Uninitialized value was created by a heap deallocation
+ #0 0x563ff0cc7480 in free /src/llvm-project/compiler-rt/lib/msan/msan_interceptors.cpp:218:3
+ #1 0x563ff0d27800 in LLVMFuzzerTestOneInput /src/cifuzz-external-example/do_stuff_fuzzer.cpp:21:5
+ #2 0x563ff0c24340 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:614:13
+ #3 0x563ff0c23b65 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:516:7
+ #4 0x563ff0c25335 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:760:19
+ #5 0x563ff0c26125 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector>&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:905:5
+ #6 0x563ff0c14436 in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:914:6
+ #7 0x563ff0c40962 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #8 0x7f4c156ed082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 87b331c034a6458c64ce09c03939e947212e18ce)
+
+DEDUP_TOKEN: __interceptor_free--LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+SUMMARY: MemorySanitizer: use-of-uninitialized-value /src/cifuzz-external-example/do_stuff_fuzzer.cpp:24:1 in LLVMFuzzerTestOneInput
+Unique heap origins: 201
+Stack depot allocated bytes: 9764880
+Unique origin histories: 181
+History depot allocated bytes: 196608
+Exiting
+MS: 5 ShuffleBytes-CopyPart-InsertByte-CopyPart-ManualDict- DE: "bar"-; base unit: adc83b19e793491b1c6ea0fd8b46cd9f32e592fc
+0xa,0x62,0x61,0x72,0xa,
+\012bar\012
+artifact_prefix='/tmp/tmp1tc5b3m2/'; Test unit written to /tmp/tmp1tc5b3m2/crash-c935b6724d7e27401ac9af3773700ca86ac38dea
+Base64: CmJhcgo=
+stat::number_of_executed_units: 159
+stat::average_exec_per_sec: 0
+stat::new_units_added: 1
+stat::slowest_unit_time_sec: 0
+stat::peak_rss_mb: 69
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/sarif_utils_systemd_stack.txt b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/sarif_utils_systemd_stack.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e632d3e659b53090d776c36a46885c6934d51f23
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/sarif_utils_systemd_stack.txt
@@ -0,0 +1,302 @@
+/github/workspace/build-out/fuzz-bus-label -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpsngf52cy/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-bus-label >fuzz-0.log 2>&1
+================== Job 0 exited with exit code 0 ============
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 2 modules (82577 inline 8-bit counters): 82573 [0x7fc55e6bedf0, 0x7fc55e6d307d), 4 [0x5e9c28, 0x5e9c2c),
+2023-05-04 01:02:55,065 - root - INFO - Not reporting crash in fuzz-bus-label because process timed out.
+2023-05-04 01:02:55,069 - root - INFO - Deleting corpus and seed corpus of fuzz-bus-label to save disk.
+INFO: Loaded 2 PC tables (82577 PCs): 82573 [0x7fc55e6d3080,0x7fc55e815950), 4 [0x5a6c78,0x5a6cb8),
+INFO: 256 files found in /github/workspace/cifuzz-corpus/fuzz-bus-label
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 1048576 bytes
+INFO: seed corpus: files: 256 min: 1b max: 5242880b total: 30968483b rss: 48Mb
+#257 INITED cov: 41 ft: 230 corp: 111/4360b exec/s: 0 rss: 73Mb
+#131072 pulse cov: 41 ft: 230 corp: 111/4360b lim: 1048576 exec/s: 43690 rss: 76Mb
+#262144 pulse cov: 41 ft: 230 corp: 111/4360b lim: 1048576 exec/s: 43690 rss: 76Mb
+#524288 pulse cov: 41 ft: 230 corp: 111/4360b lim: 1048576 exec/s: 43690 rss: 77Mb
+#609082 DONE cov: 41 ft: 230 corp: 111/4360b lim: 1048576 exec/s: 43505 rss: 77Mb
+Done 609082 runs in 14 second(s)
+stat::number_of_executed_units: 609082
+stat::average_exec_per_sec: 43505
+stat::new_units_added: 0
+stat::slowest_unit_time_sec: 0
+stat::peak_rss_mb: 77
+/github/workspace/build-out/fuzz-bus-label -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpsngf52cy/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-bus-label >fuzz-1.log 2>&1
+2023-05-04 01:02:55,082 - root - INFO - Deleting fuzz target: fuzz-bus-label.
+2023-05-04 01:02:55,083 - root - INFO - Done deleting.
+2023-05-04 01:02:55,084 - root - INFO - Fuzzer fuzz-bus-label finished running without reportable crashes.
+2023-05-04 01:02:55,084 - root - INFO - Running fuzzer: fuzz-dhcp-server.
+2023-05-04 01:02:55,085 - root - INFO - Downloading corpus from OSS-Fuzz: https://storage.googleapis.com/systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-dhcp-server/public.zip
+2023-05-04 01:02:55,088 - urllib3.connectionpool - DEBUG - Starting new HTTPS connection (1): storage.googleapis.com:443
+2023-05-04 01:02:55,145 - urllib3.connectionpool - DEBUG - https://storage.googleapis.com:443 "GET /systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-dhcp-server/public.zip HTTP/1.1" 200 806749
+2023-05-04 01:02:55,350 - root - INFO - Starting fuzzing
+Fuzzing logs:
+/github/workspace/build-out/fuzz-dhcp-server -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpyxgwwsvr/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-dhcp-server >fuzz-0.log 2>&1
+================== Job 0 exited with exit code 0 ============
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 2 modules (83640 inline 8-bit counters): 82573 [0x7fe86ff70df0, 0x7fe86ff8507d), 1067 [0x60c638, 0x60ca63),
+INFO: Loaded 2 PC tables (83640 PCs): 82573 [0x7fe86ff85080,0x7fe8700c7950), 1067 [0x60ca68,0x610d18),
+INFO: 1153 files found in /github/workspace/cifuzz-corpus/fuzz-dhcp-server
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 1048576 bytes
+INFO: seed corpus: files: 1153 min: 1b max: 5242879b total: 17056071b rss: 50Mb
+#1155 INITED cov: 577 ft: 1116 corp: 203/54Kb exec/s: 0 rss: 86Mb
+#1167 NEW cov: 577 ft: 1117 corp: 204/54Kb lim: 1048576 exec/s: 0 rss: 86Mb L: 243/1071 MS: 2 ChangeASCIIInt-CrossOver-
+#1509 NEW cov: 577 ft: 1118 corp: 205/54Kb lim: 1048576 exec/s: 0 rss: 86Mb L: 243/1071 MS: 2 ChangeBit-CopyPart-
+#63018 NEW cov: 577 ft: 1119 corp: 206/55Kb lim: 1048576 exec/s: 21006 rss: 86Mb L: 245/1071 MS: 4 InsertByte-ChangeByte-CMP-InsertByte- DE: "2\000\000\000\000\000\000\000"-
+#65536 pulse cov: 577 ft: 1119 corp: 206/55Kb lim: 1048576 exec/s: 21845 rss: 86Mb
+Loaded 1024/1155 files from /github/workspace/cifuzz-corpus/fuzz-dhcp-server
+#99784 NEW cov: 577 ft: 1120 corp: 207/55Kb lim: 1048576 exec/s: 19956 rss: 105Mb L: 243/1071 MS: 2 ChangeASCIIInt-ChangeBinInt-
+#131072 pulse cov: 577 ft: 1120 corp: 207/55Kb lim: 1048576 exec/s: 21845 rss: 105Mb
+#262144 pulse cov: 577 ft: 1120 corp: 207/55Kb lim: 1048576 exec/s: 20164 rss: 105Mb
+#275639 DONE cov: 577 ft: 1120 corp: 207/55Kb lim: 1048576 exec/s: 19688 rss: 105Mb
+###### Recommended dictionary. ######
+"2\000\000\000\000\000\000\000" # Uses: 17879
+###### End of recommended dictionary. ######
+Done 275639 runs in 14 second(s)
+stat::number_of_executed_units: 275639
+stat::average_exec_per_sec: 19688
+stat::new_units_added: 4
+stat::slowest_unit_time_sec: 0
+stat::peak_rss_mb: 105
+/github/workspace/build-out/fuzz-dhcp-server -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpyxgwwsvr/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-dhcp-server >fuzz-1.log 2>&1
+2023-05-04 01:03:18,374 - root - INFO - Not reporting crash in fuzz-dhcp-server because process timed out.
+2023-05-04 01:03:18,377 - root - INFO - Deleting corpus and seed corpus of fuzz-dhcp-server to save disk.
+2023-05-04 01:03:18,399 - root - INFO - Deleting fuzz target: fuzz-dhcp-server.
+2023-05-04 01:03:18,400 - root - INFO - Done deleting.
+2023-05-04 01:03:18,400 - root - INFO - Fuzzer fuzz-dhcp-server finished running without reportable crashes.
+2023-05-04 01:03:18,401 - root - INFO - Running fuzzer: fuzz-bcd.
+2023-05-04 01:03:18,401 - root - INFO - Downloading corpus from OSS-Fuzz: https://storage.googleapis.com/systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-bcd/public.zip
+2023-05-04 01:03:18,404 - urllib3.connectionpool - DEBUG - Starting new HTTPS connection (1): storage.googleapis.com:443
+2023-05-04 01:03:18,582 - urllib3.connectionpool - DEBUG - https://storage.googleapis.com:443 "GET /systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-bcd/public.zip HTTP/1.1" 200 2293254
+2023-05-04 01:03:18,804 - root - INFO - Starting fuzzing
+Fuzzing logs:
+/github/workspace/build-out/fuzz-bcd -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpgvqlyr8q/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-bcd >fuzz-0.log 2>&1
+================== Job 0 exited with exit code 0 ============
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 2 modules (83175 inline 8-bit counters): 82573 [0x7f1b5387edf0, 0x7f1b5389307d), 602 [0x5f8718, 0x5f8972),
+INFO: Loaded 2 PC tables (83175 PCs): 82573 [0x7f1b53893080,0x7f1b539d5950), 602 [0x5f8978,0x5faf18),
+INFO: 1260 files found in /github/workspace/cifuzz-corpus/fuzz-bcd
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 946175 bytes
+INFO: seed corpus: files: 1260 min: 1b max: 946175b total: 10373697b rss: 48Mb
+#1261 INITED cov: 137 ft: 653 corp: 282/1416Kb exec/s: 0 rss: 91Mb
+#65536 pulse cov: 137 ft: 653 corp: 282/1416Kb lim: 946175 exec/s: 32768 rss: 98Mb
+#131072 pulse cov: 137 ft: 653 corp: 282/1416Kb lim: 946175 exec/s: 32768 rss: 98Mb
+#262144 pulse cov: 137 ft: 653 corp: 282/1416Kb lim: 946175 exec/s: 37449 rss: 98Mb
+#475081 DONE cov: 137 ft: 653 corp: 282/1416Kb lim: 946175 exec/s: 33934 rss: 98Mb
+Done 475081 runs in 14 second(s)
+stat::number_of_executed_units: 475081
+stat::average_exec_per_sec: 33934
+stat::new_units_added: 0
+stat::slowest_unit_time_sec: 0
+stat::peak_rss_mb: 98
+/github/workspace/build-out/fuzz-bcd -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpgvqlyr8q/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-bcd >fuzz-1.log 2>&1
+2023-05-04 01:03:41,821 - root - INFO - Not reporting crash in fuzz-bcd because process timed out.
+2023-05-04 01:03:41,822 - root - INFO - Deleting corpus and seed corpus of fuzz-bcd to save disk.
+2023-05-04 01:03:41,848 - root - INFO - Deleting fuzz target: fuzz-bcd.
+2023-05-04 01:03:41,848 - root - INFO - Done deleting.
+2023-05-04 01:03:41,848 - root - INFO - Fuzzer fuzz-bcd finished running without reportable crashes.
+2023-05-04 01:03:41,848 - root - INFO - Running fuzzer: fuzz-varlink.
+2023-05-04 01:03:41,849 - root - INFO - Downloading corpus from OSS-Fuzz: https://storage.googleapis.com/systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-varlink/public.zip
+2023-05-04 01:03:41,852 - urllib3.connectionpool - DEBUG - Starting new HTTPS connection (1): storage.googleapis.com:443
+2023-05-04 01:03:41,906 - urllib3.connectionpool - DEBUG - https://storage.googleapis.com:443 "GET /systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-varlink/public.zip HTTP/1.1" 200 2586434
+2023-05-04 01:03:42,671 - root - INFO - Starting fuzzing
+2023-05-04 01:04:05,709 - root - INFO - Not reporting crash in fuzz-varlink because process timed out.
+Fuzzing logs:
+/github/workspace/build-out/fuzz-varlink -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpbtf4f932/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-varlink >fuzz-0.log 2>&1
+2023-05-04 01:04:05,709 - root - INFO - Deleting corpus and seed corpus of fuzz-varlink to save disk.
+2023-05-04 01:04:05,806 - root - INFO - Deleting fuzz target: fuzz-varlink.
+2023-05-04 01:04:05,806 - root - INFO - Done deleting.
+2023-05-04 01:04:05,806 - root - INFO - Fuzzer fuzz-varlink finished running without reportable crashes.
+2023-05-04 01:04:05,806 - root - INFO - Running fuzzer: fuzz-unit-file.
+2023-05-04 01:04:05,807 - root - INFO - Downloading corpus from OSS-Fuzz: https://storage.googleapis.com/systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-unit-file/public.zip
+2023-05-04 01:04:05,809 - urllib3.connectionpool - DEBUG - Starting new HTTPS connection (1): storage.googleapis.com:443
+2023-05-04 01:04:05,897 - urllib3.connectionpool - DEBUG - https://storage.googleapis.com:443 "GET /systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-unit-file/public.zip HTTP/1.1" 200 4999974
+2023-05-04 01:04:07,869 - root - INFO - Starting fuzzing
+2023-05-04 01:04:09,516 - root - INFO - Fuzzer: fuzz-unit-file. Detected bug.
+Fuzzing logs:
+/github/workspace/build-out/fuzz-unit-file -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpjhswtxiw/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-unit-file >fuzz-0.log 2>&1
+2023-05-04 01:04:09,517 - root - INFO - Trying to reproduce crash using: /tmp/tmpjhswtxiw/crash-7be9e0f3a71d95f8d5e67c5a9d84273d6f4e3c03.
+================== Job 0 exited with exit code 77 ============
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 2 modules (82576 inline 8-bit counters): 82573 [0x7f3b0de4cdf0, 0x7f3b0de6107d), 3 [0x5e9b28, 0x5e9b2b),
+INFO: Loaded 2 PC tables (82576 PCs): 82573 [0x7f3b0de61080,0x7f3b0dfa3950), 3 [0x5a6af8,0x5a6b28),
+INFO: 20907 files found in /github/workspace/cifuzz-corpus/fuzz-unit-file
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 604973 bytes
+INFO: seed corpus: files: 20907 min: 1b max: 604973b total: 16005340b rss: 61Mb
+=================================================================
+==74==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000005078 at pc 0x0000004ddffa bp 0x7fffeea64fe0 sp 0x7fffeea64fd8
+READ of size 4 at 0x602000005078 thread T0
+SCARINESS: 27 (4-byte-read-heap-buffer-overflow-far-from-bounds)
+ #0 0x4ddff9 in samLLVM2FuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:30:16
+ #1 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+ #2 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+ #3 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+ #4 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+ #5 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+ #6 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #7 0x7f3b0ce20082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+ #8 0x41f6ed in _start (build-out/fuzz-unit-file+0x41f6ed)
+
+DEDUP_TOKEN: samLLVM2FuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*)
+0x602000005078 is located 38 bytes to the right of 2-byte region [0x602000005050,0x602000005052)
+freed by thread T0 here:
+ #0 0x4a0882 in __interceptor_free /src/llvm-project/compiler-rt/lib/asan/asan_malloc_linux.cpp:52:3
+ #1 0x4ddfb7 in samLLVM2FuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:29:9
+ #2 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+ #3 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+ #4 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+ #5 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+ #6 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+ #7 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #8 0x7f3b0ce20082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+
+DEDUP_TOKEN: __interceptor_free--samLLVM2FuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+previously allocated by thread T0 here:
+ #0 0x4a0b26 in malloc /src/llvm-project/compiler-rt/lib/asan/asan_malloc_linux.cpp:69:3
+ #1 0x4ddfac in samLLVM2FuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:28:25
+ #2 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+ #3 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+ #4 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+ #5 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+ #6 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+ #7 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #8 0x7f3b0ce20082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+
+DEDUP_TOKEN: malloc--samLLVM2FuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+SUMMARY: AddressSanitizer: heap-buffer-overflow /work/build/../../src/systemd/src/core/fuzz-unit-file.c:30:16 in samLLVM2FuzzerTestOneInput
+Shadow bytes around the buggy address:
+ 0x0c047fff89b0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+ 0x0c047fff89c0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+ 0x0c047fff89d0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+ 0x0c047fff89e0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+ 0x0c047fff89f0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+=>0x0c047fff8a00: fa fa 00 02 fa fa 00 02 fa fa fd fa fa fa fa[fa]
+ 0x0c047fff8a10: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c047fff8a20: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c047fff8a30: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c047fff8a40: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c047fff8a50: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+Shadow byte legend (one shadow byte represents 8 application bytes):
+ Addressable: 00
+ Partially addressable: 01 02 03 04 05 06 07
+ Heap left redzone: fa
+ Freed heap region: fd
+ Stack left redzone: f1
+ Stack mid redzone: f2
+ Stack right redzone: f3
+ Stack after return: f5
+ Stack use after scope: f8
+ Global redzone: f9
+ Global init order: f6
+ Poisoned by user: f7
+ Container overflow: fc
+ Array cookie: ac
+ Intra object redzone: bb
+ ASan internal: fe
+ Left alloca redzone: ca
+ Right alloca redzone: cb
+==74==ABORTING
+MS: 0 ; base unit: 0000000000000000000000000000000000000000
+0x61,0x75,0x74,0x6f,0x6d,0x6f,0x75,0x6e,0x74,0x48,
+automountH
+artifact_prefix='/tmp/tmpjhswtxiw/'; Test unit written to /tmp/tmpjhswtxiw/crash-7be9e0f3a71d95f8d5e67c5a9d84273d6f4e3c03
+Base64: YXV0b21vdW50SA==
+stat::number_of_executed_units: 314
+stat::average_exec_per_sec: 0
+stat::new_units_added: 0
+stat::slowest_unit_time_sec: 0
+stat::peak_rss_mb: 67
+/github/workspace/build-out/fuzz-unit-file -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpjhswtxiw/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-unit-file >fuzz-1.log 2>&1
+================== Job 1 exited with exit code 77 ============
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 2 modules (82576 inline 8-bit counters): 82573 [0x7ff1ba038df0, 0x7ff1ba04d07d), 3 [0x5e9b28, 0x5e9b2b),
+INFO: Loaded 2 PC tables (82576 PCs): 82573 [0x7ff1ba04d080,0x7ff1ba18f950), 3 [0x5a6af8,0x5a6b28),
+INFO: 20907 files found in /github/workspace/cifuzz-corpus/fuzz-unit-file
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 604973 bytes
+INFO: seed corpus: files: 20907 min: 1b max: 604973b total: 16005340b rss: 61Mb
+=================================================================
+==78==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000005078 at pc 0x0000004ddffa bp 0x7ffc2e6825c0 sp 0x7ffc2e6825b8
+READ of size 4 at 0x602000005078 thread T0
+SCARINESS: 27 (4-byte-read-heap-buffer-overflow-far-from-bounds)
+ #0 0x4ddff9 in samLLVM2FuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:30:16
+ #1 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+ #2 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+ #3 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+ #4 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+ #5 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+ #6 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #7 0x7ff1b900c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+ #8 0x41f6ed in _start (build-out/fuzz-unit-file+0x41f6ed)
+
+DEDUP_TOKEN: samLLVM2FuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*)
+0x602000005078 is located 38 bytes to the right of 2-byte region [0x602000005050,0x602000005052)
+freed by thread T0 here:
+ #0 0x4a0882 in __interceptor_free /src/llvm-project/compiler-rt/lib/asan/asan_malloc_linux.cpp:52:3
+ #1 0x4ddfb7 in samLLVM2FuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:29:9
+ #2 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+ #3 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+ #4 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+ #5 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+ #6 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+ #7 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #8 0x7ff1b900c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+
+DEDUP_TOKEN: __interceptor_free--samLLVM2FuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+previously allocated by thread T0 here:
+ #0 0x4a0b26 in malloc /src/llvm-project/compiler-rt/lib/asan/asan_malloc_linux.cpp:69:3
+ #1 0x4ddfac in samLLVM2FuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:28:25
+ #2 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+ #3 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+ #4 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+ #5 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+ #6 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+ #7 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+ #8 0x7ff1b900c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+
+DEDUP_TOKEN: malloc--samLLVM2FuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+SUMMARY: AddressSanitizer: heap-buffer-overflow /work/build/../../src/systemd/src/core/fuzz-unit-file.c:30:16 in samsamLLVM2FuzzerTestOneInput
+Shadow bytes around the buggy address:
+ 0x0c047fff89b0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+ 0x0c047fff89c0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+ 0x0c047fff89d0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+ 0x0c047fff89e0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+ 0x0c047fff89f0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+=>0x0c047fff8a00: fa fa 00 02 fa fa 00 02 fa fa fd fa fa fa fa[fa]
+ 0x0c047fff8a10: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c047fff8a20: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c047fff8a30: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c047fff8a40: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+ 0x0c047fff8a50: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+Shadow byte legend (one shadow byte represents 8 application bytes):
+ Addressable: 00
+ Partially addressable: 01 02 03 04 05 06 07
+ Heap left redzone: fa
+ Freed heap region: fd
+ Stack left redzone: f1
+ Stack mid redzone: f2
+ Stack right redzone: f3
+ Stack after return: f5
+ Stack use after scope: f8
+ Global redzone: f9
+ Global init order: f6
+ Poisoned by user: f7
+ Container overflow: fc
+ Array cookie: ac
+ Intra object redzone: bb
+ ASan internal: fe
+ Left alloca redzone: ca
+ Right alloca redzone: cb
+==78==ABORTING
+MS: 0 ; base unit: 0000000000000000000000000000000000000000
+0x61,0x75,0x74,0x6f,0x6d,0x6f,0x75,0x6e,0x74,0x48,
+automountH
+artifact_prefix='/tmp/tmpjhswtxiw/'; Test unit written to /tmp/tmpjhswtxiw/crash-7be9e0f3a71d95f8d5e67c5a9d84273d6f4e3c03
+Base64: YXV0b21vdW50SA==
+stat::number_of_executed_units: 314
+stat::average_exec_per_sec: 0
+stat::new_units_added: 0
+stat::slowest_unit_time_sec: 0
+stat::peak_rss_mb: 68
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/Makefile b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..04db9976eac198bd430650da656998169912dc2f
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/Makefile
@@ -0,0 +1,41 @@
+.POSIX:
+CXX = clang++
+CFLAGS = -std=c++17 -Wall -Wextra -O3 -g3 -Werror
+
+all: SystemSan target target_file target_dns
+
+SystemSan: SystemSan.cpp inspect_dns.cpp inspect_utils.cpp
+ $(CXX) $(CFLAGS) -lpthread -o $@ $^
+
+# Needs atheris.
+python-test: all
+ ./SystemSan python shell_injection_poc_fuzzer.py
+
+target: target.cpp
+ $(CXX) $(CFLAGS) -fsanitize=address,fuzzer -o $@ $^
+
+target_file: target_file.cpp
+ $(CXX) $(CFLAGS) -fsanitize=address,fuzzer -o $@ $^
+
+target_dns: target_dns.cpp
+ $(CXX) $(CFLAGS) -fsanitize=address,fuzzer -o $@ $^
+
+test: all vuln.dict
+ ./SystemSan ./target -dict=vuln.dict
+ ./SystemSan ./target_file -dict=vuln.dict
+ ./SystemSan ./target_dns -dict=vuln.dict
+
+pytorch-lightning-1.5.10:
+ cp SystemSan.cpp PoEs/pytorch-lightning-1.5.10/; \
+ cd PoEs/pytorch-lightning-1.5.10/; \
+ docker build . --tag syssan_pytorch-lightning; \
+ docker run -t systemsan_pytorch-lightning:latest;
+
+node-shell-quote-v1.7.3:
+ cp SystemSan.cpp PoEs/node-shell-quote-v1.7.3/; \
+ cd PoEs/node-shell-quote-v1.7.3/; \
+ docker build . --tag systemsan_node-shell-quote; \
+ docker run -t systemsan_node-shell-quote:latest;
+
+clean:
+ rm -f SystemSan /tmp/tripwire target target_file target_dns
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/Dockerfile b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..120de50346ebeb22f0e173becb2f623e54e61139
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/Dockerfile
@@ -0,0 +1,35 @@
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+# Build and run the proof of error in shell-quote v1.7.3.
+
+FROM ghcr.io/aixcc-finals/base-builder
+
+RUN apt update && \
+ apt install -y \
+ vim \
+ npm && \
+ git clone \
+ --depth 1 \
+ https://github.com/substack/node-shell-quote.git && \
+ npm config set @gitlab-org:registry \
+ https://gitlab.com/api/v4/packages/npm/
+
+COPY ./build.sh $SRC
+RUN ./build.sh
+
+COPY . $SRC
+RUN make SystemSan
+
+CMD ["make", "run"]
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/Makefile b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..bdf30d06cc05af35782b5ee878a7a65a5ccdf107
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/Makefile
@@ -0,0 +1,12 @@
+.POSIX:
+CXX = clang++
+CFLAGS = -std=c++17 -Wall -Wextra -O3 -g3
+
+SystemSan: SystemSan.cpp
+ $(CXX) $(CFLAGS) -lpthread -o $@ $^
+
+run: clean SystemSan target.js
+ ./SystemSan jsfuzz ./target.js
+
+clean:
+ rm -f SystemSan /tmp/tripwire
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/build.sh b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/build.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8b34a8c2b09f781b773ace8bc13dfb7d345b1cfd
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/build.sh
@@ -0,0 +1,22 @@
+#!/bin/bash -eu
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+################################################################################
+
+# Build and install project (using current CFLAGS, CXXFLAGS).
+npm install ./node-shell-quote/
+
+# Build fuzzers.
+npm i -g @gitlab-org/jsfuzz
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/target.js b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/target.js
new file mode 100644
index 0000000000000000000000000000000000000000..82608cd2169fc7d757e0d69782a8eaa3b5e9cc88
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/target.js
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2022 Google LLC
+
+ * 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.
+ */
+/* Exploit shell quote with fuzzer's input as a parameter of echo.
+ * This PoC is extended from a report in GitHub Advisory Database:
+ * https://github.com/advisories/GHSA-g4rg-993r-mgx7
+ * The original report records a shell injection exploit in shell-quote v1.7.2,
+ * we show that a similar shell corruption exploit still persists in v1.7.3,
+ * after a commit that intends to fix the original exploit.
+ * */
+
+/* Fuzz the target program with buf generated by Jsfuzz. */
+function fuzz(buf) {
+ buf = String(buf)
+ const childProcess = require('child_process');
+ const shellQuote = require('shell-quote');
+ childProcess.execSync(shellQuote.quote(['echo', buf]));
+}
+
+/* Run Jsfuzz. */
+module.exports = {
+ fuzz
+};
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/Dockerfile b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..c577797f37169886ac3ffd48e12ad21c5986689d
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/Dockerfile
@@ -0,0 +1,32 @@
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+# Build and run the proof of error in pytorch-lightning.
+
+FROM ghcr.io/aixcc-finals/base-builder-python
+
+RUN apt update && \
+ apt install -y vim && \
+ git clone \
+ --depth 1 \
+ --branch 1.5.10 \
+ https://github.com/PyTorchLightning/pytorch-lightning.git
+
+COPY ./build.sh $SRC
+RUN ./build.sh
+
+COPY . $SRC
+RUN make SystemSan
+
+CMD ["make", "run"]
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/Makefile b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..2169bc15a592d7136d9d166159eb09dec8c49d01
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/Makefile
@@ -0,0 +1,12 @@
+.POSIX:
+CXX = clang++
+CFLAGS = -std=c++17 -Wall -Wextra -O3 -g3
+
+SystemSan: SystemSan.cpp
+ $(CXX) $(CFLAGS) -lpthread -o $@ $^
+
+run: clean SystemSan fuzz_pytorch_lightning.py
+ ./SystemSan ./fuzz_pytorch_lightning.py -dict=vuln.dict
+
+clean:
+ rm -f SystemSan /tmp/tripwire
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/build.sh b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/build.sh
new file mode 100644
index 0000000000000000000000000000000000000000..1c9b1adbf5a1b1241e50b8e88a03529cfb69e0b0
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/build.sh
@@ -0,0 +1,25 @@
+#!/bin/bash -eu
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+################################################################################
+
+# Build and install project (using current CFLAGS, CXXFLAGS).
+cd pytorch-lightning
+pip3 install .
+
+# Build fuzzers in $OUT.
+for fuzzer in $(find $SRC -name '*_fuzzer.py'); do
+ compile_python_fuzzer $fuzzer
+done
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/fuzz_pytorch_lightning.py b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/fuzz_pytorch_lightning.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d07da3a6269381d688e8f3ac7da5d5d0ee7d04a
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/fuzz_pytorch_lightning.py
@@ -0,0 +1,65 @@
+#!/usr/local/bin/python3
+#
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+################################################################################
+"""Exploit pytorch lightning with fuzzer's input as a random env variable.
+
+This PoC is extended from a report in GitHub Advisory Database:
+https://github.com/advisories/GHSA-r5qj-cvf9-p85h
+The original report documents an exploit using a specific environment variable,
+we show a way to achieve the same exploit with an arbitrary env variable.
+"""
+
+import os
+import sys
+import atheris
+
+with atheris.instrument_imports():
+ from pytorch_lightning import Trainer
+ from pytorch_lightning.utilities.argparse import parse_env_variables
+
+
+def prepare_fuzzing_input(data):
+ """Prepare the data needed by the exploit with input data from fuzzers."""
+ data = data.replace(b'\0', b'')
+ env_name = 'AN_ARBITRARY_ENV_NAME'
+ return data, env_name
+
+
+def exploit_target(env_value, env_name):
+ """This target is based on a snippet from the official documentation of
+ `parse_env_variables`:
+ https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.utilities.argparse.html # pylint: disable=line-too-long
+ It might not be the most realistic example,
+ but serves as a PoC to show that SystemSan works for Python."""
+ os.environb[env_name.encode()] = env_value
+ parse_env_variables(Trainer, template=env_name)
+
+
+def TestOneInput(data): # pylint: disable=invalid-name
+ """Exploit the target only with input data from fuzzers."""
+ env_value, env_name = prepare_fuzzing_input(data)
+ exploit_target(env_value, env_name)
+
+
+def main():
+ """Fuzz target with atheris."""
+ atheris.Setup(sys.argv, TestOneInput)
+ atheris.Fuzz()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/vuln.dict b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/vuln.dict
new file mode 100644
index 0000000000000000000000000000000000000000..0d19aa407357659d0beb8487443c65eead7dab6a
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/vuln.dict
@@ -0,0 +1 @@
+"os.system('/tmp/tripwire')"
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/README.md b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..48e111d1abc6d96661659f9a19dd7fc6f969baad
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/README.md
@@ -0,0 +1,66 @@
+# System Sanitizers
+
+We use `ptrace` to instrument system calls made by the target program to detect
+various vulnerabilities.
+
+## Command injection
+
+This detector currently works by
+
+- Checking if `execve` is called with `/tmp/tripwire` (which comes from our dictionary).
+- Checking if `execve` is invoking a shell with invalid syntax. This is likely
+ caused by our input.
+
+## Arbitrary file open
+
+TODO: documentation.
+
+## Proof of concept
+
+### Cleanup
+Note this will delete /tmp/tripwire if it exists.
+```shell
+make clean
+```
+
+### Run test
+Note this will overwrite /tmp/tripwire if it exists.
+```shell
+make test
+```
+
+Look for one of the following lines:
+
+> ===BUG DETECTED: Shell injection===
+
+which indicates the detection of executing the planted `/tmp/tripwire`.
+
+
+> ===BUG DETECTED: Shell corruption===
+
+which indicates the detection of executing a syntactic erroneous command.
+
+
+### Command injection PoC in Python with `pytorch-lightning`
+With `SystemSan`, [`Artheris`](https://github.com/google/atheris) can detect a shell injection bug in [version v1.5.10 of `pytorch-lightning`](https://github.com/PyTorchLightning/pytorch-lightning/tree/1.5.0).
+```shell
+make pytorch-lightning-1.5.10
+```
+
+### Command injection PoC in JavaScript with `shell-quote`
+With `SystemSan`, [`Jsfuzz`](https://gitlab.com/gitlab-org/security-products/analyzers/fuzzers/jsfuzz) can detect a shell corrpution bug in [the latest version (v1.7.3) of `shell-quote`](https://github.com/substack/node-shell-quote) without any seed.
+```shell
+make node-shell-quote-v1.7.3
+```
+This is based on [a shell injection exploit report](https://wh0.github.io/2021/10/28/shell-quote-rce-exploiting.html) of [version v1.7.2 of `shell-quote`](https://github.com/substack/node-shell-quote/tree/v1.7.2).
+`SystemSan` can also discover the same shell injection bug with a corpus file containing:
+```
+`:`/tmp/tripwire``:`
+```
+
+## Trophies
+
+-
+-
+
+
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/inspect_dns.cpp b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/inspect_dns.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..030446345096fedc53fe7ea5826a36982a460c42
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/inspect_dns.cpp
@@ -0,0 +1,236 @@
+/*
+ * Copyright 2022 Google LLC
+
+ * 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.
+ */
+/* A detector that uses ptrace to identify shell injection vulnerabilities. */
+
+/* POSIX */
+#include
+#include
+
+/* Linux */
+#include
+#include
+#include
+
+#include
+
+#include "inspect_utils.h"
+
+
+// Arbitrary domain name resolution.
+const std::string kArbitraryDomainNameResolution = "Arbitrary domain name resolution";
+
+// Global constant for one file descriptor about of a DNS socket
+int kFdDns = 0;
+const size_t kDnsHeaderLen = 12;
+
+
+void inspect_for_arbitrary_dns_connect(pid_t pid, const user_regs_struct ®s) {
+ auto memory = read_memory(pid, regs.rsi, sizeof(struct sockaddr_in));
+ if (memory.size()) {
+ struct sockaddr_in * sa = reinterpret_cast(memory.data());
+ if (sa->sin_family == AF_INET && htons(sa->sin_port) == 53) {
+ // save file descriptor for later sendmmsg
+ kFdDns = regs.rdi;
+ }
+ }
+}
+
+struct DnsHeader {
+ uint16_t tx_id;
+ uint16_t flags;
+ uint16_t questions;
+ uint16_t answers;
+ uint16_t nameservers;
+ uint16_t additional;
+};
+
+struct DnsHeader parse_dns_header(std::vector data) {
+ struct DnsHeader h;
+ h.tx_id = (((uint16_t) data[0]) << 8) | ((uint16_t) data[1]);
+ h.flags = (((uint16_t) data[2]) << 8) | ((uint16_t) data[3]);
+ h.questions = (((uint16_t) data[4]) << 8) | ((uint16_t) data[5]);
+ h.answers = (((uint16_t) data[6]) << 8) | ((uint16_t) data[7]);
+ h.nameservers = (((uint16_t) data[8]) << 8) | ((uint16_t) data[9]);
+ h.additional = (((uint16_t) data[10]) << 8) | ((uint16_t) data[11]);
+ return h;
+}
+
+bool dns_flags_standard_query(uint16_t flags) {
+ if ((flags & 0x8000) == 0) {
+ // Query, not response.
+ if (((flags & 0x7800) >> 11) == 0) {
+ // Opcode 0 is standard query.
+ if ((flags & 0x0200) == 0) {
+ // Message is not truncated.
+ if ((flags & 0x0040) == 0) {
+ // Z-bit reserved flag is unset.
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+}
+
+struct DnsRequest {
+ // Start of name in the byte vector.
+ size_t offset;
+ // End of name in the byte vector.
+ size_t end;
+ // Length of top level domain.
+ uint8_t tld_size;
+ // Number of levels/dots in domain name.
+ size_t nb_levels;
+ // DNS type like A is 1.
+ uint16_t dns_type;
+ // DNS class like IN is 1.
+ uint16_t dns_class;
+};
+
+struct DnsRequest parse_dns_request(std::vector data, size_t offset) {
+ struct DnsRequest r;
+ r.offset = offset;
+ r.tld_size = 0;
+ r.nb_levels = 0;
+ while(offset < data.size()) {
+ uint8_t rlen = uint8_t(data[offset]);
+ if (rlen == 0) {
+ offset++;
+ break;
+ }
+ r.nb_levels++;
+ offset += rlen+1;
+ r.tld_size = rlen;
+ }
+ if (offset <= 4 + data.size()) {
+ r.end = offset;
+ r.dns_type = (((uint16_t) data[offset]) << 8) | ((uint16_t) data[offset+1]);
+ r.dns_class = (((uint16_t) data[offset+2]) << 8) | ((uint16_t) data[offset+3]);
+ } else {
+ r.end = data.size();
+ }
+ return r;
+}
+
+void log_dns_request(struct DnsRequest r, std::vector data) {
+ size_t offset = r.offset;
+ std::cerr << "===Domain resolved: ";
+ while(offset < r.end) {
+ uint8_t rlen = uint8_t(data[offset]);
+ if (rlen == 0) {
+ break;
+ }
+ std::cerr << '.';
+ for (uint8_t i = 1; i < rlen+1; i++) {
+ std::cerr << (char) data[offset + i];
+ }
+ offset += rlen+1;
+ }
+ std::cerr << "===\n";
+ std::cerr << "===DNS request type: " << r.dns_type << ", class: " << r.dns_class << "===\n";
+}
+
+void inspect_for_arbitrary_dns_pkt(std::vector data, pid_t pid) {
+ if (data.size() < kDnsHeaderLen + 1) {
+ return;
+ }
+ struct DnsHeader h = parse_dns_header(data);
+ if (h.questions != 1) {
+ return;
+ }
+ if (h.answers != 0 || h.nameservers != 0) {
+ return;
+ }
+ if (!dns_flags_standard_query(h.flags)) {
+ return;
+ }
+
+ struct DnsRequest req = parse_dns_request(data, kDnsHeaderLen);
+ // Alert if the top level domain is only one character and
+ // if there is more than just the TLD.
+ if (req.tld_size == 1 && req.nb_levels > 1 && req.end < data.size()) {
+ report_bug(kArbitraryDomainNameResolution, pid);
+ log_dns_request(req, data);
+ }
+}
+
+void inspect_for_arbitrary_dns_fdbuffer(pid_t pid, const user_regs_struct ®s) {
+ if (kFdDns > 0 && kFdDns == (int) regs.rdi) {
+ auto memory = read_memory(pid, regs.rsi, regs.rdx);
+ if (memory.size()) {
+ inspect_for_arbitrary_dns_pkt(memory, pid);
+ }
+ }
+}
+
+void inspect_for_arbitrary_dns_iov(pid_t pid, unsigned long iov) {
+ auto memory = read_memory(pid, iov, sizeof(struct iovec));
+ if (memory.size()) {
+ struct iovec * iovec = reinterpret_cast(memory.data());
+ memory = read_memory(pid, (unsigned long) iovec->iov_base, iovec->iov_len);
+ if (memory.size()) {
+ inspect_for_arbitrary_dns_pkt(memory, pid);
+ }
+ }
+}
+
+void inspect_for_arbitrary_dns_sendmsg(pid_t pid, const user_regs_struct ®s) {
+ if (kFdDns > 0 && kFdDns == (int) regs.rdi) {
+ auto memory = read_memory(pid, regs.rsi, sizeof(struct msghdr));
+ if (memory.size()) {
+ struct msghdr * msg = reinterpret_cast(memory.data());
+ if (msg->msg_iovlen == 1) {
+ inspect_for_arbitrary_dns_iov(pid, (unsigned long) msg->msg_iov);
+ }
+ }
+ }
+}
+
+void inspect_for_arbitrary_dns_sendmmsg(pid_t pid, const user_regs_struct ®s) {
+ if (kFdDns > 0 && kFdDns == (int) regs.rdi) {
+ auto memory = read_memory(pid, regs.rsi, sizeof(struct mmsghdr));
+ if (memory.size()) {
+ struct mmsghdr * msg = reinterpret_cast(memory.data());
+ if (msg->msg_hdr.msg_iovlen == 1) {
+ inspect_for_arbitrary_dns_iov(pid, (unsigned long) msg->msg_hdr.msg_iov);
+ }
+ }
+ }
+}
+
+void inspect_dns_syscalls(pid_t pid, const user_regs_struct ®s) {
+ switch (regs.orig_rax) {
+ case __NR_connect:
+ inspect_for_arbitrary_dns_connect(pid, regs);
+ break;
+ case __NR_close:
+ if (kFdDns > 0 && kFdDns == (int) regs.rdi) {
+ // reset DNS file descriptor on close
+ kFdDns = 0;
+ }
+ break;
+ case __NR_sendmmsg:
+ inspect_for_arbitrary_dns_sendmmsg(pid, regs);
+ break;
+ case __NR_sendmsg:
+ inspect_for_arbitrary_dns_sendmsg(pid, regs);
+ break;
+ case __NR_sendto:
+ // fallthrough
+ case __NR_write:
+ inspect_for_arbitrary_dns_fdbuffer(pid, regs);
+ }
+}
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/inspect_dns.h b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/inspect_dns.h
new file mode 100644
index 0000000000000000000000000000000000000000..849af4e980679c3b8cbbd875216a06ba7b909f3a
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/inspect_dns.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2022 Google LLC
+
+ * 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.
+ */
+/* A detector that uses ptrace to identify DNS arbitrary resolutions. */
+
+
+/* POSIX */
+#include
+
+/* Linux */
+#include
+
+
+void inspect_dns_syscalls(pid_t pid, const user_regs_struct ®s);
diff --git a/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/inspect_utils.cpp b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/inspect_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..713d61d757c0c135271591bf17d9a1c108f37c27
--- /dev/null
+++ b/local-test-tika-delta-02/fuzz-tooling/infra/experimental/SystemSan/inspect_utils.cpp
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2022 Google LLC
+
+ * 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.
+ */
+/* A detector that uses ptrace to identify DNS arbitrary resolutions. */
+
+/* C standard library */
+#include
+
+/* POSIX */
+#include
+
+/* Linux */
+#include
+
+#include
+#include
+#include
+#include