Add files using upload-large-folder tool

local-test-tika-delta-05/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-delta-05/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-delta-05/fuzz-tooling/infra/cifuzz/base_runner_utils.py

@@ -0,0 +1,33 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Utilities for scripts from ghcr.io/aixcc-finals/base-runner."""
+
+import os
+
+import config_utils
+
+
+def get_env(config, workspace):
+  """Returns a dictionary containing the current environment with additional env
+  vars set to values needed to run a fuzzer."""
+  env = os.environ.copy()
+  env['SANITIZER'] = config.sanitizer
+  env['FUZZING_LANGUAGE'] = config.language
+  env['OUT'] = workspace.out
+  env['CIFUZZ'] = 'True'
+  env['FUZZING_ENGINE'] = config_utils.DEFAULT_ENGINE
+  env['ARCHITECTURE'] = config.architecture
+  # Do this so we don't fail in tests.
+  env['FUZZER_ARGS'] = '-rss_limit_mb=2560 -timeout=25'
+  return env

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/build_fuzzers.py

@@ -0,0 +1,217 @@
+# 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.
+"""Module used by CI tools in order to interact with fuzzers. This module helps
+CI tools to build fuzzers."""
+
+import logging
+import os
+import sys
+
+import affected_fuzz_targets
+import base_runner_utils
+import clusterfuzz_deployment
+import continuous_integration
+import docker
+import logs
+import workspace_utils
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import helper
+import utils
+
+logs.init()
+
+
+def check_project_src_path(project_src_path):
+  """Returns True if |project_src_path| exists."""
+  if not os.path.exists(project_src_path):
+    logging.error(
+        'PROJECT_SRC_PATH: %s does not exist. '
+        'Are you mounting it correctly?', project_src_path)
+    return False
+  return True
+
+
+# pylint: disable=too-many-arguments
+
+
+class Builder:  # pylint: disable=too-many-instance-attributes
+  """Class for fuzzer builders."""
+
+  def __init__(self, config, ci_system):
+    self.config = config
+    self.ci_system = ci_system
+    self.workspace = workspace_utils.Workspace(config)
+    self.workspace.initialize_dir(self.workspace.out)
+    self.workspace.initialize_dir(self.workspace.work)
+    self.clusterfuzz_deployment = (
+        clusterfuzz_deployment.get_clusterfuzz_deployment(
+            self.config, self.workspace))
+    self.image_repo_path = None
+    self.host_repo_path = None
+    self.repo_manager = None
+
+  def build_image_and_checkout_src(self):
+    """Builds the project builder image and checkout source code for the patch
+    we want to fuzz (if necessary). Returns True on success."""
+    result = self.ci_system.prepare_for_fuzzer_build()
+    if not result.success:
+      return False
+    self.image_repo_path = result.image_repo_path
+    self.repo_manager = result.repo_manager
+    if self.config.output_sarif:
+      self.workspace.make_repo_for_sarif(self.repo_manager)
+    logging.info('repo_dir: %s.', self.repo_manager.repo_dir)
+    self.host_repo_path = self.repo_manager.repo_dir
+    return True
+
+  def build_fuzzers(self):
+    """Moves the source code we want to fuzz into the project builder and builds
+    the fuzzers from that source code. Returns True on success."""
+    docker_args, docker_container = docker.get_base_docker_run_args(
+        self.workspace, self.config.sanitizer, self.config.language,
+        self.config.architecture, self.config.docker_in_docker)
+    if not docker_container:
+      docker_args.extend(
+          _get_docker_build_fuzzers_args_not_container(self.host_repo_path))
+
+    build_command = self.ci_system.get_build_command(self.host_repo_path,
+                                                     self.image_repo_path)
+
+    # Set extra environment variables so that they are visible to the build.
+    for key in self.config.extra_environment_variables:
+      # Don't specify their value in case they get echoed.
+      docker_args.extend(['-e', key])
+
+    docker_args.extend([
+        docker.get_project_image_name(self.config.oss_fuzz_project_name),
+        '/bin/bash',
+        '-c',
+        build_command,
+    ])
+    logging.info('Building with %s sanitizer.', self.config.sanitizer)
+
+    # TODO(metzman): Stop using helper.docker_run so we can get rid of
+    # docker.get_base_docker_run_args and merge its contents into
+    # docker.get_base_docker_run_command.
+    if not helper.docker_run(docker_args):
+      logging.error('Building fuzzers failed.')
+      return False
+
+    return True
+
+  def upload_build(self):
+    """Upload build."""
+    if self.config.upload_build:
+      self.clusterfuzz_deployment.upload_build(
+          self.repo_manager.get_current_commit())
+
+    return True
+
+  def check_fuzzer_build(self):
+    """Checks the fuzzer build. Returns True on success or if config specifies
+    to skip check."""
+    if not self.config.bad_build_check:
+      return True
+
+    return check_fuzzer_build(self.config)
+
+  def build(self):
+    """Builds the image, checkouts the source (if needed), builds the fuzzers
+    and then removes the unaffectted fuzzers. Returns True on success."""
+    methods = [
+        self.build_image_and_checkout_src,
+        self.build_fuzzers,
+        self.remove_unaffected_fuzz_targets,
+        self.upload_build,
+        self.check_fuzzer_build,
+    ]
+    for method in methods:
+      if not method():
+        return False
+    return True
+
+  def remove_unaffected_fuzz_targets(self):
+    """Removes the fuzzers unaffected by the patch."""
+    if self.config.keep_unaffected_fuzz_targets:
+      logging.info('Not removing unaffected fuzz targets.')
+      return True
+
+    logging.info('Removing unaffected fuzz targets.')
+    changed_files = self.ci_system.get_changed_code_under_test(
+        self.repo_manager)
+    affected_fuzz_targets.remove_unaffected_fuzz_targets(
+        self.clusterfuzz_deployment, self.workspace.out, changed_files,
+        self.image_repo_path)
+    return True
+
+
+def build_fuzzers(config):
+  """Builds all of the fuzzers for a specific OSS-Fuzz project.
+
+  Args:
+    config: The configuration object for building fuzzers.
+
+  Returns:
+    True if build succeeded.
+  """
+  # Do some quick validation.
+  if config.project_src_path and not check_project_src_path(
+      config.project_src_path):
+    return False
+
+  # Get the builder and then build the fuzzers.
+  ci_system = continuous_integration.get_ci(config)
+  logging.info('ci_system: %s.', ci_system)
+  builder = Builder(config, ci_system)
+  return builder.build()
+
+
+def check_fuzzer_build(config):
+  """Checks the integrity of the built fuzzers.
+
+  Args:
+    config: The config object.
+
+  Returns:
+    True if fuzzers pass OSS-Fuzz's build check.
+  """
+  workspace = workspace_utils.Workspace(config)
+  if not os.path.exists(workspace.out):
+    logging.error('Invalid out directory: %s.', workspace.out)
+    return False
+  if not os.listdir(workspace.out):
+    logging.error('No fuzzers found in out directory: %s.', workspace.out)
+    return False
+
+  env = base_runner_utils.get_env(config, workspace)
+  if config.allowed_broken_targets_percentage is not None:
+    env['ALLOWED_BROKEN_TARGETS_PERCENTAGE'] = (
+        config.allowed_broken_targets_percentage)
+
+  stdout, stderr, retcode = utils.execute('test_all.py', env=env)
+  print(f'Build check: stdout: {stdout}\nstderr: {stderr}')
+  if retcode == 0:
+    logging.info('Build check passed.')
+    return True
+  logging.error('Build check failed.')
+  return False
+
+
+def _get_docker_build_fuzzers_args_not_container(host_repo_path):
+  """Returns arguments to the docker build arguments that are needed to use
+  |host_repo_path| when the host of the OSS-Fuzz builder container is not
+  another container."""
+  return ['-v', f'{host_repo_path}:{host_repo_path}']

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/cifuzz_end_to_end_test.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.
+"""End-to-End tests for CIFuzz."""
+import os
+import unittest
+
+import run_cifuzz
+import test_helpers
+
+CIFUZZ_DIR = os.path.dirname(os.path.abspath(__file__))
+EXTERNAL_PROJECT_PATH = os.path.join(CIFUZZ_DIR, 'test_data',
+                                     'external-project')
+
+
+# This test will fail if not run as root because the fuzzer build process
+# creates binaries that only root can write to.
+# Use a seperate env var to keep this seperate from integration tests which
+# don't have this annoying property.
+@unittest.skipIf(not os.getenv('END_TO_END_TESTS'),
+                 'END_TO_END_TESTS=1 not set')
+class EndToEndTest(unittest.TestCase):
+  """End-to-End tests for CIFuzz."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self, runner=True)
+
+  def test_simple(self):
+    """Simple end-to-end test using run_cifuzz.main()."""
+    os.environ['REPOSITORY'] = 'external-project'
+    os.environ['PROJECT_SRC_PATH'] = EXTERNAL_PROJECT_PATH
+    os.environ['FILESTORE'] = 'no_filestore'
+    os.environ['NO_CLUSTERFUZZ_DEPLOYMENT'] = 'True'
+
+    with test_helpers.docker_temp_dir() as temp_dir:
+      os.environ['WORKSPACE'] = temp_dir
+      # TODO(metzman): Verify the crash, affected fuzzers, and other things.
+      self.assertEqual(run_cifuzz.main(), 1)

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/config_utils_test.py

@@ -0,0 +1,200 @@
+# 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 config_utils."""
+import os
+import unittest
+from unittest import mock
+
+import config_utils
+import constants
+import test_helpers
+
+# pylint: disable=no-self-use,protected-access
+
+
+class BaseConfigTest(unittest.TestCase):
+  """Tests for BaseConfig."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+
+  def _create_config(self):
+    return config_utils.BuildFuzzersConfig()
+
+  def test_language_default(self):
+    """Tests that the correct default language is set."""
+    config = self._create_config()
+    self.assertEqual(config.language, 'c++')
+
+  def test_language(self):
+    """Tests that the correct language is set."""
+    language = 'python'
+    os.environ['LANGUAGE'] = language
+    config = self._create_config()
+    self.assertEqual(config.language, language)
+
+  def test_is_coverage(self):
+    """Tests that is_coverage is set correctly."""
+    # Test it is set when it is supposed to be.
+    os.environ['SANITIZER'] = 'coverage'
+    config = self._create_config()
+    self.assertTrue(config.is_coverage)
+
+    # Test it is not set when it is not supposed to be.
+    os.environ['SANITIZER'] = 'address'
+    config = self._create_config()
+    self.assertFalse(config.is_coverage)
+
+  @mock.patch('logging.error')
+  def test_validate_no_workspace(self, mock_error):
+    """Tests that validate returns False if GITHUB_WORKSPACE isn't set."""
+    os.environ['OSS_FUZZ_PROJECT_NAME'] = 'example'
+    config = self._create_config()
+    self.assertFalse(config.validate())
+    mock_error.assert_called_with('Must set WORKSPACE.')
+
+  @mock.patch('logging.error')
+  def test_validate_invalid_language(self, mock_error):
+    """Tests that validate returns False if GITHUB_WORKSPACE isn't set."""
+    os.environ['OSS_FUZZ_PROJECT_NAME'] = 'example'
+    os.environ['WORKSPACE'] = '/workspace'
+    os.environ['LANGUAGE'] = 'invalid-language'
+    config = self._create_config()
+    self.assertFalse(config.validate())
+    mock_error.assert_called_with('Invalid LANGUAGE: %s. Must be one of: %s.',
+                                  os.environ['LANGUAGE'], constants.LANGUAGES)
+
+  @mock.patch('logging.error')
+  def test_validate_invalid_sanitizer(self, mock_error):
+    """Tests that validate returns False if GITHUB_WORKSPACE isn't set."""
+    os.environ['OSS_FUZZ_PROJECT_NAME'] = 'example'
+    os.environ['WORKSPACE'] = '/workspace'
+    os.environ['SANITIZER'] = 'invalid-sanitizer'
+    config = self._create_config()
+    self.assertFalse(config.validate())
+    mock_error.assert_called_with('Invalid SANITIZER: %s. Must be one of: %s.',
+                                  os.environ['SANITIZER'],
+                                  config_utils.SANITIZERS)
+
+  def test_validate(self):
+    """Tests that validate returns True if config is valid."""
+    os.environ['OSS_FUZZ_PROJECT_NAME'] = 'example'
+    os.environ['WORKSPACE'] = '/workspace'
+    os.environ['REPOSITORY'] = 'repo'
+    config = self._create_config()
+    self.assertTrue(config.validate())
+
+
+class BuildFuzzersConfigTest(unittest.TestCase):
+  """Tests for BuildFuzzersConfig."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+
+  def _create_config(self):
+    return config_utils.BuildFuzzersConfig()
+
+  @mock.patch('platform_config.github._get_event_data', return_value={})
+  def test_github_base_ref(self, _):
+    """Tests that base_ref is set properly."""
+    expected_base_ref = 'expected_base_ref'
+    os.environ['GITHUB_BASE_REF'] = expected_base_ref
+    os.environ['CFL_PLATFORM'] = 'github'
+    os.environ['GITHUB_REPOSITORY'] = 'owner/repo'
+    config = self._create_config()
+    self.assertEqual(config.base_ref, expected_base_ref)
+
+  def test_base_ref(self):
+    """Tests that base_ref is set properly."""
+    expected_base_ref = 'expected_base_ref'
+    os.environ['GIT_BASE_REF'] = expected_base_ref
+    config = self._create_config()
+    self.assertEqual(config.base_ref, expected_base_ref)
+
+  def test_keep_unaffected_defaults_to_true(self):
+    """Tests that keep_unaffected_fuzz_targets defaults to true."""
+    config = self._create_config()
+    self.assertTrue(config.keep_unaffected_fuzz_targets)
+
+  def test_keep_unaffected_defaults_to_false_when_pr(self):
+    """Tests that keep_unaffected_fuzz_targets defaults to false when from a
+    pr."""
+    os.environ['GIT_BASE_REF'] = 'base-ref'
+    config = self._create_config()
+    self.assertFalse(config.keep_unaffected_fuzz_targets)
+
+
+class RunFuzzersConfigTest(unittest.TestCase):
+  """Tests for RunFuzzersConfig."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+
+  def _create_config(self):
+    return config_utils.RunFuzzersConfig()
+
+  def test_coverage(self):
+    """Tests that mode is overriden properly based on is_coverage."""
+    # Test that it is overriden when it is supposed to be.
+    os.environ['SANITIZER'] = 'coverage'
+    os.environ['MODE'] = 'code-change'
+    config = self._create_config()
+    self.assertEqual(config.mode, 'coverage')
+
+    # Test that it isn't overriden when it isn't supposed to be.
+    os.environ['SANITIZER'] = 'address'
+    mode = 'code-change'
+    os.environ['MODE'] = mode
+    config = self._create_config()
+    self.assertEqual(config.mode, mode)
+
+  def test_run_config_validate(self):
+    """Tests that _run_config_validate returns True when the config is valid."""
+    self.assertTrue(self._create_config()._run_config_validate())
+
+  @mock.patch('logging.error')
+  def test_run_config_invalid_mode(self, mock_error):
+    """Tests that _run_config_validate returns False when mode is invalid."""
+    fake_mode = 'fake-mode'
+    os.environ['MODE'] = fake_mode
+    self.assertFalse(self._create_config()._run_config_validate())
+    mock_error.assert_called_with('Invalid MODE: %s. Must be one of %s.',
+                                  fake_mode,
+                                  config_utils.RunFuzzersConfig.MODES)
+
+
+class GetSanitizerTest(unittest.TestCase):
+  """Tests for _get_sanitizer."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+    self.sanitizer = 'memory'
+
+  def test_default_value(self):
+    """Tests that the default value returned by _get_sanitizer is correct."""
+    self.assertEqual(config_utils._get_sanitizer(), 'address')
+
+  def test_normal_case(self):
+    """Tests that _get_sanitizer returns the correct value in normal cases."""
+    os.environ['SANITIZER'] = self.sanitizer
+    self.assertEqual(config_utils._get_sanitizer(), self.sanitizer)
+
+  def test_capitalization(self):
+    """Tests that that _get_sanitizer handles capitalization properly."""
+    os.environ['SANITIZER'] = self.sanitizer.upper()
+    self.assertEqual(config_utils._get_sanitizer(), self.sanitizer)
+
+
+if __name__ == '__main__':
+  unittest.main()

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/continuous_integration_test.py

@@ -0,0 +1,88 @@
+# 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 continuous_integration_module."""
+import os
+import sys
+import unittest
+from unittest import mock
+
+import continuous_integration
+import docker
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import repo_manager
+
+# pylint: disable=no-self-use
+
+
+class FixGitRepoForDiffTest(unittest.TestCase):
+  """Tests for fix_git_repo_for_diff."""
+
+  @mock.patch('utils.execute')
+  def test_fix_git_repo_for_diff(self, mock_execute):
+    """Tests that fix_git_repo_for_diff works as intended."""
+    repo_dir = '/dir'
+    repo_manager_obj = repo_manager.RepoManager(repo_dir)
+    continuous_integration.fix_git_repo_for_diff(repo_manager_obj)
+    expected_command = [
+        'git', 'symbolic-ref', 'refs/remotes/origin/HEAD',
+        'refs/remotes/origin/master'
+    ]
+
+    mock_execute.assert_called_with(expected_command, location=repo_dir)
+
+
+class GetBuildCommand(unittest.TestCase):
+  """Tests for get_build_command."""
+
+  def test_build_command(self):
+    """Tests that get_build_command works as intended."""
+    self.assertEqual(continuous_integration.get_build_command(), 'compile')
+
+
+class GetReplaceRepoAndBuildCommand(unittest.TestCase):
+  """Tests for get_replace_repo_and_build_command."""
+
+  def test_get_replace_repo_and_build_command(self):
+    """Tests that get_replace_repo_and_build_command works as intended."""
+    host_repo_path = '/path/on/host/to/repo'
+    image_repo_path = '/src/repo'
+    command = continuous_integration.get_replace_repo_and_build_command(
+        host_repo_path, image_repo_path)
+    expected_command = ('cd / && rm -rf /src/repo/* && '
+                        'cp -r /path/on/host/to/repo /src && cd - '
+                        '&& compile')
+    self.assertEqual(command, expected_command)
+
+
+class BuildExternalProjetDockerImage(unittest.TestCase):
+  """Tests for build_external_project_docker_image."""
+
+  @mock.patch('helper.docker_build')
+  def test_build_external_project_docker_image(self, mock_docker_build):
+    """Tests that build_external_project_docker_image works as intended."""
+    build_integration_path = '.clusterfuzzlite'
+    project_src = '/path/to/project/src'
+    continuous_integration.build_external_project_docker_image(
+        project_src, build_integration_path)
+
+    mock_docker_build.assert_called_with([
+        '-t', docker.EXTERNAL_PROJECT_IMAGE, '-f',
+        os.path.join('.clusterfuzzlite', 'Dockerfile'), project_src
+    ])
+
+
+# TODO(metzman): Write tests for the rest of continuous_integration.py.

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/docker_test.py

@@ -0,0 +1,119 @@
+# 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 the functionality of the docker module."""
+import unittest
+from unittest import mock
+
+import docker
+import test_helpers
+import workspace_utils
+
+CONTAINER_NAME = 'example-container'
+config = test_helpers.create_run_config(oss_fuzz_project_name='project',
+                                        workspace='/workspace')
+config.workspace = '/workspace'
+WORKSPACE = workspace_utils.Workspace(config)
+SANITIZER = 'example-sanitizer'
+LANGUAGE = 'example-language'
+
+
+class GetProjectImageTest(unittest.TestCase):
+  """Tests for get_project_image."""
+
+  def test_get_project_image(self):
+    """Tests that get_project_image_name works as intended."""
+    project = 'my-project'
+    self.assertEqual(docker.get_project_image_name(project),
+                     'gcr.io/oss-fuzz/my-project')
+
+
+class GetDeleteImagesTest(unittest.TestCase):
+  """Tests for delete_images."""
+
+  @mock.patch('utils.execute')
+  def test_delete_images(self, mock_execute):  # pylint: disable=no-self-use
+    """Tests that get_project_image_name works as intended."""
+    images = ['image']
+    docker.delete_images(images)
+    expected_calls = [
+        mock.call(['docker', 'rmi', '-f'] + images),
+        mock.call(['docker', 'builder', 'prune', '-f'])
+    ]
+
+    mock_execute.assert_has_calls(expected_calls)
+
+
+class GetBaseDockerRunArgsTest(unittest.TestCase):
+  """Tests get_base_docker_run_args."""
+
+  @mock.patch('utils.get_container_name', return_value=CONTAINER_NAME)
+  def test_get_base_docker_run_args_container(self, _):
+    """Tests that get_base_docker_run_args works as intended when inside a
+    container."""
+    docker_args, docker_container = docker.get_base_docker_run_args(
+        WORKSPACE, SANITIZER, LANGUAGE)
+    self.assertEqual(docker_container, CONTAINER_NAME)
+    expected_docker_args = []
+    expected_docker_args = [
+        '-e',
+        'FUZZING_ENGINE=libfuzzer',
+        '-e',
+        'CIFUZZ=True',
+        '-e',
+        f'SANITIZER={SANITIZER}',
+        '-e',
+        'ARCHITECTURE=x86_64',
+        '-e',
+        f'FUZZING_LANGUAGE={LANGUAGE}',
+        '-e',
+        f'OUT={WORKSPACE.out}',
+        '--volumes-from',
+        CONTAINER_NAME,
+    ]
+    self.assertEqual(docker_args, expected_docker_args)
+
+  @mock.patch('utils.get_container_name', return_value=None)
+  def test_get_base_docker_run_args_no_container(self, _):
+    """Tests that get_base_docker_run_args works as intended when not inside a
+    container."""
+    docker_args, docker_container = docker.get_base_docker_run_args(
+        WORKSPACE, SANITIZER, LANGUAGE)
+    self.assertEqual(docker_container, None)
+    expected_docker_args = [
+        '-e', 'FUZZING_ENGINE=libfuzzer', '-e', 'CIFUZZ=True', '-e',
+        f'SANITIZER={SANITIZER}', '-e', 'ARCHITECTURE=x86_64', '-e',
+        f'FUZZING_LANGUAGE={LANGUAGE}', '-e', f'OUT={WORKSPACE.out}', '-v',
+        f'{WORKSPACE.workspace}:{WORKSPACE.workspace}'
+    ]
+    self.assertEqual(docker_args, expected_docker_args)
+
+
+class GetBaseDockerRunCommandTest(unittest.TestCase):
+  """Tests get_base_docker_run_args."""
+
+  @mock.patch('utils.get_container_name', return_value=None)
+  def test_get_base_docker_run_command_no_container(self, _):
+    """Tests that get_base_docker_run_args works as intended when not inside a
+    container."""
+    docker_args, docker_container = docker.get_base_docker_run_command(
+        WORKSPACE, SANITIZER, LANGUAGE)
+    self.assertEqual(docker_container, None)
+    expected_docker_command = [
+        'docker', 'run', '--rm', '--privileged', '-e',
+        'FUZZING_ENGINE=libfuzzer', '-e', 'CIFUZZ=True', '-e',
+        f'SANITIZER={SANITIZER}', '-e', 'ARCHITECTURE=x86_64', '-e',
+        f'FUZZING_LANGUAGE={LANGUAGE}', '-e', f'OUT={WORKSPACE.out}', '-v',
+        f'{WORKSPACE.workspace}:{WORKSPACE.workspace}'
+    ]
+    self.assertEqual(docker_args, expected_docker_command)

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/generate_coverage_report_test.py

@@ -0,0 +1,71 @@
+# 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 generate_coverage_report."""
+
+import unittest
+from unittest import mock
+
+import generate_coverage_report
+import test_helpers
+
+OUT_DIR = '/outdir'
+PROJECT = 'example-project'
+SANITIZER = 'coverage'
+
+
+class TestRunCoverageCommand(unittest.TestCase):
+  """Tests run_coverage_command"""
+
+  def setUp(self):
+    test_helpers.patch_environ(self, empty=True)
+
+  @mock.patch('utils.execute')
+  def test_run_coverage_command(self, mock_execute):  # pylint: disable=no-self-use
+    """Tests that run_coverage_command works as intended."""
+    config = test_helpers.create_run_config(oss_fuzz_project_name=PROJECT,
+                                            sanitizer=SANITIZER)
+    workspace = test_helpers.create_workspace()
+    generate_coverage_report.run_coverage_command(config, workspace)
+    expected_command = 'coverage'
+    expected_env = {
+        'SANITIZER': config.sanitizer,
+        'FUZZING_LANGUAGE': config.language,
+        'OUT': workspace.out,
+        'CIFUZZ': 'True',
+        'FUZZING_ENGINE': 'libfuzzer',
+        'ARCHITECTURE': 'x86_64',
+        'FUZZER_ARGS': '-rss_limit_mb=2560 -timeout=25',
+        'HTTP_PORT': '',
+        'COVERAGE_EXTRA_ARGS': '',
+        'CORPUS_DIR': workspace.corpora,
+        'COVERAGE_OUTPUT_DIR': workspace.coverage_report
+    }
+    mock_execute.assert_called_with(expected_command, env=expected_env)
+
+
+class DownloadCorporaTest(unittest.TestCase):
+  """Tests for download_corpora."""
+
+  def test_download_corpora(self):  # pylint: disable=no-self-use
+    """Tests that download_corpora works as intended."""
+    clusterfuzz_deployment = mock.Mock()
+    clusterfuzz_deployment.workspace = test_helpers.create_workspace()
+    fuzz_target_paths = ['/path/to/fuzzer1', '/path/to/fuzzer2']
+    expected_calls = [
+        mock.call('fuzzer1', '/workspace/cifuzz-corpus/fuzzer1'),
+        mock.call('fuzzer2', '/workspace/cifuzz-corpus/fuzzer2')
+    ]
+    generate_coverage_report.download_corpora(fuzz_target_paths,
+                                              clusterfuzz_deployment)
+    clusterfuzz_deployment.download_corpus.assert_has_calls(expected_calls)

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/http_utils.py

@@ -0,0 +1,118 @@
+# 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.
+"""Utility module for HTTP."""
+import json
+import logging
+import os
+import sys
+import tempfile
+import zipfile
+
+import requests
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import retry
+
+_DOWNLOAD_URL_RETRIES = 3
+_DOWNLOAD_URL_BACKOFF = 1
+_HTTP_REQUEST_TIMEOUT = 10
+
+
+def download_and_unpack_zip(url, extract_directory, headers=None):
+  """Downloads and unpacks a zip file from an HTTP URL.
+
+  Args:
+    url: A url to the zip file to be downloaded and unpacked.
+    extract_directory: The path where the zip file should be extracted to.
+    headers: (Optional) HTTP headers to send with the download request.
+
+  Returns:
+    True on success.
+  """
+  if headers is None:
+    headers = {}
+
+  if not os.path.exists(extract_directory):
+    logging.error('Extract directory: %s does not exist.', extract_directory)
+    return False
+
+  # Gives the temporary zip file a unique identifier in the case that
+  # that download_and_unpack_zip is done in parallel.
+  with tempfile.NamedTemporaryFile(suffix='.zip') as tmp_file:
+    if not download_url(url, tmp_file.name, headers=headers):
+      return False
+
+    try:
+      with zipfile.ZipFile(tmp_file.name, 'r') as zip_file:
+        zip_file.extractall(extract_directory)
+    except zipfile.BadZipFile:
+      logging.error('Error unpacking zip from %s. Bad Zipfile.', url)
+      return False
+
+  return True
+
+
+def download_url(*args, **kwargs):
+  """Wrapper around _download_url that returns False if _download_url
+  exceptions."""
+  try:
+    return _download_url(*args, **kwargs)
+  except Exception:  # pylint: disable=broad-except
+    return False
+
+
+def get_json_from_url(url):
+  """Gets a json object from a specified HTTP URL.
+
+  Args:
+    url: The url of the json to be downloaded.
+
+  Returns:
+    A dictionary deserialized from JSON or None on failure.
+  """
+  try:
+    return requests.get(url, timeout=_HTTP_REQUEST_TIMEOUT).json()
+  except (ValueError, TypeError, json.JSONDecodeError,
+          requests.exceptions.ReadTimeout) as err:
+    logging.error('Loading json from url %s failed with: %s.', url, str(err))
+    return None
+
+
+@retry.wrap(_DOWNLOAD_URL_RETRIES, _DOWNLOAD_URL_BACKOFF)
+def _download_url(url, filename, headers=None):
+  """Downloads the file located at |url|, using HTTP to |filename|.
+
+  Args:
+    url: A url to a file to download.
+    filename: The path the file should be downloaded to.
+    headers: (Optional) HTTP headers to send with the download request.
+
+  Returns:
+    True on success.
+  """
+  if headers is None:
+    headers = {}
+
+  response = requests.get(url, headers=headers)
+
+  if response.status_code != 200:
+    logging.error('Unable to download from: %s. Code: %d. Content: %s.', url,
+                  response.status_code, response.content)
+    return False
+
+  with open(filename, 'wb') as file_handle:
+    file_handle.write(response.content)
+
+  return True

local-test-tika-delta-05/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-delta-05/fuzz-tooling/infra/cifuzz/run_cifuzz.py

@@ -0,0 +1,89 @@
+# 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 running CIFuzz end-to-end. This is meant to work outside any
+docker image. This cannot depend on any CIFuzz code or third party packages."""
+import os
+import subprocess
+import sys
+import tempfile
+import logging
+
+INFRA_DIR = os.path.dirname(os.path.dirname(__file__))
+DEFAULT_ENVS = [('DRY_RUN', '0'), ('SANITIZER', 'address')]
+BASE_CIFUZZ_DOCKER_TAG = 'ghcr.io/aixcc-finals'
+
+
+def set_default_env_var_if_unset(env_var, default_value):
+  """Sets the value of |env_var| in the environment to |default_value| if it was
+  not already set."""
+  if env_var not in os.environ:
+    os.environ[env_var] = default_value
+
+
+def docker_run(name, workspace, project_src_path):
+  """Runs a CIFuzz docker container with |name|."""
+  command = [
+      'docker', 'run', '--name', name, '--rm', '-e', 'PROJECT_SRC_PATH', '-e',
+      'OSS_FUZZ_PROJECT_NAME', '-e', 'WORKSPACE', '-e', 'REPOSITORY', '-e',
+      'DRY_RUN', '-e', 'CI', '-e', 'SANITIZER', '-e', 'GIT_SHA', '-e',
+      'FILESTORE', '-e', 'NO_CLUSTERFUZZ_DEPLOYMENT'
+  ]
+  if project_src_path:
+    command += ['-v', f'{project_src_path}:{project_src_path}']
+  command += [
+      '-v', '/var/run/docker.sock:/var/run/docker.sock', '-v',
+      f'{workspace}:{workspace}', f'{BASE_CIFUZZ_DOCKER_TAG}/{name}'
+  ]
+  print('Running docker command:', command)
+  subprocess.run(command, check=True)
+
+
+def docker_build(image):
+  """Builds the CIFuzz |image|. Only suitable for building CIFuzz images."""
+  command = [
+      'docker', 'build', '-t', f'{BASE_CIFUZZ_DOCKER_TAG}/{image}', '--file',
+      f'{image}.Dockerfile', '.'
+  ]
+  subprocess.run(command, check=True, cwd=INFRA_DIR)
+
+
+def main():
+  """Builds and runs fuzzers using CIFuzz."""
+  for env_var, default_value in DEFAULT_ENVS:
+    set_default_env_var_if_unset(env_var, default_value)
+
+  repository = os.getenv('REPOSITORY')
+  assert repository
+
+  project_src_path = os.getenv('PROJECT_SRC_PATH')
+
+  with tempfile.TemporaryDirectory() as temp_dir:
+    if 'WORKSPACE' not in os.environ:
+      os.environ['WORKSPACE'] = temp_dir
+
+    workspace = os.environ['WORKSPACE']
+
+    docker_build('build_fuzzers')
+    docker_run('build_fuzzers', workspace, project_src_path)
+    docker_build('run_fuzzers')
+    try:
+      docker_run('run_fuzzers', workspace, project_src_path)
+    except subprocess.CalledProcessError:
+      logging.error('run_fuzzers failed.')
+      return 1
+    return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/run_fuzzers.py

@@ -0,0 +1,321 @@
+# 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 running fuzzers."""
+import enum
+import logging
+import os
+import sys
+import time
+
+import clusterfuzz_deployment
+import fuzz_target
+import generate_coverage_report
+import workspace_utils
+import sarif_utils
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import utils
+
+
+class RunFuzzersResult(enum.Enum):
+  """Enum result from running fuzzers."""
+  ERROR = 0
+  BUG_FOUND = 1
+  NO_BUG_FOUND = 2
+
+
+class BaseFuzzTargetRunner:
+  """Base class for fuzzer runners."""
+
+  def __init__(self, config):
+    self.config = config
+    self.workspace = workspace_utils.Workspace(config)
+    self.clusterfuzz_deployment = (
+        clusterfuzz_deployment.get_clusterfuzz_deployment(
+            self.config, self.workspace))
+
+    # Set by the initialize method.
+    self.fuzz_target_paths = None
+
+  def get_fuzz_targets(self):
+    """Returns fuzz targets in out directory."""
+    return utils.get_fuzz_targets(self.workspace.out)
+
+  def initialize(self):
+    """Initialization method. Must be called before calling run_fuzz_targets.
+    Returns True on success."""
+    # Use a separate initialization function so we can return False on failure
+    # instead of exceptioning like we need to do if this were done in the
+    # __init__ method.
+
+    logging.info('Using %s sanitizer.', self.config.sanitizer)
+
+    # TODO(metzman) Add a check to ensure we aren't over time limit.
+    if not self.config.fuzz_seconds or self.config.fuzz_seconds < 1:
+      logging.error(
+          'Fuzz_seconds argument must be greater than 1, but was: %s.',
+          self.config.fuzz_seconds)
+      return False
+
+    if not os.path.exists(self.workspace.out):
+      logging.error('Out directory: %s does not exist.', self.workspace.out)
+      return False
+
+    if not os.path.exists(self.workspace.artifacts):
+      os.makedirs(self.workspace.artifacts)
+    elif (not os.path.isdir(self.workspace.artifacts) or
+          os.listdir(self.workspace.artifacts)):
+      logging.error('Artifacts path: %s exists and is not an empty directory.',
+                    self.workspace.artifacts)
+      return False
+
+    self.fuzz_target_paths = self.get_fuzz_targets()
+    logging.info('Fuzz targets: %s', self.fuzz_target_paths)
+    if not self.fuzz_target_paths:
+      logging.error('No fuzz targets were found in out directory: %s.',
+                    self.workspace.out)
+      return False
+
+    return True
+
+  def cleanup_after_fuzz_target_run(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Cleans up after running |fuzz_target_obj|."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def run_fuzz_target(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Fuzzes with |fuzz_target_obj| and returns the result."""
+    raise NotImplementedError('Child class must implement method.')
+
+  @property
+  def quit_on_bug_found(self):
+    """Property that is checked to determine if fuzzing should quit after first
+    bug is found."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def create_fuzz_target_obj(self, target_path, run_seconds):
+    """Returns a fuzz target object."""
+    return fuzz_target.FuzzTarget(target_path, run_seconds, self.workspace,
+                                  self.clusterfuzz_deployment, self.config)
+
+  def run_fuzz_targets(self):
+    """Runs fuzz targets. Returns True if a bug was found."""
+    fuzzers_left_to_run = len(self.fuzz_target_paths)
+
+    # Make a copy since we will mutate it.
+    fuzz_seconds = self.config.fuzz_seconds
+
+    min_seconds_per_fuzzer = fuzz_seconds // fuzzers_left_to_run
+    bug_found = False
+    for target_path in self.fuzz_target_paths:
+      # By doing this, we can ensure that every fuzz target runs for at least
+      # min_seconds_per_fuzzer, but that other fuzzers will have longer to run
+      # if one ends early.
+      run_seconds = max(fuzz_seconds // fuzzers_left_to_run,
+                        min_seconds_per_fuzzer)
+
+      target = self.create_fuzz_target_obj(target_path, run_seconds)
+      start_time = time.time()
+      result = self.run_fuzz_target(target)
+      self.cleanup_after_fuzz_target_run(target)
+
+      # It's OK if this goes negative since we take max when determining
+      # run_seconds.
+      fuzz_seconds -= time.time() - start_time
+
+      fuzzers_left_to_run -= 1
+      if not result.testcase or not result.stacktrace:
+        logging.info('Fuzzer %s finished running without reportable crashes.',
+                     target.target_name)
+        continue
+
+      bug_found = True
+      if self.quit_on_bug_found:
+        logging.info('Bug found. Stopping fuzzing.')
+        break
+
+    # pylint: disable=undefined-loop-variable
+    if not target_path:
+      logging.error('Ran no fuzz targets.')
+    elif self.config.output_sarif:
+      # TODO(metzman): Handle multiple crashes.
+      write_fuzz_result_to_sarif(result, target_path, self.workspace)
+    self.clusterfuzz_deployment.upload_crashes()
+    return bug_found
+
+
+def write_fuzz_result_to_sarif(fuzz_result, target_path, workspace):
+  """Write results of fuzzing to SARIF."""
+  logging.info('Writing sarif results.')
+  sarif_utils.write_stacktrace_to_sarif(fuzz_result.stacktrace, target_path,
+                                        workspace)
+
+
+class PruneTargetRunner(BaseFuzzTargetRunner):
+  """Runner that prunes corpora."""
+
+  @property
+  def quit_on_bug_found(self):
+    return False
+
+  def run_fuzz_target(self, fuzz_target_obj):
+    """Prunes with |fuzz_target_obj| and returns the result."""
+    result = fuzz_target_obj.prune()
+    logging.debug('Corpus path contents: %s.', os.listdir(result.corpus_path))
+    self.clusterfuzz_deployment.upload_corpus(fuzz_target_obj.target_name,
+                                              result.corpus_path,
+                                              replace=True)
+    return result
+
+  def cleanup_after_fuzz_target_run(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Cleans up after pruning with |fuzz_target_obj|."""
+    fuzz_target_obj.free_disk_if_needed()
+
+
+NON_FUZZ_TARGETS_FOR_COVERAGE = {
+    'llvm-symbolizer',
+    'jazzer_agent_deploy.jar',
+    'jazzer_driver',
+    'jazzer_driver_with_sanitizer',
+}
+
+
+def is_coverage_fuzz_target(file_path):
+  """Returns whether |file_path| is a fuzz target binary for the purposes of a
+  coverage report. Inspired by infra/base-images/base-runner/coverage."""
+  if not os.path.isfile(file_path):
+    return False
+  if not utils.is_executable(file_path):
+    return False
+  filename = os.path.basename(file_path)
+  return filename not in NON_FUZZ_TARGETS_FOR_COVERAGE
+
+
+def get_coverage_fuzz_targets(out):
+  """Returns a list of fuzz targets in |out| for coverage."""
+  # We only want fuzz targets from the root because during the coverage build,
+  # a lot of the image's filesystem is copied into /out for the purpose of
+  # generating coverage reports.
+  fuzz_targets = []
+  for filename in os.listdir(out):
+    file_path = os.path.join(out, filename)
+    if is_coverage_fuzz_target(file_path):
+      fuzz_targets.append(file_path)
+  return fuzz_targets
+
+
+class CoverageTargetRunner(BaseFuzzTargetRunner):
+  """Runner that runs the 'coverage' command."""
+
+  @property
+  def quit_on_bug_found(self):
+    raise NotImplementedError('Not implemented for CoverageTargetRunner.')
+
+  def get_fuzz_targets(self):
+    """Returns fuzz targets in out directory."""
+    return get_coverage_fuzz_targets(self.workspace.out)
+
+  def run_fuzz_targets(self):
+    """Generates a coverage report. Always returns False since it never finds
+    any bugs."""
+    generate_coverage_report.generate_coverage_report(
+        self.fuzz_target_paths, self.workspace, self.clusterfuzz_deployment,
+        self.config)
+    return False
+
+  def run_fuzz_target(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Fuzzes with |fuzz_target_obj| and returns the result."""
+    raise NotImplementedError('Not implemented for CoverageTargetRunner.')
+
+  def cleanup_after_fuzz_target_run(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Cleans up after running |fuzz_target_obj|."""
+    raise NotImplementedError('Not implemented for CoverageTargetRunner.')
+
+
+class CiFuzzTargetRunner(BaseFuzzTargetRunner):
+  """Runner for fuzz targets used in CI (patch-fuzzing) context."""
+
+  @property
+  def quit_on_bug_found(self):
+    return True
+
+  def cleanup_after_fuzz_target_run(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Cleans up after running |fuzz_target_obj|."""
+    fuzz_target_obj.free_disk_if_needed()
+
+  def run_fuzz_target(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    return fuzz_target_obj.fuzz()
+
+
+class BatchFuzzTargetRunner(BaseFuzzTargetRunner):
+  """Runner for fuzz targets used in batch fuzzing context."""
+
+  @property
+  def quit_on_bug_found(self):
+    return False
+
+  def run_fuzz_target(self, fuzz_target_obj):
+    """Fuzzes with |fuzz_target_obj| and returns the result."""
+    result = fuzz_target_obj.fuzz(batch=True)
+    logging.debug('Corpus path contents: %s.', os.listdir(result.corpus_path))
+    self.clusterfuzz_deployment.upload_corpus(fuzz_target_obj.target_name,
+                                              result.corpus_path)
+    return result
+
+  def cleanup_after_fuzz_target_run(self, fuzz_target_obj):
+    """Cleans up after running |fuzz_target_obj|."""
+    # This must be done after we upload the corpus, otherwise it will be deleted
+    # before we get a chance to upload it. We can't delete the fuzz target
+    # because it is needed when we upload the build.
+    fuzz_target_obj.free_disk_if_needed(delete_fuzz_target=False)
+
+
+_MODE_RUNNER_MAPPING = {
+    'batch': BatchFuzzTargetRunner,
+    'coverage': CoverageTargetRunner,
+    'prune': PruneTargetRunner,
+    'code-change': CiFuzzTargetRunner,
+}
+
+
+def get_fuzz_target_runner(config):
+  """Returns a fuzz target runner object based on the mode of
+  |config|."""
+  runner = _MODE_RUNNER_MAPPING[config.mode](config)
+  logging.info('run fuzzers MODE is: %s. Runner: %s.', config.mode, runner)
+  return runner
+
+
+def run_fuzzers(config):  # pylint: disable=too-many-locals
+  """Runs fuzzers for a specific OSS-Fuzz project.
+
+  Args:
+    config: A RunFuzzTargetsConfig.
+
+  Returns:
+    A RunFuzzersResult enum value indicating what happened during fuzzing.
+  """
+  fuzz_target_runner = get_fuzz_target_runner(config)
+  if not fuzz_target_runner.initialize():
+    # We didn't fuzz at all because of internal (CIFuzz) errors. And we didn't
+    # find any bugs.
+    return RunFuzzersResult.ERROR
+
+  if not fuzz_target_runner.run_fuzz_targets():
+    # We fuzzed successfully, but didn't find any bugs (in the fuzz target).
+    return RunFuzzersResult.NO_BUG_FOUND
+
+  # We fuzzed successfully and found bug(s) in the fuzz targets.
+  return RunFuzzersResult.BUG_FOUND

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/run_fuzzers_entrypoint.py

@@ -0,0 +1,97 @@
+# 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.
+"""Runs a specific OSS-Fuzz project's fuzzers for CI tools."""
+import logging
+import sys
+
+import config_utils
+import docker
+import logs
+import run_fuzzers
+
+# pylint: disable=c-extension-no-member
+# pylint gets confused because of the relative import of cifuzz.
+
+logs.init()
+
+
+def delete_unneeded_docker_images(config):
+  """Deletes unneeded docker images if running in an environment with low
+  disk space."""
+  if not config.low_disk_space:
+    return
+  logging.info('Deleting builder docker images to save disk space.')
+  project_image = docker.get_project_image_name(config.oss_fuzz_project_name)
+  images = [
+      project_image,
+      docker.BASE_BUILDER_TAG,
+      docker.BASE_BUILDER_TAG + '-go',
+      docker.BASE_BUILDER_TAG + '-javascript',
+      docker.BASE_BUILDER_TAG + '-jvm',
+      docker.BASE_BUILDER_TAG + '-python',
+      docker.BASE_BUILDER_TAG + '-rust',
+      docker.BASE_BUILDER_TAG + '-ruby',
+      docker.BASE_BUILDER_TAG + '-swift',
+  ]
+  docker.delete_images(images)
+
+
+def run_fuzzers_entrypoint():
+  """This is the entrypoint for the run_fuzzers github action.
+  This action can be added to any OSS-Fuzz project's workflow that uses
+  Github."""
+  config = config_utils.RunFuzzersConfig()
+  # The default return code when an error occurs.
+  returncode = 1
+  if config.dry_run:
+    # Sets the default return code on error to success.
+    returncode = 0
+
+  delete_unneeded_docker_images(config)
+  # Run the specified project's fuzzers from the build.
+  result = run_fuzzers.run_fuzzers(config)
+  if result == run_fuzzers.RunFuzzersResult.ERROR:
+    logging.error('Error occurred while running in workspace %s.',
+                  config.workspace)
+    return returncode
+  if result == run_fuzzers.RunFuzzersResult.BUG_FOUND:
+    logging.info('Bug found.')
+    if not config.dry_run:
+      # Return 2 when a bug was found by a fuzzer causing the CI to fail.
+      return 2
+  return 0
+
+
+def main():
+  """Runs project's fuzzers for CI tools.
+  This is the entrypoint for the run_fuzzers github action.
+
+  NOTE: libFuzzer binaries must be located in the $WORKSPACE/build-out
+  directory in order for this action to be used. This action will only fuzz the
+  binaries that are located in that directory. It is recommended that you add
+  the build_fuzzers action preceding this one.
+
+  NOTE: Any crash report will be in the filepath:
+  ${GITHUB_WORKSPACE}/out/testcase
+  This can be used in parallel with the upload-artifact action to surface the
+  logs.
+
+  Returns:
+    0 on success or nonzero on failure.
+  """
+  return run_fuzzers_entrypoint()
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-delta-05/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-delta-05/fuzz-tooling/infra/cifuzz/sarif_utils_test.py

@@ -0,0 +1,128 @@
+# 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.
+"""Tests for sarif_utils.py"""
+import os
+import unittest
+from unittest import mock
+
+import sarif_utils
+
+CRASH_INFO_FILELINE = 403
+
+TEST_DATA = os.path.join(os.path.dirname(__file__), 'test_data')
+
+
+class GetSarifDataTest(unittest.TestCase):
+  """Tests for get_sarif_data."""
+
+  def setUp(self):
+    self.maxDiff = None  # pylint: disable=invalid-name
+
+  def test_get_sarif_data_none(self):
+    """Tests get_sarif_data when there was no crash."""
+    self.assertEqual(sarif_utils.get_sarif_data(None, '/root/target'),
+                     sarif_utils.SARIF_DATA)
+
+  def test_ordinary_case(self):
+    stacktrace_filename = os.path.join(TEST_DATA,
+                                       'sarif_utils_systemd_stack.txt')
+    with open(stacktrace_filename, 'r') as fp:
+      stacktrace = fp.read()
+    expected_result = {
+        'level': 'error',
+        'message': {
+            'text': 'Heap-buffer-overflow\nREAD 4'
+        },
+        'locations': [{
+            'physicalLocation': {
+                'artifactLocation': {
+                    'uri': 'src/core/fuzz-unit-file.c',
+                    'index': 0
+                },
+                'region': {
+                    'startLine': 30,
+                    # We don't have this granualarity fuzzing.
+                    'startColumn': 1,
+                }
+            }
+        }],
+        'ruleId': 'heap-buffer-overflow',
+        'ruleIndex': 2
+    }
+    actual_result = sarif_utils.get_sarif_data(
+        stacktrace, '/root/target')['runs'][0]['results'][0]
+    self.assertEqual(actual_result, expected_result)
+
+  def test_llvmfuzzertestoneinput_case(self):
+    stacktrace_filename = os.path.join(TEST_DATA,
+                                       'sarif_utils_only_llvmfuzzer_stack.txt')
+    with open(stacktrace_filename, 'r') as fp:
+      stacktrace = fp.read()
+    actual_result = sarif_utils.get_sarif_data(
+        stacktrace, '/root/target')['runs'][0]['results']
+    self.assertEqual(actual_result, [])
+
+  def test_msan(self):
+    """Tests that MSAN stacktraces don't exception."""
+    stacktrace_filename = os.path.join(TEST_DATA, 'sarif_utils_msan_stack.txt')
+    with open(stacktrace_filename, 'r') as fp:
+      stacktrace = fp.read()
+
+    actual_result = sarif_utils.get_sarif_data(stacktrace, '/root/target')
+
+
+class RedactSrcPathTest(unittest.TestCase):
+  """Tests for redact_src_path."""
+
+  def test_redact_src_path(self):
+    """Tests redact_src_path."""
+    path = '/src/src-repo/subdir/file'
+    self.assertEqual(sarif_utils.redact_src_path(path), 'subdir/file')
+
+
+def _get_mock_crash_info():
+  """Returns a mock crash_info to be used in tests."""
+  stack_frame = mock.MagicMock()
+  stack_frame.filename = '/src/repo-dir/sub/vuln.cc'
+  stack_frame.function_name = 'vuln_func'
+  stack_frame.fileline = CRASH_INFO_FILELINE
+  crash1_frames = [stack_frame, stack_frame]
+  frames = [crash1_frames]
+  crash_info = mock.MagicMock()
+  crash_info.frames = frames
+  crash_info.crash_state = 'vuln_func\nvuln_func0\nvuln_func1'
+  return crash_info
+
+
+class GetErrorSourceInfoTest(unittest.TestCase):
+  """Tests for get_error_source_info."""
+
+  def test_redact_src_path(self):
+    """Tests that get_error_source_info finds the right source info."""
+    crash_info = _get_mock_crash_info()
+    source_info = sarif_utils.get_error_source_info(crash_info)
+    expected_source_info = ('sub/vuln.cc', CRASH_INFO_FILELINE)
+    self.assertEqual(source_info, expected_source_info)
+
+
+class GetRuleIndexTest(unittest.TestCase):
+  """Tests for get_rule_index."""
+  CRASH_INFO_CRASH_TYPE = 'Heap-use-after-free READ 8'
+
+  def test_get_rule_index(self):
+    """Tests that get_rule_index finds the right rule index."""
+    index = sarif_utils.get_rule_index(self.CRASH_INFO_CRASH_TYPE)
+    self.assertEqual(sarif_utils.SARIF_RULES[index]['id'],
+                     'heap-use-after-free')
+    self.assertEqual(sarif_utils.get_rule_index('no-crashes'), 0)

local-test-tika-delta-05/fuzz-tooling/infra/cifuzz/test_helpers.py

@@ -0,0 +1,117 @@
+# 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.
+"""Contains convenient helpers for writing tests."""
+
+import contextlib
+import os
+import sys
+import shutil
+import tempfile
+from unittest import mock
+
+import config_utils
+import docker
+import workspace_utils
+
+INFRA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(INFRA_DIR)
+
+import helper
+
+
+# TODO(metzman): Get rid of these decorators.
+@mock.patch('config_utils._is_dry_run', return_value=True)
+@mock.patch('platform_config.BasePlatformConfig.project_src_path',
+            return_value=None)
+@mock.patch('os.path.basename', return_value=None)
+def _create_config(config_cls, _, __, ___, **kwargs):
+  """Creates a config object from |config_cls| and then sets every attribute
+  that is a key in |kwargs| to the corresponding value. Asserts that each key in
+  |kwargs| is an attribute of config."""
+  with mock.patch('config_utils.BaseConfig.validate', return_value=True):
+    config = config_cls()
+  for key, value in kwargs.items():
+    assert hasattr(config, key), 'Config doesn\'t have attribute: ' + key
+    setattr(config, key, value)
+
+  return config
+
+
+def create_build_config(**kwargs):
+  """Wrapper around _create_config for build configs."""
+  return _create_config(config_utils.BuildFuzzersConfig, **kwargs)
+
+
+def create_run_config(**kwargs):
+  """Wrapper around _create_config for run configs."""
+  return _create_config(config_utils.RunFuzzersConfig, **kwargs)
+
+
+def create_workspace(workspace_path='/workspace'):
+  """Returns a workspace located at |workspace_path| ('/workspace' by
+  default)."""
+  config = create_run_config(workspace=workspace_path)
+  return workspace_utils.Workspace(config)
+
+
+def patch_environ(testcase_obj, env=None, empty=False, runner=False):
+  """Patch environment. |testcase_obj| is the unittest.TestCase that contains
+  tests. |env|, if specified, is a dictionary of environment variables to start
+  from. If |empty| is True then the new patched environment will be empty. If
+  |runner| is True then the necessary environment variables will be set to run
+  the scripts from base-runner."""
+  if env is None:
+    env = {}
+
+  patcher = mock.patch.dict(os.environ, env)
+  testcase_obj.addCleanup(patcher.stop)
+  patcher.start()
+  if empty:
+    for key in os.environ.copy():
+      del os.environ[key]
+
+  if runner:
+    # Add the scripts for base-runner to the path since the wont be in
+    # /usr/local/bin on host machines during testing.
+    base_runner_dir = os.path.join(INFRA_DIR, 'base-images', 'base-runner')
+    os.environ['PATH'] = (os.environ.get('PATH', '') + os.pathsep +
+                          base_runner_dir)
+    if 'GOPATH' not in os.environ:
+      # A GOPATH must be set or else the coverage script fails, even for getting
+      # the coverage of non-Go programs.
+      os.environ['GOPATH'] = '/root/go'
+
+
+@contextlib.contextmanager
+def temp_dir_copy(directory):
+  """Context manager that yields a temporary copy of |directory|."""
+  with tempfile.TemporaryDirectory() as temp_dir:
+    temp_copy_path = os.path.join(temp_dir, os.path.basename(directory))
+    shutil.copytree(directory, temp_copy_path)
+    yield temp_copy_path
+
+
+@contextlib.contextmanager
+def docker_temp_dir():
+  """Returns a temporary a directory that is useful for use with docker. On
+  cleanup this contextmanager uses docker to delete the directory's contents so
+  that if anything is owned by root it can be deleted (which
+  tempfile.TemporaryDirectory() cannot do) by non-root users."""
+  with tempfile.TemporaryDirectory() as temp_dir:
+    yield temp_dir
+    helper.docker_run([
+        '-v', f'{temp_dir}:/temp_dir', '-t', docker.BASE_BUILDER_TAG,
+        '/bin/bash', '-c', 'rm -rf /temp_dir/*'
+    ])

local-test-tika-delta-05/fuzz-tooling/infra/experimental/SystemSan/SystemSan.cpp

@@ -0,0 +1,493 @@
+/*
+ * 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.
+ */
+/* A detector that uses ptrace to identify shell injection vulnerabilities. */
+
+/* C standard library */
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+
+/* POSIX */
+#include <sys/stat.h>
+#include <sys/user.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+/* Linux */
+#include <sys/ptrace.h>
+#include <syscall.h>
+#include <fcntl.h>
+
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "inspect_utils.h"
+#include "inspect_dns.h"
+
+#define DEBUG_LOGS 0
+
+#if DEBUG_LOGS
+#define debug_log(...)            \
+  do {                            \
+    fprintf(stderr, __VA_ARGS__); \
+    fflush(stdout);               \
+    fputc('\n', stderr);          \
+  } while (0)
+#else
+#define debug_log(...)
+#endif
+
+#define fatal_log(...)            \
+  do {                            \
+    fprintf(stderr, __VA_ARGS__); \
+    fputc('\n', stderr);          \
+    exit(EXIT_FAILURE);           \
+  } while (0)
+
+// The magic string that we'll use to detect full control over the command
+// executed.
+const std::string kTripWire = "/tmp/tripwire";
+// Shell injection bug confirmed with /tmp/tripwire.
+const std::string kInjectionError = "Shell injection";
+// Shell corruption bug detected based on syntax error.
+const std::string kCorruptionError = "Shell corruption";
+// The magic string that we'll use to detect arbitrary file open
+const std::string kFzAbsoluteDirectory = "/fz/";
+// Arbitrary file open in /fz/
+const std::string kArbitraryFileOpenError = "Arbitrary file open";
+// Assuming only shorter (than this constant) top dir are legitly used.
+constexpr int kRootDirMaxLength = 16;
+
+// The PID of the root process we're fuzzing.
+pid_t g_root_pid;
+
+// Map of a PID/TID its PID/TID creator and wether it ran exec.
+std::map<pid_t, ThreadParent> root_pids;
+
+// Assuming the longest pathname is "/bin/bash".
+constexpr int kShellPathnameLength = 20;
+
+// Syntax error messages of each shell.
+const std::map<std::string, std::set<std::string>> kShellSyntaxErrors = {
+    {"bash",
+     {
+         ": command not found",  // General
+         ": syntax error",       // Unfinished " or ' or ` or if, leading | or ;
+         ": missing `]'",        // Unfinished [
+         ": event not found",    // ! leads large numbers
+         ": No such file or directory",  // Leading < or /
+     }},
+    {"csh",
+     {
+         ": Command not found.",         // General
+         ": Missing }.",                 // Unfinished {
+         "Too many ('s.",                // Unfinished (
+         "Invalid null command.",        // Leading | or < or >
+         "Missing name for redirect.",   // Single < or >
+         ": No match.",                  // Leading ? or [ or *
+         "Modifier failed.",             // Leading ^
+         "No previous left hand side.",  // A ^
+         ": No such job.",               // Leading %
+         ": No current job.",            // A %
+         ": Undefined variable.",        // Containing $
+         ": Event not found.",           // ! leads large numbers
+         // TODO: Make this more specific.
+         "Unmatched",  // Unfinished " or ' or `, leading ;
+     }},
+    {"dash",
+     {
+         "not found",     // General
+         "Syntax error",  // Unfinished " or ' or ` or if, leading | or ; or &
+         "missing ]",     // Unfinished [
+         "No such file",  // Leading <
+     }},
+    {"zsh",
+     {
+         ": command not found",                // General
+         ": syntax error",                     // Unfinished " or ' or `
+         ": ']' expected",                     // Unfinished [
+         ": no such file or directory",        // Leading < or /
+         ": parse error near",                 // Leading |, or &
+         ": no such user or named directory",  // Leading ~
+     }},
+};
+
+// Shells used by Processes.
+std::map<pid_t, std::string> g_shell_pids;
+
+struct Tracee {
+  pid_t pid;
+  bool syscall_enter = true;
+
+  Tracee(pid_t pid) : pid(pid) {}
+};
+
+pid_t run_child(char **argv) {
+  // Run the program under test with its args as a child process
+  pid_t pid = fork();
+  switch (pid) {
+    case -1:
+      fatal_log("Fork failed: %s", strerror(errno));
+    case 0:
+      raise(SIGSTOP);
+      execvp(argv[0], argv);
+      fatal_log("execvp: %s", strerror(errno));
+  }
+  return pid;
+}
+
+// Construct a string with the memory specified in a register.
+std::string read_string(pid_t pid, unsigned long reg, unsigned long length) {
+  auto memory = read_memory(pid, reg, length);
+  if (!memory.size()) {
+    return "";
+  }
+
+  std::string content(reinterpret_cast<char *>(memory.data()),
+                      std::min(memory.size(), length));
+  return content;
+}
+
+void inspect_for_injection(pid_t pid, const user_regs_struct &regs) {
+  // Inspect a PID's registers for the sign of shell injection.
+  std::string path = read_string(pid, regs.rdi, kTripWire.length());
+  if (!path.length()) {
+    return;
+  }
+  debug_log("inspecting");
+  if (path == kTripWire) {
+    report_bug(kInjectionError, pid);
+  }
+}
+
+std::string get_pathname(pid_t pid, const user_regs_struct &regs) {
+  // Parse the pathname from the memory specified in the RDI register.
+  std::string pathname = read_string(pid, regs.rdi, kShellPathnameLength);
+  debug_log("Pathname is %s (len %lu)\n", pathname.c_str(), pathname.length());
+  return pathname;
+}
+
+std::string match_shell(std::string binary_pathname);
+
+// Identify the exact shell behind sh
+std::string identify_sh(std::string path) {
+  char shell_pathname[kShellPathnameLength];
+  auto written = readlink(path.c_str(), shell_pathname, kShellPathnameLength - 1);
+  if (written == -1) {
+    std::cerr << "Cannot query which shell is behind sh: readlink failed on "
+              << path << ": "
+              << strerror(errno) << "\n";
+    std::cerr << "Assuming the shell is dash\n";
+    return "dash";
+  }
+  shell_pathname[written] = '\0';
+
+  debug_log("sh links to %s\n", shell_pathname);
+  std::string shell_pathname_str(shell_pathname);
+
+  return match_shell(shell_pathname_str);
+}
+
+std::string match_shell(std::string binary_pathname) {
+  // Identify the name of the shell used in the pathname.
+  if (!binary_pathname.length()) {
+    return "";
+  }
+
+  // We use c_str() to accept only the null terminated string.
+  std::string binary_name = binary_pathname.substr(
+      binary_pathname.find_last_of("/") + 1).c_str();
+
+  debug_log("Binary is %s (%lu)\n", binary_name.c_str(),
+            binary_name.length());
+
+  for (const auto &item : kShellSyntaxErrors) {
+    std::string known_shell = item.first;
+    if (binary_name == "sh") {
+      debug_log("Matched sh: Needs to identify which specific shell it is.\n");
+      return identify_sh(binary_pathname);
+    }
+    if (binary_name == known_shell) {
+      debug_log("Matched %s\n", binary_name.c_str());
+      return known_shell;
+    }
+  }
+  return "";
+}
+
+std::string get_shell(pid_t pid, const user_regs_struct &regs) {
+  // Get shell name used in a process.
+  std::string binary_pathname = get_pathname(pid, regs);
+  return match_shell(binary_pathname);
+}
+
+void match_error_pattern(std::string buffer, std::string shell, pid_t pid) {
+  auto error_patterns = kShellSyntaxErrors.at(shell);
+  for (const auto &pattern : error_patterns) {
+    if (buffer.find(pattern) != std::string::npos) {
+      std::cerr << "--- Found a sign of shell corruption ---\n"
+                << buffer.c_str()
+                << "\n----------------------------------------\n";
+      // If a shell corruption error happens, kill its parent.
+      auto parent = root_pids[pid];
+      while (!parent.ran_exec) {
+        if (parent.parent_tid == g_root_pid) {
+          break;
+        }
+        parent = root_pids[parent.parent_tid];
+      }
+      report_bug(kCorruptionError, parent.parent_tid);
+    }
+  }
+}
+
+void inspect_for_corruption(pid_t pid, const user_regs_struct &regs) {
+  // Inspect a PID's registers for shell corruption.
+  std::string buffer = read_string(pid, regs.rsi, regs.rdx);
+  debug_log("Write buffer: %s\n", buffer.c_str());
+  match_error_pattern(buffer, g_shell_pids[pid], pid);
+}
+
+void log_file_open(std::string path, int flags, pid_t pid) {
+  report_bug(kArbitraryFileOpenError, pid);
+  std::cerr << "===File opened: " << path.c_str() << ", flags = " << flags << ",";
+  switch (flags & 3) {
+    case O_RDONLY:
+      std::cerr << "O_RDONLY";
+      break;
+    case O_WRONLY:
+      std::cerr << "O_WRONLY";
+      break;
+    case O_RDWR:
+      std::cerr << "O_RDWR";
+      break;
+    default:
+      std::cerr << "unknown";
+  }
+  std::cerr << "===\n";
+}
+
+bool has_unprintable(const std::string &value) {
+  for (size_t i = 0; i < value.length(); i++) {
+    if (value[i] & 0x80) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void inspect_for_arbitrary_file_open(pid_t pid, const user_regs_struct &regs) {
+  // Inspect a PID's register for the sign of arbitrary file open.
+  std::string path = read_string(pid, regs.rsi, kRootDirMaxLength);
+  if (!path.length()) {
+    return;
+  }
+  if (path.substr(0, kFzAbsoluteDirectory.length()) == kFzAbsoluteDirectory) {
+    log_file_open(path, regs.rdx, pid);
+    return;
+  }
+  if (path[0] == '/' && path.length() > 1) {
+    std::string path_absolute_topdir = path;
+    size_t root_dir_end = path.find('/', 1);
+    if (root_dir_end != std::string::npos) {
+      path_absolute_topdir = path.substr(0, root_dir_end);
+    }
+    if (has_unprintable(path_absolute_topdir)) {
+      struct stat dirstat;
+      if (stat(path_absolute_topdir.c_str(), &dirstat) != 0) {
+        log_file_open(path, regs.rdx, pid);
+      }
+    }
+  }
+}
+
+int trace(std::map<pid_t, Tracee> pids) {
+  unsigned long exit_status = 0;
+  while (!pids.empty()) {
+    std::vector<pid_t> new_pids;
+
+    auto it = pids.begin();
+
+    while (it != pids.end()) {
+      auto pid = it->first;
+      auto &tracee = it->second;
+      int status = 0;
+
+      int result = waitpid(pid, &status, __WALL | WNOHANG);
+      if (result == -1) {
+        it = pids.erase(it);
+        continue;
+      }
+
+      if (result == 0) {
+        // Nothing to report yet.
+        ++it;
+        continue;
+      }
+
+      if (WIFEXITED(status) || WIFSIGNALED(status)) {
+        debug_log("%d exited", pid);
+        it = pids.erase(it);
+        // Remove pid from the watchlist when it exits
+        g_shell_pids.erase(pid);
+        root_pids.erase(pid);
+        continue;
+      }
+
+      // ptrace sets 0x80 for syscalls (with PTRACE_O_TRACESYSGOOD set).
+      bool is_syscall =
+          WIFSTOPPED(status) && WSTOPSIG(status) == (SIGTRAP | 0x80);
+      int sig = 0;
+      if (!is_syscall) {
+        // Handle generic signal.
+        siginfo_t siginfo;
+        if (ptrace(PTRACE_GETSIGINFO, pid, nullptr, &siginfo) == -1) {
+          debug_log("ptrace(PTRACE_GETSIGINFO, %d): %s", pid, strerror(errno));
+          continue;
+        }
+        sig = siginfo.si_signo;
+        debug_log("forwarding signal %d to %d", sig, pid);
+      }
+
+      if ((status >> 8 == (SIGTRAP | (PTRACE_EVENT_EXIT << 8)))) {
+        debug_log("%d exiting", pid);
+        if (pid == g_root_pid) {
+          if (ptrace(PTRACE_GETEVENTMSG, pid, 0, &exit_status) == -1) {
+            debug_log("ptrace(PTRACE_GETEVENTMSG, %d): %s", pid, strerror(errno));
+          }
+          debug_log("got exit status from root process: %lu", exit_status);
+        }
+
+        if (ptrace(PTRACE_DETACH, pid, 0, 0) == -1) {
+          debug_log("ptrace(PTRACE_DETACH, %d): %s", pid, strerror(errno));
+        }
+        continue;
+      }
+
+      if (WIFSTOPPED(status) &&
+          (status >> 8 == (SIGTRAP | (PTRACE_EVENT_CLONE << 8)) ||
+           status >> 8 == (SIGTRAP | (PTRACE_EVENT_FORK << 8)) ||
+           status >> 8 == (SIGTRAP | (PTRACE_EVENT_VFORK << 8)))) {
+        long new_pid;
+        if (ptrace(PTRACE_GETEVENTMSG, pid, 0, &new_pid) == -1) {
+          debug_log("ptrace(PTRACE_GETEVENTMSG, %d): %s", pid, strerror(errno));
+          continue;
+        }
+        debug_log("forked %ld", new_pid);
+        new_pids.push_back(new_pid);
+        root_pids.emplace(new_pid, ThreadParent(pid));
+      }
+
+      if (is_syscall) {
+        user_regs_struct regs;
+        if (ptrace(PTRACE_GETREGS, pid, 0, &regs) == -1) {
+          debug_log("ptrace(PTRACE_GETREGS, %d): %s", pid, strerror(errno));
+          continue;
+        }
+
+        if (tracee.syscall_enter) {
+          if (regs.orig_rax == __NR_execve) {
+            // This is a new process.
+            auto parent = root_pids[pid];
+            parent.ran_exec = true;
+            root_pids[pid] = parent;
+            inspect_for_injection(pid, regs);
+            std::string shell = get_shell(pid, regs);
+            if (shell != "") {
+              debug_log("Shell parsed: %s", shell.c_str());
+              g_shell_pids.insert(std::make_pair(pid, shell));
+            }
+          }
+
+          inspect_dns_syscalls(pid, regs);
+
+          if (regs.orig_rax == __NR_openat) {
+            // TODO(metzman): Re-enable this once we have config/flag support.
+            // inspect_for_arbitrary_file_open(pid, regs);
+          }
+
+          if (regs.orig_rax == __NR_write &&
+              g_shell_pids.find(pid) != g_shell_pids.end()) {
+            debug_log("Inspecting the `write` buffer of shell process %d.",
+                      pid);
+            inspect_for_corruption(pid, regs);
+          }
+        }
+
+        // TODO: Check for commands with invalid syntax passed to /bin/sh and
+        // other shells.
+        // TODO: It's possible the process we're fuzzing can communicate with
+        // another process to execute code. Our check wouldn't catch this
+        // currently.
+        tracee.syscall_enter = !tracee.syscall_enter;
+      }
+
+      if (ptrace(PTRACE_SYSCALL, pid, nullptr, sig) == -1) {
+        debug_log("ptrace(PTRACE_SYSCALL, %d): %s", pid, strerror(errno));
+        continue;
+      }
+
+      ++it;
+    }
+
+    for (const auto &pid : new_pids) {
+      pids.emplace(pid, Tracee(pid));
+    }
+  }
+  return static_cast<int>(exit_status >> 8);
+}
+
+int main(int argc, char **argv) {
+  if (argc <= 1) {
+    fatal_log("Expecting at least one arguments, received %d", argc - 1);
+  }
+
+  // Create an executable tripwire file, as programs may check for existence
+  // before actually calling exec.
+  std::ofstream tripwire(kTripWire);
+  tripwire.close();
+  chmod(kTripWire.c_str(), 0755);
+
+  pid_t pid = run_child(argv + 1);
+
+  long options = PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACEFORK |
+                 PTRACE_O_TRACEVFORK | PTRACE_O_TRACECLONE |
+                 PTRACE_O_TRACEEXIT;
+
+  if (ptrace(PTRACE_SEIZE, pid, nullptr, options) == -1) {
+    fatal_log("ptrace(PTRACE_SEIZE): %s", strerror(errno));
+  }
+
+  if (waitpid(pid, nullptr, __WALL) == -1) {
+    fatal_log("waitpid: %s", strerror(errno));
+  }
+
+  if (ptrace(PTRACE_SYSCALL, pid, 0, 0) == -1) {
+    fatal_log("ptrace(PTRACE_SYSCALL): %s", strerror(errno));
+  }
+
+  g_root_pid = pid;
+  std::map<pid_t, Tracee> pids;
+  pids.emplace(pid, Tracee(pid));
+  root_pids.emplace(pid, ThreadParent(pid));
+  return trace(pids);
+}

local-test-tika-delta-05/fuzz-tooling/infra/experimental/chronos/build_all.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# Build all C/C++ projects.
+c_project_yaml=$(find projects/ -name project.yaml -exec grep -l 'language: c' {} \;)
+projs=$(echo $c_project_yaml | xargs dirname | xargs basename -a | sort)
+
+cd infra/experimental/chronos
+
+for proj in $projs; do
+  if [ ! -f ../../../projects/$proj/Dockerfile ]; then
+    # Incomplete integration.
+    echo "Skipping $proj as it's incomplete."
+    continue
+  fi
+
+  echo ./build_on_cloudbuild.sh $proj c
+  ./build_on_cloudbuild.sh $proj c
+done

local-test-tika-delta-05/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');
+  }
+}