Add files using upload-large-folder tool

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

@@ -0,0 +1,26 @@
+# Copyright 2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-builder:${IMG_TAG}
+
+# Copy/Run this now to make the cache more resilient.
+COPY fuzzbench_install_dependencies /usr/local/bin
+RUN fuzzbench_install_dependencies
+
+ENV OSS_FUZZ_ON_DEMAND=1
+
+COPY fuzzbench_build fuzzbench_run_fuzzer fuzzbench_measure /usr/local/bin/

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

@@ -0,0 +1,32 @@
+#! /bin/bash -eux
+# Copyright 2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# TODO(metzman): Make these configurable.
+export DB_PATH=$OUT/experiment.db
+export SNAPSHOT_PERIOD=30
+export EXPERIMENT_FILESTORE=$OUT/filestore
+export MAX_TOTAL_TIME=120
+export EXPERIMENT=oss-fuzz-on-demand
+
+rm -f $DB_PATH
+
+# FUZZER=mopt BENCHMARK=skcms
+
+export SQL_DATABASE_URL=sqlite:///$DB_PATH
+
+cd $FUZZBENCH_PATH
+PYTHONPATH=. python3 -B experiment/measurer/standalone.py $MAX_TOTAL_TIME

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

@@ -0,0 +1,41 @@
+#! /bin/bash -eux
+# Copyright 2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+export RUNNER_NICENESS="-5"
+export EXPERIMENT_FILESTORE=$OUT/filestore
+export EXPERIMENT=oss-fuzz-on-demand
+export OSS_FUZZ_ON_DEMAND=1
+export OUTPUT_CORPUS_DIR=/output-corpus
+export SEED_CORPUS_DIR=/input-corpus
+mkdir $SEED_CORPUS_DIR
+rm -rf $OUTPUT_CORPUS_DIR
+mkdir $OUTPUT_CORPUS_DIR
+export FUZZER=$FUZZING_ENGINE
+# TODO(metzman): Make this configurable.
+export MAX_TOTAL_TIME=120
+export SNAPSHOT_PERIOD=30
+export TRIAL_ID=1
+export FORCE_LOCAL=1
+
+# BENCHMARK, FUZZ_TARGET
+cd $OUT
+
+# Prevent permissions issues with pyc files and docker.
+cp -r $FUZZBENCH_PATH /tmp/fuzzbench
+
+PYTHONPATH=/tmp/fuzzbench nice -n $RUNNER_NICENESS python3 -B -u /tmp/fuzzbench/experiment/runner.py
+cat $EXPERIMENT_FILESTORE/$EXPERIMENT/experiment-folders/$BENCHMARK-$FUZZER/trial-$TRIAL_ID/results/fuzzer-log.txt

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2023 Google LLC
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *      http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+#include<stdlib.h>
+#include<signal.h>
+
+static void fixSignalHandler(int signum) {
+    struct sigaction new_action;
+    struct sigaction old_action;
+    sigemptyset (&new_action.sa_mask);
+    sigaction (signum, NULL, &old_action);
+    new_action.sa_flags = old_action.sa_flags | SA_ONSTACK;
+    new_action.sa_sigaction = old_action.sa_sigaction;
+    new_action.sa_handler = old_action.sa_handler;
+    sigaction (signum, &new_action, NULL);
+}
+
+static void FixStackSignalHandler() {
+    fixSignalHandler(SIGSEGV);
+    fixSignalHandler(SIGABRT);
+    fixSignalHandler(SIGALRM);
+    fixSignalHandler(SIGINT);
+    fixSignalHandler(SIGTERM);
+    fixSignalHandler(SIGBUS);
+    fixSignalHandler(SIGFPE);
+    fixSignalHandler(SIGXFSZ);
+    fixSignalHandler(SIGUSR1);
+    fixSignalHandler(SIGUSR2);
+}
+
+int LLVMFuzzerInitialize(int *argc, char ***argv) {
+    FixStackSignalHandler();
+    return 0;
+}

local-test-tika-delta-02/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-delta-02/fuzz-tooling/infra/base-images/base-builder-swift/precompile_swift

@@ -0,0 +1,33 @@
+#!/bin/bash -eu
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+cp /usr/local/bin/llvm-symbolizer-swift $OUT/llvm-symbolizer
+
+export SWIFTFLAGS="-Xswiftc -parse-as-library -Xswiftc -static-stdlib --static-swift-stdlib"
+if [ "$SANITIZER" = "coverage" ]
+then
+    export SWIFTFLAGS="$SWIFTFLAGS -Xswiftc -profile-generate -Xswiftc -profile-coverage-mapping -Xswiftc -sanitize=fuzzer"
+else
+    export SWIFTFLAGS="$SWIFTFLAGS -Xswiftc -sanitize=fuzzer,$SANITIZER --sanitize=$SANITIZER"
+    for f in $CFLAGS; do
+        export SWIFTFLAGS="$SWIFTFLAGS -Xcc=$f"
+    done
+
+    for f in $CXXFLAGS; do
+        export SWIFTFLAGS="$SWIFTFLAGS -Xcxx=$f"
+    done
+fi

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/.gitignore

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

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/redos.py

@@ -0,0 +1,84 @@
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Sanitizer for regular expression dos."""
+
+# pylint: disable=protected-access
+
+import time
+import os
+from pysecsan import sanlib
+
+START_RE_TIME = None
+
+
+# Hooks for regular expressions.
+# Main problem is to identify ReDOS attemps. This is a non-trivial task
+# - https://arxiv.org/pdf/1701.04045.pdf
+# - https://dl.acm.org/doi/pdf/10.1145/3236024.3236027
+# and the current approach we use is simply check for extensive computing time.
+# In essence, this is more of a refinement of traditional timeout checker from
+# the fuzzer, which, effectively will detect these types of attacks by way of
+# timeouts.
+#
+# Perhaps the smartest would be to use something like e.g.
+# https://github.com/doyensec/regexploit to scan the regex patterns.
+# Other heuristics without going too technical on identifying super-linear
+# regexes:
+# - check
+#   - if 'taint' exists in re.compile(xx)
+# - check
+#   - for backtracking possbility in PATTERN within re.comile(PATTERN)
+#   - and
+#   - 'taint' in findall(XX) calls.
+# pylint: disable=global-statement
+def hook_post_exec_re_pattern_findall(self, re_str):
+  """Hook post exeution re.compile().findall()."""
+  _ = self  # Satisfy lint
+  global START_RE_TIME
+  try:
+    endtime = time.time() - START_RE_TIME
+    if endtime > 4:
+      sanlib.abort_with_issue(f'Potential ReDOS attack.\n {re_str}', 'ReDOS')
+  except NameError:
+    sanlib.sanitizer_log(
+        'starttime is not set, which it should have. Error in PySecSan',
+        sanlib.LOG_INFO)
+    os._exit(1)
+
+
+def hook_pre_exec_re_pattern_findall(self, string):
+  """Hook pre execution of re.pattern().findall()."""
+  _ = (self, string)  # Satisfy lint
+  global START_RE_TIME
+  START_RE_TIME = time.time()
+
+
+def hook_post_exec_re_compile(retval, pattern, flags=None):
+  """Hook for re.compile post execution to hook returned objects functions."""
+  _ = (pattern, flags)  # Satisfy lint
+  sanlib.sanitizer_log('Inside of post compile hook', sanlib.LOG_DEBUG)
+  wrapper_object = sanlib.create_object_wrapper(
+      findall=(hook_pre_exec_re_pattern_findall,
+               hook_post_exec_re_pattern_findall))
+  hooked_object = wrapper_object(retval)
+  return hooked_object
+
+
+def hook_pre_exec_re_compile(pattern, flags=None):
+  """Check if tainted input exists in pattern. If so, likely chance of making
+    ReDOS possible."""
+  _ = (pattern, flags)  # Satisfy lint
+  sanlib.sanitizer_log('Inside re compile hook', sanlib.LOG_DEBUG)

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/README.md

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

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/eval_command_injection.py

@@ -0,0 +1,52 @@
+#!/usr/bin/python3
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Fuzzer targetting command injection of eval."""
+# pylint: disable=eval-used
+
+import sys
+import atheris
+import pysecsan
+
+pysecsan.add_hooks()
+
+
+def list_files_perhaps(param, magicval):
+  """Pass fuzzer data into eval."""
+  if len(param) < 3:
+    return
+  if magicval == 1337:
+    try:
+      eval("FROMFUZZ")
+    except ValueError:
+      pass
+
+
+def test_one_input(data):
+  """Fuzzer entrypoint."""
+  fdp = atheris.FuzzedDataProvider(data)
+  list_files_perhaps(fdp.ConsumeUnicodeNoSurrogates(24),
+                     fdp.ConsumeIntInRange(500, 1500))
+
+
+def main():
+  """Set up and start fuzzing."""
+
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/ansible-runner-cve-2021-4041/build.sh

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

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/ansible-runner-cve-2021-4041/fuzz_ansible_runner.py

@@ -0,0 +1,64 @@
+#!/usr/bin/python3
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Targets: https://github.com/advisories/GHSA-6j58-grhv-2769."""
+
+import sys
+import atheris
+import pexpect
+import pysecsan
+import ansible_runner
+from ansible_runner.config.runner import RunnerConfig
+
+pysecsan.add_hooks()
+
+
+def test_one_input(data):
+  """Fuzzer entrypoint."""
+  fdp = atheris.FuzzedDataProvider(data)
+
+  conf = RunnerConfig('/tmp/')
+  conf.suppress_ansible_output = True
+  conf.expect_passwords = {pexpect.TIMEOUT: None, pexpect.EOF: None}
+  conf.cwd = str('/tmp/')
+  conf.env = {}
+  conf.job_timeout = 10
+  conf.idle_timeout = 0
+  conf.pexpect_timeout = 2.
+  conf.pexpect_use_poll = True
+  conf.command = 'from_fuzzer'
+
+  runner = ansible_runner.Runner(conf)
+  runner.resource_profiling = True
+  # rc.resource_profiling_base_cgroup = "; exec-san"
+  assistance = True
+  if assistance and fdp.ConsumeIntInRange(1, 100) > 80:
+    conf.resource_profiling_base_cgroup = 'FROMFUZZ'
+  else:
+    conf.resource_profiling_base_cgroup = fdp.ConsumeUnicodeNoSurrogates(24)
+  try:
+    runner.run()
+  except (RuntimeError, ValueError, TypeError) as _:
+    pass
+
+
+def main():
+  """Set up and start fuzzing."""
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/libvcs-cve-2022-21187/build.sh

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

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/libvcs-cve-2022-21187/fuzz_libvcs.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python3
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Targets https://github.com/advisories/GHSA-mv2w-4jqc-6fg4."""
+
+import sys
+import atheris
+import pysecsan
+from libvcs.shortcuts import create_repo
+
+pysecsan.add_hooks()
+
+
+def test_one_input(data):
+  """Target code injection in libvcs."""
+  fdp = atheris.FuzzedDataProvider(data)
+  mercurial_repo = create_repo(url=fdp.ConsumeUnicodeNoSurrogates(128),
+                               vcs='hg',
+                               repo_dir='./')
+  try:
+    mercurial_repo.update_repo()
+  except (ValueError, FileNotFoundError) as exception:
+    _ = exception  # Satisfy lint
+
+
+def main():
+  """Set up and start fuzzing."""
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/python-ldap-GHSL-2021-117/build.sh

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

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/python-ldap-GHSL-2021-117/fuzz_ldap.py

@@ -0,0 +1,42 @@
+#!/usr/bin/python3
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Targets: https://github.com/python-ldap/python-ldap/security/advisories/GHSA-r8wq-qrxc-hmcm"""  # pylint: disable=line-too-long
+
+import sys
+import atheris
+import pysecsan
+import ldap.schema
+
+pysecsan.add_hooks()
+
+
+def test_one_input(data):
+  """Fuzzer targetting regex dos in ldap."""
+  fdp = atheris.FuzzedDataProvider(data)
+  try:
+    ldap.schema.split_tokens(fdp.ConsumeUnicodeNoSurrogates(1024))
+  except ValueError:
+    pass
+
+
+def main():
+  """Set up and start fuzzing."""
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/pytorch-lightning-1.5.10/fuzz_pytorch_lightning.py

@@ -0,0 +1,67 @@
+#!/usr/local/bin/python3
+#
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Exploit pytorch lightning with fuzzer's input as a random env variable.
+This PoC is extended from a report in GitHub Advisory Database:
+https://github.com/advisories/GHSA-r5qj-cvf9-p85h
+The original report documents an exploit using a specific environment variable,
+we show a way to achieve the same exploit with an arbitrary env variable.
+"""
+
+import os
+import sys
+import atheris
+import pysecsan
+
+pysecsan.add_hooks()
+
+with atheris.instrument_imports():
+  from pytorch_lightning import Trainer
+  from pytorch_lightning.utilities.argparse import parse_env_variables
+
+
+def prepare_fuzzing_input(data):
+  """Prepare the data needed by the exploit with input data from fuzzers."""
+  data = data.replace(b'\0', b'')
+  env_name = 'AN_ARBITRARY_ENV_NAME'
+  return data, env_name
+
+
+def exploit_target(env_value, env_name):
+  """This target is based on a snippet from the official documentation of
+  `parse_env_variables`:
+  https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.utilities.argparse.html  # pylint: disable=line-too-long
+  It might not be the most realistic example,
+  but serves as a PoC to show that SystemSan works for Python."""
+  os.environb[env_name.encode()] = env_value
+  parse_env_variables(Trainer, template=env_name)
+
+
+def TestOneInput(data):  # pylint: disable=invalid-name
+  """Exploit the target only with input data from fuzzers."""
+  env_value, env_name = prepare_fuzzing_input(data)
+  exploit_target(env_value, env_name)
+
+
+def main():
+  """Fuzz target with atheris."""
+  atheris.Setup(sys.argv, TestOneInput)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/subprocess_popen_injection.py

@@ -0,0 +1,51 @@
+#!/usr/bin/python3
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Fuzzer displaying insecure use of subprocess.Popen."""
+
+import sys
+import subprocess
+import atheris
+import pysecsan
+
+
+def list_files_perhaps(param):
+  """Insecure call to Popen."""
+  try:
+    subprocess.Popen(' '.join(['ls', '-la', param]), shell=True)
+  except ValueError:
+    pass
+
+
+def test_one_input(data):
+  """Fuzzer entrypoint."""
+  fdp = atheris.FuzzedDataProvider(data)
+
+  if fdp.ConsumeIntInRange(1, 10) == 5:
+    list_files_perhaps('FROMFUZZ')
+  else:
+    list_files_perhaps('.')
+
+
+def main():
+  """Set up and start fuzzing."""
+  pysecsan.add_hooks()
+
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-runner/gocoverage/convertcorpus/go.mod

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

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-runner/gocoverage/convertcorpus/go.sum

@@ -0,0 +1,24 @@
+github.com/AdaLogics/go-fuzz-headers v0.0.0-20220824214621-3c06a36a6952 h1:cs1LC1MGKD1O4neR89Rc24t0u15Vs5ASfUQ2tLr/KbY=
+github.com/AdaLogics/go-fuzz-headers v0.0.0-20220824214621-3c06a36a6952/go.mod h1:i9fr2JpcEcY/IHEvzCM3qXUZYOQHgR89dt4es1CgMhc=
+github.com/AdamKorcz/go-118-fuzz-build v0.0.0-20221110144148-3ffc89b74f84 h1:a0NR83n+t4XyUh32ifxu6XsmeLMKyOx5Lxub9IeBM7k=
+github.com/AdamKorcz/go-118-fuzz-build v0.0.0-20221110144148-3ffc89b74f84/go.mod h1:pXIs8t4wo19ehhsffZsAZxSQ+oPUF41iiDrUaIDWKFU=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/cyphar/filepath-securejoin v0.2.3 h1:YX6ebbZCZP7VkM3scTTokDgBL2TY741X51MTk3ycuNI=
+github.com/cyphar/filepath-securejoin v0.2.3/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-runner/gocoverage/convertcorpus/main.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+
+	"github.com/AdamKorcz/go-118-fuzz-build/coverage"
+)
+
+// reads all corpus files in a directory and converts
+// them from libFuzzer format to native Go format.
+func main() {
+	if len(os.Args) != 3 {
+		fmt.Println(os.Args)
+		log.Fatalf("need exactly two argument")
+	}
+	FUZZERNAME := os.Args[1]
+	CORPUS_PATH := os.Args[2]
+
+	filepath.Walk(CORPUS_PATH, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil
+		}
+		if !info.Mode().IsRegular() {
+			return nil
+		}
+		libFuzzerSeed, err := os.ReadFile(path)
+		if err != nil {
+			panic(err)
+		}
+		out := os.Getenv("OUT")
+		fuzzerContents, err := os.ReadFile(filepath.Join(out, "rawfuzzers", FUZZERNAME))
+		if err != nil {
+			panic(err)
+		}
+		goSeed := coverage.ConvertLibfuzzerSeedToGoSeed(fuzzerContents, libFuzzerSeed, FUZZERNAME)
+		err = os.Remove(path)
+		if err != nil {
+			panic(err)
+		}
+		f, err := os.Create(path)
+		if err != nil {
+			panic(err)
+		}
+		defer f.Close()
+		_, err = f.Write([]byte(goSeed))
+		if err != nil {
+			panic(err)
+		}
+		return nil
+	})
+}

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-runner/gocoverage/go.mod

@@ -0,0 +1,8 @@
+module oss-fuzz.com/gocoverage
+
+go 1.14
+
+require (
+	github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5
+	golang.org/x/tools v0.1.0
+)

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-runner/gocoverage/gocovmerge/LICENSE

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

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-runner/gocoverage/gocovmerge/gocovmerge.go

@@ -0,0 +1,111 @@
+// gocovmerge takes the results from multiple `go test -coverprofile` runs and
+// merges them into one profile
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"sort"
+
+	"golang.org/x/tools/cover"
+)
+
+func mergeProfiles(p *cover.Profile, merge *cover.Profile) {
+	if p.Mode != merge.Mode {
+		log.Fatalf("cannot merge profiles with different modes")
+	}
+	// Since the blocks are sorted, we can keep track of where the last block
+	// was inserted and only look at the blocks after that as targets for merge
+	startIndex := 0
+	for _, b := range merge.Blocks {
+		startIndex = mergeProfileBlock(p, b, startIndex)
+	}
+}
+
+func mergeProfileBlock(p *cover.Profile, pb cover.ProfileBlock, startIndex int) int {
+	sortFunc := func(i int) bool {
+		pi := p.Blocks[i+startIndex]
+		return pi.StartLine >= pb.StartLine && (pi.StartLine != pb.StartLine || pi.StartCol >= pb.StartCol)
+	}
+
+	i := 0
+	if sortFunc(i) != true {
+		i = sort.Search(len(p.Blocks)-startIndex, sortFunc)
+	}
+	i += startIndex
+	if i < len(p.Blocks) && p.Blocks[i].StartLine == pb.StartLine && p.Blocks[i].StartCol == pb.StartCol {
+		if p.Blocks[i].EndLine != pb.EndLine || p.Blocks[i].EndCol != pb.EndCol {
+			log.Fatalf("OVERLAP MERGE: %v %v %v", p.FileName, p.Blocks[i], pb)
+		}
+		switch p.Mode {
+		case "set":
+			p.Blocks[i].Count |= pb.Count
+		case "count", "atomic":
+			p.Blocks[i].Count += pb.Count
+		default:
+			log.Fatalf("unsupported covermode: '%s'", p.Mode)
+		}
+	} else {
+		if i > 0 {
+			pa := p.Blocks[i-1]
+			if pa.EndLine >= pb.EndLine && (pa.EndLine != pb.EndLine || pa.EndCol > pb.EndCol) {
+				log.Fatalf("OVERLAP BEFORE: %v %v %v", p.FileName, pa, pb)
+			}
+		}
+		if i < len(p.Blocks)-1 {
+			pa := p.Blocks[i+1]
+			if pa.StartLine <= pb.StartLine && (pa.StartLine != pb.StartLine || pa.StartCol < pb.StartCol) {
+				log.Fatalf("OVERLAP AFTER: %v %v %v", p.FileName, pa, pb)
+			}
+		}
+		p.Blocks = append(p.Blocks, cover.ProfileBlock{})
+		copy(p.Blocks[i+1:], p.Blocks[i:])
+		p.Blocks[i] = pb
+	}
+	return i + 1
+}
+
+func addProfile(profiles []*cover.Profile, p *cover.Profile) []*cover.Profile {
+	i := sort.Search(len(profiles), func(i int) bool { return profiles[i].FileName >= p.FileName })
+	if i < len(profiles) && profiles[i].FileName == p.FileName {
+		mergeProfiles(profiles[i], p)
+	} else {
+		profiles = append(profiles, nil)
+		copy(profiles[i+1:], profiles[i:])
+		profiles[i] = p
+	}
+	return profiles
+}
+
+func dumpProfiles(profiles []*cover.Profile, out io.Writer) {
+	if len(profiles) == 0 {
+		return
+	}
+	fmt.Fprintf(out, "mode: %s\n", profiles[0].Mode)
+	for _, p := range profiles {
+		for _, b := range p.Blocks {
+			fmt.Fprintf(out, "%s:%d.%d,%d.%d %d %d\n", p.FileName, b.StartLine, b.StartCol, b.EndLine, b.EndCol, b.NumStmt, b.Count)
+		}
+	}
+}
+
+func main() {
+	flag.Parse()
+
+	var merged []*cover.Profile
+
+	for _, file := range flag.Args() {
+		profiles, err := cover.ParseProfiles(file)
+		if err != nil {
+			log.Fatalf("failed to parse profiles: %v", err)
+		}
+		for _, p := range profiles {
+			merged = addProfile(merged, p)
+		}
+	}
+
+	dumpProfiles(merged, os.Stdout)
+}

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-runner/gocoverage/gocovsum/gocovsum.go

@@ -0,0 +1,171 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+
+	"go/ast"
+	"go/parser"
+	"go/token"
+
+	"golang.org/x/tools/cover"
+)
+
+type CoverageTotal struct {
+	Count     int     `json:"count"`
+	Covered   int     `json:"covered"`
+	Uncovered int     `json:"notcovered"`
+	Percent   float64 `json:"percent"`
+}
+
+type CoverageTotals struct {
+	Functions      CoverageTotal `json:"functions,omitempty"`
+	Lines          CoverageTotal `json:"lines,omitempty"`
+	Regions        CoverageTotal `json:"regions,omitempty"`
+	Instantiations CoverageTotal `json:"instantiations,omitempty"`
+	Branches       CoverageTotal `json:"branches,omitempty"`
+}
+
+type CoverageFile struct {
+	Summary  CoverageTotals `json:"summary,omitempty"`
+	Filename string         `json:"filename,omitempty"`
+}
+
+type CoverageData struct {
+	Totals CoverageTotals `json:"totals,omitempty"`
+	Files  []CoverageFile `json:"files,omitempty"`
+}
+
+type PositionInterval struct {
+	start token.Position
+	end   token.Position
+}
+
+type CoverageSummary struct {
+	Data    []CoverageData `json:"data,omitempty"`
+	Type    string         `json:"type,omitempty"`
+	Version string         `json:"version,omitempty"`
+}
+
+func isFunctionCovered(s token.Position, e token.Position, blocks []cover.ProfileBlock) bool {
+	for _, b := range blocks {
+		if b.StartLine >= s.Line && b.StartLine <= e.Line && b.EndLine >= s.Line && b.EndLine <= e.Line {
+			if b.Count > 0 {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func computePercent(s *CoverageTotals) {
+	if s.Regions.Count > 0 {
+		s.Regions.Percent = float64(100*s.Regions.Covered) / float64(s.Regions.Count)
+	}
+	if s.Lines.Count > 0 {
+		s.Lines.Percent = float64(100*s.Lines.Covered) / float64(s.Lines.Count)
+	}
+	if s.Functions.Count > 0 {
+		s.Functions.Percent = float64(100*s.Functions.Covered) / float64(s.Functions.Count)
+	}
+}
+
+func main() {
+	flag.Parse()
+
+	if len(flag.Args()) != 1 {
+		log.Fatalf("needs exactly one argument")
+	}
+	profiles, err := cover.ParseProfiles(flag.Args()[0])
+	if err != nil {
+		log.Fatalf("failed to parse profiles: %v", err)
+	}
+	r := CoverageSummary{}
+	r.Type = "oss-fuzz.go.coverage.json.export"
+	r.Version = "2.0.1"
+	r.Data = make([]CoverageData, 1)
+	for _, p := range profiles {
+		fset := token.NewFileSet() // positions are relative to fset
+		f, err := parser.ParseFile(fset, p.FileName, nil, 0)
+		if err != nil {
+			log.Printf("failed to parse go file: %v", err)
+			continue
+		}
+		fileCov := CoverageFile{}
+		fileCov.Filename = p.FileName
+		ast.Inspect(f, func(n ast.Node) bool {
+			switch x := n.(type) {
+			case *ast.FuncLit:
+				startf := fset.Position(x.Pos())
+				endf := fset.Position(x.End())
+				fileCov.Summary.Functions.Count++
+				if isFunctionCovered(startf, endf, p.Blocks) {
+					fileCov.Summary.Functions.Covered++
+				} else {
+					fileCov.Summary.Functions.Uncovered++
+				}
+			case *ast.FuncDecl:
+				startf := fset.Position(x.Pos())
+				endf := fset.Position(x.End())
+				fileCov.Summary.Functions.Count++
+				if isFunctionCovered(startf, endf, p.Blocks) {
+					fileCov.Summary.Functions.Covered++
+				} else {
+					fileCov.Summary.Functions.Uncovered++
+				}
+			}
+			return true
+		})
+
+		for _, b := range p.Blocks {
+			fileCov.Summary.Regions.Count++
+			if b.Count > 0 {
+				fileCov.Summary.Regions.Covered++
+			} else {
+				fileCov.Summary.Regions.Uncovered++
+			}
+
+			fileCov.Summary.Lines.Count += b.NumStmt
+			if b.Count > 0 {
+				fileCov.Summary.Lines.Covered += b.NumStmt
+			} else {
+				fileCov.Summary.Lines.Uncovered += b.NumStmt
+			}
+		}
+		r.Data[0].Totals.Regions.Count += fileCov.Summary.Regions.Count
+		r.Data[0].Totals.Regions.Covered += fileCov.Summary.Regions.Covered
+		r.Data[0].Totals.Regions.Uncovered += fileCov.Summary.Regions.Uncovered
+		r.Data[0].Totals.Lines.Count += fileCov.Summary.Lines.Count
+		r.Data[0].Totals.Lines.Covered += fileCov.Summary.Lines.Covered
+		r.Data[0].Totals.Lines.Uncovered += fileCov.Summary.Lines.Uncovered
+		r.Data[0].Totals.Functions.Count += fileCov.Summary.Functions.Count
+		r.Data[0].Totals.Functions.Covered += fileCov.Summary.Functions.Covered
+		r.Data[0].Totals.Functions.Uncovered += fileCov.Summary.Functions.Uncovered
+
+		computePercent(&fileCov.Summary)
+		r.Data[0].Files = append(r.Data[0].Files, fileCov)
+	}
+
+	computePercent(&r.Data[0].Totals)
+	o, err := json.Marshal(r)
+	if err != nil {
+		log.Fatalf("failed to generate json: %v", err)
+	}
+	fmt.Printf(string(o))
+}

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-runner/gocoverage/pprof-merge/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

local-test-tika-delta-02/fuzz-tooling/infra/base-images/base-runner/gocoverage/pprof-merge/main.go

@@ -0,0 +1,68 @@
+// Copyright 2019 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"flag"
+	"log"
+	"os"
+
+	"github.com/google/pprof/profile"
+)
+
+var (
+	output string
+)
+
+func main() {
+	flag.StringVar(&output, "o", "merged.data", "")
+	flag.Parse()
+
+	files := os.Args[1:]
+	if len(files) == 0 {
+		log.Fatal("Give profiles files as arguments")
+	}
+
+	var profiles []*profile.Profile
+	for _, fname := range files {
+		f, err := os.Open(fname)
+		if err != nil {
+			log.Fatalf("Cannot open profile file at %q: %v", fname, err)
+		}
+		p, err := profile.Parse(f)
+		if err != nil {
+			log.Fatalf("Cannot parse profile at %q: %v", fname, err)
+		}
+		profiles = append(profiles, p)
+	}
+
+	merged, err := profile.Merge(profiles)
+	if err != nil {
+		log.Fatalf("Cannot merge profiles: %v", err)
+	}
+
+	out, err := os.OpenFile(output, os.O_RDWR|os.O_CREATE, 0755)
+	if err != nil {
+		log.Fatalf("Cannot open output to write: %v", err)
+	}
+
+	if err := merged.Write(out); err != nil {
+		log.Fatalf("Cannot write merged profile to file: %v", err)
+	}
+
+	if err := out.Close(); err != nil {
+		log.Printf("Error when closing the output file: %v", err)
+	}
+}

local-test-tika-delta-02/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-delta-02/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-delta-02/fuzz-tooling/infra/cifuzz/filestore/filesystem/__init__.py

@@ -0,0 +1,107 @@
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Filestore implementation using a filesystem directory."""
+import logging
+import os
+import shutil
+import subprocess
+import sys
+
+from distutils import dir_util
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(
+    os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir,
+                 os.pardir, os.pardir))
+import filestore
+
+
+def recursive_list_dir(directory):
+  """Returns list of all files in |directory|, including those in
+  subdirectories."""
+  files = []
+  for root, _, filenames in os.walk(directory):
+    for filename in filenames:
+      files.append(os.path.join(root, filename))
+  return files
+
+
+class FilesystemFilestore(filestore.BaseFilestore):
+  """Filesystem implementation using a filesystem directory."""
+  BUILD_DIR = 'build'
+  CRASHES_DIR = 'crashes'
+  CORPUS_DIR = 'corpus'
+  COVERAGE_DIR = 'coverage'
+
+  def __init__(self, config):
+    super().__init__(config)
+    self._filestore_root_dir = self.config.platform_conf.filestore_root_dir
+
+  def _get_filestore_path(self, name, prefix_dir):
+    """Returns the filesystem path in the filestore for |name| and
+    |prefix_dir|."""
+    return os.path.join(self._filestore_root_dir, prefix_dir, name)
+
+  def _upload_directory(self, name, directory, prefix, delete=False):
+    filestore_path = self._get_filestore_path(name, prefix)
+    if os.path.exists(filestore_path):
+      initial_files = set(recursive_list_dir(filestore_path))
+    else:
+      initial_files = set()
+
+    # Make directory and any parents.
+    os.makedirs(filestore_path, exist_ok=True)
+    copied_files = set(dir_util.copy_tree(directory, filestore_path))
+    if not delete:
+      return True
+
+    files_to_delete = initial_files - copied_files
+    for file_path in files_to_delete:
+      os.remove(file_path)
+    return True
+
+  def _download_directory(self, name, dst_directory, prefix):
+    filestore_path = self._get_filestore_path(name, prefix)
+    return dir_util.copy_tree(filestore_path, dst_directory)
+
+  def upload_crashes(self, name, directory):
+    """Uploads the crashes at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.CRASHES_DIR)
+
+  def upload_corpus(self, name, directory, replace=False):
+    """Uploads the crashes at |directory| to |name|."""
+    return self._upload_directory(name,
+                                  directory,
+                                  self.CORPUS_DIR,
+                                  delete=replace)
+
+  def upload_build(self, name, directory):
+    """Uploads the build located at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.BUILD_DIR)
+
+  def upload_coverage(self, name, directory):
+    """Uploads the coverage report at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.COVERAGE_DIR)
+
+  def download_corpus(self, name, dst_directory):
+    """Downloads the corpus located at |name| to |dst_directory|."""
+    return self._download_directory(name, dst_directory, self.CORPUS_DIR)
+
+  def download_build(self, name, dst_directory):
+    """Downloads the build with |name| to |dst_directory|."""
+    return self._download_directory(name, dst_directory, self.BUILD_DIR)
+
+  def download_coverage(self, name, dst_directory):
+    """Downloads the latest project coverage report."""
+    return self._download_directory(name, dst_directory, self.COVERAGE_DIR)

local-test-tika-delta-02/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-delta-02/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-delta-02/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-delta-02/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-delta-02/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-delta-02/fuzz-tooling/infra/cifuzz/platform_config/platform_config_test.py

@@ -0,0 +1,82 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for platform_config."""
+import os
+import unittest
+
+import platform_config
+import test_helpers
+
+
+class GetProjectRepoOwnerAndNameTest(unittest.TestCase):
+  """Tests for get_project_repo_owner and get_project_repo_name."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+    self.repo_owner = 'repo-owner'
+    self.repo_name = 'repo-name'
+    self.env = platform_config.BasePlatformConfig()
+
+  def test_unset_repository(self):
+    """Tests that the correct result is returned when repository is not set."""
+    self.assertIsNone(self.env.project_repo_name)
+
+  def test_owner(self):
+    """Tests that the correct result is returned for owner."""
+    self.assertIsNone(self.env.project_repo_owner)
+
+  def test_empty_repository(self):
+    """Tests that the correct result is returned when repository is an empty
+    string."""
+    os.environ['REPOSITORY'] = ''
+    self.assertEqual(self.env.project_repo_name, '')
+
+  def test_repository(self):
+    """Tests that the correct result is returned when repository contains the
+    just the repo name (as it does outside of GitHub)."""
+    os.environ['REPOSITORY'] = self.repo_name
+    self.assertEqual(self.env.project_repo_name, self.repo_name)
+
+
+class ProjectSrcPathTest(unittest.TestCase):
+  """Tests for project_src_path."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+
+  def test_not_github(self):
+    """Tests that project_src_path returns the correct result not on
+    GitHub."""
+    project_src_path = 'project-src'
+    os.environ['PROJECT_SRC_PATH'] = project_src_path
+    generic_ci_env = platform_config.BasePlatformConfig()
+    self.assertEqual(generic_ci_env.project_src_path, project_src_path)
+
+
+class GetGitUrlTest(unittest.TestCase):
+  """Tests for BasePlatformConfig.git_url."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+    self.env = platform_config.BasePlatformConfig()
+
+  def test_unset_repository(self):
+    """Tests that the correct result is returned when repository is not set."""
+    self.assertEqual(self.env.git_url, None)
+
+  def test_repository(self):
+    """Tests that the correct result is returned when GITHUB_REPOSITORY is
+    set."""
+    os.environ['GITHUB_REPOSITORY'] = 'repo/owner'
+    self.assertIsNone(self.env.git_url)

local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/example_crash_fuzzer_bug_summary.txt

@@ -0,0 +1,68 @@
+AddressSanitizer: heap-buffer-overflow on address 0x62500001b530 at pc 0x00000052138a bp 0x7ffe62db2c10 sp 0x7ffe62db23d8
+READ of size 52 at 0x62500001b530 thread T0
+SCARINESS: 26 (multi-byte-read-heap-buffer-overflow)
+    #0 0x521389 in __asan_memcpy /src/llvm-project/compiler-rt/lib/asan/asan_interceptors_memintrinsics.cpp:22:3
+    #1 0x567590 in yr_object_set_string /src/yara/libyara/object.c:1122:5
+    #2 0x5afced in dex_parse /src/yara/libyara/modules/dex/dex.c:781:5
+    #3 0x5b4a8b in dex__load /src/yara/libyara/modules/dex/dex.c:1218:7
+    #4 0x56537c in yr_modules_load /src/yara/libyara/modules.c:179:16
+    #5 0x5d6583 in yr_execute_code /src/yara/libyara/exec.c:1276:18
+    #6 0x56f5c0 in yr_scanner_scan_mem_blocks /src/yara/libyara/scanner.c:444:3
+    #7 0x56bf23 in yr_rules_scan_mem_blocks /src/yara/libyara/rules.c:235:12
+    #8 0x56c182 in yr_rules_scan_mem /src/yara/libyara/rules.c:285:10
+    #9 0x5548d2 in LLVMFuzzerTestOneInput /src/yara/tests/oss-fuzz/dex_fuzzer.cc:40:3
+    #10 0x45a3b1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:556:15
+    #11 0x459ad5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:470:3
+    #12 0x45be77 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:698:19
+    #13 0x45cc05 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:830:5
+    #14 0x44ac88 in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:824:6
+    #15 0x474ab2 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:19:10
+    #16 0x7f4409b7a82f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2082f)
+    #17 0x41e348 in _start (out/dex_fuzzer+0x41e348)
+
+0x62500001b530 is located 0 bytes to the right of 9264-byte region [0x625000019100,0x62500001b530)
+allocated by thread T0 here:
+    #0 0x521f4d in malloc /src/llvm-project/compiler-rt/lib/asan/asan_malloc_linux.cpp:145:3
+    #1 0x4331b7 in operator new(unsigned long) (out/dex_fuzzer+0x4331b7)
+    #2 0x459ad5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:470:3
+    #3 0x45be77 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:698:19
+    #4 0x45cc05 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:830:5
+    #5 0x44ac88 in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:824:6
+    #6 0x474ab2 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:19:10
+    #7 0x7f4409b7a82f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2082f)
+
+SUMMARY: AddressSanitizer: heap-buffer-overflow /src/llvm-project/compiler-rt/lib/asan/asan_interceptors_memintrinsics.cpp:22:3 in __asan_memcpy
+Shadow bytes around the buggy address:
+  0x0c4a7fffb650: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x0c4a7fffb660: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x0c4a7fffb670: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x0c4a7fffb680: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x0c4a7fffb690: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+=>0x0c4a7fffb6a0: 00 00 00 00 00 00[fa]fa fa fa fa fa fa fa fa fa
+  0x0c4a7fffb6b0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c4a7fffb6c0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c4a7fffb6d0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c4a7fffb6e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c4a7fffb6f0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+
+Shadow byte legend (one shadow byte represents 8 application bytes):
+  Addressable:           00
+  Partially addressable: 01 02 03 04 05 06 07
+  Heap left redzone:       fa
+  Freed heap region:       fd
+  Stack left redzone:      f1
+  Stack mid redzone:       f2
+  Stack right redzone:     f3
+  Stack after return:      f5
+  Stack use after scope:   f8
+  Global redzone:          f9
+  Global init order:       f6
+  Poisoned by user:        f7
+  Container overflow:      fc
+  Array cookie:            ac
+  Intra object redzone:    bb
+  ASan internal:           fe
+  Left alloca redzone:     ca
+  Right alloca redzone:    cb
+  Shadow gap:              cc
+==12==ABORTING

local-test-tika-delta-02/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-delta-02/fuzz-tooling/infra/cifuzz/test_data/external-project/Makefile

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

local-test-tika-delta-02/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-delta-02/fuzz-tooling/infra/cifuzz/test_data/external-project/my_api.cpp

@@ -0,0 +1,36 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Implementation of "my_api".
+#include "my_api.h"
+
+#include <vector>
+
+// Do some computations with 'str', return the result.
+// This function contains a bug. Can you spot it?
+size_t DoStuff(const std::string &str) {
+  std::vector<int> Vec({0, 1, 2, 3, 4});
+  size_t Idx = 0;
+  if (str.size() > 5)
+    Idx++;
+  if (str.find("foo") != std::string::npos)
+    Idx++;
+  if (str.find("bar") != std::string::npos)
+    Idx++;
+  if (str.find("ouch") != std::string::npos)
+    Idx++;
+  if (str.find("omg") != std::string::npos)
+    Idx++;
+  return Vec[Idx];
+}

local-test-tika-delta-02/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-delta-02/fuzz-tooling/infra/cifuzz/test_data/external-project/standalone_fuzz_target_runner.cpp

@@ -0,0 +1,47 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Example of a standalone runner for "fuzz targets".
+// It reads all files passed as parameters and feeds their contents
+// one by one into the fuzz target (LLVMFuzzerTestOneInput).
+// This runner does not do any fuzzing, but allows us to run the fuzz target
+// on the test corpus (e.g. "do_stuff_test_data") or on a single file,
+// e.g. the one that comes from a bug report.
+
+#include <cassert>
+#include <iostream>
+#include <fstream>
+#include <vector>
+
+// Forward declare the "fuzz target" interface.
+// We deliberately keep this inteface simple and header-free.
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
+
+int main(int argc, char **argv) {
+  for (int i = 1; i < argc; i++) {
+    std::ifstream in(argv[i]);
+    in.seekg(0, in.end);
+    size_t length = in.tellg();
+    in.seekg (0, in.beg);
+    std::cout << "Reading " << length << " bytes from " << argv[i] << std::endl;
+    // Allocate exactly length bytes so that we reliably catch buffer overflows.
+    std::vector<char> bytes(length);
+    in.read(bytes.data(), bytes.size());
+    assert(in);
+    LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()),
+                           bytes.size());
+    std::cout << "Execution successful" << std::endl;
+  }
+  return 0;
+}

local-test-tika-delta-02/fuzz-tooling/infra/cifuzz/test_data/sarif_utils_only_llvmfuzzer_stack.txt

@@ -0,0 +1,302 @@
+/github/workspace/build-out/fuzz-bus-label -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpsngf52cy/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-bus-label >fuzz-0.log 2>&1
+================== Job 0 exited with exit code 0 ============
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 2 modules   (82577 inline 8-bit counters): 82573 [0x7fc55e6bedf0, 0x7fc55e6d307d), 4 [0x5e9c28, 0x5e9c2c), 
+2023-05-04 01:02:55,065 - root - INFO - Not reporting crash in fuzz-bus-label because process timed out.
+2023-05-04 01:02:55,069 - root - INFO - Deleting corpus and seed corpus of fuzz-bus-label to save disk.
+INFO: Loaded 2 PC tables (82577 PCs): 82573 [0x7fc55e6d3080,0x7fc55e815950), 4 [0x5a6c78,0x5a6cb8), 
+INFO:      256 files found in /github/workspace/cifuzz-corpus/fuzz-bus-label
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 1048576 bytes
+INFO: seed corpus: files: 256 min: 1b max: 5242880b total: 30968483b rss: 48Mb
+#257	INITED cov: 41 ft: 230 corp: 111/4360b exec/s: 0 rss: 73Mb
+#131072	pulse  cov: 41 ft: 230 corp: 111/4360b lim: 1048576 exec/s: 43690 rss: 76Mb
+#262144	pulse  cov: 41 ft: 230 corp: 111/4360b lim: 1048576 exec/s: 43690 rss: 76Mb
+#524288	pulse  cov: 41 ft: 230 corp: 111/4360b lim: 1048576 exec/s: 43690 rss: 77Mb
+#609082	DONE   cov: 41 ft: 230 corp: 111/4360b lim: 1048576 exec/s: 43505 rss: 77Mb
+Done 609082 runs in 14 second(s)
+stat::number_of_executed_units: 609082
+stat::average_exec_per_sec:     43505
+stat::new_units_added:          0
+stat::slowest_unit_time_sec:    0
+stat::peak_rss_mb:              77
+/github/workspace/build-out/fuzz-bus-label -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpsngf52cy/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-bus-label >fuzz-1.log 2>&1
+2023-05-04 01:02:55,082 - root - INFO - Deleting fuzz target: fuzz-bus-label.
+2023-05-04 01:02:55,083 - root - INFO - Done deleting.
+2023-05-04 01:02:55,084 - root - INFO - Fuzzer fuzz-bus-label finished running without reportable crashes.
+2023-05-04 01:02:55,084 - root - INFO - Running fuzzer: fuzz-dhcp-server.
+2023-05-04 01:02:55,085 - root - INFO - Downloading corpus from OSS-Fuzz: https://storage.googleapis.com/systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-dhcp-server/public.zip
+2023-05-04 01:02:55,088 - urllib3.connectionpool - DEBUG - Starting new HTTPS connection (1): storage.googleapis.com:443
+2023-05-04 01:02:55,145 - urllib3.connectionpool - DEBUG - https://storage.googleapis.com:443 "GET /systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-dhcp-server/public.zip HTTP/1.1" 200 806749
+2023-05-04 01:02:55,350 - root - INFO - Starting fuzzing
+Fuzzing logs:
+/github/workspace/build-out/fuzz-dhcp-server -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpyxgwwsvr/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-dhcp-server >fuzz-0.log 2>&1
+================== Job 0 exited with exit code 0 ============
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 2 modules   (83640 inline 8-bit counters): 82573 [0x7fe86ff70df0, 0x7fe86ff8507d), 1067 [0x60c638, 0x60ca63), 
+INFO: Loaded 2 PC tables (83640 PCs): 82573 [0x7fe86ff85080,0x7fe8700c7950), 1067 [0x60ca68,0x610d18), 
+INFO:     1153 files found in /github/workspace/cifuzz-corpus/fuzz-dhcp-server
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 1048576 bytes
+INFO: seed corpus: files: 1153 min: 1b max: 5242879b total: 17056071b rss: 50Mb
+#1155	INITED cov: 577 ft: 1116 corp: 203/54Kb exec/s: 0 rss: 86Mb
+#1167	NEW    cov: 577 ft: 1117 corp: 204/54Kb lim: 1048576 exec/s: 0 rss: 86Mb L: 243/1071 MS: 2 ChangeASCIIInt-CrossOver-
+#1509	NEW    cov: 577 ft: 1118 corp: 205/54Kb lim: 1048576 exec/s: 0 rss: 86Mb L: 243/1071 MS: 2 ChangeBit-CopyPart-
+#63018	NEW    cov: 577 ft: 1119 corp: 206/55Kb lim: 1048576 exec/s: 21006 rss: 86Mb L: 245/1071 MS: 4 InsertByte-ChangeByte-CMP-InsertByte- DE: "2\000\000\000\000\000\000\000"-
+#65536	pulse  cov: 577 ft: 1119 corp: 206/55Kb lim: 1048576 exec/s: 21845 rss: 86Mb
+Loaded 1024/1155 files from /github/workspace/cifuzz-corpus/fuzz-dhcp-server
+#99784	NEW    cov: 577 ft: 1120 corp: 207/55Kb lim: 1048576 exec/s: 19956 rss: 105Mb L: 243/1071 MS: 2 ChangeASCIIInt-ChangeBinInt-
+#131072	pulse  cov: 577 ft: 1120 corp: 207/55Kb lim: 1048576 exec/s: 21845 rss: 105Mb
+#262144	pulse  cov: 577 ft: 1120 corp: 207/55Kb lim: 1048576 exec/s: 20164 rss: 105Mb
+#275639	DONE   cov: 577 ft: 1120 corp: 207/55Kb lim: 1048576 exec/s: 19688 rss: 105Mb
+###### Recommended dictionary. ######
+"2\000\000\000\000\000\000\000" # Uses: 17879
+###### End of recommended dictionary. ######
+Done 275639 runs in 14 second(s)
+stat::number_of_executed_units: 275639
+stat::average_exec_per_sec:     19688
+stat::new_units_added:          4
+stat::slowest_unit_time_sec:    0
+stat::peak_rss_mb:              105
+/github/workspace/build-out/fuzz-dhcp-server -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpyxgwwsvr/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-dhcp-server >fuzz-1.log 2>&1
+2023-05-04 01:03:18,374 - root - INFO - Not reporting crash in fuzz-dhcp-server because process timed out.
+2023-05-04 01:03:18,377 - root - INFO - Deleting corpus and seed corpus of fuzz-dhcp-server to save disk.
+2023-05-04 01:03:18,399 - root - INFO - Deleting fuzz target: fuzz-dhcp-server.
+2023-05-04 01:03:18,400 - root - INFO - Done deleting.
+2023-05-04 01:03:18,400 - root - INFO - Fuzzer fuzz-dhcp-server finished running without reportable crashes.
+2023-05-04 01:03:18,401 - root - INFO - Running fuzzer: fuzz-bcd.
+2023-05-04 01:03:18,401 - root - INFO - Downloading corpus from OSS-Fuzz: https://storage.googleapis.com/systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-bcd/public.zip
+2023-05-04 01:03:18,404 - urllib3.connectionpool - DEBUG - Starting new HTTPS connection (1): storage.googleapis.com:443
+2023-05-04 01:03:18,582 - urllib3.connectionpool - DEBUG - https://storage.googleapis.com:443 "GET /systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-bcd/public.zip HTTP/1.1" 200 2293254
+2023-05-04 01:03:18,804 - root - INFO - Starting fuzzing
+Fuzzing logs:
+/github/workspace/build-out/fuzz-bcd -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpgvqlyr8q/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-bcd >fuzz-0.log 2>&1
+================== Job 0 exited with exit code 0 ============
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 2 modules   (83175 inline 8-bit counters): 82573 [0x7f1b5387edf0, 0x7f1b5389307d), 602 [0x5f8718, 0x5f8972), 
+INFO: Loaded 2 PC tables (83175 PCs): 82573 [0x7f1b53893080,0x7f1b539d5950), 602 [0x5f8978,0x5faf18), 
+INFO:     1260 files found in /github/workspace/cifuzz-corpus/fuzz-bcd
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 946175 bytes
+INFO: seed corpus: files: 1260 min: 1b max: 946175b total: 10373697b rss: 48Mb
+#1261	INITED cov: 137 ft: 653 corp: 282/1416Kb exec/s: 0 rss: 91Mb
+#65536	pulse  cov: 137 ft: 653 corp: 282/1416Kb lim: 946175 exec/s: 32768 rss: 98Mb
+#131072	pulse  cov: 137 ft: 653 corp: 282/1416Kb lim: 946175 exec/s: 32768 rss: 98Mb
+#262144	pulse  cov: 137 ft: 653 corp: 282/1416Kb lim: 946175 exec/s: 37449 rss: 98Mb
+#475081	DONE   cov: 137 ft: 653 corp: 282/1416Kb lim: 946175 exec/s: 33934 rss: 98Mb
+Done 475081 runs in 14 second(s)
+stat::number_of_executed_units: 475081
+stat::average_exec_per_sec:     33934
+stat::new_units_added:          0
+stat::slowest_unit_time_sec:    0
+stat::peak_rss_mb:              98
+/github/workspace/build-out/fuzz-bcd -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpgvqlyr8q/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-bcd >fuzz-1.log 2>&1
+2023-05-04 01:03:41,821 - root - INFO - Not reporting crash in fuzz-bcd because process timed out.
+2023-05-04 01:03:41,822 - root - INFO - Deleting corpus and seed corpus of fuzz-bcd to save disk.
+2023-05-04 01:03:41,848 - root - INFO - Deleting fuzz target: fuzz-bcd.
+2023-05-04 01:03:41,848 - root - INFO - Done deleting.
+2023-05-04 01:03:41,848 - root - INFO - Fuzzer fuzz-bcd finished running without reportable crashes.
+2023-05-04 01:03:41,848 - root - INFO - Running fuzzer: fuzz-varlink.
+2023-05-04 01:03:41,849 - root - INFO - Downloading corpus from OSS-Fuzz: https://storage.googleapis.com/systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-varlink/public.zip
+2023-05-04 01:03:41,852 - urllib3.connectionpool - DEBUG - Starting new HTTPS connection (1): storage.googleapis.com:443
+2023-05-04 01:03:41,906 - urllib3.connectionpool - DEBUG - https://storage.googleapis.com:443 "GET /systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-varlink/public.zip HTTP/1.1" 200 2586434
+2023-05-04 01:03:42,671 - root - INFO - Starting fuzzing
+2023-05-04 01:04:05,709 - root - INFO - Not reporting crash in fuzz-varlink because process timed out.
+Fuzzing logs:
+/github/workspace/build-out/fuzz-varlink -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpbtf4f932/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-varlink >fuzz-0.log 2>&1
+2023-05-04 01:04:05,709 - root - INFO - Deleting corpus and seed corpus of fuzz-varlink to save disk.
+2023-05-04 01:04:05,806 - root - INFO - Deleting fuzz target: fuzz-varlink.
+2023-05-04 01:04:05,806 - root - INFO - Done deleting.
+2023-05-04 01:04:05,806 - root - INFO - Fuzzer fuzz-varlink finished running without reportable crashes.
+2023-05-04 01:04:05,806 - root - INFO - Running fuzzer: fuzz-unit-file.
+2023-05-04 01:04:05,807 - root - INFO - Downloading corpus from OSS-Fuzz: https://storage.googleapis.com/systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-unit-file/public.zip
+2023-05-04 01:04:05,809 - urllib3.connectionpool - DEBUG - Starting new HTTPS connection (1): storage.googleapis.com:443
+2023-05-04 01:04:05,897 - urllib3.connectionpool - DEBUG - https://storage.googleapis.com:443 "GET /systemd-backup.clusterfuzz-external.appspot.com/corpus/libFuzzer/systemd_fuzz-unit-file/public.zip HTTP/1.1" 200 4999974
+2023-05-04 01:04:07,869 - root - INFO - Starting fuzzing
+2023-05-04 01:04:09,516 - root - INFO - Fuzzer: fuzz-unit-file. Detected bug.
+Fuzzing logs:
+/github/workspace/build-out/fuzz-unit-file -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpjhswtxiw/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-unit-file >fuzz-0.log 2>&1
+2023-05-04 01:04:09,517 - root - INFO - Trying to reproduce crash using: /tmp/tmpjhswtxiw/crash-7be9e0f3a71d95f8d5e67c5a9d84273d6f4e3c03.
+================== Job 0 exited with exit code 77 ============
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 2 modules   (82576 inline 8-bit counters): 82573 [0x7f3b0de4cdf0, 0x7f3b0de6107d), 3 [0x5e9b28, 0x5e9b2b), 
+INFO: Loaded 2 PC tables (82576 PCs): 82573 [0x7f3b0de61080,0x7f3b0dfa3950), 3 [0x5a6af8,0x5a6b28), 
+INFO:    20907 files found in /github/workspace/cifuzz-corpus/fuzz-unit-file
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 604973 bytes
+INFO: seed corpus: files: 20907 min: 1b max: 604973b total: 16005340b rss: 61Mb
+=================================================================
+==74==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000005078 at pc 0x0000004ddffa bp 0x7fffeea64fe0 sp 0x7fffeea64fd8
+READ of size 4 at 0x602000005078 thread T0
+SCARINESS: 27 (4-byte-read-heap-buffer-overflow-far-from-bounds)
+    #0 0x4ddff9 in LLVMFuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:30:16
+    #1 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+    #2 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+    #3 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+    #4 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+    #5 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+    #6 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+    #7 0x7f3b0ce20082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+    #8 0x41f6ed in _start (build-out/fuzz-unit-file+0x41f6ed)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*)
+0x602000005078 is located 38 bytes to the right of 2-byte region [0x602000005050,0x602000005052)
+freed by thread T0 here:
+    #0 0x4a0882 in __interceptor_free /src/llvm-project/compiler-rt/lib/asan/asan_malloc_linux.cpp:52:3
+    #1 0x4ddfb7 in LLVMFuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:29:9
+    #2 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+    #3 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+    #4 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+    #5 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+    #6 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+    #7 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+    #8 0x7f3b0ce20082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+
+DEDUP_TOKEN: __interceptor_free--LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+previously allocated by thread T0 here:
+    #0 0x4a0b26 in malloc /src/llvm-project/compiler-rt/lib/asan/asan_malloc_linux.cpp:69:3
+    #1 0x4ddfac in LLVMFuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:28:25
+    #2 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+    #3 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+    #4 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+    #5 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+    #6 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+    #7 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+    #8 0x7f3b0ce20082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+
+DEDUP_TOKEN: malloc--LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+SUMMARY: AddressSanitizer: heap-buffer-overflow /work/build/../../src/systemd/src/core/fuzz-unit-file.c:30:16 in LLVMFuzzerTestOneInput
+Shadow bytes around the buggy address:
+  0x0c047fff89b0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+  0x0c047fff89c0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+  0x0c047fff89d0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+  0x0c047fff89e0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+  0x0c047fff89f0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+=>0x0c047fff8a00: fa fa 00 02 fa fa 00 02 fa fa fd fa fa fa fa[fa]
+  0x0c047fff8a10: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c047fff8a20: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c047fff8a30: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c047fff8a40: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c047fff8a50: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+Shadow byte legend (one shadow byte represents 8 application bytes):
+  Addressable:           00
+  Partially addressable: 01 02 03 04 05 06 07 
+  Heap left redzone:       fa
+  Freed heap region:       fd
+  Stack left redzone:      f1
+  Stack mid redzone:       f2
+  Stack right redzone:     f3
+  Stack after return:      f5
+  Stack use after scope:   f8
+  Global redzone:          f9
+  Global init order:       f6
+  Poisoned by user:        f7
+  Container overflow:      fc
+  Array cookie:            ac
+  Intra object redzone:    bb
+  ASan internal:           fe
+  Left alloca redzone:     ca
+  Right alloca redzone:    cb
+==74==ABORTING
+MS: 0 ; base unit: 0000000000000000000000000000000000000000
+0x61,0x75,0x74,0x6f,0x6d,0x6f,0x75,0x6e,0x74,0x48,
+automountH
+artifact_prefix='/tmp/tmpjhswtxiw/'; Test unit written to /tmp/tmpjhswtxiw/crash-7be9e0f3a71d95f8d5e67c5a9d84273d6f4e3c03
+Base64: YXV0b21vdW50SA==
+stat::number_of_executed_units: 314
+stat::average_exec_per_sec:     0
+stat::new_units_added:          0
+stat::slowest_unit_time_sec:    0
+stat::peak_rss_mb:              67
+/github/workspace/build-out/fuzz-unit-file -timeout=25 -rss_limit_mb=2560 -len_control=0 -seed=1337 -artifact_prefix=/tmp/tmpjhswtxiw/ -max_total_time=13 -print_final_stats=1 /github/workspace/cifuzz-corpus/fuzz-unit-file >fuzz-1.log 2>&1
+================== Job 1 exited with exit code 77 ============
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 2 modules   (82576 inline 8-bit counters): 82573 [0x7ff1ba038df0, 0x7ff1ba04d07d), 3 [0x5e9b28, 0x5e9b2b), 
+INFO: Loaded 2 PC tables (82576 PCs): 82573 [0x7ff1ba04d080,0x7ff1ba18f950), 3 [0x5a6af8,0x5a6b28), 
+INFO:    20907 files found in /github/workspace/cifuzz-corpus/fuzz-unit-file
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 604973 bytes
+INFO: seed corpus: files: 20907 min: 1b max: 604973b total: 16005340b rss: 61Mb
+=================================================================
+==78==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000005078 at pc 0x0000004ddffa bp 0x7ffc2e6825c0 sp 0x7ffc2e6825b8
+READ of size 4 at 0x602000005078 thread T0
+SCARINESS: 27 (4-byte-read-heap-buffer-overflow-far-from-bounds)
+    #0 0x4ddff9 in LLVMFuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:30:16
+    #1 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+    #2 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+    #3 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+    #4 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+    #5 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+    #6 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+    #7 0x7ff1b900c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+    #8 0x41f6ed in _start (build-out/fuzz-unit-file+0x41f6ed)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*)
+0x602000005078 is located 38 bytes to the right of 2-byte region [0x602000005050,0x602000005052)
+freed by thread T0 here:
+    #0 0x4a0882 in __interceptor_free /src/llvm-project/compiler-rt/lib/asan/asan_malloc_linux.cpp:52:3
+    #1 0x4ddfb7 in LLVMFuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:29:9
+    #2 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+    #3 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+    #4 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+    #5 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+    #6 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+    #7 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+    #8 0x7ff1b900c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+
+DEDUP_TOKEN: __interceptor_free--LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+previously allocated by thread T0 here:
+    #0 0x4a0b26 in malloc /src/llvm-project/compiler-rt/lib/asan/asan_malloc_linux.cpp:69:3
+    #1 0x4ddfac in LLVMFuzzerTestOneInput /work/build/../../src/systemd/src/core/fuzz-unit-file.c:28:25
+    #2 0x4fc653 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:611:15
+    #3 0x4fbe3a in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:514:3
+    #4 0x4fdca4 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:826:7
+    #5 0x4fded9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:857:3
+    #6 0x4ed53f in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:912:6
+    #7 0x516b92 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+    #8 0x7ff1b900c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
+
+DEDUP_TOKEN: malloc--samLLVM2FuzzerTestOneInput --fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+SUMMARY: AddressSanitizer: heap-buffer-overflow /work/build/../../src/systemd/src/core/fuzz-unit-file.c:30:16 in samsamLLVM2FuzzerTestOneInput
+Shadow bytes around the buggy address:
+  0x0c047fff89b0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+  0x0c047fff89c0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+  0x0c047fff89d0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+  0x0c047fff89e0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+  0x0c047fff89f0: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fd
+=>0x0c047fff8a00: fa fa 00 02 fa fa 00 02 fa fa fd fa fa fa fa[fa]
+  0x0c047fff8a10: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c047fff8a20: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c047fff8a30: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c047fff8a40: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x0c047fff8a50: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+Shadow byte legend (one shadow byte represents 8 application bytes):
+  Addressable:           00
+  Partially addressable: 01 02 03 04 05 06 07 
+  Heap left redzone:       fa
+  Freed heap region:       fd
+  Stack left redzone:      f1
+  Stack mid redzone:       f2
+  Stack right redzone:     f3
+  Stack after return:      f5
+  Stack use after scope:   f8
+  Global redzone:          f9
+  Global init order:       f6
+  Poisoned by user:        f7
+  Container overflow:      fc
+  Array cookie:            ac
+  Intra object redzone:    bb
+  ASan internal:           fe
+  Left alloca redzone:     ca
+  Right alloca redzone:    cb
+==78==ABORTING
+MS: 0 ; base unit: 0000000000000000000000000000000000000000
+0x61,0x75,0x74,0x6f,0x6d,0x6f,0x75,0x6e,0x74,0x48,
+automountH
+artifact_prefix='/tmp/tmpjhswtxiw/'; Test unit written to /tmp/tmpjhswtxiw/crash-7be9e0f3a71d95f8d5e67c5a9d84273d6f4e3c03
+Base64: YXV0b21vdW50SA==
+stat::number_of_executed_units: 314
+stat::average_exec_per_sec:     0
+stat::new_units_added:          0
+stat::slowest_unit_time_sec:    0
+stat::peak_rss_mb:              68

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

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

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

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Script for generating an OSS-Fuzz job for a wycheproof project."""
+import sys
+
+
+def main():
+  """Usage generate_job.py <project>."""
+  project = sys.argv[1]
+  print(f'Name: wycheproof_nosanitizer_{project}')
+  job_definition = f"""CUSTOM_BINARY = False
+BAD_BUILD_CHECK = False
+APP_NAME = WycheproofTarget.bash
+THREAD_ALIVE_CHECK_INTERVAL = 10
+TEST_TIMEOUT = 3600
+CRASH_RETRIES = 1
+AGGREGATE_COVERAGE = False
+TESTCASE_COVERAGE = False
+FILE_GITHUB_ISSUE = False
+MANAGED = False
+MAX_FUZZ_THREADS = 1
+RELEASE_BUILD_BUCKET_PATH = gs://clusterfuzz-builds-wycheproof/{project}/{project}-none-([0-9]+).zip
+PROJECT_NAME = {project}
+SUMMARY_PREFIX = {project}
+REVISION_VARS_URL = https://commondatastorage.googleapis.com/clusterfuzz-builds-wycheproof/{project}/{project}-none-%s.srcmap.json
+FUZZ_LOGS_BUCKET = {project}-logs.clusterfuzz-external.appspot.com
+CORPUS_BUCKET = {project}-corpus.clusterfuzz-external.appspot.com
+QUARANTINE_BUCKET = {project}-quarantine.clusterfuzz-external.appspot.com
+BACKUP_BUCKET = {project}-backup.clusterfuzz-external.appspot.com
+AUTOMATIC_LABELS = Proj-{project},Engine-wycheproof
+"""
+  print(job_definition)
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-02/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-delta-02/fuzz-tooling/infra/tools/wycheproof/package.bash

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+# Script for zipping ClusterFuzz's blackbox fuzzer for wycheproof.
+zip wycheproof.zip run.py launcher.py

local-test-tika-delta-02/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())

local-test-zookeeper-delta-01/afc-zookeeper/.aixcc/README.md

@@ -0,0 +1,16 @@
+# Zookeeper - Infinite Colon Problems
+
+This challenge is a very simple delta scan challenge.
+
+The challenge includes one synthetic vulnerability (vuln\_2) inside 
+improper iPv6 validation that leads to an infinite loop.
+
+The delta for this challenge contains the new iPv6 colon-counting functionality
+in full, as well as a set of two unit tests to test the new functionality.
+
+## Challenge Rounds
+
+This challenge has been included in the following set of rounds.
+
+* Exhibition Round 1
+* Exhibition Round 2