Add files using upload-large-folder tool

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

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

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

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

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

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"]

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:
+
+<pre>
+docker run --rm -ti gcr.io/oss-fuzz/<b><i>$project</i></b> <i>&lt;command&gt;</i> <i>&lt;arguments...&gt;</i>
+</pre>
+
+# 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`):*
+
+
+<pre>
+docker run --rm -ti -e <i>SANITIZER</i>=<i>undefined</i> gcr.io/oss-fuzz/sqlite3
+</pre>
+
+
+# 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 |

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

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

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())

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 "$@"

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

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."

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.'

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."

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

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."

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 <<EOF > 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 <<EOF > 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

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()

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

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/*

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

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

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)
+}

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<header>[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<buggy>[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<header>.+)\"\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)
+}

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 <stddef.h>
+
+#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 <stddef.h>
+
+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 <stddef.h>
+
+#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 <stddef.h>
+
+#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 <stddef.h>
+
+#include <cstdint>
+
+// Some libraries like OpenSSL will use brackets for their own headers.
+#include <missingheader.h>
+
+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 <stddef.h>
+
+#include <cstdint>
+
+// 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)
+	}
+}

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

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;
+}

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;
+}

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);

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 <cassert>
+ #include <cstring>
+ 
++
++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));

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()
+	}
+}

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.

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.

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"

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']

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')

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')

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'))

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()

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"

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 <<EOF > $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

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 }}

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"]

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

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()

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

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}}

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.')

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