Add files using upload-large-folder tool

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/base-images/README.md

@@ -0,0 +1,6 @@
+Building all infra images:
+
+```bash
+# run from project root
+infra/base-images/all.sh
+```

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/base-images/all.sh

@@ -0,0 +1,28 @@
+#!/bin/bash -eux
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+docker build --pull -t ghcr.io/aixcc-finals/base-image "$@" infra/base-images/base-image
+docker build -t ghcr.io/aixcc-finals/base-clang "$@" infra/base-images/base-clang
+docker build -t ghcr.io/aixcc-finals/base-builder "$@" infra/base-images/base-builder
+docker build -t ghcr.io/aixcc-finals/base-builder-go "$@" infra/base-images/base-builder-go
+docker build -t ghcr.io/aixcc-finals/base-builder-jvm "$@" infra/base-images/base-builder-jvm
+docker build -t ghcr.io/aixcc-finals/base-builder-python "$@" infra/base-images/base-builder-python
+docker build -t ghcr.io/aixcc-finals/base-builder-rust "$@" infra/base-images/base-builder-rust
+docker build -t ghcr.io/aixcc-finals/base-builder-ruby "$@" infra/base-images/base-builder-ruby
+docker build -t ghcr.io/aixcc-finals/base-builder-swift "$@" infra/base-images/base-builder-swift
+docker build -t ghcr.io/aixcc-finals/base-runner "$@" infra/base-images/base-runner
+docker build -t ghcr.io/aixcc-finals/base-runner-debug "$@" infra/base-images/base-runner-debug

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/ci/build.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python
+# Copyright 2019 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Build modified projects."""
+
+from __future__ import print_function
+
+import enum
+import os
+import re
+import sys
+import subprocess
+import yaml
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import constants
+
+CANARY_PROJECT = 'skcms'
+
+DEFAULT_ARCHITECTURES = ['x86_64']
+DEFAULT_ENGINES = ['afl', 'honggfuzz', 'libfuzzer', 'centipede']
+DEFAULT_SANITIZERS = ['address', 'undefined']
+
+
+def get_changed_files_output():
+  """Returns the output of a git command that discovers changed files."""
+  branch_commit_hash = subprocess.check_output(
+      ['git', 'merge-base', 'HEAD', 'origin/HEAD']).strip().decode()
+
+  return subprocess.check_output(
+      ['git', 'diff', '--name-only', branch_commit_hash + '..']).decode()
+
+
+def get_modified_buildable_projects():
+  """Returns a list of all the projects modified in this commit that have a
+  build.sh file."""
+  git_output = get_changed_files_output()
+  projects_regex = '.*projects/(?P<name>.*)/.*\n'
+  modified_projects = set(re.findall(projects_regex, git_output))
+  projects_dir = os.path.join(get_oss_fuzz_root(), 'projects')
+  # Filter out projects without Dockerfile files since new projects and reverted
+  # projects frequently don't have them. In these cases we don't want Travis's
+  # builds to fail.
+  modified_buildable_projects = []
+  for project in modified_projects:
+    if not os.path.exists(os.path.join(projects_dir, project, 'Dockerfile')):
+      print('Project {0} does not have Dockerfile. skipping build.'.format(
+          project))
+      continue
+    modified_buildable_projects.append(project)
+  return modified_buildable_projects
+
+
+def get_oss_fuzz_root():
+  """Get the absolute path of the root of the oss-fuzz checkout."""
+  script_path = os.path.realpath(__file__)
+  return os.path.abspath(
+      os.path.dirname(os.path.dirname(os.path.dirname(script_path))))
+
+
+def execute_helper_command(helper_command):
+  """Execute |helper_command| using helper.py."""
+  root = get_oss_fuzz_root()
+  script_path = os.path.join(root, 'infra', 'helper.py')
+  command = ['python', script_path] + helper_command
+  print('Running command: %s' % ' '.join(command))
+  subprocess.check_call(command)
+
+
+def build_fuzzers(project, engine, sanitizer, architecture):
+  """Execute helper.py's build_fuzzers command on |project|. Build the fuzzers
+  with |engine| and |sanitizer| for |architecture|."""
+  execute_helper_command([
+      'build_fuzzers', project, '--engine', engine, '--sanitizer', sanitizer,
+      '--architecture', architecture
+  ])
+
+
+def check_build(project, engine, sanitizer, architecture):
+  """Execute helper.py's check_build command on |project|, assuming it was most
+  recently built with |engine| and |sanitizer| for |architecture|."""
+  execute_helper_command([
+      'check_build', project, '--engine', engine, '--sanitizer', sanitizer,
+      '--architecture', architecture
+  ])
+
+
+def should_build_coverage(project_yaml):
+  """Returns True if a coverage build should be done based on project.yaml
+  contents."""
+  # Enable coverage builds on projects that use engines. Those that don't use
+  # engines shouldn't get coverage builds.
+  engines = project_yaml.get('fuzzing_engines', DEFAULT_ENGINES)
+  engineless = 'none' in engines
+  if engineless:
+    assert_message = ('Forbidden to specify multiple engines for '
+                      '"fuzzing_engines" if "none" is specified.')
+    assert len(engines) == 1, assert_message
+    return False
+  if 'wycheproof' in engines:
+    return False
+
+  language = project_yaml.get('language')
+  if language not in constants.LANGUAGES_WITH_COVERAGE_SUPPORT:
+    print(('Project is written in "{language}", '
+           'coverage is not supported yet.').format(language=language))
+    return False
+
+  return True
+
+
+def flatten_options(option_list):
+  """Generator that flattens |option_list| (a list of sanitizers, architectures
+  or fuzzing engines) by returning each element in the list that isn't a
+  dictionary. For elements that are dictionaries, the sole key is returned."""
+  result = []
+  for option in option_list:
+    if isinstance(option, dict):
+      keys = list(option.keys())
+      assert len(keys) == 1
+      result.append(keys[0])
+      continue
+    result.append(option)
+  print(result)
+  return result
+
+
+def should_build(project_yaml):
+  """Returns True on if the build specified is enabled in the project.yaml."""
+
+  if os.getenv('SANITIZER') == 'coverage':
+    # This assumes we only do coverage builds with libFuzzer on x86_64.
+    return should_build_coverage(project_yaml)
+
+  def is_enabled(env_var, yaml_name, defaults):
+    """Is the value of |env_var| enabled in |project_yaml| (in the |yaml_name|
+    section)? Uses |defaults| if |yaml_name| section is unspecified."""
+    return os.getenv(env_var) in flatten_options(
+        project_yaml.get(yaml_name, defaults))
+
+  return (is_enabled('ENGINE', 'fuzzing_engines', DEFAULT_ENGINES) and
+          is_enabled('SANITIZER', 'sanitizers', DEFAULT_SANITIZERS) and
+          is_enabled('ARCHITECTURE', 'architectures', DEFAULT_ARCHITECTURES))
+
+
+def build_project(project):
+  """Do the build of |project| that is specified by the environment variables -
+  SANITIZER, ENGINE, and ARCHITECTURE."""
+  root = get_oss_fuzz_root()
+  project_yaml_path = os.path.join(root, 'projects', project, 'project.yaml')
+  with open(project_yaml_path) as file_handle:
+    project_yaml = yaml.safe_load(file_handle)
+
+  if project_yaml.get('disabled', False):
+    print('Project {0} is disabled, skipping build.'.format(project))
+    return
+
+  engine = os.getenv('ENGINE')
+  sanitizer = os.getenv('SANITIZER')
+  architecture = os.getenv('ARCHITECTURE')
+
+  if not should_build(project_yaml):
+    print(('Specified build: engine: {0}, sanitizer: {1}, architecture: {2} '
+           'not enabled for this project: {3}. Skipping build.').format(
+               engine, sanitizer, architecture, project))
+
+    return
+
+  print('Building project', project)
+  build_fuzzers(project, engine, sanitizer, architecture)
+
+  run_tests = project_yaml.get('run_tests', True)
+  if engine != 'none' and sanitizer != 'coverage' and run_tests:
+    check_build(project, engine, sanitizer, architecture)
+
+
+class BuildModifiedProjectsResult(enum.Enum):
+  """Enum containing the return values of build_modified_projects()."""
+  NONE_BUILT = 0
+  BUILD_SUCCESS = 1
+  BUILD_FAIL = 2
+
+
+def build_modified_projects():
+  """Build modified projects. Returns BuildModifiedProjectsResult.NONE_BUILT if
+  no builds were attempted. Returns BuildModifiedProjectsResult.BUILD_SUCCESS if
+  all attempts succeed, otherwise returns
+  BuildModifiedProjectsResult.BUILD_FAIL."""
+  projects = get_modified_buildable_projects()
+  if not projects:
+    return BuildModifiedProjectsResult.NONE_BUILT
+
+  failed_projects = []
+  for project in projects:
+    try:
+      build_project(project)
+    except subprocess.CalledProcessError:
+      failed_projects.append(project)
+
+  if failed_projects:
+    print('Failed projects:', ' '.join(failed_projects))
+    return BuildModifiedProjectsResult.BUILD_FAIL
+
+  return BuildModifiedProjectsResult.BUILD_SUCCESS
+
+
+def is_infra_changed():
+  """Returns True if the infra directory was changed."""
+  git_output = get_changed_files_output()
+  infra_code_regex = '.*infra/.*\n'
+  return re.search(infra_code_regex, git_output) is not None
+
+
+def build_base_images():
+  """Builds base images."""
+  # TODO(jonathanmetzman): Investigate why caching fails so often and
+  # when we improve it, build base-clang as well. Also, move this function
+  # to a helper command when we can support base-clang.
+  execute_helper_command(['pull_images'])
+  images = [
+      'base-image',
+      'base-builder',
+      'base-builder-go',
+      'base-builder-javascript',
+      'base-builder-jvm',
+      'base-builder-python',
+      'base-builder-rust',
+      'base-builder-swift',
+      'base-builder-ruby',
+      'base-runner',
+  ]
+  for image in images:
+    try:
+      execute_helper_command(['build_image', image, '--no-pull', '--cache'])
+    except subprocess.CalledProcessError:
+      return 1
+
+  return 0
+
+
+def build_canary_project():
+  """Builds a specific project when infra/ is changed to verify that infra/
+  changes don't break things. Returns False if build was attempted but
+  failed."""
+
+  try:
+    build_project('skcms')
+  except subprocess.CalledProcessError:
+    return False
+
+  return True
+
+
+def main():
+  """Build modified projects or canary project."""
+  os.environ['OSS_FUZZ_CI'] = '1'
+  infra_changed = is_infra_changed()
+  if infra_changed:
+    print('Pulling and building base images first.')
+    if build_base_images():
+      return 1
+
+  result = build_modified_projects()
+  if result == BuildModifiedProjectsResult.BUILD_FAIL:
+    return 1
+
+  # It's unnecessary to build the canary if we've built any projects already.
+  no_projects_built = result == BuildModifiedProjectsResult.NONE_BUILT
+  should_build_canary = no_projects_built and infra_changed
+  if should_build_canary and not build_canary_project():
+    return 1
+
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/ci/build_test.py

@@ -0,0 +1,124 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Tests for build.py"""
+
+import os
+import sys
+import unittest
+from unittest import mock
+
+# pylint: disable=wrong-import-position
+INFRA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(INFRA_DIR)
+
+from ci import build
+
+
+def patch_environ(testcase_obj):
+  """Patch environment."""
+  env = {}
+  patcher = mock.patch.dict(os.environ, env)
+  testcase_obj.addCleanup(patcher.stop)
+  patcher.start()
+
+
+def _set_coverage_build():
+  """Set the right environment variables for a coverage build."""
+  os.environ['SANITIZER'] = 'coverage'
+  os.environ['ENGINE'] = 'libfuzzer'
+  os.environ['ARCHITECTURE'] = 'x86_64'
+
+
+class TestShouldBuild(unittest.TestCase):
+  """Tests that should_build() works as intended."""
+
+  def setUp(self):
+    patch_environ(self)
+
+  def test_none_engine_coverage_build(self):
+    """Tests that should_build returns False for a coverage build of a
+    project that specifies 'none' for fuzzing_engines."""
+    _set_coverage_build()
+    project_yaml = {
+        'language': 'c++',
+        'fuzzing_engines': ['none'],
+        'sanitizers': ['address']
+    }
+    self.assertFalse(build.should_build(project_yaml))
+
+  def test_unspecified_engines_coverage_build(self):
+    """Tests that should_build returns True for a coverage build of a
+    project that doesn't specify fuzzing_engines."""
+    _set_coverage_build()
+    project_yaml = {'language': 'c++'}
+    self.assertTrue(build.should_build(project_yaml))
+
+  def test_libfuzzer_coverage_build(self):
+    """Tests that should_build returns True for coverage build of a project
+    specifying 'libfuzzer' for fuzzing_engines."""
+    _set_coverage_build()
+    project_yaml = {
+        'language': 'c++',
+        'fuzzing_engines': ['libfuzzer'],
+        'sanitizers': ['address']
+    }
+    self.assertTrue(build.should_build(project_yaml))
+
+  def test_go_coverage_build(self):
+    """Tests that should_build returns True for coverage build of a project
+    specifying 'libfuzzer' for fuzzing_engines."""
+    _set_coverage_build()
+    project_yaml = {'language': 'go'}
+    self.assertTrue(build.should_build(project_yaml))
+
+  def test_engine_project_none_build(self):
+    """Tests that should_build returns False for an engine: 'none' build when
+    the project doesn't specify engines."""
+    os.environ['SANITIZER'] = 'address'
+    os.environ['ENGINE'] = 'none'
+    os.environ['ARCHITECTURE'] = 'x86_64'
+    project_yaml = {
+        'language': 'c++',
+        'fuzzing_engines': ['libfuzzer'],
+        'sanitizers': ['address']
+    }
+    self.assertFalse(build.should_build(project_yaml))
+
+  def test_centipede_none_build(self):
+    """Tests that should_build returns True for none sanitizer build of a
+    project specifying 'centipede' for fuzzing_engines."""
+    os.environ['SANITIZER'] = 'none'
+    os.environ['ENGINE'] = 'centipede'
+    os.environ['ARCHITECTURE'] = 'x86_64'
+    project_yaml = {
+        'language': 'c++',
+        'fuzzing_engines': ['centipede'],
+        'sanitizers': ['none']
+    }
+    self.assertTrue(build.should_build(project_yaml))
+
+  def test_centipede_address_build(self):
+    """Tests that should_build returns True for address sanitizer build of a
+    project specifying 'centipede' for fuzzing_engines."""
+    os.environ['SANITIZER'] = 'address'
+    os.environ['ENGINE'] = 'centipede'
+    os.environ['ARCHITECTURE'] = 'x86_64'
+    project_yaml = {
+        'language': 'c++',
+        'fuzzing_engines': ['centipede'],
+        'sanitizers': ['address']
+    }
+    self.assertTrue(build.should_build(project_yaml))

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/affected_fuzz_targets.py

@@ -0,0 +1,113 @@
+# 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 fuzz targets affected by the change-under-test
+(CUT)."""
+import logging
+import os
+import sys
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import utils
+
+
+def remove_unaffected_fuzz_targets(clusterfuzz_deployment, out_dir,
+                                   files_changed, repo_path):
+  """Removes all non affected fuzz targets in the out directory.
+
+  Args:
+    clusterfuzz_deployment: The ClusterFuzz deployment object.
+    out_dir: The location of the fuzz target binaries.
+    files_changed: A list of files changed compared to HEAD.
+    repo_path: The location of the OSS-Fuzz repo in the docker image.
+
+  This function will not delete fuzz targets unless it knows that the fuzz
+  targets are unaffected. For example, this means that fuzz targets which don't
+  have coverage data on will not be deleted.
+  """
+  if not files_changed:
+    # Don't remove any fuzz targets if there is no difference from HEAD.
+    logging.info('No files changed compared to HEAD.')
+    return
+
+  logging.info('Files changed in PR: %s', files_changed)
+
+  fuzz_target_paths = utils.get_fuzz_targets(out_dir)
+  if not fuzz_target_paths:
+    # Nothing to remove.
+    logging.error('No fuzz targets found in out dir.')
+    return
+
+  coverage = clusterfuzz_deployment.get_coverage(repo_path)
+  if not coverage:
+    # Don't remove any fuzz targets unless we have data.
+    logging.error('Could not find latest coverage report.')
+    return
+
+  affected_fuzz_targets = get_affected_fuzz_targets(coverage, fuzz_target_paths,
+                                                    files_changed)
+
+  if not affected_fuzz_targets:
+    logging.info('No affected fuzz targets detected, keeping all as fallback.')
+    return
+
+  logging.info('Using affected fuzz targets: %s.', affected_fuzz_targets)
+  unaffected_fuzz_targets = set(fuzz_target_paths) - affected_fuzz_targets
+  logging.info('Removing unaffected fuzz targets: %s.', unaffected_fuzz_targets)
+
+  # Remove all the targets that are not affected.
+  for fuzz_target_path in unaffected_fuzz_targets:
+    try:
+      os.remove(fuzz_target_path)
+    except OSError as error:
+      logging.error('%s occurred while removing file %s', error,
+                    fuzz_target_path)
+
+
+def is_fuzz_target_affected(coverage, fuzz_target_path, files_changed):
+  """Returns True if a fuzz target (|fuzz_target_path|) is affected by
+  |files_changed|."""
+  fuzz_target = os.path.basename(fuzz_target_path)
+  covered_files = coverage.get_files_covered_by_target(fuzz_target)
+  if not covered_files:
+    # Assume a fuzz target is affected if we can't get its coverage from
+    # OSS-Fuzz.
+    # TODO(metzman): Figure out what we should do if covered_files is [].
+    # Should we act as if we couldn't get the coverage?
+    logging.info('Could not get coverage for %s. Treating as affected.',
+                 fuzz_target)
+    return True
+
+  covered_files = [
+      os.path.normpath(covered_file) for covered_file in covered_files
+  ]
+  logging.info('Fuzz target %s is affected by: %s', fuzz_target, covered_files)
+  for filename in files_changed:
+    if filename in covered_files:
+      logging.info('Fuzz target %s is affected by changed file: %s',
+                   fuzz_target, filename)
+      return True
+
+  logging.info('Fuzz target %s is not affected.', fuzz_target)
+  return False
+
+
+def get_affected_fuzz_targets(coverage, fuzz_target_paths, files_changed):
+  """Returns a list of paths of affected targets."""
+  affected_fuzz_targets = set()
+  for fuzz_target_path in fuzz_target_paths:
+    if is_fuzz_target_affected(coverage, fuzz_target_path, files_changed):
+      affected_fuzz_targets.add(fuzz_target_path)
+
+  return affected_fuzz_targets

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/build-images.sh

@@ -0,0 +1,34 @@
+#! /bin/bash -eux
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Script for building the docker images for cifuzz.
+
+CIFUZZ_DIR=$(dirname "$0")
+CIFUZZ_DIR=$(realpath $CIFUZZ_DIR)
+INFRA_DIR=$(realpath $CIFUZZ_DIR/..)
+OSS_FUZZ_ROOT=$(realpath $INFRA_DIR/..)
+
+# Build cifuzz-base.
+docker build --tag ghcr.io/aixcc-finals/cifuzz-base --file $CIFUZZ_DIR/cifuzz-base/Dockerfile $OSS_FUZZ_ROOT
+
+# Build run-fuzzers and build-fuzzers images.
+docker build \
+  --tag ghcr.io/aixcc-finals/clusterfuzzlite-build-fuzzers-test:v1 \
+  --tag ghcr.io/aixcc-finals/clusterfuzzlite-build-fuzzers:v1 \
+  --file $INFRA_DIR/build_fuzzers.Dockerfile $INFRA_DIR
+docker build \
+  --tag ghcr.io/aixcc-finals/clusterfuzzlite-run-fuzzers:v1 \
+  --tag ghcr.io/aixcc-finals/clusterfuzzlite-run-fuzzers-test:v1 \
+  --file $INFRA_DIR/run_fuzzers.Dockerfile $INFRA_DIR

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/build_fuzzers_entrypoint.py

@@ -0,0 +1,60 @@
+# 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.
+"""Builds a specific OSS-Fuzz project's fuzzers for CI tools."""
+import logging
+import sys
+
+import build_fuzzers
+import logs
+import config_utils
+
+# pylint: disable=c-extension-no-member
+# pylint gets confused because of the relative import of cifuzz.
+
+logs.init()
+
+
+def build_fuzzers_entrypoint():
+  """Builds OSS-Fuzz project's fuzzers for CI tools."""
+  config = config_utils.BuildFuzzersConfig()
+
+  if config.dry_run:
+    # Sets the default return code on error to success.
+    returncode = 0
+  else:
+    # The default return code when an error occurs.
+    returncode = 1
+
+  if not build_fuzzers.build_fuzzers(config):
+    logging.error('Error building fuzzers for (commit: %s, pr_ref: %s).',
+                  config.git_sha, config.pr_ref)
+    return returncode
+
+  return 0
+
+
+def main():
+  """Builds OSS-Fuzz project's fuzzers for CI tools.
+
+  Note: The resulting fuzz target binaries of this build are placed in
+  the directory: ${GITHUB_WORKSPACE}/out
+
+  Returns:
+    0 on success or nonzero on failure.
+  """
+  return build_fuzzers_entrypoint()
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/cifuzz_combined_entrypoint.py

@@ -0,0 +1,40 @@
+# 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.
+"""Builds fuzzers and runs fuzzers. Entrypoint used for external users"""
+import logging
+import sys
+
+import build_fuzzers_entrypoint
+import run_fuzzers_entrypoint
+
+
+def main():
+  """Builds and runs fuzzers for CI tools.
+
+  NOTE: Any crash report will be in the filepath: $WORKSPACE/out/testcase
+  This can be used with GitHub's upload-artifact action to surface the logs.
+
+  Required environment variables:
+  Returns:
+    0 on success or 1 on failure.
+  """
+  logging.debug("Using cifuzz_combined_entrypoint.")
+  result = build_fuzzers_entrypoint.build_fuzzers_entrypoint()
+  if result != 0:
+    return result
+  return run_fuzzers_entrypoint.run_fuzzers_entrypoint()
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/clusterfuzz_deployment.py

@@ -0,0 +1,385 @@
+# 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 interacting with the ClusterFuzz deployment."""
+import logging
+import os
+import sys
+import urllib.error
+import urllib.request
+
+import config_utils
+import continuous_integration
+import filestore_utils
+import http_utils
+import get_coverage
+import repo_manager
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import utils
+
+
+class BaseClusterFuzzDeployment:
+  """Base class for ClusterFuzz deployments."""
+
+  def __init__(self, config, workspace):
+    self.config = config
+    self.workspace = workspace
+    self.ci_system = continuous_integration.get_ci(config)
+
+  def download_latest_build(self):
+    """Downloads the latest build from ClusterFuzz.
+
+    Returns:
+      A path to where the OSS-Fuzz build was stored, or None if it wasn't.
+    """
+    raise NotImplementedError('Child class must implement method.')
+
+  def upload_build(self, commit):
+    """Uploads the build with the given commit sha to the filestore."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def download_corpus(self, target_name, corpus_dir):
+    """Downloads the corpus for |target_name| from ClusterFuzz to |corpus_dir|.
+
+    Returns:
+      A path to where the OSS-Fuzz build was stored, or None if it wasn't.
+    """
+    raise NotImplementedError('Child class must implement method.')
+
+  def upload_crashes(self):
+    """Uploads crashes in |crashes_dir| to filestore."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def upload_corpus(self, target_name, corpus_dir, replace=False):  # pylint: disable=no-self-use,unused-argument
+    """Uploads the corpus for |target_name| to filestore."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def upload_coverage(self):
+    """Uploads the coverage report to the filestore."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def get_coverage(self, repo_path):
+    """Returns the project coverage object for the project."""
+    raise NotImplementedError('Child class must implement method.')
+
+
+def _make_empty_dir_if_nonexistent(path):
+  """Makes an empty directory at |path| if it does not exist."""
+  os.makedirs(path, exist_ok=True)
+
+
+class ClusterFuzzLite(BaseClusterFuzzDeployment):
+  """Class representing a deployment of ClusterFuzzLite."""
+
+  COVERAGE_NAME = 'latest'
+  LATEST_BUILD_WINDOW = 3
+
+  def __init__(self, config, workspace):
+    super().__init__(config, workspace)
+    self.filestore = filestore_utils.get_filestore(self.config)
+
+  def download_latest_build(self):
+    if os.path.exists(self.workspace.clusterfuzz_build):
+      # This path is necessary because download_latest_build can be called
+      # multiple times.That is the case because it is called only when we need
+      # to see if a bug is novel, i.e. until we want to check a bug is novel we
+      # don't want to waste time calling this, but therefore this method can be
+      # called if multiple bugs are found.
+      return self.workspace.clusterfuzz_build
+
+    repo_dir = self.ci_system.repo_dir
+    if not repo_dir:
+      raise RuntimeError('Repo checkout does not exist.')
+
+    _make_empty_dir_if_nonexistent(self.workspace.clusterfuzz_build)
+    repo = repo_manager.RepoManager(repo_dir)
+
+    diff_base = self.ci_system.get_diff_base()
+    if not diff_base:
+      diff_base = 'HEAD^'
+
+    # Builds are stored by commit, so try the latest |LATEST_BUILD_WINDOW|
+    # commits before the current diff base.
+    # TODO(ochang): If API usage becomes an issue, this can be optimized by the
+    # filestore accepting a list of filenames to try.
+    try:
+      # TODO(metzman): Why do we default to 'origin', we should avoid going down
+      # this path entirely and not need to catch an exception.
+      commit_list = repo.get_commit_list(diff_base,
+                                         limit=self.LATEST_BUILD_WINDOW)
+    except ValueError as error:
+      logging.error('Can\'t get commit list: %s', error)
+      return None
+
+    for old_commit in commit_list:
+      logging.info('Trying to downloading previous build %s.', old_commit)
+      build_name = self._get_build_name(old_commit)
+      try:
+        if self.filestore.download_build(build_name,
+                                         self.workspace.clusterfuzz_build):
+          logging.info('Done downloading previous build.')
+          return self.workspace.clusterfuzz_build
+
+        logging.info('Build for %s does not exist.', old_commit)
+      except Exception as err:  # pylint: disable=broad-except
+        logging.error('Could not download build for %s because of: %s',
+                      old_commit, err)
+
+    return None
+
+  def download_corpus(self, target_name, corpus_dir):
+    _make_empty_dir_if_nonexistent(corpus_dir)
+    logging.info('Downloading corpus for %s to %s.', target_name, corpus_dir)
+    corpus_name = self._get_corpus_name(target_name)
+    try:
+      self.filestore.download_corpus(corpus_name, corpus_dir)
+      logging.info('Done downloading corpus. Contains %d elements.',
+                   len(os.listdir(corpus_dir)))
+    except Exception as err:  # pylint: disable=broad-except
+      logging.error('Failed to download corpus for target: %s. Error: %s',
+                    target_name, str(err))
+    return corpus_dir
+
+  def _get_build_name(self, name):
+    return f'{self.config.sanitizer}-{name}'
+
+  def _get_corpus_name(self, target_name):  # pylint: disable=no-self-use
+    """Returns the name of the corpus artifact."""
+    return target_name
+
+  def upload_corpus(self, target_name, corpus_dir, replace=False):
+    """Upload the corpus produced by |target_name|."""
+    logging.info('Uploading corpus in %s for %s.', corpus_dir, target_name)
+    name = self._get_corpus_name(target_name)
+    try:
+      self.filestore.upload_corpus(name, corpus_dir, replace=replace)
+      logging.info('Done uploading corpus.')
+    except Exception as err:  # pylint: disable=broad-except
+      logging.error('Failed to upload corpus for target: %s. Error: %s.',
+                    target_name, err)
+
+  def upload_build(self, commit):
+    """Upload the build produced by CIFuzz as the latest build."""
+    logging.info('Uploading latest build in %s.', self.workspace.out)
+    build_name = self._get_build_name(commit)
+    try:
+      result = self.filestore.upload_build(build_name, self.workspace.out)
+      logging.info('Done uploading latest build.')
+      return result
+    except Exception as err:  # pylint: disable=broad-except
+      logging.error('Failed to upload latest build: %s. Error: %s',
+                    self.workspace.out, err)
+
+  def upload_crashes(self):
+    """Uploads crashes."""
+    artifact_dirs = os.listdir(self.workspace.artifacts)
+    if not artifact_dirs:
+      logging.info('No crashes in %s. Not uploading.', self.workspace.artifacts)
+      return
+
+    for crash_target in artifact_dirs:
+      artifact_dir = os.path.join(self.workspace.artifacts, crash_target)
+      if not os.path.isdir(artifact_dir):
+        logging.warning('%s is not an expected artifact directory, skipping.',
+                        crash_target)
+        continue
+
+      logging.info('Uploading crashes in %s.', artifact_dir)
+      try:
+        self.filestore.upload_crashes(crash_target, artifact_dir)
+        logging.info('Done uploading crashes.')
+      except Exception as err:  # pylint: disable=broad-except
+        logging.error('Failed to upload crashes. Error: %s', err)
+
+  def upload_coverage(self):
+    """Uploads the coverage report to the filestore."""
+    self.filestore.upload_coverage(self.COVERAGE_NAME,
+                                   self.workspace.coverage_report)
+
+  def get_coverage(self, repo_path):
+    """Returns the project coverage object for the project."""
+    _make_empty_dir_if_nonexistent(self.workspace.clusterfuzz_coverage)
+    try:
+      if not self.filestore.download_coverage(
+          self.COVERAGE_NAME, self.workspace.clusterfuzz_coverage):
+        logging.error('Could not download coverage.')
+        return None
+      return get_coverage.FilesystemCoverage(
+          repo_path, self.workspace.clusterfuzz_coverage)
+    except Exception as err:  # pylint: disable=broad-except
+      logging.error('Could not get coverage: %s.', err)
+      return None
+
+
+class OSSFuzz(BaseClusterFuzzDeployment):
+  """The OSS-Fuzz ClusterFuzz deployment."""
+
+  # Location of clusterfuzz builds on GCS.
+  CLUSTERFUZZ_BUILDS = 'clusterfuzz-builds'
+
+  # Zip file name containing the corpus.
+  CORPUS_ZIP_NAME = 'public.zip'
+
+  def get_latest_build_name(self):
+    """Gets the name of the latest OSS-Fuzz build of a project.
+
+    Returns:
+      A string with the latest build version or None.
+    """
+    version_file = (
+        f'{self.config.oss_fuzz_project_name}-{self.config.sanitizer}'
+        '-latest.version')
+    version_url = utils.url_join(utils.GCS_BASE_URL, self.CLUSTERFUZZ_BUILDS,
+                                 self.config.oss_fuzz_project_name,
+                                 version_file)
+    try:
+      response = urllib.request.urlopen(version_url)
+    except urllib.error.HTTPError:
+      logging.error('Error getting latest build version for %s from: %s.',
+                    self.config.oss_fuzz_project_name, version_url)
+      return None
+    return response.read().decode()
+
+  def download_latest_build(self):
+    """Downloads the latest OSS-Fuzz build from GCS.
+
+    Returns:
+      A path to where the OSS-Fuzz build was stored, or None if it wasn't.
+    """
+    if os.path.exists(self.workspace.clusterfuzz_build):
+      # This function can be called multiple times, don't download the build
+      # again.
+      return self.workspace.clusterfuzz_build
+
+    _make_empty_dir_if_nonexistent(self.workspace.clusterfuzz_build)
+
+    latest_build_name = self.get_latest_build_name()
+    if not latest_build_name:
+      return None
+
+    logging.info('Downloading latest build.')
+    oss_fuzz_build_url = utils.url_join(utils.GCS_BASE_URL,
+                                        self.CLUSTERFUZZ_BUILDS,
+                                        self.config.oss_fuzz_project_name,
+                                        latest_build_name)
+    if http_utils.download_and_unpack_zip(oss_fuzz_build_url,
+                                          self.workspace.clusterfuzz_build):
+      logging.info('Done downloading latest build.')
+      return self.workspace.clusterfuzz_build
+
+    return None
+
+  def upload_build(self, commit):  # pylint: disable=no-self-use
+    """Noop Implementation of upload_build."""
+    logging.info('Not uploading latest build because on OSS-Fuzz.')
+
+  def upload_corpus(self, target_name, corpus_dir, replace=False):  # pylint: disable=no-self-use,unused-argument
+    """Noop Implementation of upload_corpus."""
+    logging.info('Not uploading corpus because on OSS-Fuzz.')
+
+  def upload_crashes(self):  # pylint: disable=no-self-use
+    """Noop Implementation of upload_crashes."""
+    logging.info('Not uploading crashes because on OSS-Fuzz.')
+
+  def download_corpus(self, target_name, corpus_dir):
+    """Downloads the latest OSS-Fuzz corpus for the target.
+
+    Returns:
+      The local path to to corpus or None if download failed.
+    """
+    _make_empty_dir_if_nonexistent(corpus_dir)
+    project_qualified_fuzz_target_name = target_name
+    qualified_name_prefix = self.config.oss_fuzz_project_name + '_'
+    if not target_name.startswith(qualified_name_prefix):
+      project_qualified_fuzz_target_name = qualified_name_prefix + target_name
+
+    corpus_url = (f'{utils.GCS_BASE_URL}{self.config.oss_fuzz_project_name}'
+                  '-backup.clusterfuzz-external.appspot.com/corpus/'
+                  f'libFuzzer/{project_qualified_fuzz_target_name}/'
+                  f'{self.CORPUS_ZIP_NAME}')
+    logging.info('Downloading corpus from OSS-Fuzz: %s', corpus_url)
+
+    if not http_utils.download_and_unpack_zip(corpus_url, corpus_dir):
+      logging.warning('Failed to download corpus for %s.', target_name)
+    return corpus_dir
+
+  def upload_coverage(self):
+    """Noop Implementation of upload_coverage_report."""
+    logging.info('Not uploading coverage report because on OSS-Fuzz.')
+
+  def get_coverage(self, repo_path):
+    """Returns the project coverage object for the project."""
+    try:
+      return get_coverage.OSSFuzzCoverage(repo_path,
+                                          self.config.oss_fuzz_project_name)
+    except get_coverage.CoverageError:
+      return None
+
+
+class NoClusterFuzzDeployment(BaseClusterFuzzDeployment):
+  """ClusterFuzzDeployment implementation used when there is no deployment of
+  ClusterFuzz to use."""
+
+  def upload_build(self, commit):  # pylint: disable=no-self-use
+    """Noop Implementation of upload_build."""
+    logging.info('Not uploading latest build because no ClusterFuzz '
+                 'deployment.')
+
+  def upload_corpus(self, target_name, corpus_dir, replace=False):  # pylint: disable=no-self-use,unused-argument
+    """Noop Implementation of upload_corpus."""
+    logging.info('Not uploading corpus because no ClusterFuzz deployment.')
+
+  def upload_crashes(self):  # pylint: disable=no-self-use
+    """Noop Implementation of upload_crashes."""
+    logging.info('Not uploading crashes because no ClusterFuzz deployment.')
+
+  def download_corpus(self, target_name, corpus_dir):
+    """Noop Implementation of download_corpus."""
+    logging.info('Not downloading corpus because no ClusterFuzz deployment.')
+    return _make_empty_dir_if_nonexistent(corpus_dir)
+
+  def download_latest_build(self):  # pylint: disable=no-self-use
+    """Noop Implementation of download_latest_build."""
+    logging.info(
+        'Not downloading latest build because no ClusterFuzz deployment.')
+
+  def upload_coverage(self):
+    """Noop Implementation of upload_coverage."""
+    logging.info(
+        'Not uploading coverage report because no ClusterFuzz deployment.')
+
+  def get_coverage(self, repo_path):
+    """Noop Implementation of get_coverage."""
+    logging.info(
+        'Not getting project coverage because no ClusterFuzz deployment.')
+
+
+_PLATFORM_CLUSTERFUZZ_DEPLOYMENT_MAPPING = {
+    config_utils.BaseConfig.Platform.INTERNAL_GENERIC_CI: OSSFuzz,
+    config_utils.BaseConfig.Platform.INTERNAL_GITHUB: OSSFuzz,
+    config_utils.BaseConfig.Platform.EXTERNAL_GENERIC_CI: ClusterFuzzLite,
+    config_utils.BaseConfig.Platform.EXTERNAL_GITHUB: ClusterFuzzLite,
+}
+
+
+def get_clusterfuzz_deployment(config, workspace):
+  """Returns object reprsenting deployment of ClusterFuzz used by |config|."""
+  deployment_cls = _PLATFORM_CLUSTERFUZZ_DEPLOYMENT_MAPPING[config.platform]
+  if config.no_clusterfuzz_deployment:
+    logging.info('Overriding ClusterFuzzDeployment. Using None.')
+    deployment_cls = NoClusterFuzzDeployment
+  result = deployment_cls(config, workspace)
+  logging.info('ClusterFuzzDeployment: %s.', result)
+  return result

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/docker.py

@@ -0,0 +1,127 @@
+# 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 docker."""
+import logging
+import os
+import sys
+import uuid
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import constants
+import utils
+import environment
+
+BASE_BUILDER_TAG = 'ghcr.io/aixcc-finals/base-builder'
+PROJECT_TAG_PREFIX = 'gcr.io/oss-fuzz/'
+
+# Default fuzz configuration.
+_DEFAULT_DOCKER_RUN_ARGS = [
+    '-e', 'FUZZING_ENGINE=' + constants.DEFAULT_ENGINE, '-e', 'CIFUZZ=True'
+]
+
+UNIQUE_ID_SUFFIX = '-' + uuid.uuid4().hex
+
+# TODO(metzman): Make run_fuzzers able to delete this image.
+EXTERNAL_PROJECT_IMAGE = 'external-cfl-project' + UNIQUE_ID_SUFFIX
+
+_DEFAULT_DOCKER_RUN_COMMAND = [
+    'docker',
+    'run',
+    '--rm',
+    '--privileged',
+]
+
+
+def get_docker_env_vars(env_mapping):
+  """Returns a list of docker arguments that sets each key in |env_mapping| as
+  an env var and the value of that key in |env_mapping| as the value."""
+  env_var_args = []
+  for env_var, env_var_val in env_mapping.items():
+    env_var_args.extend(['-e', f'{env_var}={env_var_val}'])
+  return env_var_args
+
+
+def get_project_image_name(project):
+  """Returns the name of the project builder image for |project_name|."""
+  # TODO(jonathanmetzman): We may need unique names to support parallel fuzzing
+  # for CIFuzz (like CFL supports). Don't do this for now because no one has
+  # asked for it and build_specified_commit would need to be modified to support
+  # this.
+  if project:
+    return PROJECT_TAG_PREFIX + project
+
+  return EXTERNAL_PROJECT_IMAGE
+
+
+def delete_images(images):
+  """Deletes |images|."""
+  command = ['docker', 'rmi', '-f'] + images
+  utils.execute(command)
+  utils.execute(['docker', 'builder', 'prune', '-f'])
+
+
+def get_base_docker_run_args(workspace,
+                             sanitizer=constants.DEFAULT_SANITIZER,
+                             language=constants.DEFAULT_LANGUAGE,
+                             architecture=constants.DEFAULT_ARCHITECTURE,
+                             docker_in_docker=False):
+  """Returns arguments that should be passed to every invocation of 'docker
+  run'."""
+  docker_args = _DEFAULT_DOCKER_RUN_ARGS.copy()
+  env_mapping = {
+      'SANITIZER': sanitizer,
+      'ARCHITECTURE': architecture,
+      'FUZZING_LANGUAGE': language,
+      'OUT': workspace.out
+  }
+  docker_args += get_docker_env_vars(env_mapping)
+  docker_container = environment.get('CFL_CONTAINER_ID',
+                                     utils.get_container_name())
+  logging.info('Docker container: %s.', docker_container)
+  if docker_container and not docker_in_docker:
+    # Don't map specific volumes if in a docker container, it breaks when
+    # running a sibling container.
+    docker_args += ['--volumes-from', docker_container]
+  else:
+    docker_args += _get_args_mapping_host_path_to_container(workspace.workspace)
+  return docker_args, docker_container
+
+
+def get_base_docker_run_command(workspace,
+                                sanitizer=constants.DEFAULT_SANITIZER,
+                                language=constants.DEFAULT_LANGUAGE,
+                                architecture=constants.DEFAULT_ARCHITECTURE,
+                                docker_in_docker=False):
+  """Returns part of the command that should be used everytime 'docker run' is
+  invoked."""
+  docker_args, docker_container = get_base_docker_run_args(
+      workspace,
+      sanitizer,
+      language,
+      architecture,
+      docker_in_docker=docker_in_docker)
+  command = _DEFAULT_DOCKER_RUN_COMMAND.copy() + docker_args
+  return command, docker_container
+
+
+def _get_args_mapping_host_path_to_container(host_path, container_path=None):
+  """Get arguments to docker run that will map |host_path| a path on the host to
+  a path in the container. If |container_path| is specified, that path is mapped
+  to. If not, then |host_path| is mapped to itself in the container."""
+  # WARNING: Do not use this function when running in production (and
+  # --volumes-from) is used for mapping volumes. It will break production.
+  container_path = host_path if container_path is None else container_path
+  return ['-v', f'{host_path}:{container_path}']

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/example_cifuzz.yml

@@ -0,0 +1,33 @@
+name: CIFuzz
+on: [pull_request]
+permissions: {}
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+    steps:
+    - name: Build Fuzzers
+      id: build
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'example'
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'example'
+        fuzz-seconds: 600
+        output-sarif: true
+    - name: Upload Crash
+      uses: actions/upload-artifact@v3
+      if: failure() && steps.build.outcome == 'success'
+      with:
+        name: artifacts
+        path: ./out/artifacts   
+    - name: Upload Sarif
+      if: always() && steps.build.outcome == 'success'
+      uses: github/codeql-action/upload-sarif@v2
+      with:
+        # Path to SARIF file relative to the root of the repository
+        sarif_file: cifuzz-sarif/results.sarif
+        checkout_path: cifuzz-sarif

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/filestore_utils.py

@@ -0,0 +1,48 @@
+# 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.
+"""External filestore interface. Cannot be depended on by filestore code."""
+import filestore
+import filestore.filesystem
+import filestore.git
+import filestore.github_actions
+import filestore.gsutil
+import filestore.no_filestore
+import filestore.gitlab
+
+FILESTORE_MAPPING = {
+    'filesystem': filestore.filesystem.FilesystemFilestore,
+    'gsutil': filestore.gsutil.GSUtilFilestore,
+    'github-actions': filestore.github_actions.GithubActionsFilestore,
+    'git': filestore.git.GitFilestore,
+    # TODO(metzman): Change to "no-filestore"
+    'no_filestore': filestore.no_filestore.NoFilestore,
+    'gitlab': filestore.gitlab.GitlabFilestore,
+}
+
+
+def get_filestore(config):
+  """Returns the correct filestore object based on the platform in |config|.
+  Raises an exception if there is no correct filestore for the platform."""
+  if config.platform == config.Platform.EXTERNAL_GITHUB:
+    ci_filestore = filestore.github_actions.GithubActionsFilestore(config)
+    if not config.git_store_repo:
+      return ci_filestore
+
+    return filestore.git.GitFilestore(config, ci_filestore)
+
+  filestore_cls = FILESTORE_MAPPING.get(config.filestore)
+  if filestore_cls is None:
+    raise filestore.FilestoreError(
+        f'Filestore: {config.filestore} doesn\'t exist.')
+  return filestore_cls(config)

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/logs.py

@@ -0,0 +1,25 @@
+# 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.
+"""Log helpers."""
+
+import logging
+import os
+
+
+def init():
+  """Initialize logging."""
+  log_level = logging.DEBUG if os.getenv('CIFUZZ_DEBUG') else logging.INFO
+  logging.basicConfig(
+      format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+      level=log_level)

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/requirements.txt

@@ -0,0 +1,4 @@
+clusterfuzz==2.5.9
+requests==2.28.0
+protobuf==3.20.2
+gsutil==5.20

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/sarif_utils.py

@@ -0,0 +1,251 @@
+# 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.
+"""Module for outputting SARIF data."""
+import copy
+import json
+import logging
+import os
+
+from clusterfuzz import stacktraces
+
+SARIF_RULES = [
+    {
+        'id': 'no-crashes',
+        'shortDescription': {
+            'text': 'Don\'t crash'
+        },
+        'helpUri': 'https://cwe.mitre.org/data/definitions/416.html',
+        'properties': {
+            'category': 'Crashes'
+        }
+    },
+    {
+        'id': 'heap-use-after-free',
+        'shortDescription': {
+            'text': 'Use of a heap-object after it has been freed.'
+        },
+        'helpUri': 'https://cwe.mitre.org/data/definitions/416.html',
+        'properties': {
+            'category': 'Crashes'
+        }
+    },
+    {
+        'id': 'heap-buffer-overflow',
+        'shortDescription': {
+            'text': 'A read or write past the end of a heap buffer.'
+        },
+        'helpUri': 'https://cwe.mitre.org/data/definitions/122.html',
+        'properties': {
+            'category': 'Crashes'
+        }
+    },
+    {
+        'id': 'stack-buffer-overflow',
+        'shortDescription': {
+            'text': 'A read or write past the end of a stack buffer.'
+        },
+        'helpUri': 'https://cwe.mitre.org/data/definitions/121.html',
+        'properties': {
+            'category': 'Crashes'
+        }
+    },
+    {
+        'id': 'global-buffer-overflow',
+        'shortDescription': {
+            'text': 'A read or write past the end of a global buffer.'
+        },
+        'helpUri': 'https://cwe.mitre.org/data/definitions/121.html',
+        'properties': {
+            'category': 'Crashes'
+        }
+    },
+    {
+        'id': 'stack-use-after-return',
+        'shortDescription': {
+            'text':
+                'A stack-based variable has been used after the function returned.'
+        },
+        'helpUri': 'https://cwe.mitre.org/data/definitions/562.html',
+        'properties': {
+            'category': 'Crashes'
+        }
+    },
+    {
+        'id': 'stack-use-after-scope',
+        'shortDescription': {
+            'text':
+                'A stack-based variable has been used outside of the scope in which it exists.'
+        },
+        'helpUri': 'https://cwe.mitre.org/data/definitions/562.html',
+        'properties': {
+            'category': 'Crashes'
+        }
+    },
+    {
+        'id': 'initialization-order-fiasco',
+        'shortDescription': {
+            'text': 'Problem with order of initialization of global objects.'
+        },
+        'helpUri': 'https://isocpp.org/wiki/faq/ctors#static-init-order',
+        'properties': {
+            'category': 'Crashes'
+        }
+    },
+    {
+        'id':
+            'direct-leak',
+        'shortDescription': {
+            'text': 'Memory is leaked.'
+        },
+        'helpUri':
+            'https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer',
+        'properties': {
+            'category': 'Crashes'
+        }
+    },
+    {
+        'id':
+            'indirect-leak',
+        'shortDescription': {
+            'text': 'Memory is leaked.'
+        },
+        'helpUri':
+            'https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer',
+        'properties': {
+            'category': 'Crashes'
+        }
+    },
+]
+SARIF_DATA = {
+    'version':
+        '2.1.0',
+    '$schema':
+        'http://json.schemastore.org/sarif-2.1.0-rtm.4',
+    'runs': [{
+        'tool': {
+            'driver': {
+                'name': 'ClusterFuzzLite/CIFuzz',
+                'informationUri': 'https://google.github.io/clusterfuzzlite/',
+                'rules': SARIF_RULES,
+            }
+        },
+        'results': []
+    }]
+}
+
+SRC_ROOT = '/src/'
+
+
+def redact_src_path(src_path):
+  """Redact the src path so that it can be reported to users."""
+  src_path = os.path.normpath(src_path)
+  if src_path.startswith(SRC_ROOT):
+    src_path = src_path[len(SRC_ROOT):]
+
+  src_path = os.sep.join(src_path.split(os.sep)[1:])
+  return src_path
+
+
+def get_error_frame(crash_info):
+  """Returns the stackframe where the error occurred."""
+  if not crash_info.crash_state:
+    return None
+  state = crash_info.crash_state.split('\n')[0]
+  logging.info('state: %s frames %s, %s', state, crash_info.frames,
+               [f.function_name for f in crash_info.frames[0]])
+
+  for crash_frames in crash_info.frames:
+    for frame in crash_frames:
+      # TODO(metzman): Do something less fragile here.
+      if frame.function_name is None:
+        continue
+      if state in frame.function_name:
+        return frame
+  return None
+
+
+def get_error_source_info(crash_info):
+  """Returns the filename and the line where the bug occurred."""
+  frame = get_error_frame(crash_info)
+  if not frame:
+    return (None, 1)
+  try:
+    return redact_src_path(frame.filename), int(frame.fileline or 1)
+  except TypeError:
+    return (None, 1)
+
+
+def get_rule_index(crash_type):
+  """Returns the rule index describe the rule that |crash_type| ran afoul of."""
+  # Don't include "READ" or "WRITE" or number of bytes.
+  crash_type = crash_type.replace('\n', ' ').split(' ')[0].lower()
+  logging.info('crash_type: %s.', crash_type)
+  for idx, rule in enumerate(SARIF_RULES):
+    if rule['id'] == crash_type:
+      logging.info('Rule index: %d.', idx)
+      return idx
+
+  return get_rule_index('no-crashes')
+
+
+def get_sarif_data(stacktrace, target_path):
+  """Returns a description of the crash in SARIF."""
+  data = copy.deepcopy(SARIF_DATA)
+  if stacktrace is None:
+    return data
+
+  fuzz_target = os.path.basename(target_path)
+  stack_parser = stacktraces.StackParser(fuzz_target=fuzz_target,
+                                         symbolized=True,
+                                         detect_ooms_and_hangs=True,
+                                         include_ubsan=True)
+  crash_info = stack_parser.parse(stacktrace)
+  error_source_info = get_error_source_info(crash_info)
+  rule_idx = get_rule_index(crash_info.crash_type)
+  rule_id = SARIF_RULES[rule_idx]['id']
+  uri = error_source_info[0]
+
+  result = {
+      'level': 'error',
+      'message': {
+          'text': crash_info.crash_type
+      },
+      'locations': [{
+          'physicalLocation': {
+              'artifactLocation': {
+                  'uri': uri,
+                  'index': 0
+              },
+              'region': {
+                  'startLine': error_source_info[1],
+                  # We don't have this granualarity fuzzing.
+                  'startColumn': 1,
+              }
+          }
+      }],
+      'ruleId': rule_id,
+      'ruleIndex': rule_idx
+  }
+  if uri:
+    data['runs'][0]['results'].append(result)
+  return data
+
+
+def write_stacktrace_to_sarif(stacktrace, target_path, workspace):
+  """Writes a description of the crash in stacktrace to a SARIF file."""
+  data = get_sarif_data(stacktrace, target_path)
+  if not os.path.exists(workspace.sarif):
+    os.makedirs(workspace.sarif)
+  with open(os.path.join(workspace.sarif, 'results.sarif'), 'w') as file_handle:
+    file_handle.write(json.dumps(data))

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/cifuzz/workspace_utils.py

@@ -0,0 +1,85 @@
+# 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 representing the workspace directory which CIFuzz uses."""
+
+import os
+import shutil
+
+
+class Workspace:
+  """Class representing the workspace directory."""
+
+  def __init__(self, config):
+    self.workspace = config.workspace
+
+  def initialize_dir(self, directory):  # pylint: disable=no-self-use
+    """Creates directory if it doesn't already exist, otherwise does nothing."""
+    os.makedirs(directory, exist_ok=True)
+
+  @property
+  def repo_storage(self):
+    """The parent directory for repo storage."""
+    return os.path.join(self.workspace, 'storage')
+
+  @property
+  def out(self):
+    """The out directory used for storing the fuzzer build built by
+    build_fuzzers."""
+    # Don't use 'out' because it needs to be used by artifacts.
+    return os.path.join(self.workspace, 'build-out')
+
+  @property
+  def work(self):
+    """The directory used as the work directory for the fuzzer build/run."""
+    return os.path.join(self.workspace, 'work')
+
+  @property
+  def artifacts(self):
+    """The directory used to store artifacts for download by CI-system users."""
+    # This is hardcoded by a lot of clients, so we need to use this.
+    return os.path.join(self.workspace, 'out', 'artifacts')
+
+  @property
+  def clusterfuzz_build(self):
+    """The directory where builds from ClusterFuzz are stored."""
+    return os.path.join(self.workspace, 'cifuzz-prev-build')
+
+  @property
+  def clusterfuzz_coverage(self):
+    """The directory where builds from ClusterFuzz are stored."""
+    return os.path.join(self.workspace, 'cifuzz-prev-coverage')
+
+  @property
+  def coverage_report(self):
+    """The directory where coverage reports generated by cifuzz are put."""
+    return os.path.join(self.workspace, 'cifuzz-coverage')
+
+  @property
+  def corpora(self):
+    """The directory where corpora from ClusterFuzz are stored."""
+    return os.path.join(self.workspace, 'cifuzz-corpus')
+
+  @property
+  def pruned_corpora(self):
+    """The directory where pruned corpora are stored."""
+    return os.path.join(self.workspace, 'cifuzz-pruned-corpus')
+
+  @property
+  def sarif(self):
+    """The directory where sarif files are stored."""
+    return os.path.join(self.workspace, 'cifuzz-sarif')
+
+  def make_repo_for_sarif(self, repo_manager):
+    """Copies the repo over for the sarif upload GitHub action."""
+    return shutil.copytree(repo_manager.repo_dir, self.sarif, symlinks=True)

local-test-tika-full-01-vuln_0/fuzz-tooling/infra/tools/hold_back_images.py

@@ -0,0 +1,128 @@
+#!/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 pinning builder images for projects that break on upgrades. Works
+with projects that use language builders."""
+import argparse
+import logging
+import os
+import re
+import sys
+import subprocess
+
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+PROJECTS_DIR = os.path.join(ROOT_DIR, 'projects')
+
+IMAGE_DIGEST_REGEX = re.compile(r'\[(.+)\]\n')
+FROM_LINE_REGEX = re.compile(
+    r'FROM (ghcr.io\/aixcc-finals\/base-builder[\-a-z0-9]*)(\@?.*)')
+
+
+def get_latest_docker_image_digest(image):
+  """Returns a pinnable version of the latest |image|. This version will have a
+  SHA."""
+  subprocess.run(['docker', 'pull', image], check=True)
+  subprocess.run(['docker', 'pull', image], stdout=subprocess.PIPE, check=True)
+
+  command = [
+      'docker', 'image', 'inspect', '--format', '{{.RepoDigests}}', image
+  ]
+  output = subprocess.run(command, check=True,
+                          stdout=subprocess.PIPE).stdout.decode('utf-8')
+  return IMAGE_DIGEST_REGEX.match(output).groups(1)[0]
+
+
+def get_args():
+  """Returns parsed arguments."""
+  parser = argparse.ArgumentParser(sys.argv[0],
+                                   description='Hold back builder images.')
+  parser.add_argument('projects', help='Projects.', nargs='+')
+
+  parser.add_argument('--hold-image-digest',
+                      required=False,
+                      nargs='?',
+                      default=None,
+                      help='Image to hold on to.')
+
+  parser.add_argument('--update-held',
+                      action='store_true',
+                      default=False,
+                      help='Update held images.')
+
+  parser.add_argument('--issue-number',
+                      required=False,
+                      nargs='?',
+                      default=None,
+                      help='Issue to reference.')
+
+  args = parser.parse_args()
+  return args
+
+
+def get_hold_image_digest(line, hold_image_digest, update_held):
+  """Returns the image digest for the |line| we want to pin. If the image is
+  already pinned then it is only updated if |update_held. If |hold_image_digest
+  is specified then it is returned, otherwise the latest pinnable version is
+  returned."""
+  matches = FROM_LINE_REGEX.match(line).groups()
+  if matches[1] and not update_held:
+    return None, False
+  initial_image = matches[0]
+  if hold_image_digest:
+    return hold_image_digest, True
+  return get_latest_docker_image_digest(initial_image), True
+
+
+def hold_image(project, hold_image_digest, update_held, issue_number):
+  """Rewrites the Dockerfile of |project| to pin the base-builder image on
+  upgrade."""
+  dockerfile_path = os.path.join(PROJECTS_DIR, project, 'Dockerfile')
+  with open(dockerfile_path, 'r') as dockerfile_handle:
+    dockerfile = dockerfile_handle.readlines()
+  for idx, line in enumerate(dockerfile[:]):
+    if not line.startswith('FROM ghcr.io/aixcc-finals/base-builder'):
+      continue
+
+    hold_image_digest, should_hold = get_hold_image_digest(
+        line.strip(), hold_image_digest, update_held)
+    if not should_hold:
+      logging.error('Not holding back %s.', project)
+      break
+    dockerfile[idx] = f'FROM {hold_image_digest}\n'
+    if issue_number:
+      comment = ('# Held back because of github.com/google/oss-fuzz/pull/'
+                 f'{issue_number}\n# Please fix failure and upgrade.\n')
+      dockerfile.insert(idx, comment)
+    break
+  else:
+    # This path is taken when we don't break out of the loop.
+    assert None, f'Could not find FROM line in {project}'
+  dockerfile = ''.join(dockerfile)
+  with open(dockerfile_path, 'w') as dockerfile_handle:
+    dockerfile_handle.write(dockerfile)
+
+
+def main():
+  """Script for pinning builder images for projects that break on upgrades."""
+  args = get_args()
+  for project in args.projects:
+    hold_image(project, args.hold_image_digest, args.update_held,
+               args.issue_number)
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-full-01-vuln_0/fuzz-tooling/tools/vscode-extension/src/commands/cmdBuildFuzzerFromWorkspaceCFLite.ts

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// 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.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {commandHistory} from '../commandUtils';
+import {setStatusText} from '../utils';
+import {buildFuzzersFromWorkspaceClusterfuzzLite} from '../ossfuzzWrappers';
+
+export async function cmdInputCollectorBuildFuzzersFromWorkspaceCFLite() {
+  // Create an history object
+  const args = new Object({
+    toClean: false,
+  });
+
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.WSBuildFuzzers',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchbuildFuzzersFromWorkspaceClusterfuzzLite,
+  });
+  console.log('L1: ' + commandHistory.length);
+  commandHistory.push(commandObject);
+
+  await cmdDispatchbuildFuzzersFromWorkspaceClusterfuzzLite(args);
+  return true;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function cmdDispatchbuildFuzzersFromWorkspaceClusterfuzzLite(_args: any) {
+  await setStatusText('[CFLite] Building fuzzers: starting');
+  const res = await buildFuzzersFromWorkspaceClusterfuzzLite();
+  if (res) {
+    await setStatusText('[CFLite] Building fuzzers: finished');
+  } else {
+    await setStatusText('[CFLite] Building fuzzers: failed');
+  }
+}

local-test-tika-full-01-vuln_0/fuzz-tooling/tools/vscode-extension/src/commands/cmdDisplayCoverage.ts

@@ -0,0 +1,71 @@
+// 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.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {loadCoverageIntoWorkspace} from '../coverageHelper';
+import {println} from '../logger';
+import {getApi, FileDownloader} from '@microsoft/vscode-file-downloader-api';
+
+/*
+ * Displays code coverage from OSS-Fuzz.
+ *
+ * Downloads a code coverage report from the OSS-Fuzz online storage, and then overlays
+ * the relevant source files with the coverage information.
+ */
+export async function displayCodeCoverageFromOssFuzz(
+  context: vscode.ExtensionContext
+) {
+  const projectName = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: "The project you'd like to get code coverage for.",
+  });
+  if (!projectName) {
+    return;
+  }
+  println('Getting code coverage for ' + projectName);
+
+  const fileDownloader: FileDownloader = await getApi();
+
+  const currentDate = new Date();
+  const yesterday = new Date(currentDate);
+  yesterday.setDate(yesterday.getDate() - 1);
+
+  const day = yesterday.getDate();
+  const month = yesterday.getMonth();
+  const year = yesterday.getFullYear();
+
+  try {
+    const codeCoverageFile: vscode.Uri = await fileDownloader.downloadFile(
+      vscode.Uri.parse(
+        'https://storage.googleapis.com/oss-fuzz-coverage/' +
+          projectName +
+          '/textcov_reports/' +
+          year.toString() +
+          month.toString() +
+          day.toString() +
+          '/all_cov.json'
+      ),
+      'all_cov.json',
+      context
+    );
+    await loadCoverageIntoWorkspace(context, codeCoverageFile);
+  } catch (err) {
+    println(
+      'Could not get the URL. Currently, this feature is only supported for Python projects'
+    );
+    return;
+  }
+}