Add files using upload-large-folder tool

local-test-tika-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/fuzz-tooling/infra/base-images/base-builder-swift/Dockerfile

@@ -0,0 +1,22 @@
+# 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_swift.sh
+
+COPY precompile_swift /usr/local/bin/

local-test-tika-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/fuzz-tooling/infra/cifuzz/actions/build_fuzzers/action.yml

@@ -0,0 +1,55 @@
+# action.yml
+name: 'build-fuzzers'
+description: "Builds an OSS-Fuzz project's fuzzers."
+inputs:
+  oss-fuzz-project-name:
+    description: 'Name of the corresponding OSS-Fuzz project.'
+    required: true
+  language:
+    description: 'Programming language project is written in.'
+    required: false
+    default: 'c++'
+  dry-run:
+    description: 'If set, run the action without actually reporting a failure.'
+    default: false
+  allowed-broken-targets-percentage:
+    description: 'The percentage of broken targets allowed in bad_build_check.'
+    required: false
+  sanitizer:
+    description: 'The sanitizer to build the fuzzers with.'
+    default: 'address'
+  architecture:
+    description: 'The architecture used to build the fuzzers.'
+    default: 'x86_64'
+  project-src-path:
+    description: "The path to the project's source code checkout."
+    required: false
+  bad-build-check:
+    description: "Whether or not OSS-Fuzz's check for bad builds should be done."
+    required: false
+    default: true
+  keep-unaffected-fuzz-targets:
+    description: "Whether to keep unaffected fuzzers or delete them."
+    required: false
+    default: false
+  output-sarif:
+    description: "Whether to output fuzzing results to SARIF."
+    required: false
+    default: false
+runs:
+  using: 'docker'
+  image: '../../../build_fuzzers.Dockerfile'
+  env:
+    OSS_FUZZ_PROJECT_NAME: ${{ inputs.oss-fuzz-project-name }}
+    LANGUAGE: ${{ inputs.language }}
+    DRY_RUN: ${{ inputs.dry-run}}
+    ALLOWED_BROKEN_TARGETS_PERCENTAGE: ${{ inputs.allowed-broken-targets-percentage}}
+    SANITIZER: ${{ inputs.sanitizer }}
+    ARCHITECTURE: ${{ inputs.architecture }}
+    PROJECT_SRC_PATH: ${{ inputs.project-src-path }}
+    LOW_DISK_SPACE: 'True'
+    BAD_BUILD_CHECK: ${{ inputs.bad-build-check }}
+    CIFUZZ_DEBUG: 'True'
+    CFL_PLATFORM: 'github'
+    KEEP_UNAFFECTED_FUZZ_TARGETS: ${{ inputs.keep-unaffected-fuzz-targets }}
+    OUTPUT_SARIF: ${{ inputs.output-sarif }}

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/actions/run_fuzzers/action.yml

@@ -0,0 +1,82 @@
+# action.yml
+name: 'run-fuzzers'
+description: 'Runs fuzz target binaries for a specified length of time.'
+inputs:
+  oss-fuzz-project-name:
+    description: 'The OSS-Fuzz project name.'
+    required: true
+  language:
+    description: 'Programming language project is written in.'
+    required: false
+    default: 'c++'
+  fuzz-seconds:
+    description: 'The total time allotted for fuzzing in seconds.'
+    required: true
+    default: 600
+  dry-run:
+    description: 'If set, run the action without actually reporting a failure.'
+    default: false
+  sanitizer:
+    description: 'The sanitizer to run the fuzzers with.'
+    default: 'address'
+  mode:
+    description: |
+      The mode to run the fuzzers with ("code-change", "batch", "coverage", or "prune").
+      "code-change" is for fuzzing a pull request or commit.
+      "batch" is for non-interactive fuzzing of an entire project.
+      "coverage" is for coverage generation.
+      "prune" is for corpus pruning.
+    required: false
+    default: 'code-change'
+  github-token:
+    description: |
+      Token for GitHub API. WARNING: THIS SHOULD NOT BE USED IN PRODUCTION YET
+      You should use "secrets.GITHUB_TOKEN" in your workflow file, do not
+      hardcode the token.
+      TODO(https://github.com/google/oss-fuzz/pull/5841#discussion_r639393361):
+      Document locking this down.
+    required: false
+  report-unreproducible-crashes:
+    description: 'If True, then unreproducible crashes will be reported.'
+    required: false
+    default: False
+  minimize-crashes:
+    description: 'If True, reportable crashes will be minimized.'
+    required: false
+    default: False
+  parallel-fuzzing:
+    description: "Whether to use all available cores for fuzzing."
+    required: false
+    default: false
+  output-sarif:
+    description: "Whether to output fuzzing results to SARIF."
+    required: false
+    default: false
+  report-timeouts:
+    description: "Whether to report fails due to timeout."
+    required: false
+    default: true
+  report-ooms:
+    description: "Whether to report fails due to OOM."
+    required: false
+    default: true
+runs:
+  using: 'docker'
+  image: '../../../run_fuzzers.Dockerfile'
+  env:
+    OSS_FUZZ_PROJECT_NAME: ${{ inputs.oss-fuzz-project-name }}
+    LANGUAGE: ${{ inputs.language }}
+    FUZZ_SECONDS: ${{ inputs.fuzz-seconds }}
+    DRY_RUN: ${{ inputs.dry-run}}
+    SANITIZER: ${{ inputs.sanitizer }}
+    MODE: ${{ inputs.mode }}
+    GITHUB_TOKEN: ${{ inputs.github-token }}
+    LOW_DISK_SPACE: 'True'
+    REPORT_UNREPRODUCIBLE_CRASHES: ${{ inputs.report-unreproducible-crashes }}
+    MINIMIZE_CRASHES: ${{ inputs.minimize-crashes }}
+    CIFUZZ_DEBUG: 'True'
+    CFL_PLATFORM: 'github'
+    PARALLEL_FUZZING: ${{ inputs.parallel-fuzzing }}
+    OUTPUT_SARIF: ${{ inputs.output-sarif }}
+    REPORT_TIMEOUTS: ${{ inputs.report-timeouts }}
+    REPORT_OOMS: ${{ inputs.report-ooms}}

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/cifuzz-base/Dockerfile

@@ -0,0 +1,44 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+FROM ghcr.io/aixcc-finals/base-runner
+
+RUN apt-get update && \
+    apt-get install -y systemd && \
+    wget https://download.docker.com/linux/ubuntu/dists/focal/pool/stable/amd64/docker-ce-cli_20.10.8~3-0~ubuntu-focal_amd64.deb -O /tmp/docker-ce.deb && \
+    dpkg -i /tmp/docker-ce.deb && \
+    rm /tmp/docker-ce.deb
+
+ENV PATH=/opt/gcloud/google-cloud-sdk/bin/:$PATH
+ENV OSS_FUZZ_ROOT=/opt/oss-fuzz
+
+# Do this step before copying to make rebuilding faster when developing.
+COPY ./infra/cifuzz/requirements.txt /tmp/requirements.txt
+RUN python3 -m pip install -r /tmp/requirements.txt && rm /tmp/requirements.txt
+
+ADD . ${OSS_FUZZ_ROOT}
+# Don't use the default npm location since jazzer.js can break us.
+# This means javascript needed by cifuzz/clusterfuzzlite must be executed in
+# OSS_FUZZ_ROOT.
+RUN cd ${OSS_FUZZ_ROOT} && npm install ${OSS_FUZZ_ROOT}/infra/cifuzz
+
+
+ENV PYTHONUNBUFFERED=1
+
+# Python file to execute when the docker container starts up.
+# We can't use the env var $OSS_FUZZ_ROOT here. Since it's a constant env var,
+# just expand to '/opt/oss-fuzz'.
+ENTRYPOINT ["python3", "/opt/oss-fuzz/infra/cifuzz/cifuzz_combined_entrypoint.py"]

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/external-actions/build_fuzzers/action.yml

@@ -0,0 +1,75 @@
+# action.yml
+name: 'build-fuzzers'
+description: "Builds an OSS-Fuzz project's fuzzers."
+inputs:
+  language:
+    description: 'Programming language project is written in.'
+    required: false
+    default: 'c++'
+  dry-run:
+    description: 'If set, run the action without actually reporting a failure.'
+    default: false
+  allowed-broken-targets-percentage:
+    description: 'The percentage of broken targets allowed in bad_build_check.'
+    required: false
+  sanitizer:
+    description: 'The sanitizer to build the fuzzers with.'
+    default: 'address'
+  project-src-path:
+    description: "The path to the project's source code checkout."
+    required: false
+  bad-build-check:
+    description: "Whether or not OSS-Fuzz's check for bad builds should be done."
+    required: false
+    default: true
+  keep-unaffected-fuzz-targets:
+    description: "Whether to keep unaffected fuzzers or delete them."
+    required: false
+    default: false
+  storage-repo:
+    description: |
+      The git repo to use for storing certain artifacts from fuzzing.
+    required: false
+  storage-repo-branch:
+    description: |
+      The branch of the git repo to use for storing certain artifacts from
+      fuzzing.
+    required: false
+  storage-repo-branch-coverage:
+    description: |
+      The branch of the git repo to use for storing coverage reports.
+    required: false
+  upload-build:
+    description: |
+      If set, will upload the build.
+    default: false
+  github-token:
+    description: |
+      Token for GitHub API. WARNING: THIS SHOULD NOT BE USED IN PRODUCTION YET
+      You should use "secrets.GITHUB_TOKEN" in your workflow file, do not
+      hardcode the token.
+      TODO(https://github.com/google/oss-fuzz/pull/5841#discussion_r639393361):
+      Document locking this down.
+    required: false
+  output-sarif:
+    description: "Whether to output fuzzing results to SARIF."
+    required: false
+    default: false
+runs:
+  using: 'docker'
+  image: '../../../build_fuzzers.Dockerfile'
+  env:
+    OSS_FUZZ_PROJECT_NAME: ${{ inputs.oss-fuzz-project-name }}
+    LANGUAGE: ${{ inputs.language }}
+    DRY_RUN: ${{ inputs.dry-run}}
+    ALLOWED_BROKEN_TARGETS_PERCENTAGE: ${{ inputs.allowed-broken-targets-percentage}}
+    SANITIZER: ${{ inputs.sanitizer }}
+    PROJECT_SRC_PATH: ${{ inputs.project-src-path }}
+    GITHUB_TOKEN: ${{ inputs.github-token }}
+    LOW_DISK_SPACE: 'True'
+    BAD_BUILD_CHECK: ${{ inputs.bad-build-check }}
+    UPLOAD_BUILD: ${{ inputs.upload-build }}
+    CIFUZZ_DEBUG: 'True'
+    CFL_PLATFORM: 'github'
+    KEEP_UNAFFECTED_FUZZ_TARGETS: ${{ inputs.keep-unaffected-fuzz-targets }}
+    OUTPUT_SARIF: ${{ inputs.output-sarif }}

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/external-actions/run_fuzzers/action.yml

@@ -0,0 +1,97 @@
+# action.yml
+name: 'run-fuzzers'
+description: 'Runs fuzz target binaries for a specified length of time.'
+inputs:
+  language:
+    description: 'Programming language project is written in.'
+    required: false
+    default: 'c++'
+  fuzz-seconds:
+    description: 'The total time allotted for fuzzing in seconds.'
+    required: true
+    default: 600
+  dry-run:
+    description: 'If set, run the action without actually reporting a failure.'
+    default: false
+  sanitizer:
+    description: 'The sanitizer to run the fuzzers with.'
+    default: 'address'
+  mode:
+    description: |
+      The mode to run the fuzzers with ("code-change", "batch", "coverage", or "prune").
+      "code-change" is for fuzzing a pull request or commit.
+      "batch" is for non-interactive fuzzing of an entire project.
+      "coverage" is for coverage generation.
+      "prune" is for corpus pruning.
+    required: false
+    default: 'code-change'
+  github-token:
+    description: |
+      Token for GitHub API. WARNING: THIS SHOULD NOT BE USED IN PRODUCTION YET
+      You should use "secrets.GITHUB_TOKEN" in your workflow file, do not
+      hardcode the token.
+      TODO(https://github.com/google/oss-fuzz/pull/5841#discussion_r639393361):
+      Document locking this down.
+    required: true
+  storage-repo:
+    description: |
+      The git repo to use for storing certain artifacts from fuzzing.
+    required: false
+  storage-repo-branch:
+    description: |
+      The branch of the git repo to use for storing certain artifacts from
+      fuzzing.
+    default: main
+    required: false
+  storage-repo-branch-coverage:
+    description: |
+      The branch of the git repo to use for storing coverage reports.
+    default: gh-pages
+    required: false
+  report-unreproducible-crashes:
+    description: 'If True, then unreproducible crashes will be reported.'
+    required: false
+    default: false
+  minimize-crashes:
+    description: 'If True, reportable crashes will be minimized.'
+    required: false
+    default: False
+  parallel-fuzzing:
+    description: "Whether to use all available cores for fuzzing."
+    required: false
+    default: false
+  output-sarif:
+    description: "Whether to output fuzzing results to SARIF."
+    required: false
+    default: false
+  report-timeouts:
+    description: "Whether to report fails due to timeout."
+    required: false
+    default: true
+  report-ooms:
+    description: "Whether to report fails due to OOM."
+    required: false
+    default: true
+runs:
+  using: 'docker'
+  image: '../../../run_fuzzers.Dockerfile'
+  env:
+    OSS_FUZZ_PROJECT_NAME: ${{ inputs.oss-fuzz-project-name }}
+    LANGUAGE: ${{ inputs.language }}
+    FUZZ_SECONDS: ${{ inputs.fuzz-seconds }}
+    DRY_RUN: ${{ inputs.dry-run}}
+    SANITIZER: ${{ inputs.sanitizer }}
+    MODE: ${{ inputs.mode }}
+    GITHUB_TOKEN: ${{ inputs.github-token }}
+    LOW_DISK_SPACE: 'True'
+    GIT_STORE_REPO: ${{ inputs.storage-repo }}
+    GIT_STORE_BRANCH: ${{ inputs.storage-repo-branch }}
+    GIT_STORE_BRANCH_COVERAGE: ${{ inputs.storage-repo-branch-coverage }}
+    REPORT_UNREPRODUCIBLE_CRASHES: ${{ inputs.report-unreproducible-crashes }}
+    MINIMIZE_CRASHES: ${{ inputs.minimize-crashes }}
+    CIFUZZ_DEBUG: 'True'
+    CFL_PLATFORM: 'github'
+    PARALLEL_FUZZING: ${{ inputs.parallel-fuzzing }}
+    OUTPUT_SARIF: ${{ inputs.output-sarif }}
+    REPORT_TIMEOUTS: ${{ inputs.report-timeouts }}
+    REPORT_OOMS: ${{ inputs.report-ooms}}

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/filestore/__init__.py

@@ -0,0 +1,54 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for a generic filestore."""
+
+
+class FilestoreError(Exception):
+  """Error using the filestore."""
+
+
+# pylint: disable=unused-argument,no-self-use
+class BaseFilestore:
+  """Base class for a filestore."""
+
+  def __init__(self, config):
+    self.config = config
+
+  def upload_crashes(self, name, directory):
+    """Uploads the crashes at |directory| to |name|."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def upload_corpus(self, name, directory, replace=False):
+    """Uploads the corpus at |directory| to |name|."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def upload_build(self, name, directory):
+    """Uploads the build at |directory| to |name|."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def upload_coverage(self, name, directory):
+    """Uploads the coverage report at |directory| to |name|."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def download_corpus(self, name, dst_directory):
+    """Downloads the corpus located at |name| to |dst_directory|."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def download_build(self, name, dst_directory):
+    """Downloads the build with |name| to |dst_directory|."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def download_coverage(self, name, dst_directory):
+    """Downloads the latest project coverage report."""
+    raise NotImplementedError('Child class must implement method.')

local-test-tika-full-01-vuln_7/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-full-01-vuln_7/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-full-01-vuln_7/fuzz-tooling/infra/cifuzz/filestore/git/git_test.py

@@ -0,0 +1,122 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for git."""
+import filecmp
+import os
+import tempfile
+import subprocess
+import sys
+import unittest
+from unittest import mock
+
+# 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)
+
+from filestore import git
+import test_helpers
+
+# pylint: disable=protected-access,no-self-use
+
+
+class GitFilestoreTest(unittest.TestCase):
+  """Tests for GitFilestore."""
+
+  def setUp(self):
+    self.git_dir = tempfile.TemporaryDirectory()
+    self.addCleanup(self.git_dir.cleanup)
+
+    self.local_dir = tempfile.TemporaryDirectory()
+    self.addCleanup(self.local_dir.cleanup)
+
+    self.download_dir = tempfile.TemporaryDirectory()
+    self.addCleanup(self.download_dir.cleanup)
+
+    with open(os.path.join(self.local_dir.name, 'a'), 'w') as handle:
+      handle.write('')
+
+    os.makedirs(os.path.join(self.local_dir.name, 'b'))
+
+    with open(os.path.join(self.local_dir.name, 'b', 'c'), 'w') as handle:
+      handle.write('')
+
+    self.git_repo = git.git_runner(self.git_dir.name)
+    self.git_repo('init', '--bare')
+
+    self.config = test_helpers.create_run_config(
+        git_store_repo='file://' + self.git_dir.name,
+        git_store_branch='main',
+        git_store_branch_coverage='cov-branch')
+
+    self.mock_ci_filestore = mock.MagicMock()
+    self.git_store = git.GitFilestore(self.config, self.mock_ci_filestore)
+
+  def assert_dirs_same(self, first, second):
+    """Asserts two dirs are the same."""
+    dcmp = filecmp.dircmp(first, second)
+    if dcmp.diff_files or dcmp.left_only or dcmp.right_only:
+      return False
+
+    return all(
+        self.assert_dirs_same(os.path.join(first, subdir),
+                              os.path.join(second, subdir))
+        for subdir in dcmp.common_dirs)
+
+  def get_repo_filelist(self, branch):
+    """Get files in repo."""
+    return subprocess.check_output([
+        'git', '-C', self.git_dir.name, 'ls-tree', '-r', '--name-only', branch
+    ]).decode().splitlines()
+
+  def test_upload_download_corpus(self):
+    """Tests uploading and downloading corpus."""
+    self.git_store.upload_corpus('target', self.local_dir.name)
+    self.git_store.download_corpus('target', self.download_dir.name)
+    self.assert_dirs_same(self.local_dir.name, self.download_dir.name)
+
+    self.assertCountEqual([
+        'corpus/target/a',
+        'corpus/target/b/c',
+    ], self.get_repo_filelist('main'))
+
+  def test_upload_download_coverage(self):
+    """Tests uploading and downloading corpus."""
+    self.git_store.upload_coverage('latest', self.local_dir.name)
+    self.git_store.download_coverage('latest', self.download_dir.name)
+    self.assert_dirs_same(self.local_dir.name, self.download_dir.name)
+
+    self.assertCountEqual([
+        'coverage/latest/a',
+        'coverage/latest/b/c',
+    ], self.get_repo_filelist('cov-branch'))
+
+  def test_upload_crashes(self):
+    """Tests uploading crashes."""
+    self.git_store.upload_crashes('current', self.local_dir.name)
+    self.mock_ci_filestore.upload_crashes.assert_called_with(
+        'current', self.local_dir.name)
+
+  def test_upload_build(self):
+    """Tests uploading build."""
+    self.git_store.upload_build('sanitizer', self.local_dir.name)
+    self.mock_ci_filestore.upload_build.assert_called_with(
+        'sanitizer', self.local_dir.name)
+
+  def test_download_build(self):
+    """Tests downloading build."""
+    self.git_store.download_build('sanitizer', self.download_dir.name)
+    self.mock_ci_filestore.download_build.assert_called_with(
+        'sanitizer', self.download_dir.name)

local-test-tika-full-01-vuln_7/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-full-01-vuln_7/fuzz-tooling/infra/cifuzz/filestore/github_actions/github_actions_test.py

@@ -0,0 +1,283 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for github_actions."""
+import os
+import shutil
+import sys
+import tarfile
+import tempfile
+import unittest
+from unittest import mock
+
+from pyfakefs import fake_filesystem_unittest
+
+# pylint: disable=wrong-import-position
+INFRA_DIR = os.path.dirname(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.append(INFRA_DIR)
+
+from filestore import github_actions
+import test_helpers
+
+# pylint: disable=protected-access,no-self-use
+
+
+class GithubActionsFilestoreTest(fake_filesystem_unittest.TestCase):
+  """Tests for GithubActionsFilestore."""
+
+  @mock.patch('platform_config.github._get_event_data', return_value={})
+  def setUp(self, _):  # pylint: disable=arguments-differ
+    test_helpers.patch_environ(self)
+    self.token = 'example githubtoken'
+    self.owner = 'exampleowner'
+    self.repo = 'examplerepo'
+    os.environ['GITHUB_REPOSITORY'] = f'{self.owner}/{self.repo}'
+    os.environ['GITHUB_EVENT_PATH'] = '/fake'
+    os.environ['CFL_PLATFORM'] = 'github'
+    os.environ['GITHUB_WORKSPACE'] = '/workspace'
+    self.config = test_helpers.create_run_config(token=self.token)
+    self.local_dir = '/local-dir'
+    self.testcase = os.path.join(self.local_dir, 'testcase')
+
+  def _get_expected_http_headers(self):
+    return {
+        'Authorization': f'token {self.token}',
+        'Accept': 'application/vnd.github.v3+json',
+    }
+
+  @mock.patch('filestore.github_actions.github_api.list_artifacts')
+  def test_list_artifacts(self, mock_list_artifacts):
+    """Tests that _list_artifacts works as intended."""
+    filestore = github_actions.GithubActionsFilestore(self.config)
+    filestore._list_artifacts()
+    mock_list_artifacts.assert_called_with(self.owner, self.repo,
+                                           self._get_expected_http_headers())
+
+  @mock.patch('logging.warning')
+  @mock.patch('filestore.github_actions.GithubActionsFilestore._list_artifacts',
+              return_value=None)
+  @mock.patch('filestore.github_actions.github_api.find_artifact',
+              return_value=None)
+  def test_download_build_no_artifact(self, _, __, mock_warning):
+    """Tests that download_build returns None and doesn't exception when
+    find_artifact can't find an artifact."""
+    filestore = github_actions.GithubActionsFilestore(self.config)
+    name = 'name'
+    build_dir = 'build-dir'
+    self.assertFalse(filestore.download_build(name, build_dir))
+    mock_warning.assert_called_with('Could not download artifact: %s.',
+                                    'cifuzz-build-' + name)
+
+  @mock.patch('logging.warning')
+  @mock.patch('filestore.github_actions.GithubActionsFilestore._list_artifacts',
+              return_value=None)
+  @mock.patch('filestore.github_actions.github_api.find_artifact',
+              return_value=None)
+  def test_download_corpus_no_artifact(self, _, __, mock_warning):
+    """Tests that download_corpus_build returns None and doesn't exception when
+    find_artifact can't find an artifact."""
+    filestore = github_actions.GithubActionsFilestore(self.config)
+    name = 'name'
+    dst_dir = 'local-dir'
+    self.assertFalse(filestore.download_corpus(name, dst_dir))
+    mock_warning.assert_called_with('Could not download artifact: %s.',
+                                    'cifuzz-corpus-' + name)
+
+  @mock.patch('filestore.github_actions.tar_directory')
+  @mock.patch('filestore.github_actions._upload_artifact_with_upload_js')
+  def test_upload_corpus(self, mock_upload_artifact, mock_tar_directory):
+    """Test uploading corpus."""
+    self._create_local_dir()
+
+    def mock_tar_directory_impl(_, archive_path):
+      self.fs.create_file(archive_path)
+
+    mock_tar_directory.side_effect = mock_tar_directory_impl
+
+    filestore = github_actions.GithubActionsFilestore(self.config)
+    filestore.upload_corpus('target', self.local_dir)
+    self.assert_upload(mock_upload_artifact, mock_tar_directory,
+                       'corpus-target')
+
+  @mock.patch('filestore.github_actions._upload_artifact_with_upload_js')
+  def test_upload_crashes(self, mock_upload_artifact):
+    """Test uploading crashes."""
+    self._create_local_dir()
+
+    filestore = github_actions.GithubActionsFilestore(self.config)
+    filestore.upload_crashes('current', self.local_dir)
+    mock_upload_artifact.assert_has_calls(
+        [mock.call('crashes-current', ['/local-dir/testcase'], '/local-dir')])
+
+  @mock.patch('filestore.github_actions.tar_directory')
+  @mock.patch('filestore.github_actions._upload_artifact_with_upload_js')
+  def test_upload_build(self, mock_upload_artifact, mock_tar_directory):
+    """Test uploading build."""
+    self._create_local_dir()
+
+    def mock_tar_directory_impl(_, archive_path):
+      self.fs.create_file(archive_path)
+
+    mock_tar_directory.side_effect = mock_tar_directory_impl
+
+    filestore = github_actions.GithubActionsFilestore(self.config)
+    filestore.upload_build('sanitizer', self.local_dir)
+    self.assert_upload(mock_upload_artifact, mock_tar_directory,
+                       'build-sanitizer')
+
+  @mock.patch('filestore.github_actions.tar_directory')
+  @mock.patch('filestore.github_actions._upload_artifact_with_upload_js')
+  def test_upload_coverage(self, mock_upload_artifact, mock_tar_directory):
+    """Test uploading coverage."""
+    self._create_local_dir()
+
+    def mock_tar_directory_impl(_, archive_path):
+      self.fs.create_file(archive_path)
+
+    mock_tar_directory.side_effect = mock_tar_directory_impl
+
+    filestore = github_actions.GithubActionsFilestore(self.config)
+    filestore.upload_coverage('latest', self.local_dir)
+    self.assert_upload(mock_upload_artifact, mock_tar_directory,
+                       'coverage-latest')
+
+  def assert_upload(self, mock_upload_artifact, mock_tar_directory,
+                    expected_artifact_name):
+    """Tests that upload_directory invokes tar_directory and
+    artifact_client.upload_artifact properly."""
+    # Don't assert what second argument will be since it's a temporary
+    # directory.
+    self.assertEqual(mock_tar_directory.call_args_list[0][0][0], self.local_dir)
+
+    # Don't assert what second and third arguments will be since they are
+    # temporary directories.
+    expected_artifact_name = 'cifuzz-' + expected_artifact_name
+    self.assertEqual(mock_upload_artifact.call_args_list[0][0][0],
+                     expected_artifact_name)
+
+    # Assert artifacts list contains one tarfile.
+    artifacts_list = mock_upload_artifact.call_args_list[0][0][1]
+    self.assertEqual(len(artifacts_list), 1)
+    self.assertEqual(os.path.basename(artifacts_list[0]),
+                     expected_artifact_name + '.tar')
+
+  def _create_local_dir(self):
+    """Sets up pyfakefs and creates a corpus directory containing
+    self.testcase."""
+    self.setUpPyfakefs()
+    self.fs.create_file(self.testcase, contents='hi')
+
+  @mock.patch('filestore.github_actions.GithubActionsFilestore._find_artifact')
+  @mock.patch('http_utils.download_and_unpack_zip')
+  def test_download_artifact(self, mock_download_and_unpack_zip,
+                             mock_find_artifact):
+    """Tests that _download_artifact works as intended."""
+    artifact_download_url = 'http://example.com/download'
+    artifact_listing = {
+        'expired': False,
+        'name': 'corpus',
+        'archive_download_url': artifact_download_url
+    }
+    mock_find_artifact.return_value = artifact_listing
+
+    self._create_local_dir()
+    with tempfile.TemporaryDirectory() as temp_dir:
+      # Create a tarball.
+      archive_path = os.path.join(temp_dir, 'cifuzz-corpus.tar')
+      github_actions.tar_directory(self.local_dir, archive_path)
+
+      artifact_download_dst_dir = os.path.join(temp_dir, 'dst')
+      os.mkdir(artifact_download_dst_dir)
+
+      def mock_download_and_unpack_zip_impl(url, download_artifact_temp_dir,
+                                            headers):
+        self.assertEqual(url, artifact_download_url)
+        self.assertEqual(headers, self._get_expected_http_headers())
+        shutil.copy(
+            archive_path,
+            os.path.join(download_artifact_temp_dir,
+                         os.path.basename(archive_path)))
+        return True
+
+      mock_download_and_unpack_zip.side_effect = (
+          mock_download_and_unpack_zip_impl)
+      filestore = github_actions.GithubActionsFilestore(self.config)
+      self.assertTrue(
+          filestore._download_artifact('corpus', artifact_download_dst_dir))
+      mock_find_artifact.assert_called_with('cifuzz-corpus')
+      self.assertTrue(
+          os.path.exists(
+              os.path.join(artifact_download_dst_dir,
+                           os.path.basename(self.testcase))))
+
+  @mock.patch('filestore.github_actions.github_api.list_artifacts')
+  def test_find_artifact(self, mock_list_artifacts):
+    """Tests that _find_artifact works as intended."""
+    artifact_listing_1 = {
+        'expired': False,
+        'name': 'other',
+        'archive_download_url': 'http://download1'
+    }
+    artifact_listing_2 = {
+        'expired': False,
+        'name': 'artifact',
+        'archive_download_url': 'http://download2'
+    }
+    artifact_listing_3 = {
+        'expired': True,
+        'name': 'artifact',
+        'archive_download_url': 'http://download3'
+    }
+    artifact_listing_4 = {
+        'expired': False,
+        'name': 'artifact',
+        'archive_download_url': 'http://download4'
+    }
+    artifacts = [
+        artifact_listing_1, artifact_listing_2, artifact_listing_3,
+        artifact_listing_4
+    ]
+    mock_list_artifacts.return_value = artifacts
+    filestore = github_actions.GithubActionsFilestore(self.config)
+    # Test that find_artifact will return the most recent unexpired artifact
+    # with the correct name.
+    self.assertEqual(filestore._find_artifact('artifact'), artifact_listing_2)
+    mock_list_artifacts.assert_called_with(self.owner, self.repo,
+                                           self._get_expected_http_headers())
+
+
+class TarDirectoryTest(unittest.TestCase):
+  """Tests for tar_directory."""
+
+  def test_tar_directory(self):
+    """Tests that tar_directory writes the archive to the correct location and
+    archives properly."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+      archive_path = os.path.join(temp_dir, 'myarchive.tar')
+      archived_dir = os.path.join(temp_dir, 'toarchive')
+      os.mkdir(archived_dir)
+      archived_filename = 'file1'
+      archived_file_path = os.path.join(archived_dir, archived_filename)
+      with open(archived_file_path, 'w') as file_handle:
+        file_handle.write('hi')
+      github_actions.tar_directory(archived_dir, archive_path)
+      self.assertTrue(os.path.exists(archive_path))
+
+      # Now check it archives correctly.
+      unpacked_directory = os.path.join(temp_dir, 'unpacked')
+      with tarfile.TarFile(archive_path) as artifact_tarfile:
+        artifact_tarfile.extractall(unpacked_directory)
+      unpacked_archived_file_path = os.path.join(unpacked_directory,
+                                                 archived_filename)
+      self.assertTrue(os.path.exists(unpacked_archived_file_path))

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/filestore/github_actions/github_api.py

@@ -0,0 +1,109 @@
+# 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 dealing with the GitHub API. This is different from
+github_actions_toolkit which only deals with the actions API. We need to use
+both."""
+import logging
+import os
+import sys
+
+import requests
+
+import filestore
+
+# pylint: disable=wrong-import-position,import-error
+
+sys.path.append(
+    os.path.join(__file__, os.path.pardir, os.path.pardir, os.path.pardir,
+                 os.path.pardir))
+import retry
+
+_MAX_ITEMS_PER_PAGE = 100
+
+_GET_ATTEMPTS = 3
+_GET_BACKOFF = 1
+
+
+def get_http_auth_headers(config):
+  """Returns HTTP headers for authentication to the API."""
+  authorization = f'token {config.token}'
+  return {
+      'Authorization': authorization,
+      'Accept': 'application/vnd.github.v3+json'
+  }
+
+
+def _get_artifacts_list_api_url(repo_owner, repo_name):
+  """Returns the artifacts_api_url for |repo_name| owned by |repo_owner|."""
+  github_api_url = os.getenv('GITHUB_API_URL', 'https://api.github.com')
+  return (f'{github_api_url}/repos/{repo_owner}/'
+          f'{repo_name}/actions/artifacts')
+
+
+@retry.wrap(_GET_ATTEMPTS, _GET_BACKOFF)
+def _do_get_request(*args, **kwargs):
+  """Wrapped version of requests.get that does retries."""
+  return requests.get(*args, **kwargs)
+
+
+def _get_items(url, headers):
+  """Generator that gets and yields items from a GitHub API endpoint (specified
+  by |URL|) sending |headers| with the get request."""
+  # Github API response pages are 1-indexed.
+  page_counter = 1
+
+  # Set to infinity so we run loop at least once.
+  total_num_items = float('inf')
+
+  item_num = 0
+  while item_num < total_num_items:
+    params = {'per_page': _MAX_ITEMS_PER_PAGE, 'page': str(page_counter)}
+    response = _do_get_request(url, params=params, headers=headers)
+    response_json = response.json()
+    if not response.status_code == 200:
+      # Check that request was successful.
+      logging.error('Request to %s failed. Code: %d. Response: %s',
+                    response.request.url, response.status_code, response_json)
+      raise filestore.FilestoreError('Github API request failed.')
+
+    if total_num_items == float('inf'):
+      # Set proper total_num_items
+      total_num_items = response_json['total_count']
+
+    # Get the key for the items we are after.
+    keys = [key for key in response_json.keys() if key != 'total_count']
+    assert len(keys) == 1, keys
+    items_key = keys[0]
+
+    for item in response_json[items_key]:
+      yield item
+      item_num += 1
+
+    page_counter += 1
+
+
+def find_artifact(artifact_name, artifacts):
+  """Find the artifact with the name |artifact_name| in |artifacts|."""
+  for artifact in artifacts:
+    # TODO(metzman): Handle multiple by making sure we download the latest.
+    if artifact['name'] == artifact_name and not artifact['expired']:
+      return artifact
+  return None
+
+
+def list_artifacts(owner, repo, headers):
+  """Returns a generator of all the artifacts for |owner|/|repo|."""
+  url = _get_artifacts_list_api_url(owner, repo)
+  logging.debug('Getting artifacts from: %s', url)
+  return _get_items(url, headers)

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/filestore/github_actions/github_api_test.py

@@ -0,0 +1,41 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for github_api."""
+import os
+import sys
+import unittest
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(
+    os.path.abspath(
+        os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir,
+                     os.path.pardir)))
+
+from filestore.github_actions import github_api
+import test_helpers
+
+
+class GetHttpAuthHeaders(unittest.TestCase):
+  """Tests for get_http_auth_headers."""
+
+  def test_get_http_auth_headers(self):
+    """Tests that get_http_auth_headers returns the correct result."""
+    token = 'example githubtoken'
+    run_config = test_helpers.create_run_config(token=token)
+    expected_headers = {
+        'Authorization': f'token {token}',
+        'Accept': 'application/vnd.github.v3+json',
+    }
+    self.assertEqual(expected_headers,
+                     github_api.get_http_auth_headers(run_config))

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/filestore/github_actions/upload.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// Script for uploading an artifact. Returns 0 on success.
+// Usage: upload.js <artifactName> <rootDirectory> <file 1>...<file N>
+
+const fs = require('fs');
+const { DefaultArtifactClient } = require('@actions/artifact');
+
+const artifactClient = new DefaultArtifactClient();
+const artifactName = process.argv[2];
+const rootDirectory = process.argv[3]
+const files = process.argv.slice(4);
+const options = {
+    continueOnError: true
+};
+
+async function uploadArtifact() {
+    try {
+        const uploadResult = await artifactClient.uploadArtifact(artifactName, files, rootDirectory, options);
+        console.log(uploadResult);
+        if (uploadResult.failedItems.length > 0) {
+            return 1;
+        }
+        return 0;
+    } catch (error) {
+        console.error('Error uploading artifact:', error);
+        return 1;
+    }
+}
+
+uploadArtifact().then(exitCode => {
+    process.exit(exitCode);
+});

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/filestore/gitlab/__init__.py

@@ -0,0 +1,133 @@
+# 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.
+"""GitLab filestore implementation."""
+import logging
+
+import json
+import os
+import shutil
+import tempfile
+
+import filestore
+import http_utils
+
+# pylint: disable=no-self-use,unused-argument
+
+
+class GitlabFilestore(filestore.BaseFilestore):
+  """Implementation of BaseFilestore using GitLab.
+  Needs a cache to upload and download builds.
+  Needs a git repository for corpus and coverage.
+  """
+
+  BUILD_PREFIX = 'build-'
+  CORPUS_PREFIX = 'corpus-'
+  COVERAGE_PREFIX = 'coverage-'
+  CRASHES_PREFIX = 'crashes-'
+
+  def __init__(self, config):
+    super().__init__(config)
+    self.artifacts_dir = self.config.platform_conf.artifacts_dir
+    self.cache_dir = self.config.platform_conf.cache_dir
+    if self.config.git_store_repo:
+      self.git_filestore = filestore.git.GitFilestore(config, None)
+    else:
+      self.git_filestore = None
+
+  def upload_crashes(self, name, directory):
+    """GitLab artifacts implementation of upload_crashes."""
+    # Upload crashes as job artifacts.
+    if os.listdir(directory):
+      dest_dir_artifacts = os.path.join(self.config.project_src_path,
+                                        self.artifacts_dir,
+                                        self.CRASHES_PREFIX + name)
+      logging.info('Uploading artifacts to %s.', dest_dir_artifacts)
+      shutil.copytree(directory, dest_dir_artifacts)
+
+  def upload_corpus(self, name, directory, replace=False):
+    """GitLab artifacts implementation of upload_corpus."""
+    # Use the git filestore if any.
+    if self.git_filestore:
+      self.git_filestore.upload_corpus(name, directory, replace)
+      return
+    # Fall back to cache.
+    dest_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                  self.CORPUS_PREFIX + name)
+    logging.info('Copying from %s to cache %s.', directory, dest_dir_cache)
+    # Remove previous corpus from cache if any.
+    shutil.rmtree(dest_dir_cache, ignore_errors=True)
+    shutil.copytree(directory, dest_dir_cache, dirs_exist_ok=True)
+
+  def upload_build(self, name, directory):
+    """GitLab artifacts implementation of upload_build."""
+    # Puts build into the cache.
+    dest_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                  self.BUILD_PREFIX + name)
+    logging.info('Copying from %s to cache %s.', directory, dest_dir_cache)
+    shutil.copytree(directory, dest_dir_cache, dirs_exist_ok=True)
+
+  def upload_coverage(self, name, directory):
+    """GitLab artifacts implementation of upload_coverage."""
+    # Use the git filestore.
+    if self.git_filestore:
+      self.git_filestore.upload_coverage(name, directory)
+      return
+    # Fall back to cache.
+    dest_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                  self.COVERAGE_PREFIX + name)
+    logging.info('Copying from %s to cache %s.', directory, dest_dir_cache)
+    shutil.copytree(directory, dest_dir_cache, dirs_exist_ok=True)
+    # And also updates coverage reports as artifacts
+    # as it should not be too big.
+    dest_dir_artifacts = os.path.join(self.config.project_src_path,
+                                      self.artifacts_dir,
+                                      self.COVERAGE_PREFIX + name)
+    logging.info('Uploading artifacts to %s.', dest_dir_artifacts)
+    shutil.copytree(directory, dest_dir_artifacts)
+
+  def _copy_from_cache(self, src_dir_cache, dst_directory):
+    if not os.path.exists(src_dir_cache):
+      logging.info('Cache %s does not exist.', src_dir_cache)
+      return False
+    logging.info('Copying %s from cache to %s.', src_dir_cache, dst_directory)
+    shutil.copytree(src_dir_cache, dst_directory, dirs_exist_ok=True)
+    return True
+
+  def download_corpus(self, name, dst_directory):
+    """GitLab artifacts implementation of download_corpus."""
+    # Use the git filestore if any.
+    if self.git_filestore:
+      self.git_filestore.download_corpus(name, dst_directory)
+      return
+    # Fall back to cache.
+    src_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                 self.CORPUS_PREFIX + name)
+    self._copy_from_cache(src_dir_cache, dst_directory)
+
+  def download_build(self, name, dst_directory):
+    """GitLab artifacts implementation of download_build."""
+    # Gets build from the cache.
+    src_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                 self.BUILD_PREFIX + name)
+    return self._copy_from_cache(src_dir_cache, dst_directory)
+
+  def download_coverage(self, name, dst_directory):
+    """GitLab artifacts implementation of download_coverage."""
+    # Use the git filestore if any.
+    if self.git_filestore:
+      return self.git_filestore.download_coverage(name, dst_directory)
+    # Fall back to cache.
+    src_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                 self.COVERAGE_PREFIX + name)
+    return self._copy_from_cache(src_dir_cache, dst_directory)

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/filestore/gsutil/__init__.py

@@ -0,0 +1,109 @@
+# 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.
+"""Filestore implementation using gsutil."""
+import logging
+import os
+import posixpath
+import subprocess
+import sys
+
+# 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
+import utils
+
+
+def _gsutil_execute(*args, parallel=True):
+  """Executes a gsutil command, passing |*args| to gsutil and returns the
+  stdout, stderr and returncode. Exceptions on failure."""
+  command = ['gsutil']
+  if parallel:
+    command.append('-m')
+  command += list(args)
+  logging.info('Executing gsutil command: %s', command)
+  return utils.execute(command, check_result=True)
+
+
+def _rsync(src, dst, recursive=True, delete=False):
+  """Executes gsutil rsync on |src| and |dst|"""
+  args = ['rsync']
+  if recursive:
+    args.append('-r')
+  if delete:
+    args.append('-d')
+  args += [src, dst]
+  return _gsutil_execute(*args)
+
+
+class GSUtilFilestore(filestore.BaseFilestore):
+  """Filestore implementation using gsutil."""
+  BUILD_DIR = 'build'
+  CRASHES_DIR = 'crashes'
+  CORPUS_DIR = 'corpus'
+  COVERAGE_DIR = 'coverage'
+
+  def __init__(self, config):
+    super().__init__(config)
+    self._cloud_bucket = self.config.cloud_bucket
+
+  def _get_gsutil_url(self, name, prefix_dir):
+    """Returns the gsutil URL for |name| and |prefix_dir|."""
+    if not prefix_dir:
+      return posixpath.join(self._cloud_bucket, name)
+    return posixpath.join(self._cloud_bucket, prefix_dir, name)
+
+  def _upload_directory(self, name, directory, prefix, delete=False):
+    gsutil_url = self._get_gsutil_url(name, prefix)
+    return _rsync(directory, gsutil_url, delete=delete)
+
+  def _download_directory(self, name, dst_directory, prefix):
+    gsutil_url = self._get_gsutil_url(name, prefix)
+    return _rsync(gsutil_url, dst_directory)
+
+  def upload_crashes(self, name, directory):
+    """Uploads the crashes at |directory| to |name|."""
+    # Name is going to be "current". I don't know if this makes sense outside of
+    # GitHub Actions.
+    gsutil_url = self._get_gsutil_url(name, self.CRASHES_DIR)
+    logging.info('Uploading crashes to %s.', gsutil_url)
+    return _rsync(directory, gsutil_url)
+
+  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-full-01-vuln_7/fuzz-tooling/infra/cifuzz/filestore/no_filestore/__init__.py

@@ -0,0 +1,51 @@
+# 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.
+"""Empty filestore implementation for platforms that haven't implemented it."""
+import logging
+
+import filestore
+
+# pylint:disable=no-self-use,unused-argument
+
+
+class NoFilestore(filestore.BaseFilestore):
+  """Empty Filestore implementation."""
+
+  def upload_crashes(self, name, directory):
+    """Noop implementation of upload_crashes."""
+    logging.info('Not uploading crashes because no Filestore.')
+
+  def upload_corpus(self, name, directory, replace=False):
+    """Noop implementation of upload_corpus."""
+    logging.info('Not uploading corpus because no Filestore.')
+
+  def upload_build(self, name, directory):
+    """Noop implementation of upload_build."""
+    logging.info('Not uploading build because no Filestore.')
+
+  def upload_coverage(self, name, directory):
+    """Noop implementation of upload_coverage."""
+    logging.info('Not uploading coverage because no Filestore.')
+
+  def download_corpus(self, name, dst_directory):
+    """Noop implementation of download_corpus."""
+    logging.info('Not downloading corpus because no Filestore.')
+
+  def download_build(self, name, dst_directory):
+    """Noop implementation of download_build."""
+    logging.info('Not downloading build because no Filestore.')
+
+  def download_coverage(self, name, dst_directory):
+    """Noop implementation of download_coverage."""
+    logging.info('Not downloading coverage because no Filestore.')

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/platform_config/gitlab.py

@@ -0,0 +1,78 @@
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for getting the configuration CIFuzz needs to run on GitLab."""
+import logging
+import os
+
+import environment
+import platform_config
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+  """CI environment for GitLab."""
+
+  @property
+  def workspace(self):
+    """Returns the workspace."""
+    return os.path.join(os.getenv('CI_BUILDS_DIR'), os.getenv('CI_JOB_ID'))
+
+  @property
+  def git_sha(self):
+    """Returns the Git SHA to checkout and fuzz."""
+    return os.getenv('CI_COMMIT_SHA')
+
+  @property
+  def project_src_path(self):
+    """Returns the directory with the source of the project"""
+    return os.getenv('CI_PROJECT_DIR')
+
+  @property
+  def token(self):
+    """Returns the job token"""
+    return os.getenv('CI_JOB_TOKEN')
+
+  @property
+  def project_repo_name(self):
+    """Returns the project's name"""
+    return os.getenv('CI_PROJECT_NAME')
+
+  @property
+  def base_commit(self):
+    """Returns the previous commit sha for commit-fuzzing"""
+    base_commit = None
+    if os.getenv('CI_PIPELINE_SOURCE') == 'push':
+      base_commit = os.getenv('CI_COMMIT_BEFORE_SHA')
+    logging.debug('base_commit: %s.', base_commit)
+    return base_commit
+
+  @property
+  def base_ref(self):
+    """Returns the base commit sha for a merge request"""
+    # Could also be CI_MERGE_REQUEST_TARGET_BRANCH_NAME.
+    return os.getenv('CI_MERGE_REQUEST_DIFF_BASE_SHA')
+
+  @property
+  def filestore(self):
+    """Returns the filestore used to store persistent data."""
+    return os.environ.get('FILESTORE', 'gitlab')
+
+  @property
+  def artifacts_dir(self):
+    """Gitlab: returns the directory to put artifacts"""
+    return environment.get('CFL_ARTIFACTS_DIR', 'artifacts')
+
+  @property
+  def cache_dir(self):
+    """Gitlab: returns the directory to use as cache"""
+    return environment.get('CFL_CACHE_DIR', 'cache')

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/platform_config/standalone.py

@@ -0,0 +1,33 @@
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for getting the configuration CIFuzz needs to run standalone."""
+import os
+
+import platform_config
+
+# pylint: disable=too-few-public-methods
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+  """CI environment for Standalone."""
+
+  @property
+  def filestore(self):
+    """Returns the filestore used to store persistent data."""
+    return os.environ.get('FILESTORE', 'filesystem')
+
+  @property
+  def filestore_root_dir(self):
+    """Returns the filestore used to store persistent data."""
+    return os.environ['FILESTORE_ROOT_DIR']

local-test-tika-full-01-vuln_7/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-full-01-vuln_7/fuzz-tooling/infra/cifuzz/test_data/external-project/.clusterfuzzlite/build.sh

@@ -0,0 +1,24 @@
+#!/bin/bash -eu
+# Copyright 2020 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+make clean  # Not strictly necessary, since we are building in a fresh dir.
+make -j$(nproc) all    # Build the fuzz targets.
+
+# Copy the fuzzer executables, zip-ed corpora, option and dictionary files to $OUT
+find . -name '*_fuzzer' -exec cp -v '{}' $OUT ';'
+find . -name '*_fuzzer.dict' -exec cp -v '{}' $OUT ';'     # If you have dictionaries.
+find . -name '*_fuzzer.options' -exec cp -v '{}' $OUT ';'  # If you have custom options.

local-test-tika-full-01-vuln_7/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-full-01-vuln_7/fuzz-tooling/infra/cifuzz/test_data/external-project/do_stuff_fuzzer.cpp

@@ -0,0 +1,24 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "my_api.h"
+
+#include <string>
+
+// Simple fuzz target for DoStuff().
+// See https://llvm.org/docs/LibFuzzer.html for details.
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  std::string str(reinterpret_cast<const char *>(data), size);
+  DoStuff(str);  // Disregard the output.
+  return 0;
+}

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/test_data/external-project/do_stuff_fuzzer.dict

@@ -0,0 +1,6 @@
+# A dictionary for more efficient fuzzing of DoStuff(). 
+# If the inputs contain multi-byte tokens, list them here.
+# See https://llvm.org/docs/LibFuzzer.html#dictionaries
+"foo"
+"bar"
+"ouch"

local-test-tika-full-01-vuln_7/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-full-01-vuln_7/fuzz-tooling/infra/cifuzz/test_data/external-project/my_api.h

@@ -0,0 +1,19 @@
+// 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.
+
+// A library that does ... stuff.
+// Serves as an example of good fuzz testing and OSS-Fuzz integration.
+#include <string>
+
+size_t DoStuff(const std::string &str);

local-test-tika-full-01-vuln_7/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-full-01-vuln_7/fuzz-tooling/infra/cifuzz/test_data/msan_crash_fuzzer_bug_summary.txt

@@ -0,0 +1,22 @@
+MemorySanitizer: use-of-uninitialized-value
+#0 0x52675f in LLVMFuzzerTestOneInput /src/cifuzz-example/do_stuff_fuzzer.cpp:13:7
+#1 0x45a431 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:599:15
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+#7 0x41eab8 in _start (out/do_stuff_fuzzer+0x41eab8)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&)
+Uninitialized value was created by a heap allocation
+#0 0x4d57ad in malloc /src/llvm-project/compiler-rt/lib/msan/msan_interceptors.cpp:901:3
+#1 0x437c07 in operator new(unsigned long) (out/do_stuff_fuzzer+0x437c07)
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+DEDUP_TOKEN: malloc--operator new(unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&)
+
+SUMMARY:

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/cifuzz/test_data/msan_crash_fuzzer_output.txt

@@ -0,0 +1,39 @@
+Dictionary: 3 entries
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 1 modules   (184 inline 8-bit counters): 184 [0x829300, 0x8293b8), 
+INFO: Loaded 1 PC tables (184 PCs): 184 [0x5dc910,0x5dd490), 
+INFO:        5 files found in /tmp/do_stuff_fuzzer_corpus
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
+==13==WARNING: MemorySanitizer: use-of-uninitialized-value
+#0 0x52675f in LLVMFuzzerTestOneInput /src/cifuzz-example/do_stuff_fuzzer.cpp:13:7
+#1 0x45a431 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:599:15
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+#7 0x41eab8 in _start (out/do_stuff_fuzzer+0x41eab8)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&)
+Uninitialized value was created by a heap allocation
+#0 0x4d57ad in malloc /src/llvm-project/compiler-rt/lib/msan/msan_interceptors.cpp:901:3
+#1 0x437c07 in operator new(unsigned long) (out/do_stuff_fuzzer+0x437c07)
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+DEDUP_TOKEN: malloc--operator new(unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&)
+
+SUMMARY: MemorySanitizer: use-of-uninitialized-value /src/cifuzz-example/do_stuff_fuzzer.cpp:13:7 in LLVMFuzzerTestOneInput
+Unique heap origins: 65
+Stack depot allocated bytes: 4424
+Unique origin histories: 29
+History depot allocated bytes: 696
+Exiting
+MS: 0 ; base unit: 0000000000000000000000000000000000000000
+
+
+artifact_prefix='./'; Test unit written to ./crash-da39a3ee5e6b4b0d3255bfef95601890afd80709
+Base64: 

local-test-tika-full-01-vuln_7/fuzz-tooling/infra/tools/wycheproof/.gitignore

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

local-test-tika-full-01-vuln_7/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-full-01-vuln_7/fuzz-tooling/infra/tools/wycheproof/launcher.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# 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 running wycheproof."""
+
+import logging
+import sys
+import subprocess
+
+
+def main():
+  """Runs wycheproof."""
+  if len(sys.argv) < 3:
+    logging.error('Usage: %s <test_app> <testcase>.', sys.argv[0])
+    return 1
+
+  return subprocess.run(sys.argv[1:], check=False).returncode
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-full-01-vuln_7/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-full-01-vuln_7/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())