Add files using upload-large-folder tool

local-test-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/bisect_clang_test.py

@@ -0,0 +1,294 @@
+# 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.
+#
+################################################################################
+"""Tests for bisect_clang.py"""
+import os
+from unittest import mock
+import unittest
+
+import bisect_clang
+
+FILE_DIRECTORY = os.path.dirname(__file__)
+LLVM_REPO_PATH = '/llvm-project'
+
+
+def get_git_command(*args):
+  """Returns a git command for the LLVM repo with |args| as arguments."""
+  return ['git', '-C', LLVM_REPO_PATH] + list(args)
+
+
+def patch_environ(testcase_obj):
+  """Patch environment."""
+  env = {}
+  patcher = mock.patch.dict(os.environ, env)
+  testcase_obj.addCleanup(patcher.stop)
+  patcher.start()
+
+
+class BisectClangTestMixin:  # pylint: disable=too-few-public-methods
+  """Useful mixin for bisect_clang unittests."""
+
+  def setUp(self):  # pylint: disable=invalid-name
+    """Initialization method for unittests."""
+    patch_environ(self)
+    os.environ['SRC'] = '/src'
+    os.environ['WORK'] = '/work'
+
+
+class GetClangBuildEnvTest(BisectClangTestMixin, unittest.TestCase):
+  """Tests for get_clang_build_env."""
+
+  def test_cflags(self):
+    """Test that CFLAGS are not used compiling clang."""
+    os.environ['CFLAGS'] = 'blah'
+    self.assertNotIn('CFLAGS', bisect_clang.get_clang_build_env())
+
+  def test_cxxflags(self):
+    """Test that CXXFLAGS are not used compiling clang."""
+    os.environ['CXXFLAGS'] = 'blah'
+    self.assertNotIn('CXXFLAGS', bisect_clang.get_clang_build_env())
+
+  def test_other_variables(self):
+    """Test that other env vars are used when compiling clang."""
+    key = 'other'
+    value = 'blah'
+    os.environ[key] = value
+    self.assertEqual(value, bisect_clang.get_clang_build_env()[key])
+
+
+def read_test_data(filename):
+  """Returns data from |filename| in the test_data directory."""
+  with open(os.path.join(FILE_DIRECTORY, 'test_data', filename)) as file_handle:
+    return file_handle.read()
+
+
+class SearchBisectOutputTest(BisectClangTestMixin, unittest.TestCase):
+  """Tests for search_bisect_output."""
+
+  def test_search_bisect_output(self):
+    """Test that search_bisect_output finds the responsible commit when one
+    exists."""
+    test_data = read_test_data('culprit-commit.txt')
+    self.assertEqual('ac9ee01fcbfac745aaedca0393a8e1c8a33acd8d',
+                     bisect_clang.search_bisect_output(test_data))
+
+  def test_search_bisect_output_none(self):
+    """Test that search_bisect_output doesnt find a non-existent culprit
+    commit."""
+    self.assertIsNone(bisect_clang.search_bisect_output('hello'))
+
+
+def create_mock_popen(
+    output=bytes('', 'utf-8'), err=bytes('', 'utf-8'), returncode=0):
+  """Creates a mock subprocess.Popen."""
+
+  class MockPopen:
+    """Mock subprocess.Popen."""
+    commands = []
+    testcases_written = []
+
+    def __init__(self, command, *args, **kwargs):  # pylint: disable=unused-argument
+      """Inits the MockPopen."""
+      stdout = kwargs.pop('stdout', None)
+      self.command = command
+      self.commands.append(command)
+      self.stdout = None
+      self.stderr = None
+      self.returncode = returncode
+      if hasattr(stdout, 'write'):
+        self.stdout = stdout
+
+    def communicate(self, input_data=None):  # pylint: disable=unused-argument
+      """Mock subprocess.Popen.communicate."""
+      if self.stdout:
+        self.stdout.write(output)
+
+      if self.stderr:
+        self.stderr.write(err)
+
+      return output, err
+
+    def poll(self, input_data=None):  # pylint: disable=unused-argument
+      """Mock subprocess.Popen.poll."""
+      return self.returncode
+
+  return MockPopen
+
+
+def mock_prepare_build_impl(llvm_project_path):  # pylint: disable=unused-argument
+  """Mocked prepare_build function."""
+  return '/work/llvm-build'
+
+
+class BuildClangTest(BisectClangTestMixin, unittest.TestCase):
+  """Tests for build_clang."""
+
+  def test_build_clang_test(self):
+    """Tests that build_clang works as intended."""
+    with mock.patch('subprocess.Popen', create_mock_popen()) as mock_popen:
+      with mock.patch('bisect_clang.prepare_build', mock_prepare_build_impl):
+        llvm_src_dir = '/src/llvm-project'
+        bisect_clang.build_clang(llvm_src_dir)
+        self.assertEqual([['ninja', '-C', '/work/llvm-build', 'install']],
+                         mock_popen.commands)
+
+
+class GitRepoTest(BisectClangTestMixin, unittest.TestCase):
+  """Tests for GitRepo."""
+
+  # TODO(metzman): Mock filesystem. Until then, use a real directory.
+
+  def setUp(self):
+    super().setUp()
+    self.git = bisect_clang.GitRepo(LLVM_REPO_PATH)
+    self.good_commit = 'good_commit'
+    self.bad_commit = 'bad_commit'
+    self.test_command = 'testcommand'
+
+  def test_do_command(self):
+    """Test do_command creates a new process as intended."""
+    # TODO(metzman): Test directory changing behavior.
+    command = ['subcommand', '--option']
+    with mock.patch('subprocess.Popen', create_mock_popen()) as mock_popen:
+      self.git.do_command(command)
+      self.assertEqual([get_git_command('subcommand', '--option')],
+                       mock_popen.commands)
+
+  def _test_test_start_commit_unexpected(self, label, commit, returncode):
+    """Tests test_start_commit works as intended when the test returns an
+    unexpected value."""
+
+    def mock_execute_impl(command, *args, **kwargs):  # pylint: disable=unused-argument
+      if command == self.test_command:
+        return returncode, '', ''
+      return 0, '', ''
+
+    with mock.patch('bisect_clang.execute', mock_execute_impl):
+      with mock.patch('bisect_clang.prepare_build', mock_prepare_build_impl):
+        with self.assertRaises(bisect_clang.BisectError):
+          self.git.test_start_commit(commit, label, self.test_command)
+
+  def test_test_start_commit_bad_zero(self):
+    """Tests test_start_commit works as intended when the test on the first bad
+    commit returns 0."""
+    self._test_test_start_commit_unexpected('bad', self.bad_commit, 0)
+
+  def test_test_start_commit_good_nonzero(self):
+    """Tests test_start_commit works as intended when the test on the first good
+    commit returns nonzero."""
+    self._test_test_start_commit_unexpected('good', self.good_commit, 1)
+
+  def test_test_start_commit_good_zero(self):
+    """Tests test_start_commit works as intended when the test on the first good
+    commit returns 0."""
+    self._test_test_start_commit_expected('good', self.good_commit, 0)  # pylint: disable=no-value-for-parameter
+
+  @mock.patch('bisect_clang.build_clang')
+  def _test_test_start_commit_expected(self, label, commit, returncode,
+                                       mock_build_clang):
+    """Tests test_start_commit works as intended when the test returns an
+    expected value."""
+    command_args = []
+
+    def mock_execute_impl(command, *args, **kwargs):  # pylint: disable=unused-argument
+      command_args.append(command)
+      if command == self.test_command:
+        return returncode, '', ''
+      return 0, '', ''
+
+    with mock.patch('bisect_clang.execute', mock_execute_impl):
+      self.git.test_start_commit(commit, label, self.test_command)
+      self.assertEqual([
+          get_git_command('checkout', commit), self.test_command,
+          get_git_command('bisect', label)
+      ], command_args)
+      mock_build_clang.assert_called_once_with(LLVM_REPO_PATH)
+
+  def test_test_start_commit_bad_nonzero(self):
+    """Tests test_start_commit works as intended when the test on the first bad
+    commit returns nonzero."""
+    self._test_test_start_commit_expected('bad', self.bad_commit, 1)  # pylint: disable=no-value-for-parameter
+
+  @mock.patch('bisect_clang.GitRepo.test_start_commit')
+  def test_bisect_start(self, mock_test_start_commit):
+    """Tests bisect_start works as intended."""
+    with mock.patch('subprocess.Popen', create_mock_popen()) as mock_popen:
+      self.git.bisect_start(self.good_commit, self.bad_commit,
+                            self.test_command)
+      self.assertEqual(get_git_command('bisect', 'start'),
+                       mock_popen.commands[0])
+      mock_test_start_commit.assert_has_calls([
+          mock.call('bad_commit', 'bad', 'testcommand'),
+          mock.call('good_commit', 'good', 'testcommand')
+      ])
+
+  def test_do_bisect_command(self):
+    """Test do_bisect_command executes a git bisect subcommand as intended."""
+    subcommand = 'subcommand'
+    with mock.patch('subprocess.Popen', create_mock_popen()) as mock_popen:
+      self.git.do_bisect_command(subcommand)
+      self.assertEqual([get_git_command('bisect', subcommand)],
+                       mock_popen.commands)
+
+  @mock.patch('bisect_clang.build_clang')
+  def _test_test_commit(self, label, output, returncode, mock_build_clang):
+    """Test test_commit works as intended."""
+    command_args = []
+
+    def mock_execute_impl(command, *args, **kwargs):  # pylint: disable=unused-argument
+      command_args.append(command)
+      if command == self.test_command:
+        return returncode, output, ''
+      return 0, output, ''
+
+    with mock.patch('bisect_clang.execute', mock_execute_impl):
+      result = self.git.test_commit(self.test_command)
+      self.assertEqual([self.test_command,
+                        get_git_command('bisect', label)], command_args)
+    mock_build_clang.assert_called_once_with(LLVM_REPO_PATH)
+    return result
+
+  def test_test_commit_good(self):
+    """Test test_commit labels a good commit as good."""
+    self.assertIsNone(self._test_test_commit('good', '', 0))  # pylint: disable=no-value-for-parameter
+
+  def test_test_commit_bad(self):
+    """Test test_commit labels a bad commit as bad."""
+    self.assertIsNone(self._test_test_commit('bad', '', 1))  # pylint: disable=no-value-for-parameter
+
+  def test_test_commit_culprit(self):
+    """Test test_commit returns the culprit"""
+    test_data = read_test_data('culprit-commit.txt')
+    self.assertEqual('ac9ee01fcbfac745aaedca0393a8e1c8a33acd8d',
+                     self._test_test_commit('good', test_data, 0))  # pylint: disable=no-value-for-parameter
+
+
+class GetTargetArchToBuildTest(unittest.TestCase):
+  """Tests for get_target_arch_to_build."""
+
+  def test_unrecognized(self):
+    """Test that an unrecognized architecture raises an exception."""
+    with mock.patch('bisect_clang.execute') as mock_execute:
+      mock_execute.return_value = (None, 'mips', None)
+      with self.assertRaises(Exception):
+        bisect_clang.get_clang_target_arch()
+
+  def test_recognized(self):
+    """Test that a recognized architecture returns the expected value."""
+    arch_pairs = {'x86_64': 'X86', 'aarch64': 'AArch64'}
+    for uname_result, clang_target in arch_pairs.items():
+      with mock.patch('bisect_clang.execute') as mock_execute:
+        mock_execute.return_value = (None, uname_result, None)
+        self.assertEqual(clang_target, bisect_clang.get_clang_target_arch())

local-test-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/detect_repo_test.py

@@ -0,0 +1,121 @@
+# 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.
+"""Test the functionality of the detect_repo module.
+This will consist of the following functional test:
+  1. Determine if an OSS-Fuzz projects main repo can be detected from example
+  commits.
+  2. Determine if an OSS-Fuzz project main repo can be detected from a
+  repo name.
+"""
+import os
+import re
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+import detect_repo
+
+# Appending to path for access to repo_manager module.
+# pylint: disable=wrong-import-position
+sys.path.append(
+    os.path.dirname(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__)))))
+import repo_manager
+import test_repos
+# pylint: enable=wrong-import-position
+
+
+class TestCheckForRepoName(unittest.TestCase):
+  """Tests for check_for_repo_name."""
+
+  @mock.patch('os.path.exists', return_value=True)
+  @mock.patch('detect_repo.execute',
+              return_value=('https://github.com/google/syzkaller/', None))
+  def test_go_get_style_url(self, _, __):
+    """Tests that check_for_repo_name works on repos that were downloaded using
+    go get."""
+    self.assertTrue(detect_repo.check_for_repo_name('fake-path', 'syzkaller'))
+
+  @mock.patch('os.path.exists', return_value=True)
+  @mock.patch('detect_repo.execute',
+              return_value=('https://github.com/google/syzkaller', None))
+  def test_missing_git_and_slash_url(self, _, __):
+    """Tests that check_for_repo_name works on repos who's URLs do not end in
+    ".git" or "/"."""
+    self.assertTrue(detect_repo.check_for_repo_name('fake-path', 'syzkaller'))
+
+  @mock.patch('os.path.exists', return_value=True)
+  @mock.patch('detect_repo.execute',
+              return_value=('https://github.com/google/syzkaller.git', None))
+  def test_normal_style_repo_url(self, _, __):
+    """Tests that check_for_repo_name works on normally cloned repos."""
+    self.assertTrue(detect_repo.check_for_repo_name('fake-path', 'syzkaller'))
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class DetectRepoIntegrationTest(unittest.TestCase):
+  """Class to test the functionality of the detect_repo module."""
+
+  def test_infer_main_repo_from_commit(self):
+    """Tests that the main repo can be inferred based on an example commit."""
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      # Construct example repo's to check for commits.
+      for test_repo in test_repos.TEST_REPOS:
+        repo_manager.clone_repo_and_get_manager(test_repo.git_url, tmp_dir)
+        self.check_with_repo(test_repo.git_url,
+                             test_repo.git_repo_name,
+                             tmp_dir,
+                             commit=test_repo.old_commit)
+
+  def test_infer_main_repo_from_name(self):
+    """Tests that the main project repo can be inferred from a repo name."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      for test_repo in test_repos.TEST_REPOS:
+        repo_manager.clone_repo_and_get_manager(test_repo.git_url, tmp_dir)
+        self.check_with_repo(test_repo.git_url, test_repo.git_repo_name,
+                             tmp_dir)
+
+  def check_with_repo(self, repo_origin, repo_name, tmp_dir, commit=None):
+    """Checks the detect repo's main method for a specific set of inputs.
+
+    Args:
+      repo_origin: URL of the git repo.
+      repo_name: The name of the directory it is cloned to.
+      tmp_dir: The location of the directory of git repos to be searched.
+      commit: The commit that should be used to look up the repo.
+    """
+    command = ['python3', 'detect_repo.py', '--src_dir', tmp_dir]
+
+    if commit:
+      command += ['--example_commit', commit]
+    else:
+      command += ['--repo_name', repo_name]
+
+    out, _ = detect_repo.execute(command,
+                                 location=os.path.dirname(
+                                     os.path.realpath(__file__)))
+    match = re.search(r'\bDetected repo: ([^ ]+) ([^ ]+)', out.rstrip())
+    if match and match.group(1) and match.group(2):
+      self.assertEqual(match.group(1), repo_origin)
+      self.assertEqual(match.group(2), os.path.join(tmp_dir, repo_name))
+    else:
+      self.assertIsNone(repo_origin)
+      self.assertIsNone(repo_name)
+
+
+if __name__ == '__main__':
+  unittest.main()

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/install_deps.sh

@@ -0,0 +1,44 @@
+#!/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.
+#
+################################################################################
+
+# Install base-builder's dependencies in a architecture-aware way.
+
+
+case $(uname -m) in
+    x86_64)
+	dpkg --add-architecture i386
+        ;;
+esac
+
+apt-get update && \
+    apt-get install -y \
+        binutils-dev \
+        build-essential \
+        curl \
+        wget \
+        git \
+        jq \
+        patchelf \
+        rsync \
+        subversion \
+        zip
+
+case $(uname -m) in
+    x86_64)
+	apt-get install -y libc6-dev-i386
+        ;;
+esac

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/install_java.sh

@@ -0,0 +1,31 @@
+#!/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.
+#
+################################################################################
+
+# Install OpenJDK 17 and trim its size by removing unused components. This enables using Jazzer's mutation framework.
+cd /tmp
+curl --silent -L -O https://download.java.net/java/GA/jdk17.0.2/dfd4a8d0985749f896bed50d7138ee7f/8/GPL/openjdk-17.0.2_linux-x64_bin.tar.gz && \
+mkdir -p $JAVA_HOME
+tar -xz --strip-components=1 -f openjdk-17.0.2_linux-x64_bin.tar.gz --directory $JAVA_HOME && \
+rm -f openjdk-17.0.2_linux-x64_bin.tar.gz
+rm -rf $JAVA_HOME/jmods $JAVA_HOME/lib/src.zip
+
+# Install OpenJDK 15 and trim its size by removing unused components. Some projects only run with Java 15.
+curl --silent -L -O https://download.java.net/java/GA/jdk15.0.2/0d1cfde4252546c6931946de8db48ee2/7/GPL/openjdk-15.0.2_linux-x64_bin.tar.gz && \
+mkdir -p $JAVA_15_HOME
+tar -xz --strip-components=1 -f openjdk-15.0.2_linux-x64_bin.tar.gz --directory $JAVA_15_HOME && \
+rm -f openjdk-15.0.2_linux-x64_bin.tar.gz
+rm -rf $JAVA_15_HOME/jmods $JAVA_15_HOME/lib/src.zip

local-test-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/install_swift.sh

@@ -0,0 +1,67 @@
+#!/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.
+#
+################################################################################
+
+
+SWIFT_PACKAGES="wget \
+          binutils \
+          git \
+          gnupg2 \
+          libc6-dev \
+          libcurl4 \
+          libedit2 \
+          libgcc-9-dev \
+          libpython2.7 \
+          libsqlite3-0 \
+          libstdc++-9-dev \
+          libxml2 \
+          libz3-dev \
+          pkg-config \
+          tzdata \
+          zlib1g-dev"
+SWIFT_SYMBOLIZER_PACKAGES="build-essential make cmake ninja-build git python3 g++-multilib binutils-dev zlib1g-dev"
+apt-get update && apt install -y $SWIFT_PACKAGES && \
+  apt install -y $SWIFT_SYMBOLIZER_PACKAGES --no-install-recommends
+
+
+wget -q https://download.swift.org/swift-5.10.1-release/ubuntu2004/swift-5.10.1-RELEASE/swift-5.10.1-RELEASE-ubuntu20.04.tar.gz
+tar xzf swift-5.10.1-RELEASE-ubuntu20.04.tar.gz
+cp -r swift-5.10.1-RELEASE-ubuntu20.04/usr/* /usr/
+rm -rf swift-5.10.1-RELEASE-ubuntu20.04.tar.gz swift-5.10.1-RELEASE-ubuntu20.04/
+# TODO: Move to a seperate work dir
+git clone https://github.com/llvm/llvm-project.git
+cd llvm-project
+git checkout 63bf228450b8403e0c5e828d276be47ffbcd00d0 # TODO: Keep in sync with base-clang.
+git apply ../llvmsymbol.diff --verbose
+cmake -G "Ninja" \
+    -DLIBCXX_ENABLE_SHARED=OFF \
+    -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON \
+    -DLIBCXXABI_ENABLE_SHARED=OFF \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DLLVM_TARGETS_TO_BUILD=X86 \
+    -DCMAKE_C_COMPILER=clang \
+    -DCMAKE_CXX_COMPILER=clang++ \
+    -DLLVM_BUILD_TESTS=OFF \
+    -DLLVM_INCLUDE_TESTS=OFF llvm
+ninja -j$(nproc) llvm-symbolizer
+cp bin/llvm-symbolizer /usr/local/bin/llvm-symbolizer-swift
+
+cd $SRC
+rm -rf llvm-project llvmsymbol.diff
+
+# TODO: Cleanup packages
+apt-get remove --purge -y wget zlib1g-dev
+apt-get autoremove -y

local-test-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/precompile_centipede

@@ -0,0 +1,49 @@
+#!/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 -n "Precompiling centipede"
+
+# Build Centipede with bazel.
+cd "$SRC/fuzztest/centipede/"
+apt-get update && apt-get install libssl-dev -y
+unset CXXFLAGS CFLAGS
+# We need to use an older version of BAZEL because fuzztest relies on WORKSPACE
+# Ref: https://github.com/google/oss-fuzz/pull/12838#issue-2733821058
+export USE_BAZEL_VERSION=7.4.0
+echo 'build --cxxopt=-stdlib=libc++ --linkopt=-lc++' >> /tmp/centipede.bazelrc
+bazel --bazelrc=/tmp/centipede.bazelrc build -c opt :all
+unset USE_BAZEL_VERSION
+
+# Prepare the weak symbols:
+# This is necessary because we compile the target binary and the intermediate
+# auxiliary binaries with the same cflags. The auxiliary binaries do not need
+# data-flow tracing flags, but will still throw errors when they cannot find
+# the corresponding functions.
+# The weak symbols provides fake implementations for intermediate binaries.
+$CXX "$SRC/fuzztest/centipede/weak_sancov_stubs.cc" -c -o "$SRC/fuzztest/centipede/weak.o"
+
+echo 'Removing extra stuff leftover to avoid bloating image.'
+
+rm -rf /clang-*.tgz /clang
+
+BAZEL_BIN_REAL_DIR=$(readlink -f $CENTIPEDE_BIN_DIR)
+rm -rf $CENTIPEDE_BIN_DIR
+mkdir -p $CENTIPEDE_BIN_DIR
+mv $BAZEL_BIN_REAL_DIR/centipede/{centipede,libcentipede_runner.pic.a} $CENTIPEDE_BIN_DIR
+rm -rf /root/.cache
+
+echo 'Done.'

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/precompile_honggfuzz

@@ -0,0 +1,45 @@
+#!/bin/bash -eu
+# 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.
+#
+################################################################################
+
+echo "Precompiling honggfuzz"
+export BUILD_OSSFUZZ_STATIC=true
+
+PACKAGES=(
+    libunwind8-dev
+    libblocksruntime-dev
+    liblzma-dev
+    libiberty-dev
+    zlib1g-dev
+    pkg-config)
+
+apt-get update && apt-get install -y ${PACKAGES[@]}
+
+pushd $SRC/honggfuzz > /dev/null
+make clean
+# These CFLAGs match honggfuzz's default, with the exception of -mtune to
+# improve portability and `-D_HF_LINUX_NO_BFD` to remove assembly instructions
+# from the filenames.
+CC=clang CFLAGS="-O3 -funroll-loops -D_HF_LINUX_NO_BFD" make
+
+# libhfuzz.a will be added by CC/CXX linker directly during linking,
+# but it's defined here to satisfy the build infrastructure
+ar rcs honggfuzz.a libhfuzz/*.o libhfcommon/*.o
+popd > /dev/null
+
+apt-get remove -y --purge ${PACKAGES[@]}
+apt-get autoremove -y
+echo "Done."

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/.gitignore

@@ -0,0 +1,4 @@
+dist
+pysecsan.egg-info*
+build
+.venv

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/redos.py

@@ -0,0 +1,84 @@
+# 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.
+#
+################################################################################
+"""Sanitizer for regular expression dos."""
+
+# pylint: disable=protected-access
+
+import time
+import os
+from pysecsan import sanlib
+
+START_RE_TIME = None
+
+
+# Hooks for regular expressions.
+# Main problem is to identify ReDOS attemps. This is a non-trivial task
+# - https://arxiv.org/pdf/1701.04045.pdf
+# - https://dl.acm.org/doi/pdf/10.1145/3236024.3236027
+# and the current approach we use is simply check for extensive computing time.
+# In essence, this is more of a refinement of traditional timeout checker from
+# the fuzzer, which, effectively will detect these types of attacks by way of
+# timeouts.
+#
+# Perhaps the smartest would be to use something like e.g.
+# https://github.com/doyensec/regexploit to scan the regex patterns.
+# Other heuristics without going too technical on identifying super-linear
+# regexes:
+# - check
+#   - if 'taint' exists in re.compile(xx)
+# - check
+#   - for backtracking possbility in PATTERN within re.comile(PATTERN)
+#   - and
+#   - 'taint' in findall(XX) calls.
+# pylint: disable=global-statement
+def hook_post_exec_re_pattern_findall(self, re_str):
+  """Hook post exeution re.compile().findall()."""
+  _ = self  # Satisfy lint
+  global START_RE_TIME
+  try:
+    endtime = time.time() - START_RE_TIME
+    if endtime > 4:
+      sanlib.abort_with_issue(f'Potential ReDOS attack.\n {re_str}', 'ReDOS')
+  except NameError:
+    sanlib.sanitizer_log(
+        'starttime is not set, which it should have. Error in PySecSan',
+        sanlib.LOG_INFO)
+    os._exit(1)
+
+
+def hook_pre_exec_re_pattern_findall(self, string):
+  """Hook pre execution of re.pattern().findall()."""
+  _ = (self, string)  # Satisfy lint
+  global START_RE_TIME
+  START_RE_TIME = time.time()
+
+
+def hook_post_exec_re_compile(retval, pattern, flags=None):
+  """Hook for re.compile post execution to hook returned objects functions."""
+  _ = (pattern, flags)  # Satisfy lint
+  sanlib.sanitizer_log('Inside of post compile hook', sanlib.LOG_DEBUG)
+  wrapper_object = sanlib.create_object_wrapper(
+      findall=(hook_pre_exec_re_pattern_findall,
+               hook_post_exec_re_pattern_findall))
+  hooked_object = wrapper_object(retval)
+  return hooked_object
+
+
+def hook_pre_exec_re_compile(pattern, flags=None):
+  """Check if tainted input exists in pattern. If so, likely chance of making
+    ReDOS possible."""
+  _ = (pattern, flags)  # Satisfy lint
+  sanlib.sanitizer_log('Inside re compile hook', sanlib.LOG_DEBUG)

local-test-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/README.md

@@ -0,0 +1 @@
+# Tests including Proof of Exploits

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/eval_command_injection.py

@@ -0,0 +1,52 @@
+#!/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 targetting command injection of eval."""
+# pylint: disable=eval-used
+
+import sys
+import atheris
+import pysecsan
+
+pysecsan.add_hooks()
+
+
+def list_files_perhaps(param, magicval):
+  """Pass fuzzer data into eval."""
+  if len(param) < 3:
+    return
+  if magicval == 1337:
+    try:
+      eval("FROMFUZZ")
+    except ValueError:
+      pass
+
+
+def test_one_input(data):
+  """Fuzzer entrypoint."""
+  fdp = atheris.FuzzedDataProvider(data)
+  list_files_perhaps(fdp.ConsumeUnicodeNoSurrogates(24),
+                     fdp.ConsumeIntInRange(500, 1500))
+
+
+def main():
+  """Set up and start fuzzing."""
+
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/ansible-runner-cve-2021-4041/fuzz_ansible_runner.py

@@ -0,0 +1,64 @@
+#!/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.
+"""Targets: https://github.com/advisories/GHSA-6j58-grhv-2769."""
+
+import sys
+import atheris
+import pexpect
+import pysecsan
+import ansible_runner
+from ansible_runner.config.runner import RunnerConfig
+
+pysecsan.add_hooks()
+
+
+def test_one_input(data):
+  """Fuzzer entrypoint."""
+  fdp = atheris.FuzzedDataProvider(data)
+
+  conf = RunnerConfig('/tmp/')
+  conf.suppress_ansible_output = True
+  conf.expect_passwords = {pexpect.TIMEOUT: None, pexpect.EOF: None}
+  conf.cwd = str('/tmp/')
+  conf.env = {}
+  conf.job_timeout = 10
+  conf.idle_timeout = 0
+  conf.pexpect_timeout = 2.
+  conf.pexpect_use_poll = True
+  conf.command = 'from_fuzzer'
+
+  runner = ansible_runner.Runner(conf)
+  runner.resource_profiling = True
+  # rc.resource_profiling_base_cgroup = "; exec-san"
+  assistance = True
+  if assistance and fdp.ConsumeIntInRange(1, 100) > 80:
+    conf.resource_profiling_base_cgroup = 'FROMFUZZ'
+  else:
+    conf.resource_profiling_base_cgroup = fdp.ConsumeUnicodeNoSurrogates(24)
+  try:
+    runner.run()
+  except (RuntimeError, ValueError, TypeError) as _:
+    pass
+
+
+def main():
+  """Set up and start fuzzing."""
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/libvcs-cve-2022-21187/build.sh

@@ -0,0 +1,21 @@
+#!/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.
+#
+################################################################################
+
+python3 -m pip install pysecsan
+
+python3 -m pip install libvcs==0.11.0
+python3 ./fuzz_libvcs.py

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/libvcs-cve-2022-21187/fuzz_libvcs.py

@@ -0,0 +1,45 @@
+#!/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.
+"""Targets https://github.com/advisories/GHSA-mv2w-4jqc-6fg4."""
+
+import sys
+import atheris
+import pysecsan
+from libvcs.shortcuts import create_repo
+
+pysecsan.add_hooks()
+
+
+def test_one_input(data):
+  """Target code injection in libvcs."""
+  fdp = atheris.FuzzedDataProvider(data)
+  mercurial_repo = create_repo(url=fdp.ConsumeUnicodeNoSurrogates(128),
+                               vcs='hg',
+                               repo_dir='./')
+  try:
+    mercurial_repo.update_repo()
+  except (ValueError, FileNotFoundError) as exception:
+    _ = exception  # Satisfy lint
+
+
+def main():
+  """Set up and start fuzzing."""
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/python-ldap-GHSL-2021-117/build.sh

@@ -0,0 +1,25 @@
+#!/bin/bash -eu
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+python3 -m pip install pysecsan
+
+git clone https://github.com/python-ldap/python-ldap
+cd python-ldap
+git checkout 404c36b702c5b3a7e60729745c8bda16098b1472
+python3 -m pip install .
+cd ../
+python3 ./fuzz_ldap.py

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/pytorch-lightning-1.5.10/build.sh

@@ -0,0 +1,22 @@
+#!/bin/bash -eu
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+git clone --depth 1 --branch 1.5.10 https://github.com/PyTorchLightning/pytorch-lightning.git
+cd pytorch-lightning
+python3 -m pip install .
+cd ../
+python3 ./fuzz_pytorch_lightning.py

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/pytorch-lightning-1.5.10/fuzz_pytorch_lightning.dict

@@ -0,0 +1 @@
+"os.system('exec-sanitizer')"

local-test-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/yaml_deserialization_simple.py

@@ -0,0 +1,54 @@
+#!/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 triggering insecure yaml serialization."""
+
+import sys
+import yaml
+import atheris
+import pysecsan
+
+
+def serialize_with_tainted_data(param, magicval):
+  """Pass data to insecure yaml functions."""
+  if magicval == 1337:
+    try:
+      yaml.load(param, yaml.Loader)
+    except yaml.YAMLError:
+      pass
+  elif magicval == 1338:
+    try:
+      yaml.load('FROMFUZZ', yaml.Loader)
+    except yaml.YAMLError:
+      pass
+
+
+def test_one_input(data):
+  """Fuzzer entrypoint."""
+  fdp = atheris.FuzzedDataProvider(data)
+  serialize_with_tainted_data(fdp.ConsumeUnicodeNoSurrogates(32),
+                              fdp.ConsumeIntInRange(500, 1500))
+
+
+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-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/srcmap

@@ -0,0 +1,66 @@
+#!/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.
+#
+################################################################################
+
+# Deterimine srcmap of checked out source code
+
+SRCMAP=$(tempfile)
+echo "{}" > $SRCMAP
+
+# $1 - json file, $2 - jq program
+function jq_inplace() {
+  F=$(tempfile) && cat $1 | jq "$2" > $F && mv $F $1
+}
+
+PATHS_TO_SCAN="$SRC"
+
+if [[ $FUZZING_LANGUAGE == "go" ]]; then
+  PATHS_TO_SCAN="$PATHS_TO_SCAN $GOPATH"
+fi
+
+# Git
+for DOT_GIT_DIR in $(find $PATHS_TO_SCAN -name ".git" -type d); do
+  GIT_DIR=$(dirname $DOT_GIT_DIR)
+  cd $GIT_DIR
+  GIT_URL=$(git config --get remote.origin.url)
+  GIT_REV=$(git rev-parse HEAD)
+  jq_inplace $SRCMAP ".\"$GIT_DIR\" = { type: \"git\", url: \"$GIT_URL\", rev: \"$GIT_REV\" }"
+done
+
+# Subversion
+for DOT_SVN_DIR in $(find $PATHS_TO_SCAN -name ".svn" -type d); do
+  SVN_DIR=$(dirname $DOT_SVN_DIR)
+  cd $SVN_DIR
+  SVN_URL=$(svn info | grep "^URL:" | sed  's/URL: //g')
+  SVN_REV=$(svn info -r HEAD | grep "^Revision:" | sed  's/Revision: //g')
+  jq_inplace $SRCMAP ".\"$SVN_DIR\" = { type: \"svn\", url: \"$SVN_URL\", rev: \"$SVN_REV\" }"
+done
+
+# Mercurial
+for DOT_HG_DIR in $(find $PATHS_TO_SCAN -name ".hg" -type d); do
+  HG_DIR=$(dirname $DOT_HG_DIR)
+  cd $HG_DIR
+  HG_URL=$(hg paths default)
+  HG_REV=$(hg --debug id -r. -i)
+  jq_inplace $SRCMAP ".\"$HG_DIR\" = { type: \"hg\", url: \"$HG_URL\", rev: \"$HG_REV\" }"
+done
+
+if [ "${OSSFUZZ_REVISION-}" != "" ]; then
+  jq_inplace $SRCMAP ".\"/src\" = { type: \"git\", url: \"https://github.com/google/oss-fuzz.git\", rev: \"$OSSFUZZ_REVISION\" }"
+fi
+
+cat $SRCMAP
+rm $SRCMAP

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/test_data/culprit-commit.txt

@@ -0,0 +1,30 @@
+ac9ee01fcbfac745aaedca0393a8e1c8a33acd8d is the first bad commit
+commit ac9ee01fcbfac745aaedca0393a8e1c8a33acd8d
+Author: John Doe <johndoe@example.com>
+Date:   Tue Aug 6 08:41:53 2019 +0000
+
+    [compiler-rt] Implement getrandom interception
+    
+    Summary:
+    Straightforward implementation of `getrandom` syscall and libc
+    hooks.
+    
+    Test Plan: Local MSAN failures caused by uninstrumented `getrandom`
+    calls stop failing.
+    
+    Patch by John Doe 3.
+    
+    Reviewers: jonhdoe2, johndoe
+    
+    Reviewed By: johndoe
+    
+    Subscribers: johndoe4, johndoe5, #sanitizers, llvm-commits
+    
+    Tags: #sanitizers, #llvm
+    
+    Differential Revision: https://reviews.llvm.org/D65551
+    
+    llvm-svn: 367999
+
+:040000 040000 8db10511ca83cc7b0265c7703684cd386350151b 62508fdc5e8919bbb2a0bd185cc109868192cdb0 M      compiler-rt
+bisect run success

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/write_labels.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Script for writing from project.yaml to .labels file."""
+
+import os
+import json
+import sys
+
+
+def main():
+  """Writes labels."""
+  if len(sys.argv) != 3:
+    print('Usage: write_labels.py labels_json out_dir', file=sys.stderr)
+    sys.exit(1)
+
+  labels_by_target = json.loads(sys.argv[1])
+  out = sys.argv[2]
+
+  for target_name, labels in labels_by_target.items():
+    # Skip over wildcard value applying to all fuzz targets
+    if target_name == '*':
+      continue
+    with open(os.path.join(out, target_name + '.labels'), 'w') as file_handle:
+      file_handle.write('\n'.join(labels))
+
+
+if __name__ == '__main__':
+  main()

local-test-commons-compress-full-01-vuln_2/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-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-runner/bad_build_check

@@ -0,0 +1,494 @@
+#!/bin/bash -u
+# Copyright 2017 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.
+#
+################################################################################
+
+# A minimal number of runs to test fuzz target with a non-empty input.
+MIN_NUMBER_OF_RUNS=4
+
+# The "example" target has 73 with ASan, 65 with UBSan, and 6648 with MSan.
+# Real world targets have greater values (arduinojson: 407, zlib: 664).
+# Mercurial's bdiff_fuzzer has 116 PCs when built with ASan.
+THRESHOLD_FOR_NUMBER_OF_EDGES=100
+
+# A fuzz target is supposed to have at least two functions, such as
+# LLVMFuzzerTestOneInput and an API that is being called from there.
+THRESHOLD_FOR_NUMBER_OF_FUNCTIONS=2
+
+# Threshold values for different sanitizers used by instrumentation checks.
+ASAN_CALLS_THRESHOLD_FOR_ASAN_BUILD=1000
+ASAN_CALLS_THRESHOLD_FOR_NON_ASAN_BUILD=0
+
+# The value below can definitely be higher (like 500-1000), but avoid being too
+# agressive here while still evaluating the DFT-based fuzzing approach.
+DFSAN_CALLS_THRESHOLD_FOR_DFSAN_BUILD=100
+DFSAN_CALLS_THRESHOLD_FOR_NON_DFSAN_BUILD=0
+
+MSAN_CALLS_THRESHOLD_FOR_MSAN_BUILD=1000
+# Some engines (e.g. honggfuzz) may make a very small number of calls to msan
+# for memory poisoning.
+MSAN_CALLS_THRESHOLD_FOR_NON_MSAN_BUILD=3
+
+# Usually, a non UBSan build (e.g. ASan) has 165 calls to UBSan runtime. The
+# majority of targets built with UBSan have 200+ UBSan calls, but there are
+# some very small targets that may have < 200 UBSan calls even in a UBSan build.
+# Use the threshold value of 168 (slightly > 165) for UBSan build.
+UBSAN_CALLS_THRESHOLD_FOR_UBSAN_BUILD=168
+
+# It would be risky to use the threshold value close to 165 for non UBSan build,
+# as UBSan runtime may change any time and thus we could have different number
+# of calls to UBSan runtime even in ASan build. With that, we use the threshold
+# value of 200 that would detect unnecessary UBSan instrumentation in the vast
+# majority of targets, except of a handful very small ones, which would not be
+# a big concern either way as the overhead for them would not be significant.
+UBSAN_CALLS_THRESHOLD_FOR_NON_UBSAN_BUILD=200
+
+# ASan builds on i386 generally have about 250 UBSan runtime calls.
+if [[ $ARCHITECTURE == 'i386' ]]
+then
+  UBSAN_CALLS_THRESHOLD_FOR_NON_UBSAN_BUILD=280
+fi
+
+
+# Verify that the given fuzz target is correctly built to run with a particular
+# engine.
+function check_engine {
+  local FUZZER=$1
+  local FUZZER_NAME=$(basename $FUZZER)
+  local FUZZER_OUTPUT="/tmp/$FUZZER_NAME.output"
+  local CHECK_FAILED=0
+
+  if [[ "$FUZZING_ENGINE" == libfuzzer ]]; then
+    # Store fuzz target's output into a temp file to be used for further checks.
+    $FUZZER -seed=1337 -runs=$MIN_NUMBER_OF_RUNS &>$FUZZER_OUTPUT
+    CHECK_FAILED=$(egrep "ERROR: no interesting inputs were found. Is the code instrumented" -c $FUZZER_OUTPUT)
+    if (( $CHECK_FAILED > 0 )); then
+      echo "BAD BUILD: $FUZZER does not seem to have coverage instrumentation."
+      cat $FUZZER_OUTPUT
+      # Bail out as the further check does not make any sense, there are 0 PCs.
+      return 1
+    fi
+
+    local NUMBER_OF_EDGES=$(grep -Po "INFO: Loaded [[:digit:]]+ module.*\(.*(counters|guards)\):[[:space:]]+\K[[:digit:]]+" $FUZZER_OUTPUT)
+
+    # If a fuzz target fails to start, grep won't find anything, so bail out early to let check_startup_crash deal with it.
+    [[ -z "$NUMBER_OF_EDGES" ]] && return
+
+    if (( $NUMBER_OF_EDGES < $THRESHOLD_FOR_NUMBER_OF_EDGES )); then
+      echo "BAD BUILD: $FUZZER seems to have only partial coverage instrumentation."
+    fi
+  elif [[ "$FUZZING_ENGINE" == afl ]]; then
+    AFL_FORKSRV_INIT_TMOUT=30000 AFL_NO_UI=1 SKIP_SEED_CORPUS=1 timeout --preserve-status -s INT 35s run_fuzzer $FUZZER_NAME &>$FUZZER_OUTPUT
+    CHECK_PASSED=$(egrep "All set and ready to roll" -c $FUZZER_OUTPUT)
+    if (( $CHECK_PASSED == 0 )); then
+      echo "BAD BUILD: fuzzing $FUZZER with afl-fuzz failed."
+      cat $FUZZER_OUTPUT
+      return 1
+    fi
+  elif [[ "$FUZZING_ENGINE" == honggfuzz ]]; then
+    SKIP_SEED_CORPUS=1 timeout --preserve-status -s INT 20s run_fuzzer $FUZZER_NAME &>$FUZZER_OUTPUT
+    CHECK_PASSED=$(egrep "^Sz:[0-9]+ Tm:[0-9]+" -c $FUZZER_OUTPUT)
+    if (( $CHECK_PASSED == 0 )); then
+      echo "BAD BUILD: fuzzing $FUZZER with honggfuzz failed."
+      cat $FUZZER_OUTPUT
+      return 1
+    fi
+  elif [[ "$FUZZING_ENGINE" == dataflow ]]; then
+    $FUZZER &> $FUZZER_OUTPUT
+    local NUMBER_OF_FUNCTIONS=$(grep -Po "INFO:\s+\K[[:digit:]]+(?=\s+instrumented function.*)" $FUZZER_OUTPUT)
+    [[ -z "$NUMBER_OF_FUNCTIONS" ]] && NUMBER_OF_FUNCTIONS=0
+    if (( $NUMBER_OF_FUNCTIONS < $THRESHOLD_FOR_NUMBER_OF_FUNCTIONS )); then
+      echo "BAD BUILD: $FUZZER does not seem to be properly built in 'dataflow' config."
+      cat $FUZZER_OUTPUT
+      return 1
+    fi
+  elif [[ "$FUZZING_ENGINE" == centipede \
+          && ("${HELPER:-}" == True || "$SANITIZER" == none ) ]]; then
+    # Performs run test on unsanitized binaries with auxiliary sanitized
+    # binaries if they are built with helper.py.
+    # Performs run test on unsanitized binaries without auxiliary sanitized
+    # binaries if they are from trial build and production build.
+    # TODO(Dongge): Support run test with sanitized binaries for trial and
+    # production build.
+    SKIP_SEED_CORPUS=1 timeout --preserve-status -s INT 20s run_fuzzer $FUZZER_NAME &>$FUZZER_OUTPUT
+    CHECK_PASSED=$(egrep "\[S0.0] begin-fuzz: ft: 0 corp: 0/0" -c $FUZZER_OUTPUT)
+    if (( $CHECK_PASSED == 0 )); then
+      echo "BAD BUILD: fuzzing $FUZZER with centipede failed."
+      cat $FUZZER_OUTPUT
+      return 1
+    fi
+  fi
+  
+  return 0
+}
+
+# Verify that the given fuzz target has been built properly and works.
+function check_startup_crash {
+  local FUZZER=$1
+  local FUZZER_NAME=$(basename $FUZZER)
+  local FUZZER_OUTPUT="/tmp/$FUZZER_NAME.output"
+  local CHECK_PASSED=0
+
+  if [[ "$FUZZING_ENGINE" = libfuzzer ]]; then
+    # Skip seed corpus as there is another explicit check that uses seed corpora.
+    SKIP_SEED_CORPUS=1 run_fuzzer $FUZZER_NAME -seed=1337 -runs=$MIN_NUMBER_OF_RUNS &>$FUZZER_OUTPUT
+    CHECK_PASSED=$(egrep "Done $MIN_NUMBER_OF_RUNS runs" -c $FUZZER_OUTPUT)
+  elif [[ "$FUZZING_ENGINE" = afl ]]; then
+    AFL_FORKSRV_INIT_TMOUT=30000 AFL_NO_UI=1 SKIP_SEED_CORPUS=1 timeout --preserve-status -s INT 35s run_fuzzer $FUZZER_NAME &>$FUZZER_OUTPUT
+    if [ $(egrep "target binary (crashed|terminated)" -c $FUZZER_OUTPUT) -eq 0 ]; then
+      CHECK_PASSED=1
+    fi
+  elif [[ "$FUZZING_ENGINE" = dataflow ]]; then
+    # TODO(https://github.com/google/oss-fuzz/issues/1632): add check for
+    # binaries compiled with dataflow engine when the interface becomes stable.
+    CHECK_PASSED=1
+  else
+    # TODO: add checks for another fuzzing engines if possible.
+    CHECK_PASSED=1
+  fi
+
+  if [ "$CHECK_PASSED" -eq "0" ]; then
+    echo "BAD BUILD: $FUZZER seems to have either startup crash or exit:"
+    cat $FUZZER_OUTPUT
+    return 1
+  fi
+
+  return 0
+}
+
+# Mixed sanitizers check for ASan build.
+function check_asan_build {
+  local FUZZER=$1
+  local ASAN_CALLS=$2
+  local DFSAN_CALLS=$3
+  local MSAN_CALLS=$4
+  local UBSAN_CALLS=$5
+
+  # Perform all the checks for more detailed error message.
+  if (( $ASAN_CALLS < $ASAN_CALLS_THRESHOLD_FOR_ASAN_BUILD )); then
+    echo "BAD BUILD: $FUZZER does not seem to be compiled with ASan."
+    return 1
+  fi
+
+  if (( $DFSAN_CALLS > $DFSAN_CALLS_THRESHOLD_FOR_NON_DFSAN_BUILD )); then
+    echo "BAD BUILD: ASan build of $FUZZER seems to be compiled with DFSan."
+    return 1
+  fi
+
+  if (( $MSAN_CALLS > $MSAN_CALLS_THRESHOLD_FOR_NON_MSAN_BUILD )); then
+    echo "BAD BUILD: ASan build of $FUZZER seems to be compiled with MSan."
+    return 1
+  fi
+
+  if (( $UBSAN_CALLS > $UBSAN_CALLS_THRESHOLD_FOR_NON_UBSAN_BUILD )); then
+    echo "BAD BUILD: ASan build of $FUZZER seems to be compiled with UBSan."
+    return 1
+  fi
+
+  return 0
+}
+
+# Mixed sanitizers check for DFSan build.
+function check_dfsan_build {
+  local FUZZER=$1
+  local ASAN_CALLS=$2
+  local DFSAN_CALLS=$3
+  local MSAN_CALLS=$4
+  local UBSAN_CALLS=$5
+
+  # Perform all the checks for more detailed error message.
+  if (( $ASAN_CALLS > $ASAN_CALLS_THRESHOLD_FOR_NON_ASAN_BUILD )); then
+    echo "BAD BUILD: DFSan build of $FUZZER seems to be compiled with ASan."
+    return 1
+  fi
+
+  if (( $DFSAN_CALLS < $DFSAN_CALLS_THRESHOLD_FOR_DFSAN_BUILD )); then
+    echo "BAD BUILD: $FUZZER does not seem to be compiled with DFSan."
+    return 1
+  fi
+
+  if (( $MSAN_CALLS > $MSAN_CALLS_THRESHOLD_FOR_NON_MSAN_BUILD )); then
+    echo "BAD BUILD: ASan build of $FUZZER seems to be compiled with MSan."
+    return 1
+  fi
+
+  if (( $UBSAN_CALLS > $UBSAN_CALLS_THRESHOLD_FOR_NON_UBSAN_BUILD )); then
+    echo "BAD BUILD: ASan build of $FUZZER seems to be compiled with UBSan."
+    return 1
+  fi
+
+  return 0
+}
+
+
+# Mixed sanitizers check for MSan build.
+function check_msan_build {
+  local FUZZER=$1
+  local ASAN_CALLS=$2
+  local DFSAN_CALLS=$3
+  local MSAN_CALLS=$4
+  local UBSAN_CALLS=$5
+
+  # Perform all the checks for more detailed error message.
+  if (( $ASAN_CALLS > $ASAN_CALLS_THRESHOLD_FOR_NON_ASAN_BUILD )); then
+    echo "BAD BUILD: MSan build of $FUZZER seems to be compiled with ASan."
+    return 1
+  fi
+
+  if (( $DFSAN_CALLS > $DFSAN_CALLS_THRESHOLD_FOR_NON_DFSAN_BUILD )); then
+    echo "BAD BUILD: MSan build of $FUZZER seems to be compiled with DFSan."
+    return 1
+  fi
+
+  if (( $MSAN_CALLS < $MSAN_CALLS_THRESHOLD_FOR_MSAN_BUILD )); then
+    echo "BAD BUILD: $FUZZER does not seem to be compiled with MSan."
+    return 1
+  fi
+
+  if (( $UBSAN_CALLS > $UBSAN_CALLS_THRESHOLD_FOR_NON_UBSAN_BUILD )); then
+    echo "BAD BUILD: MSan build of $FUZZER seems to be compiled with UBSan."
+    return 1
+  fi
+
+  return 0
+}
+
+# Mixed sanitizers check for UBSan build.
+function check_ubsan_build {
+  local FUZZER=$1
+  local ASAN_CALLS=$2
+  local DFSAN_CALLS=$3
+  local MSAN_CALLS=$4
+  local UBSAN_CALLS=$5
+
+  if [[ "$FUZZING_ENGINE" != libfuzzer ]]; then
+    # Ignore UBSan checks for fuzzing engines other than libFuzzer because:
+    # A) we (probably) are not going to use those with UBSan
+    # B) such builds show indistinguishable number of calls to UBSan
+    return 0
+  fi
+
+  # Perform all the checks for more detailed error message.
+  if (( $ASAN_CALLS > $ASAN_CALLS_THRESHOLD_FOR_NON_ASAN_BUILD )); then
+    echo "BAD BUILD: UBSan build of $FUZZER seems to be compiled with ASan."
+    return 1
+  fi
+
+  if (( $DFSAN_CALLS > $DFSAN_CALLS_THRESHOLD_FOR_NON_DFSAN_BUILD )); then
+    echo "BAD BUILD: UBSan build of $FUZZER seems to be compiled with DFSan."
+    return 1
+  fi
+
+  if (( $MSAN_CALLS > $MSAN_CALLS_THRESHOLD_FOR_NON_MSAN_BUILD )); then
+    echo "BAD BUILD: UBSan build of $FUZZER seems to be compiled with MSan."
+    return 1
+  fi
+
+  if (( $UBSAN_CALLS < $UBSAN_CALLS_THRESHOLD_FOR_UBSAN_BUILD )); then
+    echo "BAD BUILD: $FUZZER does not seem to be compiled with UBSan."
+    return 1
+  fi
+}
+
+# Verify that the given fuzz target is compiled with correct sanitizer.
+function check_mixed_sanitizers {
+  local FUZZER=$1
+  local result=0
+  local CALL_INSN=
+
+  if [ "${FUZZING_LANGUAGE:-}" = "jvm" ]; then
+    # Sanitizer runtime is linked into the Jazzer driver, so this check does not
+    # apply.
+    return 0
+  fi
+
+  if [ "${FUZZING_LANGUAGE:-}" = "javascript" ]; then
+    # Jazzer.js currently does not support using sanitizers with native Node.js addons.
+    # This is not relevant anyways since supporting this will be done by preloading
+    # the sanitizers in the wrapper script starting Jazzer.js.
+    return 0
+  fi
+
+  if [ "${FUZZING_LANGUAGE:-}" = "python" ]; then
+    # Sanitizer runtime is loaded via LD_PRELOAD, so this check does not apply.
+    return 0
+  fi
+
+  # For fuzztest fuzzers point to the binary instead of launcher script.
+  if [[ $FUZZER == *"@"* ]]; then
+    FUZZER=(${FUZZER//@/ }[0])
+  fi
+
+  CALL_INSN=
+  if [[ $ARCHITECTURE == "x86_64" ]]
+  then
+    CALL_INSN="callq?\s+[0-9a-f]+\s+<"
+  elif [[ $ARCHITECTURE == "i386" ]]
+  then
+    CALL_INSN="call\s+[0-9a-f]+\s+<"
+  elif [[ $ARCHITECTURE == "aarch64" ]]
+  then
+    CALL_INSN="bl\s+[0-9a-f]+\s+<"
+  else
+    echo "UNSUPPORTED ARCHITECTURE"
+    exit 1
+  fi
+  local ASAN_CALLS=$(objdump -dC $FUZZER | egrep "${CALL_INSN}__asan" -c)
+  local DFSAN_CALLS=$(objdump -dC $FUZZER | egrep "${CALL_INSN}__dfsan" -c)
+  local MSAN_CALLS=$(objdump -dC $FUZZER | egrep "${CALL_INSN}__msan" -c)
+  local UBSAN_CALLS=$(objdump -dC $FUZZER | egrep "${CALL_INSN}__ubsan" -c)
+
+
+  if [[ "$SANITIZER" = address ]]; then
+    check_asan_build $FUZZER $ASAN_CALLS $DFSAN_CALLS $MSAN_CALLS $UBSAN_CALLS
+    result=$?
+  elif [[ "$SANITIZER" = dataflow ]]; then
+    check_dfsan_build $FUZZER $ASAN_CALLS $DFSAN_CALLS $MSAN_CALLS $UBSAN_CALLS
+    result=$?
+  elif [[ "$SANITIZER" = memory ]]; then
+    check_msan_build $FUZZER $ASAN_CALLS $DFSAN_CALLS $MSAN_CALLS $UBSAN_CALLS
+    result=$?
+  elif [[ "$SANITIZER" = undefined ]]; then
+    check_ubsan_build $FUZZER $ASAN_CALLS $DFSAN_CALLS $MSAN_CALLS $UBSAN_CALLS
+    result=$?
+  elif [[ "$SANITIZER" = thread ]]; then
+    # TODO(metzman): Implement this.
+    result=0
+  fi
+
+  return $result
+}
+
+# Verify that the given fuzz target doesn't crash on the seed corpus.
+function check_seed_corpus {
+  local FUZZER=$1
+  local FUZZER_NAME="$(basename $FUZZER)"
+  local FUZZER_OUTPUT="/tmp/$FUZZER_NAME.output"
+
+  if [[ "$FUZZING_ENGINE" != libfuzzer ]]; then
+    return 0
+  fi
+
+  # Set up common fuzzing arguments, otherwise "run_fuzzer" errors out.
+  if [ -z "$FUZZER_ARGS" ]; then
+    export FUZZER_ARGS="-rss_limit_mb=2560 -timeout=25"
+  fi
+
+  bash -c "run_fuzzer $FUZZER_NAME -runs=0" &> $FUZZER_OUTPUT
+
+  # Don't output anything if fuzz target hasn't crashed.
+  if [ $? -ne 0 ]; then
+    echo "BAD BUILD: $FUZZER has a crashing input in its seed corpus:"
+    cat $FUZZER_OUTPUT
+    return 1
+  fi
+
+  return 0
+}
+
+function check_architecture {
+  local FUZZER=$1
+  local FUZZER_NAME=$(basename $FUZZER)
+
+  if [ "${FUZZING_LANGUAGE:-}" = "jvm" ]; then
+    # The native dependencies of a JVM project are not packaged, but loaded
+    # dynamically at runtime and thus cannot be checked here.
+    return 0;
+  fi
+
+  if [ "${FUZZING_LANGUAGE:-}" = "javascript" ]; then
+    # Jazzer.js fuzzers are wrapper scripts that start the fuzz target with
+    # the Jazzer.js CLI.
+    return 0;
+  fi
+
+  if [ "${FUZZING_LANGUAGE:-}" = "python" ]; then
+    FUZZER=${FUZZER}.pkg
+  fi
+
+  # For fuzztest fuzzers point to the binary instead of launcher script.
+  if [[ $FUZZER == *"@"* ]]; then
+    FUZZER=(${FUZZER//@/ }[0])
+  fi
+
+  FILE_OUTPUT=$(file $FUZZER)
+  if [[ $ARCHITECTURE == "x86_64" ]]
+  then
+    echo $FILE_OUTPUT | grep "x86-64" > /dev/null
+  elif [[ $ARCHITECTURE == "i386" ]]
+  then
+    echo $FILE_OUTPUT | grep "80386" > /dev/null
+  elif [[ $ARCHITECTURE == "aarch64" ]]
+  then
+    echo $FILE_OUTPUT | grep "aarch64" > /dev/null
+  else
+    echo "UNSUPPORTED ARCHITECTURE"
+    return 1
+  fi
+  result=$?
+  if [[ $result != 0 ]]
+  then
+    echo "BAD BUILD $FUZZER is not built for architecture: $ARCHITECTURE"
+    echo "file command output: $FILE_OUTPUT"
+    echo "check_mixed_sanitizers test will fail."
+  fi
+  return $result
+}
+
+function main {
+  local FUZZER=$1
+  local AUXILIARY_FUZZER=${2:-}
+  local checks_failed=0
+  local result=0
+
+  export RUN_FUZZER_MODE="batch"
+  check_engine $FUZZER
+  result=$?
+  checks_failed=$(( $checks_failed + $result ))
+
+  check_architecture $FUZZER
+  result=$?
+  checks_failed=$(( $checks_failed + $result ))
+
+  if [[ "$FUZZING_ENGINE" == centipede \
+        && "$SANITIZER" != none && "${HELPER:-}" == True ]]; then
+    check_mixed_sanitizers $AUXILIARY_FUZZER
+   else
+    check_mixed_sanitizers $FUZZER
+  fi
+  result=$?
+  checks_failed=$(( $checks_failed + $result ))
+
+  check_startup_crash $FUZZER
+  result=$?
+  checks_failed=$(( $checks_failed + $result ))
+
+  # TODO: re-enable after introducing bug auto-filing for bad builds.
+  # check_seed_corpus $FUZZER
+  return $checks_failed
+}
+
+
+if [ $# -ne 1 -a $# -ne 2 ]; then
+  echo "Usage: $0 <fuzz_target_binary> [<auxiliary_binary>]"
+  exit 1
+fi
+
+# Fuzz target path.
+FUZZER=$1
+AUXILIARY_FUZZER=${2:-}
+
+main $FUZZER $AUXILIARY_FUZZER
+exit $?

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-runner/gocoverage/convertcorpus/go.mod

@@ -0,0 +1,10 @@
+module oss-fuzz.com/gocoverage/convertcorpus
+
+go 1.19
+
+require github.com/AdamKorcz/go-118-fuzz-build v0.0.0-20221110144148-3ffc89b74f84
+
+require (
+	github.com/AdaLogics/go-fuzz-headers v0.0.0-20220824214621-3c06a36a6952 // indirect
+	github.com/cyphar/filepath-securejoin v0.2.3 // indirect
+)

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-runner/gocoverage/gocovmerge/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015, Wade Simmons
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-runner/gocoverage/gocovsum/gocovsum.go

@@ -0,0 +1,171 @@
+// 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 (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+
+	"go/ast"
+	"go/parser"
+	"go/token"
+
+	"golang.org/x/tools/cover"
+)
+
+type CoverageTotal struct {
+	Count     int     `json:"count"`
+	Covered   int     `json:"covered"`
+	Uncovered int     `json:"notcovered"`
+	Percent   float64 `json:"percent"`
+}
+
+type CoverageTotals struct {
+	Functions      CoverageTotal `json:"functions,omitempty"`
+	Lines          CoverageTotal `json:"lines,omitempty"`
+	Regions        CoverageTotal `json:"regions,omitempty"`
+	Instantiations CoverageTotal `json:"instantiations,omitempty"`
+	Branches       CoverageTotal `json:"branches,omitempty"`
+}
+
+type CoverageFile struct {
+	Summary  CoverageTotals `json:"summary,omitempty"`
+	Filename string         `json:"filename,omitempty"`
+}
+
+type CoverageData struct {
+	Totals CoverageTotals `json:"totals,omitempty"`
+	Files  []CoverageFile `json:"files,omitempty"`
+}
+
+type PositionInterval struct {
+	start token.Position
+	end   token.Position
+}
+
+type CoverageSummary struct {
+	Data    []CoverageData `json:"data,omitempty"`
+	Type    string         `json:"type,omitempty"`
+	Version string         `json:"version,omitempty"`
+}
+
+func isFunctionCovered(s token.Position, e token.Position, blocks []cover.ProfileBlock) bool {
+	for _, b := range blocks {
+		if b.StartLine >= s.Line && b.StartLine <= e.Line && b.EndLine >= s.Line && b.EndLine <= e.Line {
+			if b.Count > 0 {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func computePercent(s *CoverageTotals) {
+	if s.Regions.Count > 0 {
+		s.Regions.Percent = float64(100*s.Regions.Covered) / float64(s.Regions.Count)
+	}
+	if s.Lines.Count > 0 {
+		s.Lines.Percent = float64(100*s.Lines.Covered) / float64(s.Lines.Count)
+	}
+	if s.Functions.Count > 0 {
+		s.Functions.Percent = float64(100*s.Functions.Covered) / float64(s.Functions.Count)
+	}
+}
+
+func main() {
+	flag.Parse()
+
+	if len(flag.Args()) != 1 {
+		log.Fatalf("needs exactly one argument")
+	}
+	profiles, err := cover.ParseProfiles(flag.Args()[0])
+	if err != nil {
+		log.Fatalf("failed to parse profiles: %v", err)
+	}
+	r := CoverageSummary{}
+	r.Type = "oss-fuzz.go.coverage.json.export"
+	r.Version = "2.0.1"
+	r.Data = make([]CoverageData, 1)
+	for _, p := range profiles {
+		fset := token.NewFileSet() // positions are relative to fset
+		f, err := parser.ParseFile(fset, p.FileName, nil, 0)
+		if err != nil {
+			log.Printf("failed to parse go file: %v", err)
+			continue
+		}
+		fileCov := CoverageFile{}
+		fileCov.Filename = p.FileName
+		ast.Inspect(f, func(n ast.Node) bool {
+			switch x := n.(type) {
+			case *ast.FuncLit:
+				startf := fset.Position(x.Pos())
+				endf := fset.Position(x.End())
+				fileCov.Summary.Functions.Count++
+				if isFunctionCovered(startf, endf, p.Blocks) {
+					fileCov.Summary.Functions.Covered++
+				} else {
+					fileCov.Summary.Functions.Uncovered++
+				}
+			case *ast.FuncDecl:
+				startf := fset.Position(x.Pos())
+				endf := fset.Position(x.End())
+				fileCov.Summary.Functions.Count++
+				if isFunctionCovered(startf, endf, p.Blocks) {
+					fileCov.Summary.Functions.Covered++
+				} else {
+					fileCov.Summary.Functions.Uncovered++
+				}
+			}
+			return true
+		})
+
+		for _, b := range p.Blocks {
+			fileCov.Summary.Regions.Count++
+			if b.Count > 0 {
+				fileCov.Summary.Regions.Covered++
+			} else {
+				fileCov.Summary.Regions.Uncovered++
+			}
+
+			fileCov.Summary.Lines.Count += b.NumStmt
+			if b.Count > 0 {
+				fileCov.Summary.Lines.Covered += b.NumStmt
+			} else {
+				fileCov.Summary.Lines.Uncovered += b.NumStmt
+			}
+		}
+		r.Data[0].Totals.Regions.Count += fileCov.Summary.Regions.Count
+		r.Data[0].Totals.Regions.Covered += fileCov.Summary.Regions.Covered
+		r.Data[0].Totals.Regions.Uncovered += fileCov.Summary.Regions.Uncovered
+		r.Data[0].Totals.Lines.Count += fileCov.Summary.Lines.Count
+		r.Data[0].Totals.Lines.Covered += fileCov.Summary.Lines.Covered
+		r.Data[0].Totals.Lines.Uncovered += fileCov.Summary.Lines.Uncovered
+		r.Data[0].Totals.Functions.Count += fileCov.Summary.Functions.Count
+		r.Data[0].Totals.Functions.Covered += fileCov.Summary.Functions.Covered
+		r.Data[0].Totals.Functions.Uncovered += fileCov.Summary.Functions.Uncovered
+
+		computePercent(&fileCov.Summary)
+		r.Data[0].Files = append(r.Data[0].Files, fileCov)
+	}
+
+	computePercent(&r.Data[0].Totals)
+	o, err := json.Marshal(r)
+	if err != nil {
+		log.Fatalf("failed to generate json: %v", err)
+	}
+	fmt.Printf(string(o))
+}

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-runner/gocoverage/pprof-merge/main.go

@@ -0,0 +1,68 @@
+// Copyright 2019 Google Inc. All Rights Reserved.
+//
+// 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 (
+	"flag"
+	"log"
+	"os"
+
+	"github.com/google/pprof/profile"
+)
+
+var (
+	output string
+)
+
+func main() {
+	flag.StringVar(&output, "o", "merged.data", "")
+	flag.Parse()
+
+	files := os.Args[1:]
+	if len(files) == 0 {
+		log.Fatal("Give profiles files as arguments")
+	}
+
+	var profiles []*profile.Profile
+	for _, fname := range files {
+		f, err := os.Open(fname)
+		if err != nil {
+			log.Fatalf("Cannot open profile file at %q: %v", fname, err)
+		}
+		p, err := profile.Parse(f)
+		if err != nil {
+			log.Fatalf("Cannot parse profile at %q: %v", fname, err)
+		}
+		profiles = append(profiles, p)
+	}
+
+	merged, err := profile.Merge(profiles)
+	if err != nil {
+		log.Fatalf("Cannot merge profiles: %v", err)
+	}
+
+	out, err := os.OpenFile(output, os.O_RDWR|os.O_CREATE, 0755)
+	if err != nil {
+		log.Fatalf("Cannot open output to write: %v", err)
+	}
+
+	if err := merged.Write(out); err != nil {
+		log.Fatalf("Cannot write merged profile to file: %v", err)
+	}
+
+	if err := out.Close(); err != nil {
+		log.Printf("Error when closing the output file: %v", err)
+	}
+}