Add files using upload-large-folder tool

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder-fuzzbench/Dockerfile

@@ -0,0 +1,26 @@
+# 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.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-builder:${IMG_TAG}
+
+# Copy/Run this now to make the cache more resilient.
+COPY fuzzbench_install_dependencies /usr/local/bin
+RUN fuzzbench_install_dependencies
+
+ENV OSS_FUZZ_ON_DEMAND=1
+
+COPY fuzzbench_build fuzzbench_run_fuzzer fuzzbench_measure /usr/local/bin/

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder-fuzzbench/fuzzbench_build

@@ -0,0 +1,28 @@
+#! /bin/bash -eux
+# 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.
+#
+################################################################################
+
+# TODO(metzman): Do this in a docket image so we don't need to waste time
+# reinstalling.
+PYTHONPATH=$FUZZBENCH_PATH python3 -B -u -c "from fuzzers.$FUZZING_ENGINE import fuzzer; fuzzer.build()"
+
+if [ "$FUZZING_ENGINE" = "coverage" ]; then
+  cd $OUT
+  mkdir -p filestore/oss-fuzz-on-demand/coverage-binaries
+  # We expect an error regarding leading slashes. Just assume this step succeeds.
+  # TODO(metzman): Fix this when I get a chance.
+  tar -czvf filestore/oss-fuzz-on-demand/coverage-binaries/coverage-build-$PROJECT.tar.gz * /src /work || exit 0
+fi

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder-fuzzbench/fuzzbench_install_dependencies

@@ -0,0 +1,22 @@
+#! /bin/bash -eux
+# 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.
+#
+################################################################################
+
+apt-get update && apt-get install -y gcc gfortran python-dev libopenblas-dev liblapack-dev cython libpq-dev
+wget -O /tmp/requirements.txt https://raw.githubusercontent.com/google/fuzzbench/master/requirements.txt
+pip3 install pip --upgrade
+CFLAGS= CXXFLAGS= pip3 install -r /tmp/requirements.txt
+rm /tmp/requirements.txt

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder-fuzzbench/fuzzbench_measure

@@ -0,0 +1,32 @@
+#! /bin/bash -eux
+# 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.
+#
+################################################################################
+
+# TODO(metzman): Make these configurable.
+export DB_PATH=$OUT/experiment.db
+export SNAPSHOT_PERIOD=30
+export EXPERIMENT_FILESTORE=$OUT/filestore
+export MAX_TOTAL_TIME=120
+export EXPERIMENT=oss-fuzz-on-demand
+
+rm -f $DB_PATH
+
+# FUZZER=mopt BENCHMARK=skcms
+
+export SQL_DATABASE_URL=sqlite:///$DB_PATH
+
+cd $FUZZBENCH_PATH
+PYTHONPATH=. python3 -B experiment/measurer/standalone.py $MAX_TOTAL_TIME

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder-fuzzbench/fuzzbench_run_fuzzer

@@ -0,0 +1,41 @@
+#! /bin/bash -eux
+# 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.
+#
+################################################################################
+
+export RUNNER_NICENESS="-5"
+export EXPERIMENT_FILESTORE=$OUT/filestore
+export EXPERIMENT=oss-fuzz-on-demand
+export OSS_FUZZ_ON_DEMAND=1
+export OUTPUT_CORPUS_DIR=/output-corpus
+export SEED_CORPUS_DIR=/input-corpus
+mkdir $SEED_CORPUS_DIR
+rm -rf $OUTPUT_CORPUS_DIR
+mkdir $OUTPUT_CORPUS_DIR
+export FUZZER=$FUZZING_ENGINE
+# TODO(metzman): Make this configurable.
+export MAX_TOTAL_TIME=120
+export SNAPSHOT_PERIOD=30
+export TRIAL_ID=1
+export FORCE_LOCAL=1
+
+# BENCHMARK, FUZZ_TARGET
+cd $OUT
+
+# Prevent permissions issues with pyc files and docker.
+cp -r $FUZZBENCH_PATH /tmp/fuzzbench
+
+PYTHONPATH=/tmp/fuzzbench nice -n $RUNNER_NICENESS python3 -B -u /tmp/fuzzbench/experiment/runner.py
+cat $EXPERIMENT_FILESTORE/$EXPERIMENT/experiment-folders/$BENCHMARK-$FUZZER/trial-$TRIAL_ID/results/fuzzer-log.txt

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder-go/Dockerfile

@@ -0,0 +1,33 @@
+# 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}
+
+# Set up Golang environment variables (copied from /root/.bash_profile).
+ENV GOPATH /root/go
+
+# /root/.go/bin is for the standard Go binaries (i.e. go, gofmt, etc).
+# $GOPATH/bin is for the binaries from the dependencies installed via "go get".
+ENV PATH $PATH:/root/.go/bin:$GOPATH/bin
+
+COPY gosigfuzz.c $GOPATH/gosigfuzz/
+
+RUN install_go.sh
+
+# TODO(jonathanmetzman): Install this file using install_go.sh.
+COPY ossfuzz_coverage_runner.go \
+     $GOPATH/

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder-go/gosigfuzz.c

@@ -0,0 +1,47 @@
+/*
+ * 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<stdlib.h>
+#include<signal.h>
+
+static void fixSignalHandler(int signum) {
+    struct sigaction new_action;
+    struct sigaction old_action;
+    sigemptyset (&new_action.sa_mask);
+    sigaction (signum, NULL, &old_action);
+    new_action.sa_flags = old_action.sa_flags | SA_ONSTACK;
+    new_action.sa_sigaction = old_action.sa_sigaction;
+    new_action.sa_handler = old_action.sa_handler;
+    sigaction (signum, &new_action, NULL);
+}
+
+static void FixStackSignalHandler() {
+    fixSignalHandler(SIGSEGV);
+    fixSignalHandler(SIGABRT);
+    fixSignalHandler(SIGALRM);
+    fixSignalHandler(SIGINT);
+    fixSignalHandler(SIGTERM);
+    fixSignalHandler(SIGBUS);
+    fixSignalHandler(SIGFPE);
+    fixSignalHandler(SIGXFSZ);
+    fixSignalHandler(SIGUSR1);
+    fixSignalHandler(SIGUSR2);
+}
+
+int LLVMFuzzerInitialize(int *argc, char ***argv) {
+    FixStackSignalHandler();
+    return 0;
+}

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder-go/ossfuzz_coverage_runner.go

@@ -0,0 +1,80 @@
+// 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/fs"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime/pprof"
+	"testing"
+)
+
+func TestFuzzCorpus(t *testing.T) {
+	dir := os.Getenv("FUZZ_CORPUS_DIR")
+	if dir == "" {
+		t.Logf("No fuzzing corpus directory set")
+		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)
+		}
+	}
+	_, err := ioutil.ReadDir(dir)
+	if err != nil {
+		t.Logf("Not fuzzing corpus directory %s", err)
+		return
+	}
+	// recurse for regressions subdirectory
+	err = filepath.Walk(dir, func(fname string, info fs.FileInfo, err error) error {
+		if info.IsDir() {
+			return nil
+		}
+		data, err := ioutil.ReadFile(fname)
+		if err != nil {
+			t.Error("Failed to read corpus file", err)
+			return err
+		}
+		filename = fname
+		FuzzFunction(data)
+		return nil
+	})
+	if err != nil {
+		t.Error("Failed to run corpus", err)
+	}
+	if profname != "" {
+		pprof.StopCPUProfile()
+		f, err := os.Create(profname + ".heap.prof")
+		if err != nil {
+			t.Logf("error creating heap profile file %s\n", err)
+		}
+		if err = pprof.WriteHeapProfile(f); err != nil {
+			t.Logf("error writing heap profile file %s\n", err)
+		}
+		f.Close()
+	}
+}

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder-python/Dockerfile

@@ -0,0 +1,20 @@
+# 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}
+
+RUN install_python.sh

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder-swift/precompile_swift

@@ -0,0 +1,33 @@
+#!/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.
+#
+################################################################################
+
+cp /usr/local/bin/llvm-symbolizer-swift $OUT/llvm-symbolizer
+
+export SWIFTFLAGS="-Xswiftc -parse-as-library -Xswiftc -static-stdlib --static-swift-stdlib"
+if [ "$SANITIZER" = "coverage" ]
+then
+    export SWIFTFLAGS="$SWIFTFLAGS -Xswiftc -profile-generate -Xswiftc -profile-coverage-mapping -Xswiftc -sanitize=fuzzer"
+else
+    export SWIFTFLAGS="$SWIFTFLAGS -Xswiftc -sanitize=fuzzer,$SANITIZER --sanitize=$SANITIZER"
+    for f in $CFLAGS; do
+        export SWIFTFLAGS="$SWIFTFLAGS -Xcc=$f"
+    done
+
+    for f in $CXXFLAGS; do
+        export SWIFTFLAGS="$SWIFTFLAGS -Xcxx=$f"
+    done
+fi

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder/bash_parser.py

@@ -0,0 +1,235 @@
+#!/usr/bin/python3
+# 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.
+
+import os
+import sys
+
+from glob import glob
+
+import bashlex
+
+
+def find_all_bash_scripts_in_src():
+  """Finds all bash scripts that exist in SRC/. This is used to idenfiy scripts
+  that may be needed for reading during the AST parsing. This is the case
+  when a given build script calls another build script, then we need to
+  read those."""
+  all_local_scripts = [
+      y for x in os.walk('/src/') for y in glob(os.path.join(x[0], '*.sh'))
+  ]
+  scripts_we_care_about = []
+  to_ignore = {'aflplusplus', 'honggfuzz', '/fuzztest', '/centipede'}
+  for s in all_local_scripts:
+    if any([x for x in to_ignore if x in s]):
+      continue
+    scripts_we_care_about.append(s)
+
+  print(scripts_we_care_about)
+  return scripts_we_care_about
+
+
+def should_discard_command(ast_tree) -> bool:
+  """Returns True if the command shuold be avoided, otherwise False"""
+  try:
+    first_word = ast_tree.parts[0].word
+  except:  # pylint: disable=bare-except
+    return False
+
+  if ('cmake' in first_word and
+      any('--build' in part.word for part in ast_tree.parts)):
+    return False
+
+  cmds_to_avoid_replaying = {
+      'configure', 'autoheader', 'autoconf', 'autoreconf', 'cmake', 'autogen.sh'
+  }
+  if any([cmd for cmd in cmds_to_avoid_replaying if cmd in first_word]):
+    return True
+
+  # Avoid all "make clean" calls. We dont want to erase previously build
+  # files.
+  try:
+    second_word = ast_tree.parts[1].word
+  except:  # pylint: disable=bare-except
+    return False
+  if 'make' in first_word and 'clean' in second_word:
+    return True
+
+  # No match was found to commands we dont want to build. There is no
+  # indication we shuold avoid.
+  return False
+
+
+def is_local_redirection(ast_node, all_local_scripts):
+  """Return the list of scripts corresponding to the command, in case
+    the command is an execution of a local script."""
+  # print("Checking")
+
+  # Capture local script called with ./random/path/build.sh
+
+  if len(ast_node.parts) >= 2:
+    try:
+      ast_node.parts[0].word
+    except:
+      return []
+    if ast_node.parts[0].word == '.':
+      suffixes_matching = []
+      #print(ast_node.parts[1].word)
+      for bash_script in all_local_scripts:
+        #print("- %s"%(bash_script))
+        cmd_to_exec = ast_node.parts[1].word.replace('$SRC', 'src')
+        if bash_script.endswith(cmd_to_exec):
+          suffixes_matching.append(bash_script)
+      #print(suffixes_matching)
+      return suffixes_matching
+  # Capture a local script called with $SRC/random/path/build.sh
+  if len(ast_node.parts) >= 1:
+    if '$SRC' in ast_node.parts[0].word:
+      suffixes_matching = []
+      print(ast_node.parts[0].word)
+      for bash_script in all_local_scripts:
+        print("- %s" % (bash_script))
+        cmd_to_exec = ast_node.parts[0].word.replace('$SRC', 'src')
+        if bash_script.endswith(cmd_to_exec):
+          suffixes_matching.append(bash_script)
+      print(suffixes_matching)
+      return suffixes_matching
+
+  return []
+
+
+def handle_ast_command(ast_node, all_scripts_in_fs, raw_script):
+  """Generate bash script string for command node"""
+  new_script = ''
+  if should_discard_command(ast_node):
+    return ''
+
+  matches = is_local_redirection(ast_node, all_scripts_in_fs)
+  if len(matches) == 1:
+    new_script += parse_script(matches[0], all_scripts_in_fs) + '\n'
+    return ''
+
+  # Extract the command from the script string
+  idx_start = ast_node.pos[0]
+  idx_end = ast_node.pos[1]
+  new_script += raw_script[idx_start:idx_end]
+  #new_script += '\n'
+
+  # If mkdir is used, then ensure that '-p' is provided, as
+  # otherwise we will run into failures. We don't have to worry
+  # about multiple uses of -p as `mkdir -p -p -p`` is valid.
+  new_script = new_script.replace('mkdir', 'mkdir -p')
+  return new_script
+
+
+def handle_ast_list(ast_node, all_scripts_in_fs, raw_script):
+  """Handles bashlex AST list."""
+  new_script = ''
+  try_hard = 1
+
+  if not try_hard:
+    list_start = ast_node.pos[0]
+    list_end = ast_node.pos[1]
+    new_script += raw_script[list_start:list_end]  # + '\n'
+  else:
+    # This is more refined logic. Ideally, this should work, but it's a bit
+    # more intricate to get right due to e.g. white-space between positions
+    # and more extensive parsing needed. We don't neccesarily need this
+    # level of success rate for what we're trying to achieve, so am disabling
+    # this for now.
+    for part in ast_node.parts:
+      if part.kind == 'list':
+        new_script += handle_ast_list(part, all_scripts_in_fs, raw_script)
+      elif part.kind == 'command':
+        new_script += handle_ast_command(part, all_scripts_in_fs, raw_script)
+      else:
+        idx_start = part.pos[0]
+        idx_end = part.pos[1]
+        new_script += raw_script[idx_start:idx_end]
+      new_script += ' '
+
+  # Make sure what was created is valid syntax, and otherwise return empty
+  try:
+    bashlex.parse(new_script)
+  except:  # pylint: disable=bare-except
+    # Maybe return the original here instead of skipping?
+    return ''
+  return new_script
+
+
+def handle_ast_compound(ast_node, all_scripts_in_fs, raw_script):
+  """Handles bashlex compound AST node."""
+  new_script = ''
+  list_start = ast_node.pos[0]
+  list_end = ast_node.pos[1]
+  new_script += raw_script[list_start:list_end] + '\n'
+  return new_script
+
+
+def handle_node(ast_node, all_scripts_in_fs, build_script):
+  """Generates a bash script string for a given node"""
+  if ast_node.kind == 'command':
+    return handle_ast_command(ast_node, all_scripts_in_fs, build_script)
+  elif ast_node.kind == 'list':
+    return handle_ast_list(ast_node, all_scripts_in_fs, build_script)
+  elif ast_node.kind == 'compound':
+    print('todo: handle compound')
+    return handle_ast_compound(ast_node, all_scripts_in_fs, build_script)
+  elif ast_node.kind == 'pipeline':
+    # Not supported
+    return ''
+  else:
+    raise Exception(f'Missing node handling: {ast_node.kind}')
+
+
+def parse_script(bash_script, all_scripts) -> str:
+  """Top-level bash script parser"""
+  new_script = ''
+  with open(bash_script, 'r', encoding='utf-8') as f:
+    build_script = f.read()
+  try:
+    parts = bashlex.parse(build_script)
+  except bashlex.errors.ParsingError:
+    return ''
+  for part in parts:
+    new_script += handle_node(part, all_scripts, build_script)
+    new_script += '\n'
+    print("-" * 45)
+    print(part.kind)
+    print(part.dump())
+
+  return new_script
+
+
+def main():
+  """Main function"""
+  all_scripts = find_all_bash_scripts_in_src()
+  replay_bash_script = parse_script(sys.argv[1], all_scripts)
+
+  print("REPLAYABLE BASH SCRIPT")
+  print("#" * 60)
+  print(replay_bash_script)
+  print("#" * 60)
+
+  out_dir = os.getenv('OUT', '/out')
+  with open(f'{out_dir}/replay-build-script.sh', 'w', encoding='utf-8') as f:
+    f.write(replay_bash_script)
+
+  src_dir = os.getenv('SRC', '/src')
+  with open(f'{src_dir}/replay_build.sh', 'w', encoding='utf-8') as f:
+    f.write(replay_bash_script)
+
+
+if __name__ == "__main__":
+  main()

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder/install_rust.sh

@@ -0,0 +1,22 @@
+#!/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.
+#
+################################################################################
+
+curl https://sh.rustup.rs | sh -s -- -y --default-toolchain=$RUSTUP_TOOLCHAIN --profile=minimal
+cargo install cargo-fuzz --locked && rm -rf /rust/registry
+# Needed to recompile rust std library for MSAN
+rustup component add rust-src
+cp -r /usr/local/lib/x86_64-unknown-linux-gnu/* /usr/local/lib/

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-builder/precompile_afl

@@ -0,0 +1,35 @@
+#!/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.
+#
+################################################################################
+
+echo "Precompiling AFLplusplus"
+
+pushd $SRC/aflplusplus > /dev/null
+make clean
+# Unset CFLAGS and CXXFLAGS while building AFL since we don't want to slow it
+# down with sanitizers.
+SAVE_CXXFLAGS=$CXXFLAGS
+SAVE_CFLAGS=$CFLAGS
+unset CXXFLAGS
+unset CFLAGS
+export AFL_IGNORE_UNKNOWN_ENVS=1
+make clean
+AFL_NO_X86=1 PYTHON_INCLUDE=/ make
+make -C utils/aflpp_driver
+
+popd > /dev/null
+
+echo "Done."

local-test-tika-delta-05/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-tika-delta-05/fuzz-tooling/infra/base-images/base-image/Dockerfile

@@ -0,0 +1,46 @@
+# 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.
+#
+################################################################################
+
+# Base image for all other images.
+
+ARG parent_image=ubuntu:20.04@sha256:4a45212e9518f35983a976eead0de5eecc555a2f047134e9dd2cfc589076a00d
+
+FROM $parent_image
+
+ENV DEBIAN_FRONTEND noninteractive
+# Install tzadata to match ClusterFuzz
+# (https://github.com/google/oss-fuzz/issues/9280).
+
+# Use Azure mirrors for consistent apt repository access.
+RUN cp /etc/apt/sources.list /etc/apt/sources.list.backup && \
+    sed -i 's|http://archive.ubuntu.com/ubuntu/|http://azure.archive.ubuntu.com/ubuntu/|g' /etc/apt/sources.list && \
+    sed -i 's|http://security.ubuntu.com/ubuntu/|http://azure.archive.ubuntu.com/ubuntu/|g' /etc/apt/sources.list
+
+
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install -y libc6-dev binutils libgcc-9-dev tzdata locales locales-all && \
+    apt-get autoremove -y
+
+ENV OUT=/out
+ENV SRC=/src
+ENV WORK=/work
+ENV PATH="$PATH:/out"
+ENV HWASAN_OPTIONS=random_tags=0
+#set locale to utf8
+ENV LC_ALL=C.UTF-8
+
+RUN mkdir -p $OUT $SRC $WORK && chmod a+rwx $OUT $SRC $WORK

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner-debug/Dockerfile

@@ -0,0 +1,26 @@
+# 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.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-runner:${IMG_TAG}
+RUN apt-get update && apt-get install -y valgrind zip
+
+# Installing GDB 12, re https://github.com/google/oss-fuzz/issues/7513.
+RUN apt-get install -y build-essential libgmp-dev && \
+    wget https://ftp.gnu.org/gnu/gdb/gdb-12.1.tar.xz && \
+    tar -xf gdb-12.1.tar.xz && cd gdb-12.1 && ./configure &&  \
+    make -j $(expr $(nproc) / 2) && make install && cd .. && \
+    rm -rf gdb-12.1* && apt-get remove --purge -y build-essential libgmp-dev

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/Dockerfile

@@ -0,0 +1,139 @@
+# 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.
+#
+################################################################################
+
+# Build rust stuff in its own image. We only need the resulting binaries.
+# Keeping the rust toolchain in the image wastes 1 GB.
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-image:${IMG_TAG} as temp-runner-binary-builder
+
+RUN apt-get update && apt-get install -y cargo libyaml-dev
+RUN cargo install rustfilt
+
+# Using multi-stage build to copy some LLVM binaries needed in the runner image.
+FROM ghcr.io/aixcc-finals/base-clang:${IMG_TAG} AS base-clang
+FROM ghcr.io/aixcc-finals/base-builder-ruby:${IMG_TAG} AS base-ruby
+
+# The base builder image compiles a specific Python version. Using a multi-stage build
+# to copy that same Python interpreter into the runner image saves build time and keeps
+# the Python versions in sync.
+FROM ghcr.io/aixcc-finals/base-builder:${IMG_TAG} AS base-builder
+
+# Real image that will be used later.
+FROM ghcr.io/aixcc-finals/base-image:${IMG_TAG}
+
+COPY --from=temp-runner-binary-builder /root/.cargo/bin/rustfilt /usr/local/bin
+
+# Copy the binaries needed for code coverage and crash symbolization.
+COPY --from=base-clang /usr/local/bin/llvm-cov \
+     /usr/local/bin/llvm-profdata \
+     /usr/local/bin/llvm-symbolizer \
+     /usr/local/bin/
+
+# Copy the pre-compiled Python binaries and libraries
+COPY --from=base-builder /usr/local/bin/python3.10 /usr/local/bin/python3.10
+COPY --from=base-builder /usr/local/lib/libpython3.10.so.1.0 /usr/local/lib/libpython3.10.so.1.0
+COPY --from=base-builder /usr/local/include/python3.10 /usr/local/include/python3.10
+COPY --from=base-builder /usr/local/lib/python3.10 /usr/local/lib/python3.10
+COPY --from=base-builder /usr/local/bin/pip3 /usr/local/bin/pip3
+
+# Create symbolic links to ensure compatibility
+RUN ldconfig && \
+    ln -s /usr/local/bin/python3.10 /usr/local/bin/python3 && \
+    ln -s /usr/local/bin/python3.10 /usr/local/bin/python
+
+COPY install_deps.sh /
+RUN /install_deps.sh && rm /install_deps.sh
+
+ENV CODE_COVERAGE_SRC=/opt/code_coverage
+# Pin coverage to the same as in the base builder:
+# https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/install_python.sh#L22
+RUN git clone https://chromium.googlesource.com/chromium/src/tools/code_coverage $CODE_COVERAGE_SRC && \
+    cd /opt/code_coverage && \
+    git checkout edba4873b5e8a390e977a64c522db2df18a8b27d && \
+    pip3 install wheel && \
+    # If version "Jinja2==2.10" is in requirements.txt, bump it to a patch version that
+    # supports upgrading its MarkupSafe dependency to a Python 3.10 compatible release:
+    sed -i 's/Jinja2==2.10/Jinja2==2.10.3/' requirements.txt && \
+    pip3 install -r requirements.txt && \
+    pip3 install MarkupSafe==2.0.1 && \
+    pip3 install coverage==6.3.2
+
+# Default environment options for various sanitizers.
+# Note that these match the settings used in ClusterFuzz and
+# shouldn't be changed unless a corresponding change is made on
+# ClusterFuzz side as well.
+ENV ASAN_OPTIONS="alloc_dealloc_mismatch=0:allocator_may_return_null=1:allocator_release_to_os_interval_ms=500:check_malloc_usable_size=0:detect_container_overflow=1:detect_odr_violation=0:detect_leaks=1:detect_stack_use_after_return=1:fast_unwind_on_fatal=0:handle_abort=1:handle_segv=1:handle_sigill=1:max_uar_stack_size_log=16:print_scariness=1:quarantine_size_mb=10:strict_memcmp=1:strip_path_prefix=/workspace/:symbolize=1:use_sigaltstack=1:dedup_token_length=3"
+ENV MSAN_OPTIONS="print_stats=1:strip_path_prefix=/workspace/:symbolize=1:dedup_token_length=3"
+ENV UBSAN_OPTIONS="print_stacktrace=1:print_summary=1:silence_unsigned_overflow=1:strip_path_prefix=/workspace/:symbolize=1:dedup_token_length=3"
+ENV FUZZER_ARGS="-rss_limit_mb=2560 -timeout=25"
+ENV AFL_FUZZER_ARGS="-m none"
+
+# Set up Golang environment variables (copied from /root/.bash_profile).
+ENV GOPATH /root/go
+
+# /root/.go/bin is for the standard Go binaries (i.e. go, gofmt, etc).
+# $GOPATH/bin is for the binaries from the dependencies installed via "go get".
+ENV PATH $PATH:$GOPATH/bin
+COPY gocoverage $GOPATH/gocoverage
+
+COPY install_go.sh /
+RUN /install_go.sh && rm -rf /install_go.sh /root/.go
+
+# Install OpenJDK 15 and trim its size by removing unused components.
+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
+
+COPY install_java.sh /
+RUN /install_java.sh && rm /install_java.sh
+
+# Install JaCoCo for JVM coverage.
+RUN wget https://repo1.maven.org/maven2/org/jacoco/org.jacoco.cli/0.8.7/org.jacoco.cli-0.8.7-nodeps.jar -O /opt/jacoco-cli.jar && \
+    wget https://repo1.maven.org/maven2/org/jacoco/org.jacoco.agent/0.8.7/org.jacoco.agent-0.8.7-runtime.jar -O /opt/jacoco-agent.jar && \
+    echo "37df187b76888101ecd745282e9cd1ad4ea508d6  /opt/jacoco-agent.jar" | shasum --check && \
+    echo "c1814e7bba5fd8786224b09b43c84fd6156db690  /opt/jacoco-cli.jar" | shasum --check
+
+COPY install_javascript.sh /
+RUN /install_javascript.sh && rm /install_javascript.sh
+
+# Copy built ruby and ruzzy from builder
+COPY --from=base-ruby /usr/local/rvm /usr/local/rvm
+COPY --from=base-ruby /install/ruzzy /install/ruzzy
+COPY ruzzy /usr/bin/ruzzy
+ENV PATH="$PATH:/usr/local/rvm/rubies/ruby-3.3.1/bin"
+# RubyGems installation directory
+ENV GEM_HOME="$OUT/fuzz-gem"
+ENV GEM_PATH="/install/ruzzy"
+
+# Do this last to make developing these files easier/faster due to caching.
+COPY bad_build_check \
+    coverage \
+    coverage_helper \
+    download_corpus \
+    jacoco_report_converter.py \
+    nyc_report_converter.py \
+    rcfilt \
+    reproduce \
+    run_fuzzer \
+    parse_options.py \
+    generate_differential_cov_report.py \
+    profraw_update.py \
+    targets_list \
+    test_all.py \
+    test_one.py \
+    python_coverage_runner_help.py \
+    /usr/local/bin/

local-test-tika-delta-05/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-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/coverage

@@ -0,0 +1,549 @@
+#!/bin/bash -u
+# Copyright 2018 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.
+#
+################################################################################
+cd $OUT
+
+if (( $# > 0 )); then
+  FUZZ_TARGETS="$@"
+else
+  FUZZ_TARGETS="$(find . -maxdepth 1 -type f -executable -printf '%P\n' | \
+      grep -v -x -F \
+      -e 'llvm-symbolizer' \
+      -e 'jazzer_agent_deploy.jar' \
+      -e 'jazzer_driver' \
+      -e 'jazzer_driver_with_sanitizer' \
+      -e 'sanitizer_with_fuzzer.so')"
+fi
+
+COVERAGE_OUTPUT_DIR=${COVERAGE_OUTPUT_DIR:-$OUT}
+
+DUMPS_DIR="$COVERAGE_OUTPUT_DIR/dumps"
+FUZZERS_COVERAGE_DUMPS_DIR="$DUMPS_DIR/fuzzers_coverage"
+MERGED_COVERAGE_DIR="$COVERAGE_OUTPUT_DIR/merged_coverage"
+FUZZER_STATS_DIR="$COVERAGE_OUTPUT_DIR/fuzzer_stats"
+TEXTCOV_REPORT_DIR="$COVERAGE_OUTPUT_DIR/textcov_reports"
+LOGS_DIR="$COVERAGE_OUTPUT_DIR/logs"
+REPORT_ROOT_DIR="$COVERAGE_OUTPUT_DIR/report"
+REPORT_BY_TARGET_ROOT_DIR="$COVERAGE_OUTPUT_DIR/report_target"
+PLATFORM=linux
+REPORT_PLATFORM_DIR="$COVERAGE_OUTPUT_DIR/report/$PLATFORM"
+
+for directory in $DUMPS_DIR $FUZZER_STATS_DIR $LOGS_DIR $REPORT_ROOT_DIR $TEXTCOV_REPORT_DIR\
+                 $REPORT_PLATFORM_DIR $REPORT_BY_TARGET_ROOT_DIR $FUZZERS_COVERAGE_DUMPS_DIR $MERGED_COVERAGE_DIR; do
+  rm -rf $directory
+  mkdir -p $directory
+done
+
+PROFILE_FILE="$DUMPS_DIR/merged.profdata"
+SUMMARY_FILE="$REPORT_PLATFORM_DIR/summary.json"
+COVERAGE_TARGET_FILE="$FUZZER_STATS_DIR/coverage_targets.txt"
+
+# Use path mapping, as $SRC directory from the builder is copied into $OUT/$SRC.
+PATH_EQUIVALENCE_ARGS="-path-equivalence=/,$OUT"
+
+# It's important to use $COVERAGE_EXTRA_ARGS as the last argument, because it
+# can contain paths to source files / directories which are positional args.
+LLVM_COV_COMMON_ARGS="$PATH_EQUIVALENCE_ARGS \
+    -ignore-filename-regex=.*src/libfuzzer/.* $COVERAGE_EXTRA_ARGS"
+
+# Options to extract branch coverage.
+BRANCH_COV_ARGS="--show-branches=count --show-expansions"
+
+# Timeout for running a single fuzz target.
+TIMEOUT=1h
+
+# This will be used by llvm-cov command to generate the actual report.
+objects=""
+
+# Number of CPUs available, this is needed for running tests in parallel.
+# Set the max number of parallel jobs to be the CPU count and a max of 10.
+NPROC=$(nproc)
+MAX_PARALLEL_COUNT=10
+
+CORPUS_DIR=${CORPUS_DIR:-"/corpus"}
+
+function run_fuzz_target {
+  local target=$1
+
+  # '%1m' will produce separate dump files for every object. For example, if a
+  # fuzz target loads a shared library, we will have dumps for both of them.
+  local profraw_file="$DUMPS_DIR/$target.%1m.profraw"
+  local profraw_file_mask="$DUMPS_DIR/$target.*.profraw"
+  local profdata_file="$DUMPS_DIR/$target.profdata"
+  local corpus_real="$CORPUS_DIR/${target}"
+
+  # -merge=1 requires an output directory, create a new, empty dir for that.
+  local corpus_dummy="$OUT/dummy_corpus_dir_for_${target}"
+  rm -rf $corpus_dummy && mkdir -p $corpus_dummy
+
+  # Use -merge=1 instead of -runs=0 because merge is crash resistant and would
+  # let to get coverage using all corpus files even if there are crash inputs.
+  # Merge should not introduce any significant overhead compared to -runs=0,
+  # because (A) corpuses are already minimized; (B) we do not use sancov, and so
+  # libFuzzer always finishes merge with an empty output dir.
+  # Use 100s timeout instead of 25s as code coverage builds can be very slow.
+  local args="-merge=1 -timeout=100 $corpus_dummy $corpus_real"
+
+  export LLVM_PROFILE_FILE=$profraw_file
+  timeout $TIMEOUT $OUT/$target $args &> $LOGS_DIR/$target.log
+  if (( $? != 0 )); then
+    echo "Error occured while running $target:"
+    cat $LOGS_DIR/$target.log
+  fi
+
+  rm -rf $corpus_dummy
+  if (( $(du -c $profraw_file_mask | tail -n 1 | cut -f 1) == 0 )); then
+    # Skip fuzz targets that failed to produce profile dumps.
+    return 0
+  fi
+
+  # If necessary translate to latest profraw version.
+  if [[ $target == *"@"* ]]; then
+    # Extract fuzztest binary name from fuzztest wrapper script.
+    target=(${target//@/ }[0])
+  fi
+  profraw_update.py $OUT/$target -i $profraw_file_mask
+  llvm-profdata merge -j=1 -sparse $profraw_file_mask -o $profdata_file
+
+  # Delete unnecessary and (potentially) large .profraw files.
+  rm $profraw_file_mask
+
+  shared_libraries=$(coverage_helper shared_libs -build-dir=$OUT -object=$target)
+
+  llvm-cov export -summary-only -instr-profile=$profdata_file -object=$target \
+      $shared_libraries $LLVM_COV_COMMON_ARGS > $FUZZER_STATS_DIR/$target.json
+
+  # For introspector.
+  llvm-cov show -instr-profile=$profdata_file -object=$target -line-coverage-gt=0 $shared_libraries $BRANCH_COV_ARGS $LLVM_COV_COMMON_ARGS > ${TEXTCOV_REPORT_DIR}/$target.covreport
+}
+
+function run_go_fuzz_target {
+  local target=$1
+
+  echo "Running go target $target"
+  export FUZZ_CORPUS_DIR="$CORPUS_DIR/${target}/"
+  export FUZZ_PROFILE_NAME="$DUMPS_DIR/$target.perf"
+
+  # setup for native go fuzzers
+  cd $OUT
+  mkdir -p "testdata/fuzz/${target}"
+  cp -r "${FUZZ_CORPUS_DIR}" "testdata/fuzz/"
+
+  # rewrite libFuzzer corpus to Std Go corpus if native fuzzing
+  grep "TestFuzzCorpus" $target > /dev/null 2>&1 && $SYSGOPATH/bin/convertcorpus $target "testdata/fuzz/${target}"
+  cd -
+
+  timeout $TIMEOUT $OUT/$target -test.coverprofile $DUMPS_DIR/$target.profdata &> $LOGS_DIR/$target.log
+  if (( $? != 0 )); then
+    echo "Error occured while running $target:"
+    cat $LOGS_DIR/$target.log
+  fi
+
+  # cleanup after native go fuzzers
+  rm -r "${OUT}/testdata/fuzz/${target}"
+
+  # The Go 1.18 fuzzers are renamed to "*_fuzz_.go" during "infra/helper.py build_fuzzers".
+  # They are are therefore refered to as "*_fuzz_.go" in the profdata files.
+  # Since the copies named "*_fuzz_.go" do not exist in the file tree during
+  # the coverage build, we change the references in the .profdata files
+  # to the original file names.
+  #sed -i "s/_test.go_fuzz_.go/_test.go/g" $DUMPS_DIR/$target.profdata
+  # translate from golangish paths to current absolute paths
+  cat $OUT/$target.gocovpath | while read i; do sed -i $i $DUMPS_DIR/$target.profdata; done
+  # cf PATH_EQUIVALENCE_ARGS
+  sed -i 's=/='$OUT'/=' $DUMPS_DIR/$target.profdata
+  $SYSGOPATH/bin/gocovsum $DUMPS_DIR/$target.profdata > $FUZZER_STATS_DIR/$target.json
+}
+
+function run_python_fuzz_target {
+  local target=$1
+  local zipped_sources="$DUMPS_DIR/$target.deps.zip"
+  local corpus_real="$CORPUS_DIR/${target}"
+  # Write dummy stats file
+  echo "{}" > "$FUZZER_STATS_DIR/$target.json"
+
+  # Run fuzzer
+  $OUT/$target $corpus_real -atheris_runs=$(ls -la $corpus_real | wc -l) > $LOGS_DIR/$target.log 2>&1
+  if (( $? != 0 )); then
+    echo "Error happened getting coverage of $target"
+    echo "This is likely because Atheris did not exit gracefully"
+    cat $LOGS_DIR/$target.log
+    return 0
+  fi
+  mv .coverage $OUT/.coverage_$target
+}
+
+function run_java_fuzz_target {
+  local target=$1
+
+  local exec_file="$DUMPS_DIR/$target.exec"
+  local class_dump_dir="$DUMPS_DIR/${target}_classes/"
+  mkdir "$class_dump_dir"
+  local corpus_real="$CORPUS_DIR/${target}"
+
+  # -merge=1 requires an output directory, create a new, empty dir for that.
+  local corpus_dummy="$OUT/dummy_corpus_dir_for_${target}"
+  rm -rf $corpus_dummy && mkdir -p $corpus_dummy
+
+  # Use 100s timeout instead of 25s as code coverage builds can be very slow.
+  local jacoco_args="destfile=$exec_file,classdumpdir=$class_dump_dir,excludes=com.code_intelligence.jazzer.*\\:com.sun.tools.attach.VirtualMachine"
+  local args="-merge=1 -timeout=100 --nohooks \
+      --additional_jvm_args=-javaagent\\:/opt/jacoco-agent.jar=$jacoco_args \
+      $corpus_dummy $corpus_real"
+
+  timeout $TIMEOUT $OUT/$target $args &> $LOGS_DIR/$target.log
+  if (( $? != 0 )); then
+    echo "Error occured while running $target:"
+    cat $LOGS_DIR/$target.log
+  fi
+
+  if (( $(du -c $exec_file | tail -n 1 | cut -f 1) == 0 )); then
+    # Skip fuzz targets that failed to produce .exec files.
+    echo "$target failed to produce .exec file."
+    return 0
+  fi
+
+  # Generate XML report only as input to jacoco_report_converter.
+  # Source files are not needed for the summary.
+  local xml_report="$DUMPS_DIR/${target}.xml"
+  local summary_file="$FUZZER_STATS_DIR/$target.json"
+  java -jar /opt/jacoco-cli.jar report $exec_file \
+      --xml $xml_report \
+      --classfiles $class_dump_dir
+
+  # Write llvm-cov summary file.
+  jacoco_report_converter.py $xml_report $summary_file
+}
+
+function run_javascript_fuzz_target {
+  local target=$1
+  local corpus_real="$CORPUS_DIR/${target}"
+
+  # -merge=1 requires an output directory, create a new, empty dir for that.
+  local corpus_dummy="$OUT/dummy_corpus_dir_for_${target}"
+  rm -rf $corpus_dummy && mkdir -p $corpus_dummy
+
+  # IstanbulJS currently does not work when the tested program creates
+  # subprocesses. For this reason, we first minimize the corpus removing
+  # any crashing inputs so that we can report source-based code coverage
+  # with a single sweep over the minimized corpus
+  local merge_args="-merge=1 -timeout=100 $corpus_dummy $corpus_real"
+  timeout $TIMEOUT $OUT/$target $merge_args &> $LOGS_DIR/$target.log
+
+  # nyc saves the coverage reports in a directory with the default name "coverage"
+  local coverage_dir="$DUMPS_DIR/coverage_dir_for_${target}"
+  rm -rf $coverage_dir && mkdir -p $coverage_dir
+
+  local nyc_json_coverage_file="$coverage_dir/coverage-final.json"
+  local nyc_json_summary_file="$coverage_dir/coverage-summary.json"
+
+  local args="-runs=0 $corpus_dummy"
+  local jazzerjs_args="--coverage --coverageDirectory $coverage_dir --coverageReporters json --coverageReporters json-summary"
+
+  JAZZERJS_EXTRA_ARGS=$jazzerjs_args $OUT/$target $args &> $LOGS_DIR/$target.log
+
+  if (( $? != 0 )); then
+    echo "Error occured while running $target:"
+    cat $LOGS_DIR/$target.log
+  fi
+
+  if [ ! -s $nyc_json_coverage_file ]; then
+    # Skip fuzz targets that failed to produce coverage-final.json file.
+    echo "$target failed to produce coverage-final.json file."
+    return 0
+  fi
+
+  cp $nyc_json_coverage_file $FUZZERS_COVERAGE_DUMPS_DIR/$target.json
+
+  local summary_file="$FUZZER_STATS_DIR/$target.json"
+
+  nyc_report_converter.py $nyc_json_summary_file $summary_file
+}
+
+function generate_html {
+  local profdata=$1
+  local shared_libraries=$2
+  local objects=$3
+  local output_dir=$4
+
+  rm -rf "$output_dir"
+  mkdir -p "$output_dir/$PLATFORM"
+
+  local llvm_cov_args="-instr-profile=$profdata $objects $LLVM_COV_COMMON_ARGS"
+  llvm-cov show -format=html -output-dir=$output_dir -Xdemangler rcfilt $llvm_cov_args
+
+  # Export coverage summary in JSON format.
+  local summary_file=$output_dir/$PLATFORM/summary.json
+
+  llvm-cov export -summary-only $llvm_cov_args > $summary_file
+
+  coverage_helper -v post_process -src-root-dir=/ -summary-file=$summary_file \
+      -output-dir=$output_dir $PATH_EQUIVALENCE_ARGS
+}
+
+export SYSGOPATH=$GOPATH
+export GOPATH=$OUT/$GOPATH
+# Run each fuzz target, generate raw coverage dumps.
+for fuzz_target in $FUZZ_TARGETS; do
+  # Test if fuzz target is a golang one.
+  if [[ $FUZZING_LANGUAGE == "go" ]]; then
+    # Continue if not a fuzz target.
+    if [[ $FUZZING_ENGINE != "none" ]]; then
+      grep "FUZZ_CORPUS_DIR" $fuzz_target > /dev/null 2>&1 || grep "testing\.T" $fuzz_target > /dev/null 2>&1 || continue
+    fi
+    # Log the target in the targets file.
+    echo ${fuzz_target} >> $COVERAGE_TARGET_FILE
+
+    # Run the coverage collection.
+    run_go_fuzz_target $fuzz_target &
+  elif [[ $FUZZING_LANGUAGE == "python" ]]; then
+    echo "Entering python fuzzing"
+    # Log the target in the targets file.
+    echo ${fuzz_target} >> $COVERAGE_TARGET_FILE
+
+    # Run the coverage collection.
+    run_python_fuzz_target $fuzz_target
+  elif [[ $FUZZING_LANGUAGE == "jvm" ]]; then
+    # Continue if not a fuzz target.
+    if [[ $FUZZING_ENGINE != "none" ]]; then
+      grep "LLVMFuzzerTestOneInput" $fuzz_target > /dev/null 2>&1 || continue
+    fi
+
+    echo "Running $fuzz_target"
+    # Log the target in the targets file.
+    echo ${fuzz_target} >> $COVERAGE_TARGET_FILE
+
+    # Run the coverage collection.
+    run_java_fuzz_target $fuzz_target &
+  elif [[ $FUZZING_LANGUAGE == "javascript" ]]; then
+    # Continue if not a fuzz target.
+    if [[ $FUZZING_ENGINE != "none" ]]; then
+      grep "LLVMFuzzerTestOneInput" $fuzz_target > /dev/null 2>&1 || continue
+    fi
+
+    echo "Running $fuzz_target"
+    # Log the target in the targets file.
+    echo ${fuzz_target} >> $COVERAGE_TARGET_FILE
+
+    # Run the coverage collection.
+    run_javascript_fuzz_target $fuzz_target &
+  else
+    # Continue if not a fuzz target.
+    if [[ $FUZZING_ENGINE != "none" ]]; then
+      grep "LLVMFuzzerTestOneInput" $fuzz_target > /dev/null 2>&1 || continue
+    fi
+
+    echo "Running $fuzz_target"
+    # Log the target in the targets file.
+    echo ${fuzz_target} >> $COVERAGE_TARGET_FILE
+
+    # Run the coverage collection.
+    run_fuzz_target $fuzz_target &
+
+    # Rewrite object if its a FUZZTEST target
+    if [[ $fuzz_target == *"@"* ]]; then
+      # Extract fuzztest binary name from fuzztest wrapper script.
+      fuzz_target=(${fuzz_target//@/ }[0])
+    fi
+    if [[ -z $objects ]]; then
+      # The first object needs to be passed without -object= flag.
+      objects="$fuzz_target"
+    else
+      objects="$objects -object=$fuzz_target"
+    fi
+  fi
+
+
+  # Limit the number of processes to be spawned.
+  n_child_proc=$(jobs -rp | wc -l)
+  while [[ "$n_child_proc" -eq "$NPROC" || "$n_child_proc" -gt "$MAX_PARALLEL_COUNT" ]]; do
+    sleep 4
+    n_child_proc=$(jobs -rp | wc -l)
+  done
+done
+
+# Wait for background processes to finish.
+wait
+
+if [[ $FUZZING_LANGUAGE == "go" ]]; then
+  echo $DUMPS_DIR
+  $SYSGOPATH/bin/gocovmerge $DUMPS_DIR/*.profdata > fuzz.cov
+  gotoolcover -html=fuzz.cov -o $REPORT_ROOT_DIR/index.html
+  $SYSGOPATH/bin/gocovsum fuzz.cov > $SUMMARY_FILE
+  cp $REPORT_ROOT_DIR/index.html $REPORT_PLATFORM_DIR/index.html
+  $SYSGOPATH/bin/pprof-merge $DUMPS_DIR/*.perf.cpu.prof
+  mv merged.data $REPORT_ROOT_DIR/cpu.prof
+  $SYSGOPATH/bin/pprof-merge $DUMPS_DIR/*.perf.heap.prof
+  mv merged.data $REPORT_ROOT_DIR/heap.prof
+  #TODO some proxy for go tool pprof -http=127.0.0.1:8001 $DUMPS_DIR/cpu.prof
+  echo "Finished generating code coverage report for Go fuzz targets."
+elif [[ $FUZZING_LANGUAGE == "python" ]]; then
+  # Extract source files from all dependency zip folders
+  mkdir -p /pythoncovmergedfiles/medio
+  PYCOVDIR=/pycovdir/
+  mkdir $PYCOVDIR
+  for fuzzer in $FUZZ_TARGETS; do
+    fuzzer_deps=${fuzzer}.pkg.deps.zip
+    unzip $OUT/${fuzzer_deps}
+    rsync -r ./medio /pythoncovmergedfiles/medio
+    rm -rf ./medio
+
+    # Translate paths in unzipped folders to paths that we can use
+    mv $OUT/.coverage_$fuzzer .coverage
+    python3 /usr/local/bin/python_coverage_runner_help.py translate /pythoncovmergedfiles/medio
+    cp .new_coverage $PYCOVDIR/.coverage_$fuzzer
+    cp .new_coverage $OUT/coverage_d_$fuzzer
+  done
+
+  # Combine coverage
+  cd $PYCOVDIR
+  python3 /usr/local/bin/python_coverage_runner_help.py combine .coverage_*
+  python3 /usr/local/bin/python_coverage_runner_help.py html
+  # Produce all_cov file used by fuzz introspector.
+  python3 /usr/local/bin/python_coverage_runner_help.py json -o ${TEXTCOV_REPORT_DIR}/all_cov.json
+
+  # Generate .json with similar format to llvm-cov output.
+  python3 /usr/local/bin/python_coverage_runner_help.py \
+      convert-to-summary-json ${TEXTCOV_REPORT_DIR}/all_cov.json $SUMMARY_FILE
+
+  # Copy coverage date out
+  cp htmlcov/status.json ${TEXTCOV_REPORT_DIR}/html_status.json
+
+  mv htmlcov/* $REPORT_PLATFORM_DIR/
+  mv .coverage_* $REPORT_PLATFORM_DIR/
+elif [[ $FUZZING_LANGUAGE == "jvm" ]]; then
+
+  # From this point on the script does not tolerate any errors.
+  set -e
+
+  # Merge .exec files from the individual targets.
+  jacoco_merged_exec=$DUMPS_DIR/jacoco.merged.exec
+  java -jar /opt/jacoco-cli.jar merge $DUMPS_DIR/*.exec \
+      --destfile $jacoco_merged_exec
+
+  # Prepare classes directory for jacoco process
+  classes_dir=$DUMPS_DIR/classes
+  mkdir $classes_dir
+
+  # Only copy class files found in $OUT/$SRC to ensure they are
+  # lively compiled from the project, avoiding inclusion of
+  # dependency classes. This also includes the fuzzer classes.
+  find "$OUT/$SRC" -type f -name "*.class" | while read -r class_file; do
+    # Skip module-info.class
+    if [[ "$(basename "$class_file")" == "module-info.class" ]]; then
+        continue
+    fi
+
+    # Use javap to extract the fully qualified name of the class and copy it to $classes_dir
+    fqn=$(javap -verbose "$class_file" 2>/dev/null | grep "this_class:" | grep -oP '(?<=// ).*')
+    if [ -n "$fqn" ]; then
+      mkdir -p $classes_dir/$(dirname $fqn)
+      cp $class_file $classes_dir/$fqn.class
+    fi
+  done
+
+  # Heuristically determine source directories based on Maven structure.
+  # Always include the $SRC root as it likely contains the fuzzer sources.
+  sourcefiles_args=(--sourcefiles $OUT/$SRC)
+  source_dirs=$(find $OUT/$SRC -type d -name 'java')
+  for source_dir in $source_dirs; do
+    sourcefiles_args+=(--sourcefiles "$source_dir")
+  done
+
+  # Generate HTML and XML reports.
+  xml_report=$REPORT_PLATFORM_DIR/index.xml
+  java -jar /opt/jacoco-cli.jar report $jacoco_merged_exec \
+      --html $REPORT_PLATFORM_DIR \
+      --xml $xml_report \
+      --classfiles $classes_dir \
+      "${sourcefiles_args[@]}"
+
+  # Also serve the raw exec file and XML report, which can be useful for
+  # automated analysis.
+  cp $jacoco_merged_exec $REPORT_PLATFORM_DIR/jacoco.exec
+  cp $xml_report $REPORT_PLATFORM_DIR/jacoco.xml
+  cp $xml_report $TEXTCOV_REPORT_DIR/jacoco.xml
+
+  # Write llvm-cov summary file.
+  jacoco_report_converter.py $xml_report $SUMMARY_FILE
+
+  set +e
+elif [[ $FUZZING_LANGUAGE == "javascript" ]]; then
+
+  # From this point on the script does not tolerate any errors.
+  set -e
+
+  json_report=$MERGED_COVERAGE_DIR/coverage.json
+  nyc merge $FUZZERS_COVERAGE_DUMPS_DIR $json_report
+
+  nyc report -t $MERGED_COVERAGE_DIR --report-dir $REPORT_PLATFORM_DIR --reporter=html --reporter=json-summary
+
+  nyc_json_summary_file=$REPORT_PLATFORM_DIR/coverage-summary.json
+
+  # Write llvm-cov summary file.
+  nyc_report_converter.py $nyc_json_summary_file $SUMMARY_FILE
+
+  set +e
+else
+
+  # From this point on the script does not tolerate any errors.
+  set -e
+
+  # Merge all dumps from the individual targets.
+  rm -f $PROFILE_FILE
+  llvm-profdata merge -sparse $DUMPS_DIR/*.profdata -o $PROFILE_FILE
+
+  # TODO(mmoroz): add script from Chromium for rendering directory view reports.
+  # The first path in $objects does not have -object= prefix (llvm-cov format).
+  shared_libraries=$(coverage_helper shared_libs -build-dir=$OUT -object=$objects)
+  objects="$objects $shared_libraries"
+
+  generate_html $PROFILE_FILE "$shared_libraries" "$objects" "$REPORT_ROOT_DIR"
+
+  # Per target reports.
+  for fuzz_target in $FUZZ_TARGETS; do
+    if [[ $fuzz_target == *"@"* ]]; then
+      profdata_path=$DUMPS_DIR/$fuzz_target.profdata
+      report_dir=$REPORT_BY_TARGET_ROOT_DIR/$fuzz_target
+      # Extract fuzztest binary name from fuzztest wrapper script.
+      fuzz_target=(${fuzz_target//@/ }[0])
+    else
+      profdata_path=$DUMPS_DIR/$fuzz_target.profdata
+      report_dir=$REPORT_BY_TARGET_ROOT_DIR/$fuzz_target
+    fi
+    if [[ ! -f "$profdata_path" ]]; then
+      echo "WARNING: $fuzz_target has no profdata generated."
+      continue
+    fi
+
+    generate_html $profdata_path "$shared_libraries" "$fuzz_target" "$report_dir"
+  done
+
+  set +e
+fi
+
+# Make sure report is readable.
+chmod -R +r $REPORT_ROOT_DIR $REPORT_BY_TARGET_ROOT_DIR
+find $REPORT_ROOT_DIR $REPORT_BY_TARGET_ROOT_DIR -type d -exec chmod +x {} +
+
+# HTTP_PORT is optional.
+set +u
+if [[ -n $HTTP_PORT ]]; then
+  # Serve the report locally.
+  echo "Serving the report on http://127.0.0.1:$HTTP_PORT/linux/index.html"
+  cd $REPORT_ROOT_DIR
+  python3 -m http.server $HTTP_PORT
+fi

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/coverage_helper

@@ -0,0 +1,17 @@
+#!/bin/bash -u
+# Copyright 2018 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.
+#
+################################################################################
+python3 $CODE_COVERAGE_SRC/coverage_utils.py $@

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/download_corpus

@@ -0,0 +1,30 @@
+#!/bin/bash -u
+# Copyright 2018 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 (( $# < 1 )); then
+  echo "Usage: $0 \"path_download_to url_download_from\" (can be repeated)" >&2
+  exit 1
+fi
+
+for pair in "$@"; do
+  read path url <<< "$pair"
+  wget -q -O $path $url
+done
+
+# Always exit with 0 as we do not track wget return codes and should not rely
+# on the latest command execution.
+exit 0

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/generate_differential_cov_report.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+#
+# 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.
+#
+################################################################################
+"""Script for generating differential coverage reports.
+generate_differential_cov_report.py <profdata-dump-directory> \
+<profdata-directory-to-subtract-from-first> <output-directory>
+"""
+import os
+import shutil
+import subprocess
+import sys
+
+
+class ProfData:
+  """Class representing a profdata file."""
+
+  def __init__(self, text):
+    self.function_profs = []
+    for function_prof in text.split('\n\n'):
+      if not function_prof:
+        continue
+      self.function_profs.append(FunctionProf(function_prof))
+
+  def to_string(self):
+    """Convert back to a string."""
+    return '\n'.join(
+        [function_prof.to_string() for function_prof in self.function_profs])
+
+  def find_function(self, function, idx=None):
+    """Find the same function in this profdata."""
+    if idx is not None:
+      try:
+        possibility = self.function_profs[idx]
+        if function.func_hash == possibility.func_hash:
+          return possibility
+      except IndexError:
+        pass
+    for function_prof in self.function_profs:
+      if function_prof.func_hash == function.func_hash:
+        return function_prof
+    return None
+
+  def subtract(self, subtrahend):
+    """Subtract subtrahend from this profdata."""
+    for idx, function_prof in enumerate(self.function_profs):
+      subtrahend_function_prof = subtrahend.find_function(function_prof, idx)
+      function_prof.subtract(subtrahend_function_prof)
+
+
+class FunctionProf:
+  """Profile of a function."""
+  FUNC_HASH_COMMENT_LINE = '# Func Hash:'
+  NUM_COUNTERS_COMMENT_LINE = '# Num Counters:'
+  COUNTER_VALUES_COMMENT_LINE = '# Counter Values:'
+
+  def __init__(self, text):
+    print(text)
+    lines = text.splitlines()
+    self.function = lines[0]
+    assert self.FUNC_HASH_COMMENT_LINE == lines[1]
+    self.func_hash = lines[2]
+    assert self.NUM_COUNTERS_COMMENT_LINE == lines[3]
+    self.num_counters = int(lines[4])
+    assert self.COUNTER_VALUES_COMMENT_LINE == lines[5]
+    self.counter_values = [1 if int(line) else 0 for line in lines[6:]]
+
+  def to_string(self):
+    """Convert back to text."""
+    lines = [
+        self.function,
+        self.FUNC_HASH_COMMENT_LINE,
+        self.func_hash,
+        self.NUM_COUNTERS_COMMENT_LINE,
+        str(self.num_counters),
+        self.COUNTER_VALUES_COMMENT_LINE,
+    ] + [str(num) for num in self.counter_values]
+    return '\n'.join(lines)
+
+  def subtract(self, subtrahend_prof):
+    """Subtract this other function from this function."""
+    if not subtrahend_prof:
+      print(self.function, 'has no subtrahend')
+      # Nothing to subtract.
+      return
+    self.counter_values = [
+        max(counter1 - counter2, 0) for counter1, counter2 in zip(
+            self.counter_values, subtrahend_prof.counter_values)
+    ]
+
+
+def get_profdata_files(directory):
+  """Returns profdata files in |directory|."""
+  profdatas = []
+  for filename in os.listdir(directory):
+    filename = os.path.join(directory, filename)
+    if filename.endswith('.profdata'):
+      profdatas.append(filename)
+  return profdatas
+
+
+def convert_profdata_to_text(profdata):
+  """Convert a profdata binary file to a profdata text file."""
+  profdata_text = f'{profdata}.txt'
+  if os.path.exists(profdata_text):
+    os.remove(profdata_text)
+  command = [
+      'llvm-profdata', 'merge', '-j=1', '-sparse', profdata, '--text', '-o',
+      profdata_text
+  ]
+  print(command)
+  subprocess.run(command, check=True)
+  return profdata_text
+
+
+def convert_text_profdata_to_bin(profdata_text):
+  """Convert a profdata text file to a profdata binary file."""
+  profdata = profdata_text.replace('.txt', '').replace('.profdata',
+                                                       '') + '.profdata'
+  print('bin profdata', profdata)
+  if os.path.exists(profdata):
+    os.remove(profdata)
+  command = [
+      'llvm-profdata', 'merge', '-j=1', '-sparse', profdata_text, '-o', profdata
+  ]
+  print(command)
+  subprocess.run(command, check=True)
+  return profdata
+
+
+def get_difference(minuend_filename, subtrahend_filename):
+  """Subtract subtrahend_filename from minuend_filename."""
+  with open(minuend_filename, 'r', encoding='utf-8') as minuend_file:
+    print('minuend', minuend_filename)
+    minuend = ProfData(minuend_file.read())
+  with open(subtrahend_filename, 'r', encoding='utf-8') as subtrahend_file:
+    print('subtrahend', subtrahend_filename)
+    subtrahend = ProfData(subtrahend_file.read())
+
+  minuend.subtract(subtrahend)
+  return minuend
+
+
+def profdatas_to_objects(profdatas):
+  """Get the corresponding objects for each profdata."""
+  return [
+      os.path.splitext(os.path.basename(profdata))[0] for profdata in profdatas
+  ]
+
+
+def generate_differential_cov_reports(minuend_profdatas, subtrahend_profdatas,
+                                      difference_dir):
+  """Calculate the differences between all profdatas and generate differential
+  coverage reports."""
+  profdata_objects = profdatas_to_objects(minuend_profdatas)
+  real_profdata_objects = [
+      binobject for binobject in profdata_objects if binobject != 'merged'
+  ]
+  for minuend, subtrahend, binobject in zip(minuend_profdatas,
+                                            subtrahend_profdatas,
+                                            profdata_objects):
+    minuend_text = convert_profdata_to_text(minuend)
+    subtrahend_text = convert_profdata_to_text(subtrahend)
+    difference = get_difference(minuend_text, subtrahend_text)
+    basename = os.path.basename(minuend_text)
+    difference_text = os.path.join(difference_dir, basename)
+    with open(difference_text, 'w', encoding='utf-8') as file_handle:
+      file_handle.write(difference.to_string())
+    difference_profdata = convert_text_profdata_to_bin(difference_text)
+    if not difference_profdata.endswith('merged.profdata'):
+      generate_html_report(difference_profdata, [binobject],
+                           os.path.join(difference_dir, binobject))
+    else:
+      generate_html_report(difference_profdata, real_profdata_objects,
+                           os.path.join(difference_dir, 'merged'))
+
+
+def generate_html_report(profdata, objects, directory):
+  """Generate an HTML coverage report."""
+  # TODO(metzman): Deal with shared libs.
+  html_dir = os.path.join(directory, 'reports')
+  if os.path.exists(html_dir):
+    os.remove(html_dir)
+  os.makedirs(html_dir)
+  out_dir = os.getenv('OUT', '/out')
+  command = [
+      'llvm-cov', 'show', f'-path-equivalence=/,{out_dir}', '-format=html',
+      '-Xdemangler', 'rcfilt', f'-instr-profile={profdata}'
+  ]
+
+  objects = [os.path.join(out_dir, binobject) for binobject in objects]
+  command += objects + ['-o', html_dir]
+  print(' '.join(command))
+  subprocess.run(command, check=True)
+
+
+def main():
+  """Generate differential coverage reports."""
+  if len(sys.argv) != 4:
+    print(
+        f'Usage: {sys.argv[0]} <minuend_dir> <subtrahend_dir> <difference_dir>')
+  minuend_dir = sys.argv[1]
+  subtrahend_dir = sys.argv[2]
+  difference_dir = sys.argv[3]
+  if os.path.exists(difference_dir):
+    shutil.rmtree(difference_dir)
+  os.makedirs(difference_dir, exist_ok=True)
+  minuend_profdatas = get_profdata_files(minuend_dir)
+  subtrahend_profdatas = get_profdata_files(subtrahend_dir)
+  generate_differential_cov_reports(minuend_profdatas, subtrahend_profdatas,
+                                    difference_dir)
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/install_deps.sh

@@ -0,0 +1,37 @@
+#!/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 dependencies in a platform-aware way.
+
+apt-get update && apt-get install -y \
+    binutils \
+    file \
+    ca-certificates \
+    fonts-dejavu \
+    git \
+    libcap2 \
+    rsync \
+    unzip \
+    wget \
+    zip --no-install-recommends
+
+case $(uname -m) in
+  x86_64)
+    # We only need to worry about i386 if we are on x86_64.
+    apt-get install -y lib32gcc1 libc6-i386
+    ;;
+esac

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/install_go.sh

@@ -0,0 +1,41 @@
+#!/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 go on x86_64, don't do anything on ARM.
+
+case $(uname -m) in
+    x86_64)
+      # Download and install Go 1.19.
+      wget -q https://storage.googleapis.com/golang/getgo/installer_linux -O $SRC/installer_linux
+      chmod +x $SRC/installer_linux
+      SHELL="bash" $SRC/installer_linux -version 1.19
+      rm $SRC/installer_linux
+      # Set up Golang coverage modules.
+      printf $(find . -name gocoverage)
+      cd $GOPATH/gocoverage && /root/.go/bin/go install ./...
+      cd convertcorpus && /root/.go/bin/go install .
+      cd /root/.go/src/cmd/cover && /root/.go/bin/go build && mv cover $GOPATH/bin/gotoolcover
+      ;;
+    aarch64)
+      # Don't install go because installer is not provided.
+      echo "Not installing go: aarch64."
+      ;;
+    *)
+      echo "Error: unsupported architecture: $(uname -m)"
+      exit 1
+      ;;
+esac

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/install_java.sh

@@ -0,0 +1,46 @@
+#!/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 java in a platform-aware way.
+
+ARCHITECTURE=
+case $(uname -m) in
+    x86_64)
+      ARCHITECTURE=x64
+        ;;
+    aarch64)
+      ARCHITECTURE=aarch64
+      ;;
+    *)
+      echo "Error: unsupported architecture: $(uname -m)"
+      exit 1
+      ;;
+esac
+
+wget -q https://download.java.net/java/GA/jdk17.0.2/dfd4a8d0985749f896bed50d7138ee7f/8/GPL/openjdk-17.0.2_linux-"$ARCHITECTURE"_bin.tar.gz -O /tmp/openjdk-17.0.2_linux-"$ARCHITECTURE"_bin.tar.gz
+wget -q https://download.java.net/java/GA/jdk15.0.2/0d1cfde4252546c6931946de8db48ee2/7/GPL/openjdk-15.0.2_linux-"$ARCHITECTURE"_bin.tar.gz -O /tmp/openjdk-15.0.2_linux-"$ARCHITECTURE"_bin.tar.gz
+cd /tmp
+mkdir -p $JAVA_HOME
+tar -xz --strip-components=1 -f openjdk-17.0.2_linux-"$ARCHITECTURE"_bin.tar.gz --directory $JAVA_HOME
+rm -f openjdk-17.0.2_linux-"$ARCHITECTURE"_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.
+mkdir -p $JAVA_15_HOME
+tar -xz --strip-components=1 -f openjdk-15.0.2_linux-"$ARCHITECTURE"_bin.tar.gz --directory $JAVA_15_HOME
+rm -f openjdk-15.0.2_linux-"$ARCHITECTURE"_bin.tar.gz
+rm -rf $JAVA_15_HOME/jmods $JAVA_15_HOME/lib/src.zip

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/install_javascript.sh

@@ -0,0 +1,30 @@
+#!/bin/bash -eux
+# 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.
+#
+################################################################################
+# 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
+
+# Install latest versions of nyc for source-based coverage reporting
+npm install --global nyc

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/jacoco_report_converter.py

@@ -0,0 +1,174 @@
+#!/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.
+#
+################################################################################
+"""Helper script for creating an llvm-cov style JSON summary from a JaCoCo XML
+report."""
+import json
+import os
+import sys
+import xml.etree.ElementTree as ET
+
+
+def convert(xml):
+  """Turns a JaCoCo XML report into an llvm-cov JSON summary."""
+  summary = {
+      'type': 'oss-fuzz.java.coverage.json.export',
+      'version': '1.0.0',
+      'data': [{
+          'totals': {},
+          'files': [],
+      }],
+  }
+
+  report = ET.fromstring(xml)
+  totals = make_element_summary(report)
+  summary['data'][0]['totals'] = totals
+
+  # Since Java compilation does not track source file location, we match
+  # coverage info to source files via the full class name, e.g. we search for
+  # a path in /out/src ending in foo/bar/Baz.java for the class foo.bar.Baz.
+  # Under the assumptions that a given project only ever contains a single
+  # version of a class and that no class name appears as a suffix of another
+  # class name, we can assign coverage info to every source file matched in that
+  # way.
+  src_files = list_src_files()
+
+  for class_element in report.findall('./package/class'):
+    # Skip fuzzer classes
+    if is_fuzzer_class(class_element):
+      continue
+
+    # Skip non class elements
+    if 'sourcefilename' not in class_element.attrib:
+      continue
+
+    class_name = class_element.attrib['name']
+    package_name = os.path.dirname(class_name)
+    basename = class_element.attrib['sourcefilename']
+    # This path is 'foo/Bar.java' for the class element
+    # <class name="foo/Bar" sourcefilename="Bar.java">.
+    canonical_path = os.path.join(package_name, basename)
+
+    class_summary = make_element_summary(class_element)
+    for src_file in relative_to_src_path(src_files, canonical_path):
+      summary['data'][0]['files'].append({
+          'filename': src_file,
+          'summary': class_summary,
+      })
+
+  return json.dumps(summary)
+
+
+def list_src_files():
+  """Returns a map from basename to full path for all files in $OUT/$SRC."""
+  filename_to_paths = {}
+  out_path = os.environ['OUT'] + '/'
+  src_path = os.environ['SRC']
+  src_in_out = out_path + src_path
+  for dirpath, _, filenames in os.walk(src_in_out):
+    for filename in filenames:
+      full_path = dirpath + '/' + filename
+      # Map /out//src/... to /src/...
+      file_path = full_path[len(out_path):]
+      filename_to_paths.setdefault(filename, []).append(file_path)
+  return filename_to_paths
+
+
+def is_fuzzer_class(class_element):
+  """Check if the class is fuzzer class."""
+  method_elements = class_element.find('./method[@name=\"fuzzerTestOneInput\"]')
+  if method_elements:
+    return True
+
+  return False
+
+
+def relative_to_src_path(src_files, canonical_path):
+  """Returns all paths in src_files ending in canonical_path."""
+  basename = os.path.basename(canonical_path)
+  if basename not in src_files:
+    return []
+  candidate_paths = src_files[basename]
+  return [
+      path for path in candidate_paths if path.endswith("/" + canonical_path)
+  ]
+
+
+def make_element_summary(element):
+  """Returns a coverage summary for an element in the XML report."""
+  summary = {}
+
+  function_counter = element.find('./counter[@type=\'METHOD\']')
+  summary['functions'] = make_counter_summary(function_counter)
+
+  line_counter = element.find('./counter[@type=\'LINE\']')
+  summary['lines'] = make_counter_summary(line_counter)
+
+  # JaCoCo tracks branch coverage, which counts the covered control-flow edges
+  # between llvm-cov's regions instead of the covered regions themselves. For
+  # non-trivial code parts, the difference is usually negligible. However, if
+  # all methods of a class consist of a single region only (no branches),
+  # JaCoCo does not report any branch coverage even if there is instruction
+  # coverage. Since this would give incorrect results for CI Fuzz purposes, we
+  # increase the regions counter by 1 if there is any amount of instruction
+  # coverage.
+  instruction_counter = element.find('./counter[@type=\'INSTRUCTION\']')
+  has_some_coverage = instruction_counter is not None and int(
+      instruction_counter.attrib["covered"]) > 0
+  branch_covered_adjustment = 1 if has_some_coverage else 0
+  region_counter = element.find('./counter[@type=\'BRANCH\']')
+  summary['regions'] = make_counter_summary(
+      region_counter, covered_adjustment=branch_covered_adjustment)
+
+  return summary
+
+
+def make_counter_summary(counter_element, covered_adjustment=0):
+  """Turns a JaCoCo <counter> element into an llvm-cov totals entry."""
+  summary = {}
+  covered = covered_adjustment
+  missed = 0
+  if counter_element is not None:
+    covered += int(counter_element.attrib['covered'])
+    missed += int(counter_element.attrib['missed'])
+  summary['covered'] = covered
+  summary['notcovered'] = missed
+  summary['count'] = summary['covered'] + summary['notcovered']
+  if summary['count'] != 0:
+    summary['percent'] = (100.0 * summary['covered']) / summary['count']
+  else:
+    summary['percent'] = 0
+  return summary
+
+
+def main():
+  """Produces an llvm-cov style JSON summary from a JaCoCo XML report."""
+  if len(sys.argv) != 3:
+    sys.stderr.write('Usage: %s <path_to_jacoco_xml> <out_path_json>\n' %
+                     sys.argv[0])
+    return 1
+
+  with open(sys.argv[1], 'r') as xml_file:
+    xml_report = xml_file.read()
+  json_summary = convert(xml_report)
+  with open(sys.argv[2], 'w') as json_file:
+    json_file.write(json_summary)
+
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/nyc_report_converter.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# 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.
+#
+################################################################################
+"""Helper script for creating a llvm-cov style JSON summary from a nyc
+JSON summary."""
+import json
+import sys
+
+
+def convert(nyc_json_summary):
+  """Turns a nyc JSON report into a llvm-cov JSON summary."""
+  summary = {
+      'type':
+          'oss-fuzz.javascript.coverage.json.export',
+      'version':
+          '1.0.0',
+      'data': [{
+          'totals':
+              file_summary(nyc_json_summary['total']),
+          'files': [{
+              'filename': src_file,
+              'summary': file_summary(nyc_json_summary[src_file])
+          } for src_file in nyc_json_summary if src_file != 'total'],
+      }],
+  }
+
+  return json.dumps(summary)
+
+
+def file_summary(nyc_file_summary):
+  """Returns a summary for a given file in the nyc JSON summary report."""
+  return {
+      'functions': element_summary(nyc_file_summary['functions']),
+      'lines': element_summary(nyc_file_summary['lines']),
+      'regions': element_summary(nyc_file_summary['branches'])
+  }
+
+
+def element_summary(element):
+  """Returns a summary of a coverage element in the nyc JSON summary
+  of the file"""
+  return {
+      'count': element['total'],
+      'covered': element['covered'],
+      'notcovered': element['total'] - element['covered'] - element['skipped'],
+      'percent': element['pct'] if element['pct'] != 'Unknown' else 0
+  }
+
+
+def main():
+  """Produces a llvm-cov style JSON summary from a nyc JSON summary."""
+  if len(sys.argv) != 3:
+    sys.stderr.write('Usage: %s <path_to_nyc_json_summary> <out_path_json>\n' %
+                     sys.argv[0])
+    return 1
+
+  with open(sys.argv[1], 'r') as nyc_json_summary_file:
+    nyc_json_summary = json.load(nyc_json_summary_file)
+  json_summary = convert(nyc_json_summary)
+  with open(sys.argv[2], 'w') as json_output_file:
+    json_output_file.write(json_summary)
+
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/parse_options.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# 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.
+#
+################################################################################
+"""Helper script for parsing custom fuzzing options."""
+import configparser
+import sys
+
+
+def parse_options(options_file_path, options_section):
+  """Parses the given file and returns options from the given section."""
+  parser = configparser.ConfigParser()
+  parser.read(options_file_path)
+
+  if not parser.has_section(options_section):
+    return None
+
+  options = parser[options_section]
+
+  if options_section == 'libfuzzer':
+    options_string = ' '.join(
+        '-%s=%s' % (key, value) for key, value in options.items())
+  else:
+    # Sanitizer options.
+    options_string = ':'.join(
+        '%s=%s' % (key, value) for key, value in options.items())
+
+  return options_string
+
+
+def main():
+  """Processes the arguments and prints the options in the correct format."""
+  if len(sys.argv) < 3:
+    sys.stderr.write('Usage: %s <path_to_options_file> <options_section>\n' %
+                     sys.argv[0])
+    return 1
+
+  options = parse_options(sys.argv[1], sys.argv[2])
+  if options is not None:
+    print(options)
+
+  return 0
+
+
+if __name__ == "__main__":
+  sys.exit(main())

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/profraw_update.py

@@ -0,0 +1,182 @@
+#!/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.
+#
+################################################################################
+"""Helper script for upgrading a profraw file to latest version."""
+
+from collections import namedtuple
+import struct
+import subprocess
+import sys
+
+HeaderGeneric = namedtuple('HeaderGeneric', 'magic version')
+HeaderVersion9 = namedtuple(
+    'HeaderVersion9',
+    'BinaryIdsSize DataSize PaddingBytesBeforeCounters CountersSize \
+    PaddingBytesAfterCounters NumBitmapBytes PaddingBytesAfterBitmapBytes NamesSize CountersDelta BitmapDelta NamesDelta ValueKindLast'
+)
+
+PROFRAW_MAGIC = 0xff6c70726f667281
+
+
+def relativize_address(data, offset, databegin, sect_prf_cnts, sect_prf_data):
+  """Turns an absolute offset into a relative one."""
+  value = struct.unpack('Q', data[offset:offset + 8])[0]
+  if sect_prf_cnts <= value < sect_prf_data:
+    # If the value is an address in the right section, make it relative.
+    value = (value - databegin) & 0xffffffffffffffff
+    value = struct.pack('Q', value)
+    for i in range(8):
+      data[offset + i] = value[i]
+    # address was made relative
+    return True
+  # no changes done
+  return False
+
+
+def upgrade(data, sect_prf_cnts, sect_prf_data):
+  """Upgrades profraw data, knowing the sections addresses."""
+  generic_header = HeaderGeneric._make(struct.unpack('QQ', data[:16]))
+  if generic_header.magic != PROFRAW_MAGIC:
+    raise Exception('Bad magic.')
+  base_version = generic_header.version
+
+  if base_version >= 9:
+    # Nothing to do.
+    return data
+  if base_version < 5 or base_version == 6:
+    raise Exception('Unhandled version.')
+
+  if generic_header.version == 5:
+    generic_header = generic_header._replace(version=7)
+    # Upgrade from version 5 to 7 by adding binaryids field.
+    data = data[:8] + struct.pack('Q', generic_header.version) + struct.pack(
+        'Q', 0) + data[16:]
+  if generic_header.version == 7:
+    # cf https://reviews.llvm.org/D111123
+    generic_header = generic_header._replace(version=8)
+    data = data[:8] + struct.pack('Q', generic_header.version) + data[16:]
+  if generic_header.version == 8:
+    # see https://reviews.llvm.org/D138846
+    generic_header = generic_header._replace(version=9)
+    # Upgrade from version 8 to 9 by adding NumBitmapBytes, PaddingBytesAfterBitmapBytes and BitmapDelta fields.
+    data = data[:8] + struct.pack(
+        'Q', generic_header.version) + data[16:56] + struct.pack(
+            'QQ', 0, 0) + data[56:72] + struct.pack('Q', 0) + data[72:]
+
+  v9_header = HeaderVersion9._make(struct.unpack('QQQQQQQQQQQQ', data[16:112]))
+
+  if base_version <= 8 and v9_header.BinaryIdsSize % 8 != 0:
+    # Adds padding for binary ids.
+    # cf commit b9f547e8e51182d32f1912f97a3e53f4899ea6be
+    # cf https://reviews.llvm.org/D110365
+    padlen = 8 - (v9_header.BinaryIdsSize % 8)
+    v7_header = v9_header._replace(BinaryIdsSize=v9_header.BinaryIdsSize +
+                                   padlen)
+    data = data[:16] + struct.pack('Q', v9_header.BinaryIdsSize) + data[24:]
+    data = data[:112 + v9_header.BinaryIdsSize] + bytes(
+        padlen) + data[112 + v9_header.BinaryIdsSize:]
+
+  if base_version <= 8:
+    offset = 112 + v9_header.BinaryIdsSize
+    for d in range(v9_header.DataSize):
+      # Add BitmapPtr and aligned u32(NumBitmapBytes)
+      data = data[:offset + 3 * 8] + struct.pack(
+          'Q', 0) + data[offset + 3 * 8:offset + 6 * 8] + struct.pack(
+              'Q', 0) + data[offset + 6 * 8:]
+      value = struct.unpack('Q',
+                            data[offset + 2 * 8:offset + 3 * 8])[0] - 16 * d
+      data = data[:offset + 2 * 8] + struct.pack('Q',
+                                                 value) + data[offset + 3 * 8:]
+      offset += 8 * 8
+
+  if base_version >= 8:
+    # Nothing more to do.
+    return data
+
+  # Last changes are relaed to bump from 7 to version 8 making CountersPtr relative.
+  dataref = sect_prf_data
+  # 80 is offset of CountersDelta.
+  if not relativize_address(data, 80, dataref, sect_prf_cnts, sect_prf_data):
+    return data
+
+  offset = 112 + v9_header.BinaryIdsSize
+  # This also works for C+Rust binaries compiled with
+  # clang-14/rust-nightly-clang-13.
+  for _ in range(v9_header.DataSize):
+    # 16 is the offset of CounterPtr in ProfrawData structure.
+    relativize_address(data, offset + 16, dataref, sect_prf_cnts, sect_prf_data)
+    # We need this because of CountersDelta -= sizeof(*SrcData);
+    # seen in __llvm_profile_merge_from_buffer.
+    dataref += 44 + 2 * (v9_header.ValueKindLast + 1)
+    if was8:
+      #profraw9 added RelativeBitmapPtr and NumBitmapBytes (8+4 rounded up to 16)
+      dataref -= 16
+    # This is the size of one ProfrawData structure.
+    offset += 44 + 2 * (v9_header.ValueKindLast + 1)
+
+  return data
+
+
+def main():
+  """Helper script for upgrading a profraw file to latest version."""
+  if len(sys.argv) < 3:
+    sys.stderr.write('Usage: %s <binary> options? <profraw>...\n' % sys.argv[0])
+    return 1
+
+  # First find llvm profile sections addresses in the elf, quick and dirty.
+  process = subprocess.Popen(['readelf', '-S', sys.argv[1]],
+                             stdout=subprocess.PIPE)
+  output, err = process.communicate()
+  if err:
+    print('readelf failed')
+    return 2
+  for line in iter(output.split(b'\n')):
+    if b'__llvm_prf_cnts' in line:
+      sect_prf_cnts = int(line.split()[3], 16)
+    elif b'__llvm_prf_data' in line:
+      sect_prf_data = int(line.split()[3], 16)
+
+  out_name = "default.profup"
+  in_place = False
+  start = 2
+  if sys.argv[2] == "-i":
+    in_place = True
+    start = start + 1
+  elif sys.argv[2] == "-o":
+    out_name = sys.argv[3]
+    start = 4
+
+  if len(sys.argv) < start:
+    sys.stderr.write('Usage: %s <binary> options <profraw>...\n' % sys.argv[0])
+    return 1
+
+  for i in range(start, len(sys.argv)):
+    # Then open and read the input profraw file.
+    with open(sys.argv[i], 'rb') as input_file:
+      profraw_base = bytearray(input_file.read())
+    # Do the upgrade, returning a bytes object.
+    profraw_latest = upgrade(profraw_base, sect_prf_cnts, sect_prf_data)
+    # Write the output to the file given to the command line.
+    if in_place:
+      out_name = sys.argv[i]
+    with open(out_name, 'wb') as output_file:
+      output_file.write(profraw_latest)
+
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/python_coverage_runner_help.py

@@ -0,0 +1,181 @@
+# 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.
+"""
+Helper to manage coverage.py related operations. Does two main
+things: (1) pass commands into the coverage.py library and (2)
+translate .coverage created from a pyinstaller executable into
+paths that match local files. This is needed for html report creation.
+"""
+import os
+import re
+import json
+import sys
+from coverage.cmdline import main as coverage_main
+from coverage.data import CoverageData
+
+
+def should_exclude_file(filepath):
+  """Returns whether the path should be excluded from the coverage report."""
+  # Skip all atheris code
+  if "atheris" in filepath:
+    return True
+
+  # Filter out all standard python libraries
+  if ('/usr/local/lib/python' in filepath and
+      'site-packages' not in filepath and 'dist-packages' not in filepath):
+    return True
+
+  # Avoid all PyInstaller modules.
+  if 'PyInstaller' in filepath:
+    return True
+
+  return False
+
+
+def translate_lines(cov_data, new_cov_data, all_file_paths):
+  """
+  Translate lines in a .coverage file created by coverage.py such that
+  the file paths points to local files instead. This is needed when collecting
+  coverage from executables created by pyinstaller.
+  """
+  for pyinstaller_file_path in cov_data.measured_files():
+    stripped_py_file_path = pyinstaller_file_path
+    if stripped_py_file_path.startswith('/tmp/_MEI'):
+      stripped_py_file_path = '/'.join(stripped_py_file_path.split('/')[3:])
+    if stripped_py_file_path.startswith('/out/'):
+      stripped_py_file_path = stripped_py_file_path.replace('/out/', '')
+
+    # Check if this file exists in our file paths:
+    for local_file_path in all_file_paths:
+      if should_exclude_file(local_file_path):
+        continue
+      if local_file_path.endswith(stripped_py_file_path):
+        print('Found matching: %s' % (local_file_path))
+        new_cov_data.add_lines(
+            {local_file_path: cov_data.lines(pyinstaller_file_path)})
+
+
+def translate_coverage(all_file_paths):
+  """
+  Translate pyinstaller-generated file paths in .coverage (produced by
+  coverage.py) into local file paths. Place result in .new_coverage.
+  """
+  covdata_pre_translation = CoverageData('.coverage')
+  covdata_post_translation = CoverageData('.new_coverage')
+
+  covdata_pre_translation.read()
+  translate_lines(covdata_pre_translation, covdata_post_translation,
+                  all_file_paths)
+  covdata_post_translation.write()
+
+
+def convert_coveragepy_cov_to_summary_json(src, dst):
+  """
+  Converts a json file produced by coveragepy into a summary.json file
+  similary to llvm-cov output. `src` is the source coveragepy json file,
+  `dst` is the destination json file, which will be overwritten.
+  """
+  dst_dict = {'data': [{'files': {}}]}
+  lines_covered = 0
+  lines_count = 0
+  with open(src, "r") as src_f:
+    src_json = json.loads(src_f.read())
+    if 'files' in src_json:
+      for elem in src_json.get('files'):
+        if 'summary' not in src_json['files'][elem]:
+          continue
+        src_dict = src_json['files'][elem]['summary']
+        count = src_dict['covered_lines'] + src_dict['missing_lines']
+        covered = src_dict['covered_lines']
+        notcovered = src_dict['missing_lines']
+        percent = src_dict['percent_covered']
+
+        # Accumulate line coverage
+        lines_covered += covered
+        lines_count += count
+
+        dst_dict['data'][0]['files'][elem] = {
+            'summary': {
+                'lines': {
+                    'count': count,
+                    'covered': covered,
+                    'notcovered': notcovered,
+                    'percent': percent
+                }
+            }
+        }
+  if lines_count > 0:
+    lines_covered_percent = lines_covered / lines_count
+  else:
+    lines_covered_percent = 0.0
+  dst_dict['data'][0]['totals'] = {
+      'branches': {
+          'count': 0,
+          'covered': 0,
+          'notcovered': 0,
+          'percent': 0.0
+      },
+      'functions': {
+          'count': 0,
+          'covered': 0,
+          'percent': 0.0
+      },
+      'instantiations': {
+          'count': 0,
+          'covered': 0,
+          'percent': 0.0
+      },
+      'lines': {
+          'count': lines_count,
+          'covered': lines_covered,
+          'percent': lines_covered_percent
+      },
+      'regions': {
+          'count': 0,
+          'covered': 0,
+          'notcovered': 0,
+          'percent': 0.0
+      }
+  }
+
+  with open(dst, 'w') as dst_f:
+    dst_f.write(json.dumps(dst_dict))
+
+
+def main():
+  """
+  Main handler.
+  """
+  if sys.argv[1] == 'translate':
+    print('Translating the coverage')
+    files_path = sys.argv[2]
+    all_file_paths = list()
+    for root, _, files in os.walk(files_path):
+      for relative_file_path in files:
+        abs_file_path = os.path.abspath(os.path.join(root, relative_file_path))
+        all_file_paths.append(abs_file_path)
+    print('Done with path walk')
+    translate_coverage(all_file_paths)
+  elif sys.argv[1] == 'convert-to-summary-json':
+    src = sys.argv[2]
+    dst = sys.argv[3]
+    convert_coveragepy_cov_to_summary_json(src, dst)
+  else:
+    # Pass commands into coverage package
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(coverage_main())
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/rcfilt

@@ -0,0 +1,21 @@
+#!/bin/bash -u
+# 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.
+#
+# Symbol demangling for both C++ and Rust
+#
+################################################################################
+
+# simply pipe
+rustfilt | c++filt -n

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/reproduce

@@ -0,0 +1,34 @@
+#!/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.
+#
+################################################################################
+
+FUZZER=$1
+shift
+
+if [ ! -v TESTCASE ]; then
+    TESTCASE="/testcase"
+fi
+
+if [ ! -f $TESTCASE ]; then
+  echo "Error: $TESTCASE not found, use: docker run -v <path>:$TESTCASE ..."
+  exit 1
+fi
+
+export RUN_FUZZER_MODE="interactive"
+export FUZZING_ENGINE="libfuzzer"
+export SKIP_SEED_CORPUS="1"
+
+run_fuzzer $FUZZER $@ $TESTCASE

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/run_fuzzer

@@ -0,0 +1,228 @@
+#!/bin/bash -eu
+# 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.
+#
+################################################################################
+
+# Fuzzer runner. Appends .options arguments and seed corpus to users args.
+# Usage: $0 <fuzzer_name> <fuzzer_args>
+
+sysctl -w vm.mmap_rnd_bits=28
+
+export PATH=$OUT:$PATH
+cd $OUT
+
+DEBUGGER=${DEBUGGER:-}
+
+FUZZER=$1
+shift
+
+# This env var is set by CIFuzz. CIFuzz fills this directory with the corpus
+# from ClusterFuzz.
+CORPUS_DIR=${CORPUS_DIR:-}
+if [ -z "$CORPUS_DIR" ]
+then
+  CORPUS_DIR="/tmp/${FUZZER}_corpus"
+  rm -rf $CORPUS_DIR && mkdir -p $CORPUS_DIR
+fi
+
+SANITIZER=${SANITIZER:-}
+if [ -z $SANITIZER ]; then
+  # If $SANITIZER is not specified (e.g. calling from `reproduce` command), it
+  # is not important and can be set to any value.
+  SANITIZER="default"
+fi
+
+if [[ "$RUN_FUZZER_MODE" = interactive ]]; then
+  FUZZER_OUT="$OUT/${FUZZER}_${FUZZING_ENGINE}_${SANITIZER}_out"
+else
+  FUZZER_OUT="/tmp/${FUZZER}_${FUZZING_ENGINE}_${SANITIZER}_out"
+fi
+
+function get_dictionary() {
+  local options_file="$FUZZER.options"
+  local dict_file="$FUZZER.dict"
+  local dict=""
+  if [[ -f "$options_file" ]]; then
+    dict=$(sed -n 's/^\s*dict\s*=\s*\(.*\)/\1/p' "$options_file" | tail -1)
+  fi
+  if [[ -z "$dict" && -f "$dict_file" ]]; then
+    dict="$dict_file"
+  fi
+  [[ -z "$dict" ]] && return
+  if [[ "$FUZZING_ENGINE" = "libfuzzer" ]]; then
+     printf -- "-dict=%s" "$dict"
+  elif [[ "$FUZZING_ENGINE" = "afl" ]]; then
+     printf -- "-x %s" "$dict"
+  elif [[ "$FUZZING_ENGINE" = "honggfuzz" ]]; then
+     printf -- "--dict %s" "$dict"
+  elif [[ "$FUZZING_ENGINE" = "centipede" ]]; then
+     printf -- "--dictionary %s" "$dict"
+  else
+     printf "Unexpected FUZZING_ENGINE: $FUZZING_ENGINE, ignoring\n" >&2
+  fi
+}
+
+function get_extra_binaries() {
+  [[ "$FUZZING_ENGINE" != "centipede" ]] && return
+
+  extra_binaries="$OUT/__centipede_${SANITIZER}/${FUZZER}"
+  if compgen -G "$extra_binaries" >> /dev/null; then
+    printf -- "--extra_binaries %s" \""$extra_binaries\""
+  fi
+
+}
+
+rm -rf $FUZZER_OUT && mkdir -p $FUZZER_OUT
+
+SEED_CORPUS="${FUZZER}_seed_corpus.zip"
+
+# TODO: Investigate why this code block is skipped
+# by all default fuzzers in bad_build_check.
+# They all set SKIP_SEED_CORPUS=1.
+if [ -f $SEED_CORPUS ] && [ -z ${SKIP_SEED_CORPUS:-} ]; then
+  echo "Using seed corpus: $SEED_CORPUS"
+  unzip -o -d ${CORPUS_DIR}/ $SEED_CORPUS > /dev/null
+fi
+
+OPTIONS_FILE="${FUZZER}.options"
+CUSTOM_LIBFUZZER_OPTIONS=""
+
+if [ -f $OPTIONS_FILE ]; then
+  custom_asan_options=$(parse_options.py $OPTIONS_FILE asan)
+  if [ ! -z $custom_asan_options ]; then
+    export ASAN_OPTIONS="$ASAN_OPTIONS:$custom_asan_options"
+  fi
+
+  custom_msan_options=$(parse_options.py $OPTIONS_FILE msan)
+  if [ ! -z $custom_msan_options ]; then
+    export MSAN_OPTIONS="$MSAN_OPTIONS:$custom_msan_options"
+  fi
+
+  custom_ubsan_options=$(parse_options.py $OPTIONS_FILE ubsan)
+  if [ ! -z $custom_ubsan_options ]; then
+    export UBSAN_OPTIONS="$UBSAN_OPTIONS:$custom_ubsan_options"
+  fi
+
+  CUSTOM_LIBFUZZER_OPTIONS=$(parse_options.py $OPTIONS_FILE libfuzzer)
+fi
+
+if [[ "$FUZZING_ENGINE" = afl ]]; then
+
+  # Set afl++ environment options.
+  export ASAN_OPTIONS="$ASAN_OPTIONS:abort_on_error=1:symbolize=0:detect_odr_violation=0:"
+  export MSAN_OPTIONS="$MSAN_OPTIONS:exit_code=86:symbolize=0"
+  export UBSAN_OPTIONS="$UBSAN_OPTIONS:symbolize=0"
+  export AFL_I_DONT_CARE_ABOUT_MISSING_CRASHES=1
+  export AFL_SKIP_CPUFREQ=1
+  export AFL_TRY_AFFINITY=1
+  export AFL_FAST_CAL=1
+  export AFL_CMPLOG_ONLY_NEW=1
+  export AFL_FORKSRV_INIT_TMOUT=30000
+  export AFL_IGNORE_PROBLEMS=1
+  export AFL_IGNORE_UNKNOWN_ENVS=1
+
+  # If $OUT/afl_cmplog.txt is present this means the target was compiled for
+  # CMPLOG. So we have to add the proper parameters to afl-fuzz.
+  test -e "$OUT/afl_cmplog.txt" && AFL_FUZZER_ARGS="$AFL_FUZZER_ARGS -c $OUT/$FUZZER"
+
+  # If $OUT/afl++.dict we load it as a dictionary for afl-fuzz.
+  test -e "$OUT/afl++.dict" && AFL_FUZZER_ARGS="$AFL_FUZZER_ARGS -x $OUT/afl++.dict"
+
+  # Ensure timeout is a bit larger than 1sec as some of the OSS-Fuzz fuzzers
+  # are slower than this.
+  AFL_FUZZER_ARGS="$AFL_FUZZER_ARGS -t 5000+"
+
+  # AFL expects at least 1 file in the input dir.
+  echo input > ${CORPUS_DIR}/input
+
+  CMD_LINE="$OUT/afl-fuzz $AFL_FUZZER_ARGS -i $CORPUS_DIR -o $FUZZER_OUT $(get_dictionary) $* -- $OUT/$FUZZER"
+
+  echo afl++ setup:
+  env|grep AFL_
+  cat "$OUT/afl_options.txt"
+
+elif [[ "$FUZZING_ENGINE" = honggfuzz ]]; then
+
+  # Honggfuzz expects at least 1 file in the input dir.
+  echo input > $CORPUS_DIR/input
+  # --exit_upon_crash: exit whith a first crash seen
+  # -V: verify crashes
+  # -R (report): save report file to this location
+  # -W (working dir): where the crashes go
+  # -v (verbose): don't use VTE UI, just stderr
+  # -z: use software-instrumentation of clang (trace-pc-guard....)
+  # -P: use persistent mode of fuzzing (i.e. LLVMFuzzerTestOneInput)
+  # -f: location of the initial (and destination) file corpus
+  # -n: number of fuzzing threads (and processes)
+  CMD_LINE="$OUT/honggfuzz -n 1 --exit_upon_crash -V -R /tmp/${FUZZER}_honggfuzz.report -W $FUZZER_OUT -v -z -P -f \"$CORPUS_DIR\" $(get_dictionary) $* -- \"$OUT/$FUZZER\""
+
+  if [[ $(LC_ALL=C grep -P "\x01_LIBHFUZZ_NETDRIVER_BINARY_SIGNATURE_\x02\xFF" "$FUZZER" ) ]]; then
+    # Honggfuzz Netdriver port. This must match the port in Clusterfuzz.
+    export HFND_TCP_PORT=8666
+  fi
+elif [[ "$FUZZING_ENGINE" = centipede ]]; then
+
+  # Create the work and corpus directory for Centipede.
+  CENTIPEDE_WORKDIR="${CENTIPEDE_WORKDIR:-$OUT}"
+
+  # Centipede only saves crashes to crashes/ in workdir.
+  rm -rf $FUZZER_OUT
+
+  # --workdir: Dir that stores corpus&features in Centipede's own format.
+  # --corpus_dir: Location of the initial (and destination) file corpus.
+  # --fork_server: Execute the target(s) via the fork server.
+  #   Run in fork mode to continue fuzzing indefinitely in case of
+  #   OOMs, timeouts, and crashes.
+  # --exit_on_crash=0: Do not exit on crash.
+  # --timeout=1200: The process that executes target binary will abort
+  #   if an input runs >= 1200s.
+  # --rss_limit_mb=0: Disable RSS limit.
+  # --address_space_limit_mb=0: No address space limit.
+  # --binary: The target binary under test without sanitizer.
+  # --extra_binary: The target binaries under test with sanitizers.
+  CMD_LINE="$OUT/centipede --workdir=$CENTIPEDE_WORKDIR --corpus_dir=\"$CORPUS_DIR\" --fork_server=1 --exit_on_crash=1 --timeout=1200 --rss_limit_mb=4096 --address_space_limit_mb=5120 $(get_dictionary) --binary=\"$OUT/${FUZZER}\" $(get_extra_binaries) $*"
+else
+
+  CMD_LINE="$OUT/$FUZZER $FUZZER_ARGS $*"
+
+  if [ -z ${SKIP_SEED_CORPUS:-} ]; then
+    CMD_LINE="$CMD_LINE $CORPUS_DIR"
+  fi
+
+  if [[ ! -z ${CUSTOM_LIBFUZZER_OPTIONS} ]]; then
+    CMD_LINE="$CMD_LINE $CUSTOM_LIBFUZZER_OPTIONS"
+  fi
+
+  if [[ ! "$CMD_LINE" =~ "-dict=" ]]; then
+    if [ -f "$FUZZER.dict" ]; then
+      CMD_LINE="$CMD_LINE -dict=$FUZZER.dict"
+    fi
+  fi
+
+  CMD_LINE="$CMD_LINE < /dev/null"
+
+fi
+
+echo $CMD_LINE
+
+# Unset OUT so the fuzz target can't rely on it.
+unset OUT
+
+if [ ! -z "$DEBUGGER" ]; then
+  CMD_LINE="$DEBUGGER $CMD_LINE"
+fi
+
+bash -c "$CMD_LINE"
+

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/ruzzy

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# 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.
+#
+################################################################################
+
+ASAN_OPTIONS="allocator_may_return_null=1:detect_leaks=0:use_sigaltstack=0" LD_PRELOAD=$(ruby -e 'require "ruzzy"; print Ruzzy::ASAN_PATH') \
+	ruby $@

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/targets_list

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+for binary in $(find $OUT/ -executable -type f); do
+  [[ "$binary" != *.so ]] || continue
+  [[ $(basename "$binary") != jazzer_driver* ]] || continue
+  file "$binary" | grep -e ELF -e "shell script" > /dev/null 2>&1 || continue
+  grep "LLVMFuzzerTestOneInput" "$binary" > /dev/null 2>&1 || continue
+
+  basename "$binary"
+done

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/test_all.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+# 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.
+#
+################################################################################
+"""Does bad_build_check on all fuzz targets in $OUT."""
+
+import contextlib
+import multiprocessing
+import os
+import re
+import subprocess
+import stat
+import sys
+import tempfile
+
+BASE_TMP_FUZZER_DIR = '/tmp/not-out'
+
+EXECUTABLE = stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH
+
+IGNORED_TARGETS = [
+    r'do_stuff_fuzzer', r'checksum_fuzzer', r'fuzz_dump', r'fuzz_keyring',
+    r'xmltest', r'fuzz_compression_sas_rle', r'ares_*_fuzzer'
+]
+
+IGNORED_TARGETS_RE = re.compile('^' + r'$|^'.join(IGNORED_TARGETS) + '$')
+
+
+def move_directory_contents(src_directory, dst_directory):
+  """Moves contents of |src_directory| to |dst_directory|."""
+  # Use mv because mv preserves file permissions. If we don't preserve file
+  # permissions that can mess up CheckFuzzerBuildTest in cifuzz_test.py and
+  # other cases where one is calling test_all on files not in OSS-Fuzz's real
+  # out directory.
+  src_contents = [
+      os.path.join(src_directory, filename)
+      for filename in os.listdir(src_directory)
+  ]
+  command = ['mv'] + src_contents + [dst_directory]
+  subprocess.check_call(command)
+
+
+def is_elf(filepath):
+  """Returns True if |filepath| is an ELF file."""
+  result = subprocess.run(['file', filepath],
+                          stdout=subprocess.PIPE,
+                          check=False)
+  return b'ELF' in result.stdout
+
+
+def is_shell_script(filepath):
+  """Returns True if |filepath| is a shell script."""
+  result = subprocess.run(['file', filepath],
+                          stdout=subprocess.PIPE,
+                          check=False)
+  return b'shell script' in result.stdout
+
+
+def find_fuzz_targets(directory):
+  """Returns paths to fuzz targets in |directory|."""
+  # TODO(https://github.com/google/oss-fuzz/issues/4585): Use libClusterFuzz for
+  # this.
+  fuzz_targets = []
+  for filename in os.listdir(directory):
+    path = os.path.join(directory, filename)
+    if filename == 'llvm-symbolizer':
+      continue
+    if filename.startswith('afl-'):
+      continue
+    if filename.startswith('jazzer_'):
+      continue
+    if not os.path.isfile(path):
+      continue
+    if not os.stat(path).st_mode & EXECUTABLE:
+      continue
+    # Fuzz targets can either be ELF binaries or shell scripts (e.g. wrapper
+    # scripts for Python and JVM targets or rules_fuzzing builds with runfiles
+    # trees).
+    if not is_elf(path) and not is_shell_script(path):
+      continue
+    if os.getenv('FUZZING_ENGINE') not in {'none', 'wycheproof'}:
+      with open(path, 'rb') as file_handle:
+        binary_contents = file_handle.read()
+        if b'LLVMFuzzerTestOneInput' not in binary_contents:
+          continue
+    fuzz_targets.append(path)
+  return fuzz_targets
+
+
+def do_bad_build_check(fuzz_target):
+  """Runs bad_build_check on |fuzz_target|. Returns a
+  Subprocess.ProcessResult."""
+  print('INFO: performing bad build checks for', fuzz_target)
+  if centipede_needs_auxiliaries():
+    print('INFO: Finding Centipede\'s auxiliary for target', fuzz_target)
+    auxiliary_path = find_centipede_auxiliary(fuzz_target)
+    print('INFO: Using auxiliary binary:', auxiliary_path)
+    auxiliary = [auxiliary_path]
+  else:
+    auxiliary = []
+
+  command = ['bad_build_check', fuzz_target] + auxiliary
+  with tempfile.TemporaryDirectory() as temp_centipede_workdir:
+    # Do this so that centipede doesn't fill up the disk during bad build check
+    env = os.environ.copy()
+    env['CENTIPEDE_WORKDIR'] = temp_centipede_workdir
+    return subprocess.run(command,
+                          stderr=subprocess.PIPE,
+                          stdout=subprocess.PIPE,
+                          env=env,
+                          check=False)
+
+
+def get_broken_fuzz_targets(bad_build_results, fuzz_targets):
+  """Returns a list of broken fuzz targets and their process results in
+  |fuzz_targets| where each item in |bad_build_results| is the result of
+  bad_build_check on the corresponding element in |fuzz_targets|."""
+  broken = []
+  for result, fuzz_target in zip(bad_build_results, fuzz_targets):
+    if result.returncode != 0:
+      broken.append((fuzz_target, result))
+  return broken
+
+
+def has_ignored_targets(out_dir):
+  """Returns True if |out_dir| has any fuzz targets we are supposed to ignore
+  bad build checks of."""
+  out_files = set(os.listdir(out_dir))
+  for filename in out_files:
+    if re.match(IGNORED_TARGETS_RE, filename):
+      return True
+  return False
+
+
+@contextlib.contextmanager
+def use_different_out_dir():
+  """Context manager that moves OUT to subdirectory of BASE_TMP_FUZZER_DIR. This
+  is useful for catching hardcoding. Note that this sets the environment
+  variable OUT and therefore must be run before multiprocessing.Pool is created.
+  Resets OUT at the end."""
+  # Use a fake OUT directory to catch path hardcoding that breaks on
+  # ClusterFuzz.
+  initial_out = os.getenv('OUT')
+  os.makedirs(BASE_TMP_FUZZER_DIR, exist_ok=True)
+  # Use a random subdirectory of BASE_TMP_FUZZER_DIR to allow running multiple
+  # instances of test_all in parallel (useful for integration testing).
+  with tempfile.TemporaryDirectory(dir=BASE_TMP_FUZZER_DIR) as out:
+    # Set this so that run_fuzzer which is called by bad_build_check works
+    # properly.
+    os.environ['OUT'] = out
+    # We move the contents of the directory because we can't move the
+    # directory itself because it is a mount.
+    move_directory_contents(initial_out, out)
+    try:
+      yield out
+    finally:
+      move_directory_contents(out, initial_out)
+      os.environ['OUT'] = initial_out
+
+
+def test_all_outside_out(allowed_broken_targets_percentage):
+  """Wrapper around test_all that changes OUT and returns the result."""
+  with use_different_out_dir() as out:
+    return test_all(out, allowed_broken_targets_percentage)
+
+
+def centipede_needs_auxiliaries():
+  """Checks if auxiliaries are needed for Centipede."""
+  # Centipede always requires unsanitized binaries as the main fuzz targets,
+  # and separate sanitized binaries as auxiliaries.
+  # 1. Building sanitized binaries with helper.py (i.e., local or GitHub CI):
+  # Unsanitized ones will be built automatically into the same docker container.
+  # Script bad_build_check tests both
+  # a) If main fuzz targets can run with the auxiliaries, and
+  # b) If the auxiliaries are built with the correct sanitizers.
+  # 2. In Trial build and production build:
+  # Two kinds of binaries will be in separated buckets / docker containers.
+  # Script bad_build_check tests either
+  # a) If the unsanitized binaries can run without the sanitized ones, or
+  # b) If the sanitized binaries are built with the correct sanitizers.
+  return (os.getenv('FUZZING_ENGINE') == 'centipede' and
+          os.getenv('SANITIZER') != 'none' and os.getenv('HELPER') == 'True')
+
+
+def find_centipede_auxiliary(main_fuzz_target_path):
+  """Finds the sanitized binary path that corresponds to |main_fuzz_target| for
+  bad_build_check."""
+  target_dir, target_name = os.path.split(main_fuzz_target_path)
+  sanitized_binary_dir = os.path.join(target_dir,
+                                      f'__centipede_{os.getenv("SANITIZER")}')
+  sanitized_binary_path = os.path.join(sanitized_binary_dir, target_name)
+
+  if os.path.isfile(sanitized_binary_path):
+    return sanitized_binary_path
+
+  # Neither of the following two should ever happen, returns None to indicate
+  # an error.
+  if os.path.isdir(sanitized_binary_dir):
+    print('ERROR: Unable to identify Centipede\'s sanitized target'
+          f'{sanitized_binary_path} in {os.listdir(sanitized_binary_dir)}')
+  else:
+    print('ERROR: Unable to identify Centipede\'s sanitized target directory'
+          f'{sanitized_binary_dir} in {os.listdir(target_dir)}')
+  return None
+
+
+def test_all(out, allowed_broken_targets_percentage):  # pylint: disable=too-many-return-statements
+  """Do bad_build_check on all fuzz targets."""
+  # TODO(metzman): Refactor so that we can convert test_one to python.
+  fuzz_targets = find_fuzz_targets(out)
+  if not fuzz_targets:
+    print('ERROR: No fuzz targets found.')
+    return False
+
+  if centipede_needs_auxiliaries():
+    for fuzz_target in fuzz_targets:
+      if not find_centipede_auxiliary(fuzz_target):
+        print(f'ERROR: Couldn\'t find auxiliary for {fuzz_target}.')
+        return False
+
+  pool = multiprocessing.Pool()
+  bad_build_results = pool.map(do_bad_build_check, fuzz_targets)
+  pool.close()
+  pool.join()
+  broken_targets = get_broken_fuzz_targets(bad_build_results, fuzz_targets)
+  broken_targets_count = len(broken_targets)
+  if not broken_targets_count:
+    return True
+
+  print('Retrying failed fuzz targets sequentially', broken_targets_count)
+  pool = multiprocessing.Pool(1)
+  retry_targets = []
+  for broken_target, result in broken_targets:
+    retry_targets.append(broken_target)
+  bad_build_results = pool.map(do_bad_build_check, retry_targets)
+  pool.close()
+  pool.join()
+  broken_targets = get_broken_fuzz_targets(bad_build_results, broken_targets)
+  broken_targets_count = len(broken_targets)
+  if not broken_targets_count:
+    return True
+
+  print('Broken fuzz targets', broken_targets_count)
+  total_targets_count = len(fuzz_targets)
+  broken_targets_percentage = 100 * broken_targets_count / total_targets_count
+  for broken_target, result in broken_targets:
+    print(broken_target)
+    # Use write because we can't print binary strings.
+    sys.stdout.buffer.write(result.stdout + result.stderr + b'\n')
+
+  if broken_targets_percentage > allowed_broken_targets_percentage:
+    print('ERROR: {broken_targets_percentage}% of fuzz targets seem to be '
+          'broken. See the list above for a detailed information.'.format(
+              broken_targets_percentage=broken_targets_percentage))
+    if has_ignored_targets(out):
+      print('Build check automatically passing because of ignored targets.')
+      return True
+    return False
+  print('{total_targets_count} fuzzers total, {broken_targets_count} '
+        'seem to be broken ({broken_targets_percentage}%).'.format(
+            total_targets_count=total_targets_count,
+            broken_targets_count=broken_targets_count,
+            broken_targets_percentage=broken_targets_percentage))
+  return True
+
+
+def get_allowed_broken_targets_percentage():
+  """Returns the value of the environment value
+  'ALLOWED_BROKEN_TARGETS_PERCENTAGE' as an int or returns a reasonable
+  default."""
+  return int(os.getenv('ALLOWED_BROKEN_TARGETS_PERCENTAGE') or '10')
+
+
+def main():
+  """Does bad_build_check on all fuzz targets in parallel. Returns 0 on success.
+  Returns 1 on failure."""
+  allowed_broken_targets_percentage = get_allowed_broken_targets_percentage()
+  if not test_all_outside_out(allowed_broken_targets_percentage):
+    return 1
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/test_all_test.py

@@ -0,0 +1,38 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Tests test_all.py"""
+import unittest
+from unittest import mock
+
+import test_all
+
+
+class TestTestAll(unittest.TestCase):
+  """Tests for the test_all_function."""
+
+  @mock.patch('test_all.find_fuzz_targets', return_value=[])
+  @mock.patch('builtins.print')
+  def test_test_all_no_fuzz_targets(self, mock_print, _):
+    """Tests that test_all returns False when there are no fuzz targets."""
+    outdir = '/out'
+    allowed_broken_targets_percentage = 0
+    self.assertFalse(
+        test_all.test_all(outdir, allowed_broken_targets_percentage))
+    mock_print.assert_called_with('ERROR: No fuzz targets found.')
+
+
+if __name__ == '__main__':
+  unittest.main()

local-test-tika-delta-05/fuzz-tooling/infra/base-images/base-runner/test_one.py

@@ -0,0 +1,47 @@
+#!/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.
+#
+################################################################################
+"""Does bad_build_check on a fuzz target in $OUT."""
+import os
+import sys
+
+import test_all
+
+
+def test_one(fuzz_target):
+  """Does bad_build_check on one fuzz target. Returns True on success."""
+  with test_all.use_different_out_dir():
+    fuzz_target_path = os.path.join(os.environ['OUT'], fuzz_target)
+    result = test_all.do_bad_build_check(fuzz_target_path)
+    if result.returncode != 0:
+      sys.stdout.buffer.write(result.stdout + result.stderr + b'\n')
+      return False
+    return True
+
+
+def main():
+  """Does bad_build_check on one fuzz target. Returns 1 on failure, 0 on
+  success."""
+  if len(sys.argv) != 2:
+    print('Usage: %d <fuzz_target>', sys.argv[0])
+    return 1
+
+  fuzz_target_binary = sys.argv[1]
+  return 0 if test_one(fuzz_target_binary) else 1
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/filestore/filesystem/__init__.py

@@ -0,0 +1,107 @@
+# 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.
+"""Filestore implementation using a filesystem directory."""
+import logging
+import os
+import shutil
+import subprocess
+import sys
+
+from distutils import dir_util
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(
+    os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir,
+                 os.pardir, os.pardir))
+import filestore
+
+
+def recursive_list_dir(directory):
+  """Returns list of all files in |directory|, including those in
+  subdirectories."""
+  files = []
+  for root, _, filenames in os.walk(directory):
+    for filename in filenames:
+      files.append(os.path.join(root, filename))
+  return files
+
+
+class FilesystemFilestore(filestore.BaseFilestore):
+  """Filesystem implementation using a filesystem directory."""
+  BUILD_DIR = 'build'
+  CRASHES_DIR = 'crashes'
+  CORPUS_DIR = 'corpus'
+  COVERAGE_DIR = 'coverage'
+
+  def __init__(self, config):
+    super().__init__(config)
+    self._filestore_root_dir = self.config.platform_conf.filestore_root_dir
+
+  def _get_filestore_path(self, name, prefix_dir):
+    """Returns the filesystem path in the filestore for |name| and
+    |prefix_dir|."""
+    return os.path.join(self._filestore_root_dir, prefix_dir, name)
+
+  def _upload_directory(self, name, directory, prefix, delete=False):
+    filestore_path = self._get_filestore_path(name, prefix)
+    if os.path.exists(filestore_path):
+      initial_files = set(recursive_list_dir(filestore_path))
+    else:
+      initial_files = set()
+
+    # Make directory and any parents.
+    os.makedirs(filestore_path, exist_ok=True)
+    copied_files = set(dir_util.copy_tree(directory, filestore_path))
+    if not delete:
+      return True
+
+    files_to_delete = initial_files - copied_files
+    for file_path in files_to_delete:
+      os.remove(file_path)
+    return True
+
+  def _download_directory(self, name, dst_directory, prefix):
+    filestore_path = self._get_filestore_path(name, prefix)
+    return dir_util.copy_tree(filestore_path, dst_directory)
+
+  def upload_crashes(self, name, directory):
+    """Uploads the crashes at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.CRASHES_DIR)
+
+  def upload_corpus(self, name, directory, replace=False):
+    """Uploads the crashes at |directory| to |name|."""
+    return self._upload_directory(name,
+                                  directory,
+                                  self.CORPUS_DIR,
+                                  delete=replace)
+
+  def upload_build(self, name, directory):
+    """Uploads the build located at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.BUILD_DIR)
+
+  def upload_coverage(self, name, directory):
+    """Uploads the coverage report at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.COVERAGE_DIR)
+
+  def download_corpus(self, name, dst_directory):
+    """Downloads the corpus located at |name| to |dst_directory|."""
+    return self._download_directory(name, dst_directory, self.CORPUS_DIR)
+
+  def download_build(self, name, dst_directory):
+    """Downloads the build with |name| to |dst_directory|."""
+    return self._download_directory(name, dst_directory, self.BUILD_DIR)
+
+  def download_coverage(self, name, dst_directory):
+    """Downloads the latest project coverage report."""
+    return self._download_directory(name, dst_directory, self.COVERAGE_DIR)

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/filestore/git/__init__.py

@@ -0,0 +1,158 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for a git based filestore."""
+
+import logging
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+import filestore
+
+# pylint: disable=wrong-import-position
+INFRA_DIR = os.path.dirname(
+    os.path.dirname(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__)))))
+sys.path.append(INFRA_DIR)
+
+import retry
+
+_PUSH_RETRIES = 3
+_PUSH_BACKOFF = 1
+_GIT_EMAIL = 'cifuzz@clusterfuzz.com'
+_GIT_NAME = 'CIFuzz'
+_CORPUS_DIR = 'corpus'
+_COVERAGE_DIR = 'coverage'
+
+
+def git_runner(repo_path):
+  """Returns a gits runner for the repo_path."""
+
+  def func(*args):
+    return subprocess.check_call(('git', '-C', repo_path) + args)
+
+  return func
+
+
+# pylint: disable=unused-argument,no-self-use
+class GitFilestore(filestore.BaseFilestore):
+  """Generic git filestore. This still relies on another filestore provided by
+  the CI for larger artifacts or artifacts which make sense to be included as
+  the result of a workflow run."""
+
+  def __init__(self, config, ci_filestore):
+    super().__init__(config)
+    self.repo_path = tempfile.mkdtemp()
+    self._git = git_runner(self.repo_path)
+    self._clone(self.config.git_store_repo)
+
+    self._ci_filestore = ci_filestore
+
+  def __del__(self):
+    shutil.rmtree(self.repo_path)
+
+  def _clone(self, repo_url):
+    """Clones repo URL."""
+    self._git('clone', repo_url, '.')
+    self._git('config', '--local', 'user.email', _GIT_EMAIL)
+    self._git('config', '--local', 'user.name', _GIT_NAME)
+
+  def _reset_git(self, branch):
+    """Resets the git repo."""
+    self._git('fetch', 'origin')
+    try:
+      self._git('checkout', '-B', branch, 'origin/' + branch)
+      self._git('reset', '--hard', 'HEAD')
+    except subprocess.CalledProcessError:
+      self._git('checkout', '--orphan', branch)
+
+    self._git('clean', '-fxd')
+
+  # pylint: disable=too-many-arguments
+  @retry.wrap(_PUSH_RETRIES, _PUSH_BACKOFF)
+  def _upload_to_git(self,
+                     message,
+                     branch,
+                     upload_path,
+                     local_path,
+                     replace=False):
+    """Uploads a directory to git. If `replace` is True, then existing contents
+    in the upload_path is deleted."""
+    self._reset_git(branch)
+
+    full_repo_path = os.path.join(self.repo_path, upload_path)
+    if replace and os.path.exists(full_repo_path):
+      shutil.rmtree(full_repo_path)
+
+    shutil.copytree(local_path, full_repo_path, dirs_exist_ok=True)
+    self._git('add', '.')
+    try:
+      self._git('commit', '-m', message)
+    except subprocess.CalledProcessError:
+      logging.debug('No changes, skipping git push.')
+      return
+
+    self._git('push', 'origin', branch)
+
+  def upload_crashes(self, name, directory):
+    """Uploads the crashes at |directory| to |name|."""
+    return self._ci_filestore.upload_crashes(name, directory)
+
+  def upload_corpus(self, name, directory, replace=False):
+    """Uploads the corpus at |directory| to |name|."""
+    self._upload_to_git('Corpus upload',
+                        self.config.git_store_branch,
+                        os.path.join(_CORPUS_DIR, name),
+                        directory,
+                        replace=replace)
+
+  def upload_build(self, name, directory):
+    """Uploads the build at |directory| to |name|."""
+    return self._ci_filestore.upload_build(name, directory)
+
+  def upload_coverage(self, name, directory):
+    """Uploads the coverage report at |directory| to |name|."""
+    self._upload_to_git('Coverage upload',
+                        self.config.git_store_branch_coverage,
+                        os.path.join(_COVERAGE_DIR, name),
+                        directory,
+                        replace=True)
+
+  def download_corpus(self, name, dst_directory):
+    """Downloads the corpus located at |name| to |dst_directory|."""
+    self._reset_git(self.config.git_store_branch)
+    path = os.path.join(self.repo_path, _CORPUS_DIR, name)
+    if not os.path.exists(path):
+      logging.debug('Corpus does not exist at %s.', path)
+      return False
+
+    shutil.copytree(path, dst_directory, dirs_exist_ok=True)
+    return True
+
+  def download_build(self, name, dst_directory):
+    """Downloads the build with |name| to |dst_directory|."""
+    return self._ci_filestore.download_build(name, dst_directory)
+
+  def download_coverage(self, name, dst_directory):
+    """Downloads the latest project coverage report."""
+    self._reset_git(self.config.git_store_branch_coverage)
+    path = os.path.join(self.repo_path, _COVERAGE_DIR, name)
+    if not os.path.exists(path):
+      logging.debug('Coverage does not exist at %s.', path)
+      return False
+
+    shutil.copytree(path, dst_directory, dirs_exist_ok=True)
+    return True

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/filestore/github_actions/__init__.py

@@ -0,0 +1,179 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Implementation of a filestore using Github actions artifacts."""
+import logging
+import os
+import shutil
+import sys
+import tarfile
+import tempfile
+
+# pylint: disable=wrong-import-position,import-error
+INFRA_DIR = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir,
+                 os.path.pardir))
+sys.path.append(INFRA_DIR)
+OSS_FUZZ_ROOT_DIR = os.path.dirname(INFRA_DIR)
+
+import utils
+import http_utils
+import filestore
+from filestore.github_actions import github_api
+
+UPLOAD_JS = os.path.join(os.path.dirname(__file__), 'upload.js')
+
+
+def tar_directory(directory, archive_path):
+  """Tars a |directory| and stores archive at |archive_path|. |archive_path|
+  must end in .tar"""
+  assert archive_path.endswith('.tar')
+  # Do this because make_archive will append the extension to archive_path.
+  archive_path = os.path.splitext(archive_path)[0]
+
+  root_directory = os.path.abspath(directory)
+  shutil.make_archive(archive_path,
+                      'tar',
+                      root_dir=root_directory,
+                      base_dir='./')
+
+
+class GithubActionsFilestore(filestore.BaseFilestore):
+  """Implementation of BaseFilestore using Github actions artifacts. Relies on
+  github_actions_toolkit for using the GitHub actions API and the github_api
+  module for using GitHub's standard API. We need to use both because the GitHub
+  actions API is the only way to upload an artifact but it does not support
+  downloading artifacts from other runs. The standard GitHub API does support
+  this however."""
+
+  ARTIFACT_PREFIX = 'cifuzz-'
+  BUILD_PREFIX = 'build-'
+  CRASHES_PREFIX = 'crashes-'
+  CORPUS_PREFIX = 'corpus-'
+  COVERAGE_PREFIX = 'coverage-'
+
+  def __init__(self, config):
+    super().__init__(config)
+    self.github_api_http_headers = github_api.get_http_auth_headers(config)
+
+  def _get_artifact_name(self, name):
+    """Returns |name| prefixed with |self.ARITFACT_PREFIX| if it isn't already
+    prefixed. Otherwise returns |name|."""
+    if name.startswith(self.ARTIFACT_PREFIX):
+      return name
+    return f'{self.ARTIFACT_PREFIX}{name}'
+
+  def _upload_directory(self, name, directory):  # pylint: disable=no-self-use
+    """Uploads |directory| as artifact with |name|."""
+    name = self._get_artifact_name(name)
+    with tempfile.TemporaryDirectory() as temp_dir:
+      archive_path = os.path.join(temp_dir, name + '.tar')
+      tar_directory(directory, archive_path)
+      _raw_upload_directory(name, temp_dir)
+
+  def upload_crashes(self, name, directory):
+    """Uploads the crashes at |directory| to |name|."""
+    return _raw_upload_directory(self.CRASHES_PREFIX + name, directory)
+
+  def upload_corpus(self, name, directory, replace=False):
+    """Uploads the corpus at |directory| to |name|."""
+    # Not applicable as the the entire corpus is uploaded under a single
+    # artifact name.
+    del replace
+    return self._upload_directory(self.CORPUS_PREFIX + name, directory)
+
+  def upload_build(self, name, directory):
+    """Uploads the build at |directory| to |name|."""
+    return self._upload_directory(self.BUILD_PREFIX + name, directory)
+
+  def upload_coverage(self, name, directory):
+    """Uploads the coverage report at |directory| to |name|."""
+    return self._upload_directory(self.COVERAGE_PREFIX + name, directory)
+
+  def download_corpus(self, name, dst_directory):  # pylint: disable=unused-argument,no-self-use
+    """Downloads the corpus located at |name| to |dst_directory|."""
+    return self._download_artifact(self.CORPUS_PREFIX + name, dst_directory)
+
+  def _find_artifact(self, name):
+    """Finds an artifact using the GitHub API and returns it."""
+    logging.debug('Listing artifacts.')
+    artifacts = self._list_artifacts()
+    artifact = github_api.find_artifact(name, artifacts)
+    logging.debug('Artifact: %s.', artifact)
+    return artifact
+
+  def _download_artifact(self, name, dst_directory):
+    """Downloads artifact with |name| to |dst_directory|. Returns True on
+    success."""
+    name = self._get_artifact_name(name)
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+      if not self._raw_download_artifact(name, temp_dir):
+        logging.warning('Could not download artifact: %s.', name)
+        return False
+
+      artifact_tarfile_path = os.path.join(temp_dir, name + '.tar')
+      if not os.path.exists(artifact_tarfile_path):
+        logging.error('Artifact zip did not contain a tarfile.')
+        return False
+
+      # TODO(jonathanmetzman): Replace this with archive.unpack from
+      # libClusterFuzz so we can avoid path traversal issues.
+      with tarfile.TarFile(artifact_tarfile_path) as artifact_tarfile:
+        artifact_tarfile.extractall(dst_directory)
+    return True
+
+  def _raw_download_artifact(self, name, dst_directory):
+    """Downloads the artifact with |name| to |dst_directory|. Returns True on
+    success. Does not do any untarring or adding prefix to |name|."""
+    artifact = self._find_artifact(name)
+    if not artifact:
+      logging.warning('Could not find artifact: %s.', name)
+      return False
+    download_url = artifact['archive_download_url']
+    return http_utils.download_and_unpack_zip(
+        download_url, dst_directory, headers=self.github_api_http_headers)
+
+  def _list_artifacts(self):
+    """Returns a list of artifacts."""
+    return github_api.list_artifacts(self.config.project_repo_owner,
+                                     self.config.project_repo_name,
+                                     self.github_api_http_headers)
+
+  def download_build(self, name, dst_directory):
+    """Downloads the build with name |name| to |dst_directory|."""
+    return self._download_artifact(self.BUILD_PREFIX + name, dst_directory)
+
+  def download_coverage(self, name, dst_directory):
+    """Downloads the latest project coverage report."""
+    return self._download_artifact(self.COVERAGE_PREFIX + name, dst_directory)
+
+
+def _upload_artifact_with_upload_js(name, artifact_paths, directory):
+  """Uploads the artifacts in |artifact_paths| that are located in |directory|
+  to |name|, using the upload.js script."""
+  command = [UPLOAD_JS, name, directory] + artifact_paths
+  _, _, retcode = utils.execute(command, location=OSS_FUZZ_ROOT_DIR)
+  return retcode == 0
+
+
+def _raw_upload_directory(name, directory):
+  """Uploads the artifacts located in |directory| to |name|. Does not do any
+  tarring or adding prefixes to |name|."""
+  # Get file paths.
+  artifact_paths = []
+  for root, _, curr_file_paths in os.walk(directory):
+    for file_path in curr_file_paths:
+      artifact_paths.append(os.path.join(root, file_path))
+  logging.debug('Artifact paths: %s.', artifact_paths)
+  return _upload_artifact_with_upload_js(name, artifact_paths, directory)

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/test_data/external-project/.clusterfuzzlite/Dockerfile

@@ -0,0 +1,22 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+FROM ghcr.io/aixcc-finals/base-builder
+RUN apt-get update && apt-get install -y make
+
+COPY . $SRC/external-project
+WORKDIR $SRC/external-project
+COPY .clusterfuzzlite/build.sh $SRC/

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/test_data/external-project/Makefile

@@ -0,0 +1,44 @@
+# Copyright 2017 Google Inc. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+
+# Simple example of a build file that nicely integrates a fuzz target
+# with the rest of the project.
+#
+# We use 'make' as the build system, but these ideas are applicable
+# to any other build system
+
+# By default, use our own standalone_fuzz_target_runner.
+# This runner does no fuzzing, but simply executes the inputs
+# provided via parameters.
+# Run e.g. "make all LIB_FUZZING_ENGINE=/path/to/libFuzzer.a"
+# to link the fuzzer(s) against a real fuzzing engine.
+#
+# OSS-Fuzz will define its own value for LIB_FUZZING_ENGINE.
+LIB_FUZZING_ENGINE ?= standalone_fuzz_target_runner.o
+
+# Values for CC, CFLAGS, CXX, CXXFLAGS are provided by OSS-Fuzz.
+# Outside of OSS-Fuzz use the ones you prefer or rely on the default values.
+# Do not use the -fsanitize=* flags by default.
+# OSS-Fuzz will use different -fsanitize=* flags for different builds (asan, ubsan, msan, ...)
+
+# You may add extra compiler flags like this:
+CXXFLAGS += -std=c++11
+
+all: do_stuff_fuzzer
+
+clean:
+	rm -fv *.a *.o *_fuzzer crash-* *.zip
+
+# Fuzz target, links against $LIB_FUZZING_ENGINE, so that
+# you may choose which fuzzing engine to use.
+do_stuff_fuzzer: do_stuff_fuzzer.cpp my_api.a standalone_fuzz_target_runner.o
+	${CXX} ${CXXFLAGS} $< my_api.a ${LIB_FUZZING_ENGINE} -o $@
+
+
+# The library itself.
+my_api.a: my_api.cpp my_api.h
+	${CXX} ${CXXFLAGS} $< -c
+	ar ruv my_api.a my_api.o
+
+# The standalone fuzz target runner.
+standalone_fuzz_target_runner.o: standalone_fuzz_target_runner.cpp

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/test_data/external-project/my_api.cpp

@@ -0,0 +1,36 @@
+// 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.
+
+// Implementation of "my_api".
+#include "my_api.h"
+
+#include <vector>
+
+// Do some computations with 'str', return the result.
+// This function contains a bug. Can you spot it?
+size_t DoStuff(const std::string &str) {
+  std::vector<int> Vec({0, 1, 2, 3, 4});
+  size_t Idx = 0;
+  if (str.size() > 5)
+    Idx++;
+  if (str.find("foo") != std::string::npos)
+    Idx++;
+  if (str.find("bar") != std::string::npos)
+    Idx++;
+  if (str.find("ouch") != std::string::npos)
+    Idx++;
+  if (str.find("omg") != std::string::npos)
+    Idx++;
+  return Vec[Idx];
+}

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/test_data/external-project/standalone_fuzz_target_runner.cpp

@@ -0,0 +1,47 @@
+// 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.
+
+// Example of a standalone runner for "fuzz targets".
+// It reads all files passed as parameters and feeds their contents
+// one by one into the fuzz target (LLVMFuzzerTestOneInput).
+// This runner does not do any fuzzing, but allows us to run the fuzz target
+// on the test corpus (e.g. "do_stuff_test_data") or on a single file,
+// e.g. the one that comes from a bug report.
+
+#include <cassert>
+#include <iostream>
+#include <fstream>
+#include <vector>
+
+// Forward declare the "fuzz target" interface.
+// We deliberately keep this inteface simple and header-free.
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
+
+int main(int argc, char **argv) {
+  for (int i = 1; i < argc; i++) {
+    std::ifstream in(argv[i]);
+    in.seekg(0, in.end);
+    size_t length = in.tellg();
+    in.seekg (0, in.beg);
+    std::cout << "Reading " << length << " bytes from " << argv[i] << std::endl;
+    // Allocate exactly length bytes so that we reliably catch buffer overflows.
+    std::vector<char> bytes(length);
+    in.read(bytes.data(), bytes.size());
+    assert(in);
+    LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()),
+                           bytes.size());
+    std::cout << "Execution successful" << std::endl;
+  }
+  return 0;
+}

local-test-tika-delta-05/fuzz-tooling/infra/tools/wycheproof/.gitignore

@@ -0,0 +1 @@
+wycheproof.zip

local-test-tika-delta-05/fuzz-tooling/infra/tools/wycheproof/generate_job.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env 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.
+#
+################################################################################
+"""Script for generating an OSS-Fuzz job for a wycheproof project."""
+import sys
+
+
+def main():
+  """Usage generate_job.py <project>."""
+  project = sys.argv[1]
+  print(f'Name: wycheproof_nosanitizer_{project}')
+  job_definition = f"""CUSTOM_BINARY = False
+BAD_BUILD_CHECK = False
+APP_NAME = WycheproofTarget.bash
+THREAD_ALIVE_CHECK_INTERVAL = 10
+TEST_TIMEOUT = 3600
+CRASH_RETRIES = 1
+AGGREGATE_COVERAGE = False
+TESTCASE_COVERAGE = False
+FILE_GITHUB_ISSUE = False
+MANAGED = False
+MAX_FUZZ_THREADS = 1
+RELEASE_BUILD_BUCKET_PATH = gs://clusterfuzz-builds-wycheproof/{project}/{project}-none-([0-9]+).zip
+PROJECT_NAME = {project}
+SUMMARY_PREFIX = {project}
+REVISION_VARS_URL = https://commondatastorage.googleapis.com/clusterfuzz-builds-wycheproof/{project}/{project}-none-%s.srcmap.json
+FUZZ_LOGS_BUCKET = {project}-logs.clusterfuzz-external.appspot.com
+CORPUS_BUCKET = {project}-corpus.clusterfuzz-external.appspot.com
+QUARANTINE_BUCKET = {project}-quarantine.clusterfuzz-external.appspot.com
+BACKUP_BUCKET = {project}-backup.clusterfuzz-external.appspot.com
+AUTOMATIC_LABELS = Proj-{project},Engine-wycheproof
+"""
+  print(job_definition)
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-05/fuzz-tooling/infra/tools/wycheproof/package.bash

@@ -0,0 +1,18 @@
+#!/bin/bash
+# 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.
+#
+################################################################################
+# Script for zipping ClusterFuzz's blackbox fuzzer for wycheproof.
+zip wycheproof.zip run.py launcher.py

local-test-tika-delta-05/fuzz-tooling/infra/tools/wycheproof/run.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env 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.
+#
+################################################################################
+"""Script for creating "testcases" to run wycheproof on."""
+
+import argparse
+import os
+import sys
+
+
+def get_args():
+  """Returns parsed program arguments."""
+  parser = argparse.ArgumentParser()
+  parser.add_argument(
+      '--input_dir',
+      help='Ignored.',
+  )
+  parser.add_argument('--output_dir',
+                      help='Directory for writing testcases.',
+                      required=True)
+  parser.add_argument('--no_of_files', type=int, help='Ignored.')
+  return parser.parse_args()
+
+
+def main():
+  """Generates a dummy testcase for use by a ClusterFuzz blackbox fuzzer."""
+  args = get_args()
+  if not os.path.exists(args.output_dir):
+    os.mkdir(args.output_dir)
+  testcase = os.path.join(args.output_dir, 'fuzz-0')
+  with open(testcase, 'w') as file_handle:
+    file_handle.write(' ')
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())