Add files using upload-large-folder tool

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

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

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

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

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

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

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

@@ -0,0 +1,109 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for dealing with the GitHub API. This is different from
+github_actions_toolkit which only deals with the actions API. We need to use
+both."""
+import logging
+import os
+import sys
+
+import requests
+
+import filestore
+
+# pylint: disable=wrong-import-position,import-error
+
+sys.path.append(
+    os.path.join(__file__, os.path.pardir, os.path.pardir, os.path.pardir,
+                 os.path.pardir))
+import retry
+
+_MAX_ITEMS_PER_PAGE = 100
+
+_GET_ATTEMPTS = 3
+_GET_BACKOFF = 1
+
+
+def get_http_auth_headers(config):
+  """Returns HTTP headers for authentication to the API."""
+  authorization = f'token {config.token}'
+  return {
+      'Authorization': authorization,
+      'Accept': 'application/vnd.github.v3+json'
+  }
+
+
+def _get_artifacts_list_api_url(repo_owner, repo_name):
+  """Returns the artifacts_api_url for |repo_name| owned by |repo_owner|."""
+  github_api_url = os.getenv('GITHUB_API_URL', 'https://api.github.com')
+  return (f'{github_api_url}/repos/{repo_owner}/'
+          f'{repo_name}/actions/artifacts')
+
+
+@retry.wrap(_GET_ATTEMPTS, _GET_BACKOFF)
+def _do_get_request(*args, **kwargs):
+  """Wrapped version of requests.get that does retries."""
+  return requests.get(*args, **kwargs)
+
+
+def _get_items(url, headers):
+  """Generator that gets and yields items from a GitHub API endpoint (specified
+  by |URL|) sending |headers| with the get request."""
+  # Github API response pages are 1-indexed.
+  page_counter = 1
+
+  # Set to infinity so we run loop at least once.
+  total_num_items = float('inf')
+
+  item_num = 0
+  while item_num < total_num_items:
+    params = {'per_page': _MAX_ITEMS_PER_PAGE, 'page': str(page_counter)}
+    response = _do_get_request(url, params=params, headers=headers)
+    response_json = response.json()
+    if not response.status_code == 200:
+      # Check that request was successful.
+      logging.error('Request to %s failed. Code: %d. Response: %s',
+                    response.request.url, response.status_code, response_json)
+      raise filestore.FilestoreError('Github API request failed.')
+
+    if total_num_items == float('inf'):
+      # Set proper total_num_items
+      total_num_items = response_json['total_count']
+
+    # Get the key for the items we are after.
+    keys = [key for key in response_json.keys() if key != 'total_count']
+    assert len(keys) == 1, keys
+    items_key = keys[0]
+
+    for item in response_json[items_key]:
+      yield item
+      item_num += 1
+
+    page_counter += 1
+
+
+def find_artifact(artifact_name, artifacts):
+  """Find the artifact with the name |artifact_name| in |artifacts|."""
+  for artifact in artifacts:
+    # TODO(metzman): Handle multiple by making sure we download the latest.
+    if artifact['name'] == artifact_name and not artifact['expired']:
+      return artifact
+  return None
+
+
+def list_artifacts(owner, repo, headers):
+  """Returns a generator of all the artifacts for |owner|/|repo|."""
+  url = _get_artifacts_list_api_url(owner, repo)
+  logging.debug('Getting artifacts from: %s', url)
+  return _get_items(url, headers)

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

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

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

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

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

@@ -0,0 +1,133 @@
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""GitLab filestore implementation."""
+import logging
+
+import json
+import os
+import shutil
+import tempfile
+
+import filestore
+import http_utils
+
+# pylint: disable=no-self-use,unused-argument
+
+
+class GitlabFilestore(filestore.BaseFilestore):
+  """Implementation of BaseFilestore using GitLab.
+  Needs a cache to upload and download builds.
+  Needs a git repository for corpus and coverage.
+  """
+
+  BUILD_PREFIX = 'build-'
+  CORPUS_PREFIX = 'corpus-'
+  COVERAGE_PREFIX = 'coverage-'
+  CRASHES_PREFIX = 'crashes-'
+
+  def __init__(self, config):
+    super().__init__(config)
+    self.artifacts_dir = self.config.platform_conf.artifacts_dir
+    self.cache_dir = self.config.platform_conf.cache_dir
+    if self.config.git_store_repo:
+      self.git_filestore = filestore.git.GitFilestore(config, None)
+    else:
+      self.git_filestore = None
+
+  def upload_crashes(self, name, directory):
+    """GitLab artifacts implementation of upload_crashes."""
+    # Upload crashes as job artifacts.
+    if os.listdir(directory):
+      dest_dir_artifacts = os.path.join(self.config.project_src_path,
+                                        self.artifacts_dir,
+                                        self.CRASHES_PREFIX + name)
+      logging.info('Uploading artifacts to %s.', dest_dir_artifacts)
+      shutil.copytree(directory, dest_dir_artifacts)
+
+  def upload_corpus(self, name, directory, replace=False):
+    """GitLab artifacts implementation of upload_corpus."""
+    # Use the git filestore if any.
+    if self.git_filestore:
+      self.git_filestore.upload_corpus(name, directory, replace)
+      return
+    # Fall back to cache.
+    dest_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                  self.CORPUS_PREFIX + name)
+    logging.info('Copying from %s to cache %s.', directory, dest_dir_cache)
+    # Remove previous corpus from cache if any.
+    shutil.rmtree(dest_dir_cache, ignore_errors=True)
+    shutil.copytree(directory, dest_dir_cache, dirs_exist_ok=True)
+
+  def upload_build(self, name, directory):
+    """GitLab artifacts implementation of upload_build."""
+    # Puts build into the cache.
+    dest_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                  self.BUILD_PREFIX + name)
+    logging.info('Copying from %s to cache %s.', directory, dest_dir_cache)
+    shutil.copytree(directory, dest_dir_cache, dirs_exist_ok=True)
+
+  def upload_coverage(self, name, directory):
+    """GitLab artifacts implementation of upload_coverage."""
+    # Use the git filestore.
+    if self.git_filestore:
+      self.git_filestore.upload_coverage(name, directory)
+      return
+    # Fall back to cache.
+    dest_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                  self.COVERAGE_PREFIX + name)
+    logging.info('Copying from %s to cache %s.', directory, dest_dir_cache)
+    shutil.copytree(directory, dest_dir_cache, dirs_exist_ok=True)
+    # And also updates coverage reports as artifacts
+    # as it should not be too big.
+    dest_dir_artifacts = os.path.join(self.config.project_src_path,
+                                      self.artifacts_dir,
+                                      self.COVERAGE_PREFIX + name)
+    logging.info('Uploading artifacts to %s.', dest_dir_artifacts)
+    shutil.copytree(directory, dest_dir_artifacts)
+
+  def _copy_from_cache(self, src_dir_cache, dst_directory):
+    if not os.path.exists(src_dir_cache):
+      logging.info('Cache %s does not exist.', src_dir_cache)
+      return False
+    logging.info('Copying %s from cache to %s.', src_dir_cache, dst_directory)
+    shutil.copytree(src_dir_cache, dst_directory, dirs_exist_ok=True)
+    return True
+
+  def download_corpus(self, name, dst_directory):
+    """GitLab artifacts implementation of download_corpus."""
+    # Use the git filestore if any.
+    if self.git_filestore:
+      self.git_filestore.download_corpus(name, dst_directory)
+      return
+    # Fall back to cache.
+    src_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                 self.CORPUS_PREFIX + name)
+    self._copy_from_cache(src_dir_cache, dst_directory)
+
+  def download_build(self, name, dst_directory):
+    """GitLab artifacts implementation of download_build."""
+    # Gets build from the cache.
+    src_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                 self.BUILD_PREFIX + name)
+    return self._copy_from_cache(src_dir_cache, dst_directory)
+
+  def download_coverage(self, name, dst_directory):
+    """GitLab artifacts implementation of download_coverage."""
+    # Use the git filestore if any.
+    if self.git_filestore:
+      return self.git_filestore.download_coverage(name, dst_directory)
+    # Fall back to cache.
+    src_dir_cache = os.path.join(self.config.project_src_path, self.cache_dir,
+                                 self.COVERAGE_PREFIX + name)
+    return self._copy_from_cache(src_dir_cache, dst_directory)

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

@@ -0,0 +1,109 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Filestore implementation using gsutil."""
+import logging
+import os
+import posixpath
+import subprocess
+import sys
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(
+    os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir,
+                 os.pardir, os.pardir))
+import filestore
+import utils
+
+
+def _gsutil_execute(*args, parallel=True):
+  """Executes a gsutil command, passing |*args| to gsutil and returns the
+  stdout, stderr and returncode. Exceptions on failure."""
+  command = ['gsutil']
+  if parallel:
+    command.append('-m')
+  command += list(args)
+  logging.info('Executing gsutil command: %s', command)
+  return utils.execute(command, check_result=True)
+
+
+def _rsync(src, dst, recursive=True, delete=False):
+  """Executes gsutil rsync on |src| and |dst|"""
+  args = ['rsync']
+  if recursive:
+    args.append('-r')
+  if delete:
+    args.append('-d')
+  args += [src, dst]
+  return _gsutil_execute(*args)
+
+
+class GSUtilFilestore(filestore.BaseFilestore):
+  """Filestore implementation using gsutil."""
+  BUILD_DIR = 'build'
+  CRASHES_DIR = 'crashes'
+  CORPUS_DIR = 'corpus'
+  COVERAGE_DIR = 'coverage'
+
+  def __init__(self, config):
+    super().__init__(config)
+    self._cloud_bucket = self.config.cloud_bucket
+
+  def _get_gsutil_url(self, name, prefix_dir):
+    """Returns the gsutil URL for |name| and |prefix_dir|."""
+    if not prefix_dir:
+      return posixpath.join(self._cloud_bucket, name)
+    return posixpath.join(self._cloud_bucket, prefix_dir, name)
+
+  def _upload_directory(self, name, directory, prefix, delete=False):
+    gsutil_url = self._get_gsutil_url(name, prefix)
+    return _rsync(directory, gsutil_url, delete=delete)
+
+  def _download_directory(self, name, dst_directory, prefix):
+    gsutil_url = self._get_gsutil_url(name, prefix)
+    return _rsync(gsutil_url, dst_directory)
+
+  def upload_crashes(self, name, directory):
+    """Uploads the crashes at |directory| to |name|."""
+    # Name is going to be "current". I don't know if this makes sense outside of
+    # GitHub Actions.
+    gsutil_url = self._get_gsutil_url(name, self.CRASHES_DIR)
+    logging.info('Uploading crashes to %s.', gsutil_url)
+    return _rsync(directory, gsutil_url)
+
+  def upload_corpus(self, name, directory, replace=False):
+    """Uploads the crashes at |directory| to |name|."""
+    return self._upload_directory(name,
+                                  directory,
+                                  self.CORPUS_DIR,
+                                  delete=replace)
+
+  def upload_build(self, name, directory):
+    """Uploads the build located at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.BUILD_DIR)
+
+  def upload_coverage(self, name, directory):
+    """Uploads the coverage report at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.COVERAGE_DIR)
+
+  def download_corpus(self, name, dst_directory):
+    """Downloads the corpus located at |name| to |dst_directory|."""
+    return self._download_directory(name, dst_directory, self.CORPUS_DIR)
+
+  def download_build(self, name, dst_directory):
+    """Downloads the build with |name| to |dst_directory|."""
+    return self._download_directory(name, dst_directory, self.BUILD_DIR)
+
+  def download_coverage(self, name, dst_directory):
+    """Downloads the latest project coverage report."""
+    return self._download_directory(name, dst_directory, self.COVERAGE_DIR)

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

@@ -0,0 +1,51 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Empty filestore implementation for platforms that haven't implemented it."""
+import logging
+
+import filestore
+
+# pylint:disable=no-self-use,unused-argument
+
+
+class NoFilestore(filestore.BaseFilestore):
+  """Empty Filestore implementation."""
+
+  def upload_crashes(self, name, directory):
+    """Noop implementation of upload_crashes."""
+    logging.info('Not uploading crashes because no Filestore.')
+
+  def upload_corpus(self, name, directory, replace=False):
+    """Noop implementation of upload_corpus."""
+    logging.info('Not uploading corpus because no Filestore.')
+
+  def upload_build(self, name, directory):
+    """Noop implementation of upload_build."""
+    logging.info('Not uploading build because no Filestore.')
+
+  def upload_coverage(self, name, directory):
+    """Noop implementation of upload_coverage."""
+    logging.info('Not uploading coverage because no Filestore.')
+
+  def download_corpus(self, name, dst_directory):
+    """Noop implementation of download_corpus."""
+    logging.info('Not downloading corpus because no Filestore.')
+
+  def download_build(self, name, dst_directory):
+    """Noop implementation of download_build."""
+    logging.info('Not downloading build because no Filestore.')
+
+  def download_coverage(self, name, dst_directory):
+    """Noop implementation of download_coverage."""
+    logging.info('Not downloading coverage because no Filestore.')

local-test-tika-full-01-vuln_1/fuzz-tooling/infra/cifuzz/platform_config/prow.py

@@ -0,0 +1,64 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for getting the configuration CIFuzz needs to run on prow."""
+import logging
+import os
+
+import platform_config
+
+# pylint: disable=too-few-public-methods
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+  """CI environment for Prow."""
+
+  @property
+  def project_src_path(self):
+    """Returns the manually checked out path of the project's source if
+    specified or the current directory if not. Prow will run ClusterfuzzLite
+    at the directory head for the repo."""
+    project_src_path = os.getenv('PROJECT_SRC_PATH', os.getcwd())
+    logging.debug('PROJECT_SRC_PATH: %s.', project_src_path)
+    return project_src_path
+
+  @property
+  def workspace(self):
+    """Returns the workspace."""
+    # Let Prow user override workspace, but default to using artifacts dir
+    return os.getenv('WORKSPACE', os.getenv('ARTIFACTS'))
+
+  @property
+  def base_ref(self):
+    """Returns the base branch to diff against (pr fuzzing)."""
+    return os.getenv('PULL_BASE_REF')
+
+  @property
+  def project_repo_name(self):
+    """Returns the project repo name."""
+    return os.getenv('REPO_NAME')
+
+  @property
+  def base_commit(self):
+    """Returns the base commit to diff against (commit fuzzing)."""
+    return os.getenv('PULL_BASE_SHA')
+
+  @property
+  def docker_in_docker(self):
+    """Returns True if using Docker in Docker."""
+    return True
+
+  @property
+  def filestore(self):
+    """Returns the filestore used to store persistent data."""
+    return os.environ.get('FILESTORE', 'gsutil')

local-test-tika-full-01-vuln_1/fuzz-tooling/infra/cifuzz/test_data/external-project/.clusterfuzzlite/build.sh

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

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

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

local-test-tika-full-01-vuln_1/fuzz-tooling/infra/cifuzz/test_data/external-project/my_api.cpp

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

local-test-tika-full-01-vuln_1/fuzz-tooling/infra/cifuzz/test_data/external-project/my_api.h

@@ -0,0 +1,19 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// A library that does ... stuff.
+// Serves as an example of good fuzz testing and OSS-Fuzz integration.
+#include <string>
+
+size_t DoStuff(const std::string &str);

local-test-tika-full-01-vuln_1/fuzz-tooling/infra/cifuzz/test_data/external-project/standalone_fuzz_target_runner.cpp

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

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

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

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

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

local-test-tika-full-01-vuln_1/fuzz-tooling/infra/tools/wycheproof/generate_job.py

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

local-test-tika-full-01-vuln_1/fuzz-tooling/infra/tools/wycheproof/launcher.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Script for running wycheproof."""
+
+import logging
+import sys
+import subprocess
+
+
+def main():
+  """Runs wycheproof."""
+  if len(sys.argv) < 3:
+    logging.error('Usage: %s <test_app> <testcase>.', sys.argv[0])
+    return 1
+
+  return subprocess.run(sys.argv[1:], check=False).returncode
+
+
+if __name__ == '__main__':
+  sys.exit(main())

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