Add files using upload-large-folder tool

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/MAINTAINERS.csv

@@ -0,0 +1,7 @@
+Name,Email,Github Username
+Adam Korcz,adam@adalogics.com,AdamKorcz
+David Korczynski,david@adalogics.com,DavidKorczynski
+Dongge Liu,donggeliu@google.com,Alan32Liu
+Holly Gong,gongh@google.com,hogo6002
+Jonathan Metzman,metzman@google.com,jonathanmetzman
+Oliver Chang,ochang@google.com,oliverchang

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/README.md

@@ -0,0 +1,23 @@
+# infra
+> OSS-Fuzz project infrastructure
+
+Core infrastructure:
+* [`base-images`](base-images/) - docker images for building fuzz targets & corresponding jenkins
+  pipeline.
+
+Continuous Integration infrastructure:
+
+* [`ci`](ci/) - script to build projects in CI.
+
+## helper.py
+> script to automate common docker operations
+
+| Command | Description |
+|---------|-------------
+| `generate`      | Generates skeleton files for a new project |
+| `build_image`   | Builds a docker image for a given project |
+| `build_fuzzers` | Builds fuzz targets for a given project |
+| `run_fuzzer`    | Runs a fuzz target in a docker container |
+| `coverage`      | Runs fuzz target(s) in a docker container and generates a code coverage report. See [Code Coverage doc](https://google.github.io/oss-fuzz/advanced-topics/code-coverage/) |
+| `reproduce`     | Runs a testcase to reproduce a crash |
+| `shell`         | Starts a shell inside the docker image for a project |

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/bisector.py

@@ -0,0 +1,318 @@
+# Copyright 2019 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.
+"""Uses bisection to determine which commit a bug was introduced and fixed.
+This module takes a high and a low commit SHA, a repo name, and a bug.
+The module bisects the high and low commit SHA searching for the location
+where the bug was introduced. It also looks for where the bug was fixed.
+This is done with the following steps:
+
+
+  NOTE: Needs to be run from root of the OSS-Fuzz source checkout.
+
+  Typical usage example:
+        python3 infra/bisector.py
+          --old_commit 1e403e9259a1abedf108ab86f711ba52c907226d
+          --new_commit f79be4f2330f4b89ea2f42e1c44ca998c59a0c0f
+          --fuzz_target rules_fuzzer
+          --project_name yara
+          --testcase infra/yara_testcase
+          --sanitizer address
+"""
+
+import argparse
+import collections
+import logging
+import os
+import sys
+import tempfile
+
+import build_specified_commit
+import helper
+import repo_manager
+import utils
+
+Result = collections.namedtuple('Result', ['repo_url', 'commit'])
+
+START_MARKERS = [
+    '==ERROR',
+    '==WARNING',
+]
+
+END_MARKERS = [
+    'SUMMARY:',
+]
+
+DEDUP_TOKEN_MARKER = 'DEDUP_TOKEN:'
+
+
+class BisectError(Exception):
+  """Bisection error."""
+
+  def __init__(self, message, repo_url):
+    super().__init__(message)
+    self.repo_url = repo_url
+
+
+def main():
+  """Finds the commit SHA where an error was initally introduced."""
+  logging.getLogger().setLevel(logging.INFO)
+  utils.chdir_to_root()
+  parser = argparse.ArgumentParser(
+      description='git bisection for finding introduction of bugs')
+
+  parser.add_argument('--project_name',
+                      help='The name of the project where the bug occurred.',
+                      required=True)
+  parser.add_argument('--new_commit',
+                      help='The newest commit SHA to be bisected.',
+                      required=True)
+  parser.add_argument('--old_commit',
+                      help='The oldest commit SHA to be bisected.',
+                      required=True)
+  parser.add_argument('--fuzz_target',
+                      help='The name of the fuzzer to be built.',
+                      required=True)
+  parser.add_argument('--test_case_path',
+                      help='The path to test case.',
+                      required=True)
+  parser.add_argument('--engine',
+                      help='The default is "libfuzzer".',
+                      default='libfuzzer')
+  parser.add_argument('--sanitizer',
+                      default='address',
+                      help='The default is "address".')
+  parser.add_argument('--type',
+                      choices=['regressed', 'fixed'],
+                      help='The bisection type.',
+                      required=True)
+  parser.add_argument('--architecture', default='x86_64')
+  args = parser.parse_args()
+
+  build_data = build_specified_commit.BuildData(project_name=args.project_name,
+                                                engine=args.engine,
+                                                sanitizer=args.sanitizer,
+                                                architecture=args.architecture)
+
+  result = bisect(args.type, args.old_commit, args.new_commit,
+                  args.test_case_path, args.fuzz_target, build_data)
+  if not result.commit:
+    logging.error('No error was found in commit range %s:%s', args.old_commit,
+                  args.new_commit)
+    return 1
+  if result.commit == args.old_commit:
+    logging.error(
+        'Bisection Error: Both the first and the last commits in'
+        'the given range have the same behavior, bisection is not possible. ')
+    return 1
+  if args.type == 'regressed':
+    print('Error was introduced at commit %s' % result.commit)
+  elif args.type == 'fixed':
+    print('Error was fixed at commit %s' % result.commit)
+  return 0
+
+
+def _get_dedup_token(output):
+  """Get dedup token."""
+  for line in output.splitlines():
+    token_location = line.find(DEDUP_TOKEN_MARKER)
+    if token_location == -1:
+      continue
+
+    return line[token_location + len(DEDUP_TOKEN_MARKER):].strip()
+
+  return None
+
+
+def _check_for_crash(project_name, fuzz_target, testcase_path):
+  """Check for crash."""
+
+  def docker_run(args, **kwargs):
+    del kwargs
+    command = ['docker', 'run', '--rm', '--privileged']
+    if sys.stdin.isatty():
+      command.append('-i')
+
+    return utils.execute(command + args)
+
+  logging.info('Checking for crash')
+  out, err, return_code = helper.reproduce_impl(
+      project=helper.Project(project_name),
+      fuzzer_name=fuzz_target,
+      valgrind=False,
+      env_to_add=[],
+      fuzzer_args=[],
+      testcase_path=testcase_path,
+      run_function=docker_run,
+      err_result=(None, None, None))
+  if return_code is None:
+    return None
+
+  logging.info('stdout =\n%s', out)
+  logging.info('stderr =\n%s', err)
+
+  # pylint: disable=unsupported-membership-test
+  has_start_marker = any(
+      marker in out or marker in err for marker in START_MARKERS)
+  has_end_marker = any(marker in out or marker in err for marker in END_MARKERS)
+  if not has_start_marker or not has_end_marker:
+    return None
+
+  return _get_dedup_token(out + err)
+
+
+# pylint: disable=too-many-locals
+# pylint: disable=too-many-arguments
+# pylint: disable=too-many-statements
+def _bisect(bisect_type, old_commit, new_commit, testcase_path, fuzz_target,
+            build_data):
+  """Perform the bisect."""
+  # pylint: disable=too-many-branches
+  base_builder_repo = build_specified_commit.load_base_builder_repo()
+
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    repo_url, repo_path = build_specified_commit.detect_main_repo(
+        build_data.project_name, commit=new_commit)
+    if not repo_url or not repo_path:
+      raise ValueError('Main git repo can not be determined.')
+
+    if old_commit == new_commit:
+      raise BisectError('old_commit is the same as new_commit', repo_url)
+
+    # Copy /src from the built Docker container to ensure all dependencies
+    # exist. This will be mounted when running them.
+    host_src_dir = build_specified_commit.copy_src_from_docker(
+        build_data.project_name, tmp_dir)
+
+    bisect_repo_manager = repo_manager.RepoManager(
+        os.path.join(host_src_dir, os.path.basename(repo_path)))
+    bisect_repo_manager.fetch_all_remotes()
+
+    commit_list = bisect_repo_manager.get_commit_list(new_commit, old_commit)
+
+    old_idx = len(commit_list) - 1
+    new_idx = 0
+    logging.info('Testing against new_commit (%s)', commit_list[new_idx])
+    if not build_specified_commit.build_fuzzers_from_commit(
+        commit_list[new_idx],
+        bisect_repo_manager,
+        host_src_dir,
+        build_data,
+        base_builder_repo=base_builder_repo):
+      raise BisectError('Failed to build new_commit', repo_url)
+
+    if bisect_type == 'fixed':
+      should_crash = False
+    elif bisect_type == 'regressed':
+      should_crash = True
+    else:
+      raise BisectError('Invalid bisect type ' + bisect_type, repo_url)
+
+    expected_error = _check_for_crash(build_data.project_name, fuzz_target,
+                                      testcase_path)
+    logging.info('new_commit result = %s', expected_error)
+
+    if not should_crash and expected_error:
+      logging.warning('new_commit crashed but not shouldn\'t. '
+                      'Continuing to see if stack changes.')
+
+    range_valid = False
+    for _ in range(2):
+      logging.info('Testing against old_commit (%s)', commit_list[old_idx])
+      if not build_specified_commit.build_fuzzers_from_commit(
+          commit_list[old_idx],
+          bisect_repo_manager,
+          host_src_dir,
+          build_data,
+          base_builder_repo=base_builder_repo):
+        raise BisectError('Failed to build old_commit', repo_url)
+
+      if _check_for_crash(build_data.project_name, fuzz_target,
+                          testcase_path) == expected_error:
+        logging.warning('old_commit %s had same result as new_commit %s',
+                        old_commit, new_commit)
+        # Try again on an slightly older commit.
+        old_commit = bisect_repo_manager.get_parent(old_commit, 64)
+        if not old_commit:
+          break
+
+        commit_list = bisect_repo_manager.get_commit_list(
+            new_commit, old_commit)
+        old_idx = len(commit_list) - 1
+        continue
+
+      range_valid = True
+      break
+
+    if not range_valid:
+      raise BisectError('old_commit had same result as new_commit', repo_url)
+
+    while old_idx - new_idx > 1:
+      curr_idx = (old_idx + new_idx) // 2
+      logging.info('Testing against %s (idx=%d)', commit_list[curr_idx],
+                   curr_idx)
+      if not build_specified_commit.build_fuzzers_from_commit(
+          commit_list[curr_idx],
+          bisect_repo_manager,
+          host_src_dir,
+          build_data,
+          base_builder_repo=base_builder_repo):
+        # Treat build failures as if we couldn't repo.
+        # TODO(ochang): retry nearby commits?
+        old_idx = curr_idx
+        continue
+
+      current_error = _check_for_crash(build_data.project_name, fuzz_target,
+                                       testcase_path)
+      logging.info('Current result = %s', current_error)
+      if expected_error == current_error:
+        new_idx = curr_idx
+      else:
+        old_idx = curr_idx
+    return Result(repo_url, commit_list[new_idx])
+
+
+# pylint: disable=too-many-locals
+# pylint: disable=too-many-arguments
+def bisect(bisect_type, old_commit, new_commit, testcase_path, fuzz_target,
+           build_data):
+  """From a commit range, this function caluclates which introduced a
+  specific error from a fuzz testcase_path.
+
+  Args:
+    bisect_type: The type of the bisect ('regressed' or 'fixed').
+    old_commit: The oldest commit in the error regression range.
+    new_commit: The newest commit in the error regression range.
+    testcase_path: The file path of the test case that triggers the error
+    fuzz_target: The name of the fuzzer to be tested.
+    build_data: a class holding all of the input parameters for bisection.
+
+  Returns:
+    The commit SHA that introduced the error or None.
+
+  Raises:
+    ValueError: when a repo url can't be determine from the project.
+  """
+  try:
+    return _bisect(bisect_type, old_commit, new_commit, testcase_path,
+                   fuzz_target, build_data)
+  finally:
+    # Clean up projects/ as _bisect may have modified it.
+    oss_fuzz_repo_manager = repo_manager.RepoManager(helper.OSS_FUZZ_DIR)
+    oss_fuzz_repo_manager.git(['reset', 'projects'])
+    oss_fuzz_repo_manager.git(['checkout', 'projects'])
+    oss_fuzz_repo_manager.git(['clean', '-fxd', 'projects'])
+
+
+if __name__ == '__main__':
+  main()

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/build_specified_commit_test.py

@@ -0,0 +1,126 @@
+# Copyright 2019 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.
+"""Test the functionality of the build image from commit module.
+The will consist of the following functional tests:
+  1. The inference of the main repo for a specific project.
+  2. The building of a projects fuzzers from a specific commit.
+
+"""
+import os
+import tempfile
+import unittest
+
+import build_specified_commit
+import helper
+import repo_manager
+import test_repos
+
+# necessary because __file__ changes with os.chdir
+TEST_DIR_PATH = os.path.dirname(os.path.realpath(__file__))
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class BuildImageIntegrationTest(unittest.TestCase):
+  """Tests if an image can be built from different states e.g. a commit."""
+
+  @unittest.skip('Test is failing (spuriously?).')
+  def test_build_fuzzers_from_commit(self):
+    """Tests if the fuzzers can build at a specified commit.
+
+    This is done by using a known regression range for a specific test case.
+    The old commit should show the error when its fuzzers run and the new one
+    should not.
+    """
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      test_repo = test_repos.TEST_REPOS[1]
+      self.assertTrue(helper.build_image_impl(test_repo.project_name))
+      host_src_dir = build_specified_commit.copy_src_from_docker(
+          test_repo.project_name, tmp_dir)
+
+      test_repo_manager = repo_manager.clone_repo_and_get_manager(
+          test_repo.git_url, host_src_dir, test_repo.oss_repo_name)
+      build_data = build_specified_commit.BuildData(
+          sanitizer='address',
+          architecture='x86_64',
+          engine='libfuzzer',
+          project_name=test_repo.project_name)
+
+      build_specified_commit.build_fuzzers_from_commit(test_repo.old_commit,
+                                                       test_repo_manager,
+                                                       host_src_dir, build_data)
+      project = helper.Project(test_repo.project_name)
+      old_result = helper.reproduce_impl(project=project,
+                                         fuzzer_name=test_repo.fuzz_target,
+                                         valgrind=False,
+                                         env_to_add=[],
+                                         fuzzer_args=[],
+                                         testcase_path=test_repo.testcase_path)
+      build_specified_commit.build_fuzzers_from_commit(test_repo.project_name,
+                                                       test_repo_manager,
+                                                       host_src_dir, build_data)
+      new_result = helper.reproduce_impl(project=project,
+                                         fuzzer_name=test_repo.fuzz_target,
+                                         valgrind=False,
+                                         env_to_add=[],
+                                         fuzzer_args=[],
+                                         testcase_path=test_repo.testcase_path)
+      self.assertNotEqual(new_result, old_result)
+
+  def test_detect_main_repo_from_commit(self):
+    """Test the detect main repo function from build specific commit module."""
+    # TODO(metzman): Fix these tests so they don't randomly break because of
+    # changes in the outside world.
+    for example_repo in test_repos.TEST_REPOS:
+      if example_repo.new_commit:
+        # TODO(metzman): This function calls _build_image_with_retries which
+        # has a long delay (30 seconds). Figure out how to make this quicker.
+        repo_origin, repo_name = build_specified_commit.detect_main_repo(
+            example_repo.project_name, commit=example_repo.new_commit)
+        self.assertEqual(repo_origin, example_repo.git_url)
+        self.assertEqual(repo_name,
+                         os.path.join('/src', example_repo.oss_repo_name))
+
+    repo_origin, repo_name = build_specified_commit.detect_main_repo(
+        test_repos.INVALID_REPO.project_name,
+        test_repos.INVALID_REPO.new_commit)
+    self.assertIsNone(repo_origin)
+    self.assertIsNone(repo_name)
+
+  def test_detect_main_repo_from_name(self):
+    """Test the detect main repo function from build specific commit module."""
+    for example_repo in test_repos.TEST_REPOS:
+      if example_repo.project_name == 'gonids':
+        # It's unclear how this test ever passed, but we can't infer the repo
+        # because gonids doesn't really check it out, it uses "go get".
+        continue
+      repo_origin, repo_name = build_specified_commit.detect_main_repo(
+          example_repo.project_name, repo_name=example_repo.git_repo_name)
+      self.assertEqual(repo_origin, example_repo.git_url)
+      self.assertEqual(
+          repo_name,
+          os.path.join(example_repo.image_location, example_repo.oss_repo_name))
+
+    repo_origin, repo_name = build_specified_commit.detect_main_repo(
+        test_repos.INVALID_REPO.project_name,
+        test_repos.INVALID_REPO.oss_repo_name)
+    self.assertIsNone(repo_origin)
+    self.assertIsNone(repo_name)
+
+
+if __name__ == '__main__':
+  # Change to oss-fuzz main directory so helper.py runs correctly.
+  if os.getcwd() != os.path.dirname(TEST_DIR_PATH):
+    os.chdir(os.path.dirname(TEST_DIR_PATH))
+  unittest.main()

local-test-commons-compress-full-01-vuln_5/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-commons-compress-full-01-vuln_5/fuzz-tooling/infra/cifuzz/build_fuzzers_test.py

@@ -0,0 +1,403 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests the functionality of the cifuzz module."""
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+import parameterized
+
+# pylint: disable=wrong-import-position
+INFRA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(INFRA_DIR)
+
+OSS_FUZZ_DIR = os.path.dirname(INFRA_DIR)
+
+import build_fuzzers
+import continuous_integration
+import repo_manager
+import test_helpers
+
+# NOTE: This integration test relies on
+# https://github.com/google/oss-fuzz/tree/master/projects/example project.
+EXAMPLE_PROJECT = 'example'
+
+# Location of data used for testing.
+TEST_DATA_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                              'test_data')
+
+# An example fuzzer that triggers an crash.
+# Binary is a copy of the example project's do_stuff_fuzzer and can be
+# generated by running "python3 infra/helper.py build_fuzzers example".
+EXAMPLE_CRASH_FUZZER = 'example_crash_fuzzer'
+
+# An example fuzzer that does not trigger a crash.
+# Binary is a modified version of example project's do_stuff_fuzzer. It is
+# created by removing the bug in my_api.cpp.
+EXAMPLE_NOCRASH_FUZZER = 'example_nocrash_fuzzer'
+
+# A fuzzer to be built in build_fuzzers integration tests.
+EXAMPLE_BUILD_FUZZER = 'do_stuff_fuzzer'
+
+# pylint: disable=no-self-use,protected-access,too-few-public-methods,unused-argument
+
+
+def docker_command_has_env_var_arg(command, env_var_arg):
+  """Returns True if a docker command has a specific env var argument."""
+  for idx, element in enumerate(command):
+    if idx == 0:
+      # We're looking for the variable which can't be the first argument.
+      continue
+
+    if element == env_var_arg and command[idx - 1] == '-e':
+      return True
+  return False
+
+
+class BuildFuzzersTest(unittest.TestCase):
+  """Unit tests for build_fuzzers."""
+
+  @mock.patch('build_specified_commit.detect_main_repo',
+              return_value=('example.com', '/path'))
+  @mock.patch('repo_manager._clone', return_value=None)
+  @mock.patch('continuous_integration.checkout_specified_commit')
+  @mock.patch('helper.docker_run', return_value=False)  # We want to quit early.
+  def test_cifuzz_env_var(self, mock_docker_run, _, __, ___):
+    """Tests that the CIFUZZ env var is set."""
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      build_fuzzers.build_fuzzers(
+          test_helpers.create_build_config(
+              oss_fuzz_project_name=EXAMPLE_PROJECT,
+              project_repo_name=EXAMPLE_PROJECT,
+              workspace=tmp_dir,
+              pr_ref='refs/pull/1757/merge'))
+
+      docker_run_command = mock_docker_run.call_args_list[0][0][0]
+
+    self.assertTrue(
+        docker_command_has_env_var_arg(docker_run_command, 'CIFUZZ=True'))
+
+  @mock.patch('build_specified_commit.detect_main_repo',
+              return_value=('example.com', '/path'))
+  @mock.patch('repo_manager._clone', return_value=None)
+  @mock.patch('continuous_integration.checkout_specified_commit')
+  @mock.patch('helper.docker_run', return_value=False)  # We want to quit early.
+  def test_extra_env_var(self, mock_docker_run, _, __, ___):
+    """Tests that the CIFUZZ env var is set."""
+
+    extra_env_var = 'CFL_EXTRA_TOKEN'
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      with mock.patch.dict(os.environ, {extra_env_var: 'BLAH'}):
+        build_fuzzers.build_fuzzers(
+            test_helpers.create_build_config(
+                oss_fuzz_project_name=EXAMPLE_PROJECT,
+                project_repo_name=EXAMPLE_PROJECT,
+                workspace=tmp_dir,
+                pr_ref='refs/pull/1757/merge'))
+
+    docker_run_command = mock_docker_run.call_args_list[0][0][0]
+    self.assertTrue(
+        docker_command_has_env_var_arg(docker_run_command, extra_env_var))
+
+
+class InternalGithubBuildTest(unittest.TestCase):
+  """Tests for building OSS-Fuzz projects on GitHub actions."""
+  PROJECT_REPO_NAME = 'myproject'
+  SANITIZER = 'address'
+  GIT_SHA = 'fake'
+  PR_REF = 'fake'
+
+  def _create_builder(self, tmp_dir, oss_fuzz_project_name='myproject'):
+    """Creates an InternalGithubBuilder and returns it."""
+    config = test_helpers.create_build_config(
+        oss_fuzz_project_name=oss_fuzz_project_name,
+        project_repo_name=self.PROJECT_REPO_NAME,
+        workspace=tmp_dir,
+        sanitizer=self.SANITIZER,
+        git_sha=self.GIT_SHA,
+        pr_ref=self.PR_REF,
+        cfl_platform='github')
+    cfl_platform = continuous_integration.get_ci(config)
+    builder = build_fuzzers.Builder(config, cfl_platform)
+    builder.repo_manager = repo_manager.RepoManager('/fake')
+    return builder
+
+  @mock.patch('helper.docker_run', return_value=True)
+  @mock.patch('continuous_integration.checkout_specified_commit',
+              side_effect=None)
+  def test_correct_host_repo_path(self, _, __):
+    """Tests that the correct self.host_repo_path is set by
+    build_image_and_checkout_src. Specifically, we want the name of the
+    directory the repo is in to match the name used in the docker
+    image/container, so that it will replace the host's copy properly."""
+    image_repo_path = '/src/repo_dir'
+    with tempfile.TemporaryDirectory() as tmp_dir, mock.patch(
+        'build_specified_commit.detect_main_repo',
+        return_value=('inferred_url', image_repo_path)):
+      builder = self._create_builder(tmp_dir)
+      builder.build_image_and_checkout_src()
+
+    self.assertEqual(os.path.basename(builder.host_repo_path),
+                     os.path.basename(image_repo_path))
+
+  @mock.patch('clusterfuzz_deployment.ClusterFuzzLite.upload_build',
+              return_value=True)
+  def test_upload_build_disabled(self, mock_upload_build):
+    """Test upload build (disabled)."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      builder = self._create_builder(tmp_dir)
+      builder.upload_build()
+
+    mock_upload_build.assert_not_called()
+
+  @mock.patch('repo_manager.RepoManager.get_current_commit',
+              return_value='commit')
+  @mock.patch('clusterfuzz_deployment.ClusterFuzzLite.upload_build',
+              return_value=True)
+  def test_upload_build(self, mock_upload_build, mock_get_current_commit):
+    """Test upload build."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      builder = self._create_builder(tmp_dir, oss_fuzz_project_name='')
+      builder.config.upload_build = True
+      builder.upload_build()
+
+    mock_upload_build.assert_called_with('commit')
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class BuildFuzzersIntegrationTest(unittest.TestCase):
+  """Integration tests for build_fuzzers."""
+
+  def setUp(self):
+    self.temp_dir_ctx_manager = test_helpers.docker_temp_dir()
+    self.workspace = self.temp_dir_ctx_manager.__enter__()
+    self.out_dir = os.path.join(self.workspace, 'build-out')
+    test_helpers.patch_environ(self)
+
+    base_runner_path = os.path.join(INFRA_DIR, 'base-images', 'base-runner')
+    os.environ['PATH'] = os.environ['PATH'] + os.pathsep + base_runner_path
+
+  def tearDown(self):
+    self.temp_dir_ctx_manager.__exit__(None, None, None)
+
+  def test_external_github_project(self):
+    """Tests building fuzzers from an external project on Github."""
+    project_repo_name = 'external-project'
+    git_url = 'https://github.com/jonathanmetzman/cifuzz-external-example.git'
+    # This test is dependant on the state of
+    # github.com/jonathanmetzman/cifuzz-external-example.
+    config = test_helpers.create_build_config(
+        project_repo_name=project_repo_name,
+        workspace=self.workspace,
+        git_url=git_url,
+        git_sha='HEAD',
+        cfl_platform='github',
+        base_commit='HEAD^1')
+    self.assertTrue(build_fuzzers.build_fuzzers(config))
+    self.assertTrue(
+        os.path.exists(os.path.join(self.out_dir, EXAMPLE_BUILD_FUZZER)))
+
+  def test_external_generic_project(self):
+    """Tests building fuzzers from an external project not on Github."""
+    project_repo_name = 'cifuzz-external-example'
+    git_url = 'https://github.com/jonathanmetzman/cifuzz-external-example.git'
+    # This test is dependant on the state of
+    # github.com/jonathanmetzman/cifuzz-external-example.
+    manager = repo_manager.clone_repo_and_get_manager(
+        'https://github.com/jonathanmetzman/cifuzz-external-example',
+        self.workspace)
+    project_src_path = manager.repo_dir
+    config = test_helpers.create_build_config(
+        project_repo_name=project_repo_name,
+        workspace=self.workspace,
+        git_url=git_url,
+        filestore='no_filestore',
+        git_sha='HEAD',
+        project_src_path=project_src_path,
+        base_commit='HEAD^1')
+    self.assertTrue(build_fuzzers.build_fuzzers(config))
+    self.assertTrue(
+        os.path.exists(os.path.join(self.out_dir, EXAMPLE_BUILD_FUZZER)))
+
+  def test_valid_commit(self):
+    """Tests building fuzzers with valid inputs."""
+    config = test_helpers.create_build_config(
+        oss_fuzz_project_name=EXAMPLE_PROJECT,
+        project_repo_name='oss-fuzz',
+        workspace=self.workspace,
+        git_sha='0b95fe1039ed7c38fea1f97078316bfc1030c523',
+        base_commit='da0746452433dc18bae699e355a9821285d863c8',
+        cfl_platform='github')
+    self.assertTrue(build_fuzzers.build_fuzzers(config))
+    self.assertTrue(
+        os.path.exists(os.path.join(self.out_dir, EXAMPLE_BUILD_FUZZER)))
+
+  def test_valid_pull_request(self):
+    """Tests building fuzzers with valid pull request."""
+    config = test_helpers.create_build_config(
+        oss_fuzz_project_name=EXAMPLE_PROJECT,
+        project_repo_name='oss-fuzz',
+        workspace=self.workspace,
+        pr_ref='refs/pull/1757/merge',
+        base_ref='master',
+        cfl_platform='github')
+    self.assertTrue(build_fuzzers.build_fuzzers(config))
+    self.assertTrue(
+        os.path.exists(os.path.join(self.out_dir, EXAMPLE_BUILD_FUZZER)))
+
+  def test_invalid_pull_request(self):
+    """Tests building fuzzers with invalid pull request."""
+    config = test_helpers.create_build_config(
+        oss_fuzz_project_name=EXAMPLE_PROJECT,
+        project_repo_name='oss-fuzz',
+        workspace=self.workspace,
+        pr_ref='ref-1/merge',
+        base_ref='master',
+        cfl_platform='github')
+    self.assertTrue(build_fuzzers.build_fuzzers(config))
+
+  def test_invalid_oss_fuzz_project_name(self):
+    """Tests building fuzzers with invalid project name."""
+    config = test_helpers.create_build_config(
+        oss_fuzz_project_name='not_a_valid_project',
+        project_repo_name='oss-fuzz',
+        workspace=self.workspace,
+        git_sha='0b95fe1039ed7c38fea1f97078316bfc1030c523')
+    self.assertFalse(build_fuzzers.build_fuzzers(config))
+
+  def test_invalid_repo_name(self):
+    """Tests building fuzzers with invalid repo name."""
+    config = test_helpers.create_build_config(
+        oss_fuzz_project_name=EXAMPLE_PROJECT,
+        project_repo_name='not-real-repo',
+        workspace=self.workspace,
+        git_sha='0b95fe1039ed7c38fea1f97078316bfc1030c523')
+    self.assertFalse(build_fuzzers.build_fuzzers(config))
+
+  def test_invalid_git_sha(self):
+    """Tests building fuzzers with invalid commit SHA."""
+    config = test_helpers.create_build_config(
+        oss_fuzz_project_name=EXAMPLE_PROJECT,
+        project_repo_name='oss-fuzz',
+        workspace=self.workspace,
+        git_sha='',
+        cfl_platform='github')
+    with self.assertRaises(AssertionError):
+      build_fuzzers.build_fuzzers(config)
+
+  def test_invalid_workspace(self):
+    """Tests building fuzzers with invalid workspace."""
+    config = test_helpers.create_build_config(
+        oss_fuzz_project_name=EXAMPLE_PROJECT,
+        project_repo_name='oss-fuzz',
+        workspace=os.path.join(self.workspace, 'not', 'a', 'dir'),
+        git_sha='0b95fe1039ed7c38fea1f97078316bfc1030c523')
+    self.assertFalse(build_fuzzers.build_fuzzers(config))
+
+
+class CheckFuzzerBuildTest(unittest.TestCase):
+  """Tests the check_fuzzer_build function in the cifuzz module."""
+
+  SANITIZER = 'address'
+  LANGUAGE = 'c++'
+
+  def setUp(self):
+    self.temp_dir_obj = tempfile.TemporaryDirectory()
+    workspace_path = os.path.join(self.temp_dir_obj.name, 'workspace')
+    self.config = test_helpers.create_build_config(
+        oss_fuzz_project_name=EXAMPLE_PROJECT,
+        sanitizer=self.SANITIZER,
+        language=self.LANGUAGE,
+        workspace=workspace_path,
+        pr_ref='refs/pull/1757/merge')
+    self.workspace = test_helpers.create_workspace(workspace_path)
+    shutil.copytree(TEST_DATA_PATH, workspace_path)
+    test_helpers.patch_environ(self, runner=True)
+
+  def tearDown(self):
+    self.temp_dir_obj.cleanup()
+
+  def test_correct_fuzzer_build(self):
+    """Checks check_fuzzer_build function returns True for valid fuzzers."""
+    self.assertTrue(build_fuzzers.check_fuzzer_build(self.config))
+
+  def test_not_a_valid_path(self):
+    """Tests that False is returned when a nonexistent path is given."""
+    self.config.workspace = 'not/a/valid/path'
+    self.assertFalse(build_fuzzers.check_fuzzer_build(self.config))
+
+  def test_no_valid_fuzzers(self):
+    """Tests that False is returned when an empty directory is given."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      self.config.workspace = tmp_dir
+      os.mkdir(os.path.join(self.config.workspace, 'build-out'))
+      self.assertFalse(build_fuzzers.check_fuzzer_build(self.config))
+
+  @mock.patch('utils.execute', return_value=(None, None, 0))
+  def test_allow_broken_fuzz_targets_percentage(self, mock_execute):
+    """Tests that ALLOWED_BROKEN_TARGETS_PERCENTAGE is set when running
+    docker if passed to check_fuzzer_build."""
+    percentage = '0'
+    self.config.allowed_broken_targets_percentage = percentage
+    build_fuzzers.check_fuzzer_build(self.config)
+    self.assertEqual(
+        mock_execute.call_args[1]['env']['ALLOWED_BROKEN_TARGETS_PERCENTAGE'],
+        percentage)
+
+
+@unittest.skip('Test is too long to be run with presubmit.')
+class BuildSantizerIntegrationTest(unittest.TestCase):
+  """Integration tests for the build_fuzzers.
+    Note: This test relies on "curl" being an OSS-Fuzz project."""
+  PROJECT_NAME = 'curl'
+  PR_REF = 'fake_pr'
+
+  @classmethod
+  def _create_config(cls, tmp_dir, sanitizer):
+    return test_helpers.create_build_config(
+        oss_fuzz_project_name=cls.PROJECT_NAME,
+        project_repo_name=cls.PROJECT_NAME,
+        workspace=tmp_dir,
+        pr_ref=cls.PR_REF,
+        sanitizer=sanitizer)
+
+  @parameterized.parameterized.expand([('memory',), ('undefined',)])
+  def test_valid_project_curl(self, sanitizer):
+    """Tests that MSAN can be detected from project.yaml"""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      self.assertTrue(
+          build_fuzzers.build_fuzzers(self._create_config(tmp_dir, sanitizer)))
+
+
+class GetDockerBuildFuzzersArgsNotContainerTest(unittest.TestCase):
+  """Tests that _get_docker_build_fuzzers_args_not_container works as
+  intended."""
+
+  def test_get_docker_build_fuzzers_args_no_container(self):
+    """Tests that _get_docker_build_fuzzers_args_not_container works
+    as intended."""
+    host_repo_path = '/host/repo'
+    result = build_fuzzers._get_docker_build_fuzzers_args_not_container(
+        host_repo_path)
+    expected_result = ['-v', '/host/repo:/host/repo']
+    self.assertEqual(result, expected_result)
+
+
+if __name__ == '__main__':
+  unittest.main()

local-test-commons-compress-full-01-vuln_5/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-commons-compress-full-01-vuln_5/fuzz-tooling/infra/cifuzz/cloudbuild.yaml

@@ -0,0 +1,52 @@
+# TODO(metzman): Get rid of cifuzz-build-fuzzers and cifuzz-run-fuzzers.
+steps:
+- name: 'gcr.io/cloud-builders/docker'
+  args:
+  - build
+  - '-t'
+  - ghcr.io/aixcc-finals/cifuzz-base
+  - '-t'
+  - ghcr.io/aixcc-finals/cifuzz-base:v1
+  - '-f'
+  - infra/cifuzz/cifuzz-base/Dockerfile
+  - .
+- name: 'gcr.io/cloud-builders/docker'
+  args:
+  - build
+  - '-t'
+  - ghcr.io/aixcc-finals/cifuzz-build-fuzzers
+  - '-t'
+  - ghcr.io/aixcc-finals/cifuzz-build-fuzzers:v1
+  - '-t'
+  - ghcr.io/aixcc-finals/clusterfuzzlite-build-fuzzers
+  - '-t'
+  - ghcr.io/aixcc-finals/clusterfuzzlite-build-fuzzers:v1
+  - '-f'
+  - infra/build_fuzzers.Dockerfile
+  - infra
+- name: 'gcr.io/cloud-builders/docker'
+  args:
+  - build
+  - '-t'
+  - ghcr.io/aixcc-finals/cifuzz-run-fuzzers
+  - '-t'
+  - ghcr.io/aixcc-finals/cifuzz-run-fuzzers:v1
+  - '-t'
+  - ghcr.io/aixcc-finals/clusterfuzzlite-run-fuzzers
+  - '-t'
+  - ghcr.io/aixcc-finals/clusterfuzzlite-run-fuzzers:v1
+  - '-f'
+  - infra/run_fuzzers.Dockerfile
+  - infra
+images:
+- ghcr.io/aixcc-finals/cifuzz-base
+- ghcr.io/aixcc-finals/cifuzz-base:v1
+- ghcr.io/aixcc-finals/cifuzz-run-fuzzers
+- ghcr.io/aixcc-finals/cifuzz-run-fuzzers:v1
+- ghcr.io/aixcc-finals/cifuzz-build-fuzzers
+- ghcr.io/aixcc-finals/cifuzz-build-fuzzers:v1
+- ghcr.io/aixcc-finals/clusterfuzzlite-build-fuzzers
+- ghcr.io/aixcc-finals/clusterfuzzlite-build-fuzzers:v1
+- ghcr.io/aixcc-finals/clusterfuzzlite-run-fuzzers
+- ghcr.io/aixcc-finals/clusterfuzzlite-run-fuzzers:v1
+timeout: 1800s

local-test-commons-compress-full-01-vuln_5/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-commons-compress-full-01-vuln_5/fuzz-tooling/infra/cifuzz/environment.py

@@ -0,0 +1,51 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for dealing with env vars."""
+
+import ast
+import os
+
+
+def _eval_value(value_string):
+  """Returns evaluated value."""
+  try:
+    return ast.literal_eval(value_string)
+  except:  # pylint: disable=bare-except
+    # String fallback.
+    return value_string
+
+
+def get(env_var, default_value=None):
+  """Returns an environment variable value."""
+  value_string = os.getenv(env_var)
+  if value_string is None:
+    return default_value
+
+  return _eval_value(value_string)
+
+
+def get_bool(env_var, default_value=None):
+  """Returns a boolean environment variable value. This is needed because a lot
+  of CIFuzz users specified 'false' for dry-run. So we need to special case
+  this."""
+  value = get(env_var, default_value)
+  if not isinstance(value, str):
+    return bool(value)
+
+  lower_value = value.lower()
+  allowed_values = {'true', 'false'}
+  if lower_value not in allowed_values:
+    raise Exception(f'Bool env var {env_var} value {value} is invalid. '
+                    f'Must be one of {allowed_values}.')
+  return lower_value == 'true'

local-test-commons-compress-full-01-vuln_5/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-commons-compress-full-01-vuln_5/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-commons-compress-full-01-vuln_5/fuzz-tooling/infra/cifuzz/workspace_utils.py

@@ -0,0 +1,85 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for representing the workspace directory which CIFuzz uses."""
+
+import os
+import shutil
+
+
+class Workspace:
+  """Class representing the workspace directory."""
+
+  def __init__(self, config):
+    self.workspace = config.workspace
+
+  def initialize_dir(self, directory):  # pylint: disable=no-self-use
+    """Creates directory if it doesn't already exist, otherwise does nothing."""
+    os.makedirs(directory, exist_ok=True)
+
+  @property
+  def repo_storage(self):
+    """The parent directory for repo storage."""
+    return os.path.join(self.workspace, 'storage')
+
+  @property
+  def out(self):
+    """The out directory used for storing the fuzzer build built by
+    build_fuzzers."""
+    # Don't use 'out' because it needs to be used by artifacts.
+    return os.path.join(self.workspace, 'build-out')
+
+  @property
+  def work(self):
+    """The directory used as the work directory for the fuzzer build/run."""
+    return os.path.join(self.workspace, 'work')
+
+  @property
+  def artifacts(self):
+    """The directory used to store artifacts for download by CI-system users."""
+    # This is hardcoded by a lot of clients, so we need to use this.
+    return os.path.join(self.workspace, 'out', 'artifacts')
+
+  @property
+  def clusterfuzz_build(self):
+    """The directory where builds from ClusterFuzz are stored."""
+    return os.path.join(self.workspace, 'cifuzz-prev-build')
+
+  @property
+  def clusterfuzz_coverage(self):
+    """The directory where builds from ClusterFuzz are stored."""
+    return os.path.join(self.workspace, 'cifuzz-prev-coverage')
+
+  @property
+  def coverage_report(self):
+    """The directory where coverage reports generated by cifuzz are put."""
+    return os.path.join(self.workspace, 'cifuzz-coverage')
+
+  @property
+  def corpora(self):
+    """The directory where corpora from ClusterFuzz are stored."""
+    return os.path.join(self.workspace, 'cifuzz-corpus')
+
+  @property
+  def pruned_corpora(self):
+    """The directory where pruned corpora are stored."""
+    return os.path.join(self.workspace, 'cifuzz-pruned-corpus')
+
+  @property
+  def sarif(self):
+    """The directory where sarif files are stored."""
+    return os.path.join(self.workspace, 'cifuzz-sarif')
+
+  def make_repo_for_sarif(self, repo_manager):
+    """Copies the repo over for the sarif upload GitHub action."""
+    return shutil.copytree(repo_manager.repo_dir, self.sarif, symlinks=True)

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/helper.py

@@ -0,0 +1,1810 @@
+#!/usr/bin/env python
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Helper script for OSS-Fuzz users. Can do common tasks like building
+projects/fuzzers, running them etc."""
+
+from __future__ import print_function
+from multiprocessing.dummy import Pool as ThreadPool
+import argparse
+import datetime
+import errno
+import logging
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+
+import constants
+import templates
+
+OSS_FUZZ_DIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+BUILD_DIR = os.path.join(OSS_FUZZ_DIR, 'build')
+
+BASE_IMAGE_TAG = ':v1.2.1' # no tag for latest
+
+BASE_RUNNER_IMAGE = f'ghcr.io/aixcc-finals/base-runner{BASE_IMAGE_TAG}'
+
+BASE_IMAGES = {
+    'generic': [
+        f'ghcr.io/aixcc-finals/base-image{BASE_IMAGE_TAG}',
+        f'ghcr.io/aixcc-finals/base-clang{BASE_IMAGE_TAG}',
+        f'ghcr.io/aixcc-finals/base-builder{BASE_IMAGE_TAG}',
+        BASE_RUNNER_IMAGE,
+        f'ghcr.io/aixcc-finals/base-runner-debug{BASE_IMAGE_TAG}',
+    ],
+    'go': [f'ghcr.io/aixcc-finals/base-builder-go{BASE_IMAGE_TAG}'],
+    'javascript': [f'ghcr.io/aixcc-finals/base-builder-javascript{BASE_IMAGE_TAG}'],
+    'jvm': [f'ghcr.io/aixcc-finals/base-builder-jvm{BASE_IMAGE_TAG}'],
+    'python': [f'ghcr.io/aixcc-finals/base-builder-python{BASE_IMAGE_TAG}'],
+    'rust': [f'ghcr.io/aixcc-finals/base-builder-rust{BASE_IMAGE_TAG}'],
+    'ruby': [f'ghcr.io/aixcc-finals/base-builder-ruby{BASE_IMAGE_TAG}'],
+    'swift': [f'ghcr.io/aixcc-finals/base-builder-swift{BASE_IMAGE_TAG}'],
+}
+
+VALID_PROJECT_NAME_REGEX = re.compile(r'^[a-zA-Z0-9_-]+$')
+MAX_PROJECT_NAME_LENGTH = 26
+
+CORPUS_URL_FORMAT = (
+    'gs://{project_name}-corpus.clusterfuzz-external.appspot.com/libFuzzer/'
+    '{fuzz_target}/')
+CORPUS_BACKUP_URL_FORMAT = (
+    'gs://{project_name}-backup.clusterfuzz-external.appspot.com/corpus/'
+    'libFuzzer/{fuzz_target}/')
+
+HTTPS_CORPUS_BACKUP_URL_FORMAT = (
+    'https://storage.googleapis.com/{project_name}-backup.clusterfuzz-external'
+    '.appspot.com/corpus/libFuzzer/{fuzz_target}/public.zip')
+
+LANGUAGE_REGEX = re.compile(r'[^\s]+')
+PROJECT_LANGUAGE_REGEX = re.compile(r'\s*language\s*:\s*([^\s]+)')
+
+WORKDIR_REGEX = re.compile(r'\s*WORKDIR\s*([^\s]+)')
+
+# Regex to match special chars in project name.
+SPECIAL_CHARS_REGEX = re.compile('[^a-zA-Z0-9_-]')
+
+LANGUAGE_TO_BASE_BUILDER_IMAGE = {
+    'c': 'base-builder',
+    'c++': 'base-builder',
+    'go': 'base-builder-go',
+    'javascript': 'base-builder-javascript',
+    'jvm': 'base-builder-jvm',
+    'python': 'base-builder-python',
+    'ruby': 'base-builder-ruby',
+    'rust': 'base-builder-rust',
+    'swift': 'base-builder-swift'
+}
+ARM_BUILDER_NAME = 'oss-fuzz-buildx-builder'
+
+CLUSTERFUZZLITE_ENGINE = 'libfuzzer'
+CLUSTERFUZZLITE_ARCHITECTURE = 'x86_64'
+CLUSTERFUZZLITE_FILESTORE_DIR = 'filestore'
+CLUSTERFUZZLITE_DOCKER_IMAGE = 'ghcr.io/aixcc-finals/cifuzz-run-fuzzers'
+
+logger = logging.getLogger(__name__)
+
+if sys.version_info[0] >= 3:
+  raw_input = input  # pylint: disable=invalid-name
+
+# pylint: disable=too-many-lines
+
+
+class Project:
+  """Class representing a project that is in OSS-Fuzz or an external project
+  (ClusterFuzzLite user)."""
+
+  def __init__(
+      self,
+      project_name_or_path,
+      is_external=False,
+      build_integration_path=constants.DEFAULT_EXTERNAL_BUILD_INTEGRATION_PATH):
+    self.is_external = is_external
+    if self.is_external:
+      self.path = os.path.abspath(project_name_or_path)
+      self.name = os.path.basename(self.path)
+      self.build_integration_path = os.path.join(self.path,
+                                                 build_integration_path)
+    else:
+      self.name = project_name_or_path
+      self.path = os.path.join(OSS_FUZZ_DIR, 'projects', self.name)
+      self.build_integration_path = self.path
+
+  @property
+  def dockerfile_path(self):
+    """Returns path to the project Dockerfile."""
+    return os.path.join(self.build_integration_path, 'Dockerfile')
+
+  @property
+  def language(self):
+    """Returns project language."""
+    project_yaml_path = os.path.join(self.build_integration_path,
+                                     'project.yaml')
+    if not os.path.exists(project_yaml_path):
+      logger.warning('No project.yaml. Assuming c++.')
+      return constants.DEFAULT_LANGUAGE
+
+    with open(project_yaml_path) as file_handle:
+      content = file_handle.read()
+      for line in content.splitlines():
+        match = PROJECT_LANGUAGE_REGEX.match(line)
+        if match:
+          return match.group(1)
+
+    logger.warning('Language not specified in project.yaml. Assuming c++.')
+    return constants.DEFAULT_LANGUAGE
+
+  @property
+  def coverage_extra_args(self):
+    """Returns project coverage extra args."""
+    project_yaml_path = os.path.join(self.build_integration_path,
+                                     'project.yaml')
+    if not os.path.exists(project_yaml_path):
+      logger.warning('project.yaml not found: %s.', project_yaml_path)
+      return ''
+
+    with open(project_yaml_path) as file_handle:
+      content = file_handle.read()
+
+    coverage_flags = ''
+    read_coverage_extra_args = False
+    # Pass the yaml file and extract the value of the coverage_extra_args key.
+    # This is naive yaml parsing and we do not handle comments at this point.
+    for line in content.splitlines():
+      if read_coverage_extra_args:
+        # Break reading coverage args if a new yaml key is defined.
+        if len(line) > 0 and line[0] != ' ':
+          break
+        coverage_flags += line
+      if 'coverage_extra_args' in line:
+        read_coverage_extra_args = True
+        # Include the first line only if it's not a multi-line value.
+        if 'coverage_extra_args: >' not in line:
+          coverage_flags += line.replace('coverage_extra_args: ', '')
+    return coverage_flags
+
+  @property
+  def out(self):
+    """Returns the out dir for the project. Creates it if needed."""
+    return _get_out_dir(self.name)
+
+  @property
+  def work(self):
+    """Returns the out dir for the project. Creates it if needed."""
+    return _get_project_build_subdir(self.name, 'work')
+
+  @property
+  def corpus(self):
+    """Returns the out dir for the project. Creates it if needed."""
+    return _get_project_build_subdir(self.name, 'corpus')
+
+
+def main():  # pylint: disable=too-many-branches,too-many-return-statements
+  """Gets subcommand from program arguments and does it. Returns 0 on success 1
+  on error."""
+  logging.basicConfig(level=logging.INFO)
+  parser = get_parser()
+  args = parse_args(parser)
+
+  # Need to do this before chdir.
+  # TODO(https://github.com/google/oss-fuzz/issues/6758): Get rid of chdir.
+  if hasattr(args, 'testcase_path'):
+    args.testcase_path = _get_absolute_path(args.testcase_path)
+  # Note: this has to happen after parse_args above as parse_args needs to know
+  # the original CWD for external projects.
+  os.chdir(OSS_FUZZ_DIR)
+  if not os.path.exists(BUILD_DIR):
+    os.mkdir(BUILD_DIR)
+
+  # We have different default values for `sanitizer` depending on the `engine`.
+  # Some commands do not have `sanitizer` argument, so `hasattr` is necessary.
+  if hasattr(args, 'sanitizer') and not args.sanitizer:
+    if args.project.language == 'javascript':
+      args.sanitizer = 'none'
+    else:
+      args.sanitizer = constants.DEFAULT_SANITIZER
+
+  if args.command == 'generate':
+    result = generate(args)
+  elif args.command == 'build_image':
+    result = build_image(args)
+  elif args.command == 'build_fuzzers':
+    result = build_fuzzers(args)
+  elif args.command == 'fuzzbench_build_fuzzers':
+    result = fuzzbench_build_fuzzers(args)
+  elif args.command == 'fuzzbench_run_fuzzer':
+    result = fuzzbench_run_fuzzer(args)
+  elif args.command == 'fuzzbench_measure':
+    result = fuzzbench_measure(args)
+  elif args.command == 'check_build':
+    result = check_build(args)
+  elif args.command == 'download_corpora':
+    result = download_corpora(args)
+  elif args.command == 'run_fuzzer':
+    result = run_fuzzer(args)
+  elif args.command == 'coverage':
+    result = coverage(args)
+  elif args.command == 'introspector':
+    result = introspector(args)
+  elif args.command == 'reproduce':
+    result = reproduce(args)
+    if args.propagate_exit_codes:
+      return result
+  elif args.command == 'shell':
+    result = shell(args)
+  elif args.command == 'pull_images':
+    result = pull_images()
+  elif args.command == 'run_clusterfuzzlite':
+    result = run_clusterfuzzlite(args)
+  else:
+    # Print help string if no arguments provided.
+    parser.print_help()
+    result = False
+  return bool_to_retcode(result)
+
+
+def bool_to_retcode(boolean):
+  """Returns 0 if |boolean| is Truthy, 0 is the standard return code for a
+  successful process execution. Returns 1 otherwise, indicating the process
+  failed."""
+  return 0 if boolean else 1
+
+
+def parse_args(parser, args=None):
+  """Parses |args| using |parser| and returns parsed args. Also changes
+  |args.build_integration_path| to have correct default behavior."""
+  # Use default argument None for args so that in production, argparse does its
+  # normal behavior, but unittesting is easier.
+  parsed_args = parser.parse_args(args)
+  project = getattr(parsed_args, 'project', None)
+  if not project:
+    return parsed_args
+
+  # Use hacky method for extracting attributes so that ShellTest works.
+  # TODO(metzman): Fix this.
+  is_external = getattr(parsed_args, 'external', False)
+  parsed_args.project = Project(parsed_args.project, is_external)
+  return parsed_args
+
+
+def _add_external_project_args(parser):
+  parser.add_argument(
+      '--external',
+      help='Is project external?',
+      default=False,
+      action='store_true',
+  )
+
+
+def get_parser():  # pylint: disable=too-many-statements,too-many-locals
+  """Returns an argparse parser."""
+  parser = argparse.ArgumentParser('helper.py', description='oss-fuzz helpers')
+  subparsers = parser.add_subparsers(dest='command')
+
+  generate_parser = subparsers.add_parser(
+      'generate', help='Generate files for new project.')
+  generate_parser.add_argument('project')
+  generate_parser.add_argument('--language',
+                               default=constants.DEFAULT_LANGUAGE,
+                               choices=LANGUAGE_TO_BASE_BUILDER_IMAGE.keys(),
+                               help='Project language.')
+  _add_external_project_args(generate_parser)
+
+  build_image_parser = subparsers.add_parser('build_image',
+                                             help='Build an image.')
+  build_image_parser.add_argument('project')
+  build_image_parser.add_argument('--pull',
+                                  action='store_true',
+                                  help='Pull latest base image.')
+  _add_architecture_args(build_image_parser)
+  build_image_parser.add_argument('--cache',
+                                  action='store_true',
+                                  default=False,
+                                  help='Use docker cache when building image.')
+  build_image_parser.add_argument('--no-pull',
+                                  action='store_true',
+                                  help='Do not pull latest base image.')
+  build_image_parser.add_argument('--docker_image_tag',
+                                    dest='docker_image_tag',
+                                    default='latest',
+                                    help='docker image build tag'
+                                    'default: latest')
+  _add_external_project_args(build_image_parser)
+
+  build_fuzzers_parser = subparsers.add_parser(
+      'build_fuzzers', help='Build fuzzers for a project.')
+  _add_architecture_args(build_fuzzers_parser)
+  _add_engine_args(build_fuzzers_parser)
+  _add_sanitizer_args(build_fuzzers_parser)
+  _add_environment_args(build_fuzzers_parser)
+  _add_external_project_args(build_fuzzers_parser)
+  build_fuzzers_parser.add_argument('project')
+  build_fuzzers_parser.add_argument('source_path',
+                                    help='path of local source',
+                                    nargs='?')
+  build_fuzzers_parser.add_argument('--mount_path',
+                                    dest='mount_path',
+                                    help='path to mount local source in '
+                                    '(defaults to WORKDIR)')
+  build_fuzzers_parser.add_argument('--clean',
+                                    dest='clean',
+                                    action='store_true',
+                                    help='clean existing artifacts.')
+  build_fuzzers_parser.add_argument('--no-clean',
+                                    dest='clean',
+                                    action='store_false',
+                                    help='do not clean existing artifacts '
+                                    '(default).')
+  build_fuzzers_parser.add_argument('--docker_image_tag',
+                                    dest='docker_image_tag',
+                                    default='latest',
+                                    help='docker image build tag'
+                                    'default: latest')
+  build_fuzzers_parser.set_defaults(clean=False)
+
+  fuzzbench_build_fuzzers_parser = subparsers.add_parser(
+      'fuzzbench_build_fuzzers')
+  _add_architecture_args(fuzzbench_build_fuzzers_parser)
+  fuzzbench_build_fuzzers_parser.add_argument('--engine')
+  _add_sanitizer_args(fuzzbench_build_fuzzers_parser)
+  _add_environment_args(fuzzbench_build_fuzzers_parser)
+  _add_external_project_args(fuzzbench_build_fuzzers_parser)
+  fuzzbench_build_fuzzers_parser.add_argument('project')
+  check_build_parser = subparsers.add_parser(
+      'check_build', help='Checks that fuzzers execute without errors.')
+  _add_architecture_args(check_build_parser)
+  _add_engine_args(check_build_parser, choices=constants.ENGINES)
+  _add_sanitizer_args(check_build_parser, choices=constants.SANITIZERS)
+  _add_environment_args(check_build_parser)
+  check_build_parser.add_argument('project',
+                                  help='name of the project or path (external)')
+  check_build_parser.add_argument('fuzzer_name',
+                                  help='name of the fuzzer',
+                                  nargs='?')
+  _add_external_project_args(check_build_parser)
+
+  run_fuzzer_parser = subparsers.add_parser(
+      'run_fuzzer', help='Run a fuzzer in the emulated fuzzing environment.')
+  _add_architecture_args(run_fuzzer_parser)
+  _add_engine_args(run_fuzzer_parser)
+  _add_sanitizer_args(run_fuzzer_parser)
+  _add_environment_args(run_fuzzer_parser)
+  _add_external_project_args(run_fuzzer_parser)
+  run_fuzzer_parser.add_argument(
+      '--corpus-dir', help='directory to store corpus for the fuzz target')
+  run_fuzzer_parser.add_argument('project',
+                                 help='name of the project or path (external)')
+  run_fuzzer_parser.add_argument('fuzzer_name', help='name of the fuzzer')
+  run_fuzzer_parser.add_argument('fuzzer_args',
+                                 help='arguments to pass to the fuzzer',
+                                 nargs='*')
+
+  fuzzbench_run_fuzzer_parser = subparsers.add_parser('fuzzbench_run_fuzzer')
+  _add_architecture_args(fuzzbench_run_fuzzer_parser)
+  fuzzbench_run_fuzzer_parser.add_argument('--engine')
+  _add_sanitizer_args(fuzzbench_run_fuzzer_parser)
+  _add_environment_args(fuzzbench_run_fuzzer_parser)
+  _add_external_project_args(fuzzbench_run_fuzzer_parser)
+  fuzzbench_run_fuzzer_parser.add_argument(
+      '--corpus-dir', help='directory to store corpus for the fuzz target')
+  fuzzbench_run_fuzzer_parser.add_argument(
+      'project', help='name of the project or path (external)')
+  fuzzbench_run_fuzzer_parser.add_argument('fuzzer_name',
+                                           help='name of the fuzzer')
+  fuzzbench_run_fuzzer_parser.add_argument(
+      'fuzzer_args', help='arguments to pass to the fuzzer', nargs='*')
+
+  fuzzbench_measure_parser = subparsers.add_parser('fuzzbench_measure')
+  fuzzbench_measure_parser.add_argument(
+      'project', help='name of the project or path (external)')
+  fuzzbench_measure_parser.add_argument('engine_name',
+                                        help='name of the fuzzer')
+  fuzzbench_measure_parser.add_argument('fuzz_target_name',
+                                        help='name of the fuzzer')
+
+  coverage_parser = subparsers.add_parser(
+      'coverage', help='Generate code coverage report for the project.')
+  coverage_parser.add_argument('--no-corpus-download',
+                               action='store_true',
+                               help='do not download corpus backup from '
+                               'OSS-Fuzz; use corpus located in '
+                               'build/corpus/<project>/<fuzz_target>/')
+  coverage_parser.add_argument('--no-serve',
+                               action='store_true',
+                               help='do not serve a local HTTP server.')
+  coverage_parser.add_argument('--port',
+                               default='8008',
+                               help='specify port for'
+                               ' a local HTTP server rendering coverage report')
+  coverage_parser.add_argument('--fuzz-target',
+                               help='specify name of a fuzz '
+                               'target to be run for generating coverage '
+                               'report')
+  coverage_parser.add_argument('--corpus-dir',
+                               help='specify location of corpus'
+                               ' to be used (requires --fuzz-target argument)')
+  coverage_parser.add_argument('--public',
+                               action='store_true',
+                               help='if set, will download public '
+                               'corpus using wget')
+  coverage_parser.add_argument('project',
+                               help='name of the project or path (external)')
+  coverage_parser.add_argument('extra_args',
+                               help='additional arguments to '
+                               'pass to llvm-cov utility.',
+                               nargs='*')
+  _add_external_project_args(coverage_parser)
+  _add_architecture_args(coverage_parser)
+
+  introspector_parser = subparsers.add_parser(
+      'introspector',
+      help='Run a complete end-to-end run of '
+      'fuzz introspector. This involves (1) '
+      'building the fuzzers with ASAN; (2) '
+      'running all fuzzers; (3) building '
+      'fuzzers with coverge; (4) extracting '
+      'coverage; (5) building fuzzers using '
+      'introspector')
+  introspector_parser.add_argument('project', help='name of the project')
+  introspector_parser.add_argument('--seconds',
+                                   help='number of seconds to run fuzzers',
+                                   default=10)
+  introspector_parser.add_argument('source_path',
+                                   help='path of local source',
+                                   nargs='?')
+  introspector_parser.add_argument(
+      '--public-corpora',
+      help='if specified, will use public corpora for code coverage',
+      default=False,
+      action='store_true')
+  introspector_parser.add_argument(
+      '--private-corpora',
+      help='if specified, will use private corpora',
+      default=False,
+      action='store_true')
+
+  download_corpora_parser = subparsers.add_parser(
+      'download_corpora', help='Download all corpora for a project.')
+  download_corpora_parser.add_argument('--fuzz-target',
+                                       nargs='+',
+                                       help='specify name of a fuzz target')
+  download_corpora_parser.add_argument('--public',
+                                       action='store_true',
+                                       help='if set, will download public '
+                                       'corpus using wget')
+  download_corpora_parser.add_argument(
+      'project', help='name of the project or path (external)')
+
+  reproduce_parser = subparsers.add_parser('reproduce',
+                                           help='Reproduce a crash.')
+  reproduce_parser.add_argument('--valgrind',
+                                action='store_true',
+                                help='run with valgrind')
+  reproduce_parser.add_argument('--propagate_exit_codes',
+                                action='store_true',
+                                default=False,
+                                help='return underlying exit codes instead of True/False.')
+  reproduce_parser.add_argument('--not_privileged',
+                                dest='privileged',
+                                action='store_false',
+                                default=True,
+                                help='reproduce without running docker in privileged mode.')
+  reproduce_parser.add_argument('--err_result', 
+                                help='exit code override for missing harness / fuzz targets '
+                                '(default err_result = 1).',
+                                type=int)
+  reproduce_parser.add_argument('--timeout', 
+                                help='timeout for reproduce subprocess '
+                                '(default: None).',
+                                default=None,
+                                type=int)
+  reproduce_parser.add_argument('project',
+                                help='name of the project or path (external)')
+  reproduce_parser.add_argument('fuzzer_name', help='name of the fuzzer')
+  reproduce_parser.add_argument('testcase_path', help='path of local testcase')
+  reproduce_parser.add_argument('fuzzer_args',
+                                help='arguments to pass to the fuzzer',
+                                nargs='*')
+  _add_environment_args(reproduce_parser)
+  _add_external_project_args(reproduce_parser)
+  _add_architecture_args(reproduce_parser)
+
+  shell_parser = subparsers.add_parser(
+      'shell', help='Run /bin/bash within the builder container.')
+  shell_parser.add_argument('project',
+                            help='name of the project or path (external)')
+  shell_parser.add_argument('source_path',
+                            help='path of local source',
+                            nargs='?')
+  shell_parser.add_argument('--docker_image_tag',
+                            dest='docker_image_tag',
+                            default='latest',
+                            help='docker image build tag'
+                            'default: latest')
+  _add_architecture_args(shell_parser)
+  _add_engine_args(shell_parser)
+  _add_sanitizer_args(shell_parser)
+  _add_environment_args(shell_parser)
+  _add_external_project_args(shell_parser)
+
+  run_clusterfuzzlite_parser = subparsers.add_parser(
+      'run_clusterfuzzlite', help='Run ClusterFuzzLite on a project.')
+  _add_sanitizer_args(run_clusterfuzzlite_parser)
+  _add_environment_args(run_clusterfuzzlite_parser)
+  run_clusterfuzzlite_parser.add_argument('project')
+  run_clusterfuzzlite_parser.add_argument('--clean',
+                                          dest='clean',
+                                          action='store_true',
+                                          help='clean existing artifacts.')
+  run_clusterfuzzlite_parser.add_argument(
+      '--no-clean',
+      dest='clean',
+      action='store_false',
+      help='do not clean existing artifacts '
+      '(default).')
+  run_clusterfuzzlite_parser.add_argument('--branch',
+                                          default='master',
+                                          required=True)
+  _add_external_project_args(run_clusterfuzzlite_parser)
+  run_clusterfuzzlite_parser.set_defaults(clean=False)
+
+  subparsers.add_parser('pull_images', help='Pull base images.')
+  return parser
+
+
+def is_base_image(image_name):
+  """Checks if the image name is a base image."""
+  return os.path.exists(os.path.join('infra', 'base-images', image_name))
+
+
+def check_project_exists(project):
+  """Checks if a project exists."""
+  if os.path.exists(project.path):
+    return True
+
+  if project.is_external:
+    descriptive_project_name = project.path
+  else:
+    descriptive_project_name = project.name
+
+  logger.error('"%s" does not exist.', descriptive_project_name)
+  return False
+
+
+def _check_fuzzer_exists(project, fuzzer_name, architecture='x86_64'):
+  """Checks if a fuzzer exists."""
+  platform = 'linux/arm64' if architecture == 'aarch64' else 'linux/amd64'
+  command = ['docker', 'run', '--rm', '--platform', platform]
+  command.extend(['-v', '%s:/out' % project.out])
+  command.append(BASE_RUNNER_IMAGE)
+
+  command.extend(['/bin/bash', '-c', 'test -f /out/%s' % fuzzer_name])
+
+  try:
+    subprocess.check_call(command)
+  except subprocess.CalledProcessError:
+    logger.error('%s does not seem to exist. Please run build_fuzzers first.',
+                 fuzzer_name)
+    return False
+
+  return True
+
+
+def _normalized_name(name):
+  """Return normalized name with special chars like slash, colon, etc normalized
+  to hyphen(-). This is important as otherwise these chars break local and cloud
+  storage paths."""
+  return SPECIAL_CHARS_REGEX.sub('-', name).strip('-')
+
+
+def _get_absolute_path(path):
+  """Returns absolute path with user expansion."""
+  return os.path.abspath(os.path.expanduser(path))
+
+
+def _get_command_string(command):
+  """Returns a shell escaped command string."""
+  return ' '.join(shlex.quote(part) for part in command)
+
+
+def _get_project_build_subdir(project, subdir_name):
+  """Creates the |subdir_name| subdirectory of the |project| subdirectory in
+  |BUILD_DIR| and returns its path."""
+  directory = os.path.join(BUILD_DIR, subdir_name, project)
+  os.makedirs(directory, exist_ok=True)
+
+  return directory
+
+
+def _get_out_dir(project=''):
+  """Creates and returns path to /out directory for the given project (if
+  specified)."""
+  return _get_project_build_subdir(project, 'out')
+
+
+def _add_architecture_args(parser, choices=None):
+  """Adds common architecture args."""
+  if choices is None:
+    choices = constants.ARCHITECTURES
+  parser.add_argument('--architecture',
+                      default=constants.DEFAULT_ARCHITECTURE,
+                      choices=choices)
+
+
+def _add_engine_args(parser, choices=None):
+  """Adds common engine args."""
+  if choices is None:
+    choices = constants.ENGINES
+  parser.add_argument('--engine',
+                      default=constants.DEFAULT_ENGINE,
+                      choices=choices)
+
+
+def _add_sanitizer_args(parser, choices=None):
+  """Adds common sanitizer args."""
+  if choices is None:
+    choices = constants.SANITIZERS
+  parser.add_argument('--sanitizer',
+                      default=None,
+                      choices=choices,
+                      help='the default is "address"')
+
+
+def _add_environment_args(parser):
+  """Adds common environment args."""
+  parser.add_argument('-e',
+                      action='append',
+                      help="set environment variable e.g. VAR=value")
+
+
+def build_image_impl(project, cache=True, pull=False, 
+                     architecture='x86_64', 
+                     docker_image_tag='latest'):
+  """Builds image."""
+  image_name = project.name
+
+  if is_base_image(image_name):
+    image_project = 'aixcc-finals'
+    docker_build_dir = os.path.join(OSS_FUZZ_DIR, 'infra', 'base-images',
+                                    image_name)
+    dockerfile_path = os.path.join(docker_build_dir, 'Dockerfile')
+    image_name = 'ghcr.io/%s/%s%s' % (image_project, image_name, BASE_IMAGE_TAG)
+  else:
+    if not check_project_exists(project):
+      return False
+    dockerfile_path = project.dockerfile_path
+    docker_build_dir = project.path
+    image_project = 'aixcc-afc'
+    image_name = '%s/%s:%s' % (image_project, image_name, docker_image_tag)
+
+  if pull and not pull_images(project.language):
+    return False
+
+  build_args = []
+  if architecture == 'aarch64':
+    build_args += [
+        'buildx',
+        'build',
+        '--platform',
+        'linux/arm64',
+        '--progress',
+        'plain',
+        '--load',
+    ]
+  if not cache:
+    build_args.append('--no-cache')
+
+  build_args += ['-t', image_name, '--file', dockerfile_path]
+  build_args.append(docker_build_dir)
+
+  if architecture == 'aarch64':
+    command = ['docker'] + build_args
+    subprocess.check_call(command)
+    return True
+  return docker_build(build_args)
+
+
+def _env_to_docker_args(env_list):
+  """Turns envirnoment variable list into docker arguments."""
+  return sum([['-e', v] for v in env_list], [])
+
+
+def workdir_from_lines(lines, default='/src'):
+  """Gets the WORKDIR from the given lines."""
+  for line in reversed(lines):  # reversed to get last WORKDIR.
+    match = re.match(WORKDIR_REGEX, line)
+    if match:
+      workdir = match.group(1)
+      workdir = workdir.replace('$SRC', '/src')
+
+      if not os.path.isabs(workdir):
+        workdir = os.path.join('/src', workdir)
+
+      return os.path.normpath(workdir)
+
+  return default
+
+
+def _workdir_from_dockerfile(project):
+  """Parses WORKDIR from the Dockerfile for the given project."""
+  with open(project.dockerfile_path) as file_handle:
+    lines = file_handle.readlines()
+
+  return workdir_from_lines(lines, default=os.path.join('/src', project.name))
+
+
+def prepare_aarch64_emulation():
+  """Run some necessary commands to use buildx to build AArch64 targets using
+  QEMU emulation on an x86_64 host."""
+  subprocess.check_call(
+      ['docker', 'buildx', 'create', '--name', ARM_BUILDER_NAME])
+  subprocess.check_call(['docker', 'buildx', 'use', ARM_BUILDER_NAME])
+
+
+def docker_run(run_args, print_output=True, architecture='x86_64', propagate_exit_codes=False, privileged=True, timeout=None):
+  """Calls `docker run`."""
+  platform = 'linux/arm64' if architecture == 'aarch64' else 'linux/amd64'
+
+  if privileged:
+      command = [
+          'docker', 'run', '--privileged', '--shm-size=2g', '--platform', platform
+      ]
+  else:
+      command = [
+          'docker', 'run', '--shm-size=2g', '--platform', platform
+      ]
+
+  if os.getenv('OSS_FUZZ_SAVE_CONTAINERS_NAME'):
+    command.append('--name')
+    command.append(os.getenv('OSS_FUZZ_SAVE_CONTAINERS_NAME'))
+  else:
+    command.append('--rm')
+
+  # Support environments with a TTY.
+  if sys.stdin.isatty():
+    command.append('-i')
+
+  command.extend(run_args)
+
+  logger.info('Running: %s.', _get_command_string(command))
+  stdout = None
+  if not print_output:
+    stdout = open(os.devnull, 'w')
+
+  exit_code = 0
+
+  try:
+    subprocess.check_call(command, stdout=stdout, stderr=subprocess.STDOUT,
+                          timeout=timeout)
+  except subprocess.CalledProcessError as e:
+    print(f'subprocess command returned a non-zero exit status: {e.returncode}')
+    exit_code = e.returncode
+  except subprocess.TimeoutExpired:
+    print(f'subprocess command timed out: {timeout=}')
+    exit_code = 124
+
+  return exit_code if propagate_exit_codes else exit_code == 0
+
+
+def docker_build(build_args):
+  """Calls `docker build`."""
+  command = ['docker', 'build']
+  command.extend(build_args)
+  logger.info('Running: %s.', _get_command_string(command))
+
+  try:
+    subprocess.check_call(command)
+  except subprocess.CalledProcessError:
+    logger.error('Docker build failed.')
+    return False
+
+  return True
+
+
+def docker_pull(image):
+  """Call `docker pull`."""
+  command = ['docker', 'pull', image]
+  logger.info('Running: %s', _get_command_string(command))
+
+  try:
+    subprocess.check_call(command)
+  except subprocess.CalledProcessError:
+    logger.error('Docker pull failed.')
+    return False
+
+  return True
+
+
+def build_image(args):
+  """Builds docker image."""
+  if args.pull and args.no_pull:
+    logger.error('Incompatible arguments --pull and --no-pull.')
+    return False
+
+  if args.pull:
+    pull = True
+  elif args.no_pull:
+    pull = False
+  else:
+    y_or_n = raw_input('Pull latest base images (compiler/runtime)? (y/N): ')
+    pull = y_or_n.lower() == 'y'
+
+  if pull:
+    logger.info('Pulling latest base images...')
+  else:
+    logger.info('Using cached base images...')
+
+  # If build_image is called explicitly, don't use cache.
+  if build_image_impl(args.project,
+                      cache=args.cache,
+                      pull=pull,
+                      architecture=args.architecture,
+                      docker_image_tag=args.docker_image_tag):
+    return True
+
+  return False
+
+
+def build_fuzzers_impl(  # pylint: disable=too-many-arguments,too-many-locals,too-many-branches
+    project,
+    clean,
+    engine,
+    sanitizer,
+    architecture,
+    env_to_add,
+    source_path,
+    mount_path=None,
+    child_dir='',
+    build_project_image=True,
+    docker_image_tag='latest'):
+  """Builds fuzzers."""
+  if build_project_image and not build_image_impl(project,
+                                                  architecture=architecture,
+                                                  docker_image_tag=docker_image_tag):
+    return False
+
+  docker_image = f'aixcc-afc/{project.name}:{docker_image_tag}'
+
+  project_out = os.path.join(project.out, child_dir)
+  if clean:
+    logger.info('Cleaning existing build artifacts.')
+
+    # Clean old and possibly conflicting artifacts in project's out directory.
+    docker_run([
+        '-v', f'{project_out}:/out', '-t', f'{docker_image}',
+        '/bin/bash', '-c', 'rm -rf /out/*'
+    ],
+               architecture=architecture)
+
+    docker_run([
+        '-v',
+        '%s:/work' % project.work, '-t',
+        f'{docker_image}', '/bin/bash', '-c', 'rm -rf /work/*'
+    ],
+               architecture=architecture)
+
+  else:
+    logger.info('Keeping existing build artifacts as-is (if any).')
+  env = [
+      'FUZZING_ENGINE=' + engine,
+      'SANITIZER=' + sanitizer,
+      'ARCHITECTURE=' + architecture,
+      'PROJECT_NAME=' + project.name,
+      'HELPER=True',
+  ]
+
+  _add_oss_fuzz_ci_if_needed(env)
+
+  if project.language:
+    env.append('FUZZING_LANGUAGE=' + project.language)
+
+  if env_to_add:
+    env += env_to_add
+
+  command = _env_to_docker_args(env)
+  if source_path:
+    workdir = _workdir_from_dockerfile(project)
+    stateless_path = mount_path if mount_path else workdir
+
+    if stateless_path == '/src':
+      logger.error('Cannot mount local source targeting "/src".')
+      return False
+
+    command += [
+        '-v',
+        '%s:%s:ro' % (_get_absolute_path(source_path), '/local-source-mount'),
+    ]
+
+  command += [
+      '-v', f'{project_out}:/out', '-v', f'{project.work}:/work',
+      f'{docker_image}'
+  ]
+
+  if sys.stdin.isatty():
+    command.insert(-1, '-t')
+
+  if source_path:
+    default_cmd = 'compile'
+    command += [
+      '/bin/bash', 
+      '-c', 
+      f'pushd $SRC && rm -rf {stateless_path} && cp -r /local-source-mount {stateless_path} && popd && {default_cmd}'
+    ]
+
+  result = docker_run(command, architecture=architecture)
+  if not result:
+    logger.error('Building fuzzers failed.')
+    return False
+
+  return True
+
+
+def run_clusterfuzzlite(args):
+  """Runs ClusterFuzzLite on a local repo."""
+  if not os.path.exists(CLUSTERFUZZLITE_FILESTORE_DIR):
+    os.mkdir(CLUSTERFUZZLITE_FILESTORE_DIR)
+
+  try:
+    with tempfile.TemporaryDirectory() as workspace:
+
+      if args.external:
+        project_src_path = os.path.join(workspace, args.project.name)
+        shutil.copytree(args.project.path, project_src_path)
+
+      build_command = [
+          '--tag', 'ghcr.io/aixcc-finals/cifuzz-run-fuzzers', '--file',
+          'infra/run_fuzzers.Dockerfile', 'infra'
+      ]
+      if not docker_build(build_command):
+        return False
+      filestore_path = os.path.abspath(CLUSTERFUZZLITE_FILESTORE_DIR)
+      docker_run_command = []
+      if args.external:
+        docker_run_command += [
+            '-e',
+            f'PROJECT_SRC_PATH={project_src_path}',
+        ]
+      else:
+        docker_run_command += [
+            '-e',
+            f'OSS_FUZZ_PROJECT_NAME={args.project.name}',
+        ]
+      docker_run_command += [
+          '-v',
+          f'{filestore_path}:{filestore_path}',
+          '-v',
+          f'{workspace}:{workspace}',
+          '-e',
+          f'FILESTORE_ROOT_DIR={filestore_path}',
+          '-e',
+          f'WORKSPACE={workspace}',
+          '-e',
+          f'REPOSITORY={args.project.name}',
+          '-e',
+          'CFL_PLATFORM=standalone',
+          '--entrypoint',
+          '',
+          '-v',
+          '/var/run/docker.sock:/var/run/docker.sock',
+          CLUSTERFUZZLITE_DOCKER_IMAGE,
+          'python3',
+          '/opt/oss-fuzz/infra/cifuzz/cifuzz_combined_entrypoint.py',
+      ]
+      return docker_run(docker_run_command)
+
+  except PermissionError as error:
+    logger.error('PermissionError: %s.', error)
+    # Tempfile can't delete the workspace because of a permissions issue. This
+    # is because docker creates files in the workspace that are owned by root
+    # but this process is probably being run as another user. Use a docker image
+    # to delete the temp directory (workspace) so that we have permission.
+    docker_run([
+        '-v', f'{workspace}:{workspace}', '--entrypoint', '',
+        CLUSTERFUZZLITE_DOCKER_IMAGE, 'rm', '-rf',
+        os.path.join(workspace, '*')
+    ])
+    return False
+
+
+def build_fuzzers(args):
+  """Builds fuzzers."""
+  if args.engine == 'centipede' and args.sanitizer != 'none':
+    # Centipede always requires separate binaries for sanitizers:
+    # An unsanitized binary, which Centipede requires for fuzzing.
+    # A sanitized binary, placed in the child directory.
+    sanitized_binary_directories = (
+        ('none', ''),
+        (args.sanitizer, f'__centipede_{args.sanitizer}'),
+    )
+  else:
+    # Generally, a fuzzer only needs one sanitized binary in the default dir.
+    sanitized_binary_directories = ((args.sanitizer, ''),)
+  return all(
+      build_fuzzers_impl(args.project,
+                         args.clean,
+                         args.engine,
+                         sanitizer,
+                         args.architecture,
+                         args.e,
+                         args.source_path,
+                         mount_path=args.mount_path,
+                         child_dir=child_dir,
+                         docker_image_tag=args.docker_image_tag)
+      for sanitizer, child_dir in sanitized_binary_directories)
+
+
+def fuzzbench_build_fuzzers(args):
+  """Builds fuzz targets with an arbitrary fuzzer from FuzzBench."""
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    tmp_dir = os.path.abspath(tmp_dir)
+    fuzzbench_path = os.path.join(tmp_dir, 'fuzzbench')
+    subprocess.run([
+        'git', 'clone', 'https://github.com/google/fuzzbench', '--depth', '1',
+        fuzzbench_path
+    ],
+                   check=True)
+    env = [
+        f'FUZZBENCH_PATH={fuzzbench_path}', 'OSS_FUZZ_ON_DEMAND=1',
+        f'PROJECT={args.project.name}'
+    ]
+    tag = f'aixcc-afc/{args.project.name}'
+    subprocess.run([
+        'docker', 'tag', 'ghcr.io/aixcc-finals/base-builder-fuzzbench',
+        f'ghcr.io/aixcc-finals/base-builder{BASE_IMAGE_TAG}'
+    ],
+                   check=True)
+    build_image_impl(args.project)
+    assert docker_build([
+        '--tag', tag, '--build-arg', f'parent_image={tag}', '--file',
+        os.path.join(fuzzbench_path, 'fuzzers', args.engine,
+                     'builder.Dockerfile'),
+        os.path.join(fuzzbench_path, 'fuzzers', args.engine)
+    ])
+
+    return build_fuzzers_impl(args.project,
+                              False,
+                              args.engine,
+                              args.sanitizer,
+                              args.architecture,
+                              env,
+                              source_path=fuzzbench_path,
+                              mount_path=fuzzbench_path,
+                              build_project_image=False)
+
+
+def _add_oss_fuzz_ci_if_needed(env):
+  """Adds value of |OSS_FUZZ_CI| environment variable to |env| if it is set."""
+  oss_fuzz_ci = os.getenv('OSS_FUZZ_CI')
+  if oss_fuzz_ci:
+    env.append('OSS_FUZZ_CI=' + oss_fuzz_ci)
+
+
+def check_build(args):
+  """Checks that fuzzers in the container execute without errors."""
+  if not check_project_exists(args.project):
+    return False
+
+  if (args.fuzzer_name and not _check_fuzzer_exists(
+      args.project, args.fuzzer_name, args.architecture)):
+    return False
+
+  env = [
+      'FUZZING_ENGINE=' + args.engine,
+      'SANITIZER=' + args.sanitizer,
+      'ARCHITECTURE=' + args.architecture,
+      'FUZZING_LANGUAGE=' + args.project.language,
+      'HELPER=True',
+  ]
+  _add_oss_fuzz_ci_if_needed(env)
+  if args.e:
+    env += args.e
+
+  run_args = _env_to_docker_args(env) + [
+      '-v', f'{args.project.out}:/out', '-t', BASE_RUNNER_IMAGE
+  ]
+
+  if args.fuzzer_name:
+    run_args += ['test_one.py', args.fuzzer_name]
+  else:
+    run_args.append('test_all.py')
+
+  result = docker_run(run_args, architecture=args.architecture)
+  if result:
+    logger.info('Check build passed.')
+  else:
+    logger.error('Check build failed.')
+
+  return result
+
+
+def _get_fuzz_targets(project):
+  """Returns names of fuzz targest build in the project's /out directory."""
+  fuzz_targets = []
+  for name in os.listdir(project.out):
+    if name.startswith('afl-'):
+      continue
+    if name == 'centipede':
+      continue
+    if name.startswith('jazzer_'):
+      continue
+    if name == 'llvm-symbolizer':
+      continue
+
+    path = os.path.join(project.out, name)
+    # Python and JVM fuzz targets are only executable for the root user, so
+    # we can't use os.access.
+    if os.path.isfile(path) and (os.stat(path).st_mode & 0o111):
+      fuzz_targets.append(name)
+
+  return fuzz_targets
+
+
+def _get_latest_corpus(project, fuzz_target, base_corpus_dir):
+  """Downloads the latest corpus for the given fuzz target."""
+  corpus_dir = os.path.join(base_corpus_dir, fuzz_target)
+  os.makedirs(corpus_dir, exist_ok=True)
+
+  if not fuzz_target.startswith(project.name + '_'):
+    fuzz_target = '%s_%s' % (project.name, fuzz_target)
+
+  # Normalise fuzz target name.
+  fuzz_target = _normalized_name(fuzz_target)
+
+  corpus_backup_url = CORPUS_BACKUP_URL_FORMAT.format(project_name=project.name,
+                                                      fuzz_target=fuzz_target)
+  command = ['gsutil', 'ls', corpus_backup_url]
+
+  # Don't capture stderr. We want it to print in real time, in case gsutil is
+  # asking for two-factor authentication.
+  corpus_listing = subprocess.Popen(command, stdout=subprocess.PIPE)
+  output, _ = corpus_listing.communicate()
+
+  # Some fuzz targets (e.g. new ones) may not have corpus yet, just skip those.
+  if corpus_listing.returncode:
+    logger.warning('Corpus for %s not found:\n', fuzz_target)
+    return
+
+  if output:
+    latest_backup_url = output.splitlines()[-1]
+    archive_path = corpus_dir + '.zip'
+    command = ['gsutil', '-q', 'cp', latest_backup_url, archive_path]
+    subprocess.check_call(command)
+
+    command = ['unzip', '-q', '-o', archive_path, '-d', corpus_dir]
+    subprocess.check_call(command)
+    os.remove(archive_path)
+  else:
+    # Sync the working corpus copy if a minimized backup is not available.
+    corpus_url = CORPUS_URL_FORMAT.format(project_name=project.name,
+                                          fuzz_target=fuzz_target)
+    command = ['gsutil', '-m', '-q', 'rsync', '-R', corpus_url, corpus_dir]
+    subprocess.check_call(command)
+
+
+def _get_latest_public_corpus(args, fuzzer):
+  """Downloads the public corpus"""
+  target_corpus_dir = "build/corpus/%s" % args.project.name
+  if not os.path.isdir(target_corpus_dir):
+    os.makedirs(target_corpus_dir)
+
+  target_zip = os.path.join(target_corpus_dir, fuzzer + ".zip")
+
+  project_qualified_fuzz_target_name = fuzzer
+  qualified_name_prefix = args.project.name + '_'
+  if not fuzzer.startswith(qualified_name_prefix):
+    project_qualified_fuzz_target_name = qualified_name_prefix + fuzzer
+
+  download_url = HTTPS_CORPUS_BACKUP_URL_FORMAT.format(
+      project_name=args.project.name,
+      fuzz_target=project_qualified_fuzz_target_name)
+
+  cmd = ['wget', download_url, '-O', target_zip]
+  try:
+    with open(os.devnull, 'w') as stdout:
+      subprocess.check_call(cmd, stdout=stdout)
+  except OSError:
+    logger.error('Failed to download corpus')
+
+  target_fuzzer_dir = os.path.join(target_corpus_dir, fuzzer)
+  if not os.path.isdir(target_fuzzer_dir):
+    os.mkdir(target_fuzzer_dir)
+
+  target_corpus_dir = os.path.join(target_corpus_dir, fuzzer)
+  try:
+    with open(os.devnull, 'w') as stdout:
+      subprocess.check_call(
+          ['unzip', '-q', '-o', target_zip, '-d', target_fuzzer_dir],
+          stdout=stdout)
+  except OSError:
+    logger.error('Failed to unzip corpus')
+
+  # Remove the downloaded zip
+  os.remove(target_zip)
+  return True
+
+
+def download_corpora(args):
+  """Downloads most recent corpora from GCS for the given project."""
+  if not check_project_exists(args.project):
+    return False
+
+  if args.public:
+    logger.info("Downloading public corpus")
+    try:
+      with open(os.devnull, 'w') as stdout:
+        subprocess.check_call(['wget', '--version'], stdout=stdout)
+    except OSError:
+      logger.error('wget not found')
+      return False
+  else:
+    try:
+      with open(os.devnull, 'w') as stdout:
+        subprocess.check_call(['gsutil', '--version'], stdout=stdout)
+    except OSError:
+      logger.error('gsutil not found. Please install it from '
+                   'https://cloud.google.com/storage/docs/gsutil_install')
+      return False
+
+  if args.fuzz_target:
+    fuzz_targets = args.fuzz_target
+  else:
+    fuzz_targets = _get_fuzz_targets(args.project)
+
+  if not fuzz_targets:
+    logger.error(
+        'Fuzz targets not found. Please build project first '
+        '(python3 infra/helper.py build_fuzzers %s) so that download_corpora '
+        'can automatically identify targets.', args.project.name)
+    return False
+
+  corpus_dir = args.project.corpus
+
+  def _download_for_single_target(fuzz_target):
+    try:
+      if args.public:
+        _get_latest_public_corpus(args, fuzz_target)
+      else:
+        _get_latest_corpus(args.project, fuzz_target, corpus_dir)
+      return True
+    except Exception as error:  # pylint:disable=broad-except
+      logger.error('Corpus download for %s failed: %s.', fuzz_target,
+                   str(error))
+      return False
+
+  logger.info('Downloading corpora for %s project to %s.', args.project.name,
+              corpus_dir)
+  thread_pool = ThreadPool()
+  return all(thread_pool.map(_download_for_single_target, fuzz_targets))
+
+
+def coverage(args):  # pylint: disable=too-many-branches
+  """Generates code coverage using clang source based code coverage."""
+  if args.corpus_dir and not args.fuzz_target:
+    logger.error(
+        '--corpus-dir requires specifying a particular fuzz target using '
+        '--fuzz-target')
+    return False
+
+  if not check_project_exists(args.project):
+    return False
+
+  if args.project.language not in constants.LANGUAGES_WITH_COVERAGE_SUPPORT:
+    logger.error(
+        'Project is written in %s, coverage for it is not supported yet.',
+        args.project.language)
+    return False
+
+  if (not args.no_corpus_download and not args.corpus_dir and
+      not args.project.is_external):
+    if not download_corpora(args):
+      return False
+
+  extra_cov_args = (
+      f'{args.project.coverage_extra_args.strip()} {" ".join(args.extra_args)}')
+  env = [
+      'FUZZING_ENGINE=libfuzzer',
+      'HELPER=True',
+      'FUZZING_LANGUAGE=%s' % args.project.language,
+      'PROJECT=%s' % args.project.name,
+      'SANITIZER=coverage',
+      'COVERAGE_EXTRA_ARGS=%s' % extra_cov_args,
+      'ARCHITECTURE=' + args.architecture,
+  ]
+
+  if not args.no_serve:
+    env.append(f'HTTP_PORT={args.port}')
+
+  run_args = _env_to_docker_args(env)
+
+  if args.port:
+    run_args.extend([
+        '-p',
+        '%s:%s' % (args.port, args.port),
+    ])
+
+  if args.corpus_dir:
+    if not os.path.exists(args.corpus_dir):
+      logger.error('The path provided in --corpus-dir argument does not '
+                   'exist.')
+      return False
+    corpus_dir = os.path.realpath(args.corpus_dir)
+    run_args.extend(['-v', '%s:/corpus/%s' % (corpus_dir, args.fuzz_target)])
+  else:
+    run_args.extend(['-v', '%s:/corpus' % args.project.corpus])
+
+  run_args.extend([
+      '-v',
+      '%s:/out' % args.project.out,
+      '-t',
+      BASE_RUNNER_IMAGE,
+  ])
+
+  run_args.append('coverage')
+  if args.fuzz_target:
+    run_args.append(args.fuzz_target)
+
+  result = docker_run(run_args, architecture=args.architecture)
+  if result:
+    logger.info('Successfully generated clang code coverage report.')
+  else:
+    logger.error('Failed to generate clang code coverage report.')
+
+  return result
+
+
+def _introspector_prepare_corpus(args):
+  """Helper function for introspector runs to generate corpora."""
+  parser = get_parser()
+  # Generate corpus, either by downloading or running fuzzers.
+  if args.private_corpora or args.public_corpora:
+    corpora_command = ['download_corpora']
+    if args.public_corpora:
+      corpora_command.append('--public')
+    corpora_command.append(args.project.name)
+    if not download_corpora(parse_args(parser, corpora_command)):
+      logger.error('Failed to download corpora')
+      return False
+  else:
+    fuzzer_targets = _get_fuzz_targets(args.project)
+    for fuzzer_name in fuzzer_targets:
+      # Make a corpus directory.
+      fuzzer_corpus_dir = args.project.corpus + f'/{fuzzer_name}'
+      if not os.path.isdir(fuzzer_corpus_dir):
+        os.makedirs(fuzzer_corpus_dir)
+      run_fuzzer_command = [
+          'run_fuzzer', '--sanitizer', 'address', '--corpus-dir',
+          fuzzer_corpus_dir, args.project.name, fuzzer_name
+      ]
+
+      parsed_args = parse_args(parser, run_fuzzer_command)
+      parsed_args.fuzzer_args = [
+          f'-max_total_time={args.seconds}', '-detect_leaks=0'
+      ]
+      # Continue even if run command fails, because we do not have 100%
+      # accuracy in fuzz target detection, i.e. we might try to run something
+      # that is not a target.
+      run_fuzzer(parsed_args)
+  return True
+
+
+def introspector(args):
+  """Runs a complete end-to-end run of introspector."""
+  parser = get_parser()
+
+  args_to_append = []
+  if args.source_path:
+    args_to_append.append(_get_absolute_path(args.source_path))
+
+  # Build fuzzers with ASAN.
+  build_fuzzers_command = [
+      'build_fuzzers', '--sanitizer=address', args.project.name
+  ] + args_to_append
+  if not build_fuzzers(parse_args(parser, build_fuzzers_command)):
+    logger.error('Failed to build project with ASAN')
+    return False
+
+  if not _introspector_prepare_corpus(args):
+    return False
+
+  # Build code coverage.
+  build_fuzzers_command = [
+      'build_fuzzers', '--sanitizer=coverage', args.project.name
+  ] + args_to_append
+  if not build_fuzzers(parse_args(parser, build_fuzzers_command)):
+    logger.error('Failed to build project with coverage instrumentation')
+    return False
+
+  # Collect coverage.
+  coverage_command = [
+      'coverage', '--no-corpus-download', '--port', '', args.project.name
+  ]
+  if not coverage(parse_args(parser, coverage_command)):
+    logger.error('Failed to extract coverage')
+    return False
+
+  # Build introspector.
+  build_fuzzers_command = [
+      'build_fuzzers', '--sanitizer=introspector', args.project.name
+  ] + args_to_append
+  if not build_fuzzers(parse_args(parser, build_fuzzers_command)):
+    logger.error('Failed to build project with introspector')
+    return False
+
+  introspector_dst = os.path.join(args.project.out,
+                                  "introspector-report/inspector")
+  shutil.rmtree(introspector_dst, ignore_errors=True)
+  shutil.copytree(os.path.join(args.project.out, "inspector"), introspector_dst)
+
+  # Copy the coverage reports into the introspector report.
+  dst_cov_report = os.path.join(introspector_dst, "covreport")
+  shutil.copytree(os.path.join(args.project.out, "report"), dst_cov_report)
+
+  # Copy per-target coverage reports
+  src_target_cov_report = os.path.join(args.project.out, "report_target")
+  for target_cov_dir in os.listdir(src_target_cov_report):
+    dst_target_cov_report = os.path.join(dst_cov_report, target_cov_dir)
+    shutil.copytree(os.path.join(src_target_cov_report, target_cov_dir),
+                    dst_target_cov_report)
+
+  logger.info('Introspector run complete. Report in %s', introspector_dst)
+  logger.info(
+      'To browse the report, run: `python3 -m http.server 8008 --directory %s`'
+      'and navigate to localhost:8008/fuzz_report.html in your browser',
+      introspector_dst)
+  return True
+
+
+def run_fuzzer(args):
+  """Runs a fuzzer in the container."""
+  if not check_project_exists(args.project):
+    return False
+
+  if not _check_fuzzer_exists(args.project, args.fuzzer_name,
+                              args.architecture):
+    return False
+
+  env = [
+      'FUZZING_ENGINE=' + args.engine,
+      'SANITIZER=' + args.sanitizer,
+      'RUN_FUZZER_MODE=interactive',
+      'HELPER=True',
+  ]
+
+  if args.e:
+    env += args.e
+
+  run_args = _env_to_docker_args(env)
+
+  if args.corpus_dir:
+    if not os.path.exists(args.corpus_dir):
+      logger.error('The path provided in --corpus-dir argument does not exist')
+      return False
+    corpus_dir = os.path.realpath(args.corpus_dir)
+    run_args.extend([
+        '-v',
+        '{corpus_dir}:/tmp/{fuzzer}_corpus'.format(corpus_dir=corpus_dir,
+                                                   fuzzer=args.fuzzer_name)
+    ])
+
+  run_args.extend([
+      '-v',
+      '%s:/out' % args.project.out,
+      '-t',
+      BASE_RUNNER_IMAGE,
+      'run_fuzzer',
+      args.fuzzer_name,
+  ] + args.fuzzer_args)
+
+  return docker_run(run_args, architecture=args.architecture)
+
+
+def fuzzbench_run_fuzzer(args):
+  """Runs a fuzz target built by fuzzbench in the container."""
+  if not check_project_exists(args.project):
+    return False
+
+  env = [
+      'FUZZING_ENGINE=' + args.engine,
+      'SANITIZER=' + args.sanitizer,
+      'RUN_FUZZER_MODE=interactive',
+      'HELPER=True',
+      f'FUZZ_TARGET={args.fuzzer_name}',
+      f'BENCHMARK={args.project.name}',
+      'TRIAL_ID=1',
+      'EXPERIMENT_TYPE=bug',
+  ]
+
+  if args.e:
+    env += args.e
+
+  run_args = _env_to_docker_args(env)
+
+  if args.corpus_dir:
+    if not os.path.exists(args.corpus_dir):
+      logger.error('The path provided in --corpus-dir argument does not exist')
+      return False
+    corpus_dir = os.path.realpath(args.corpus_dir)
+    run_args.extend([
+        '-v',
+        '{corpus_dir}:/tmp/{fuzzer}_corpus'.format(corpus_dir=corpus_dir,
+                                                   fuzzer=args.fuzzer_name)
+    ])
+
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    tmp_dir = os.path.abspath(tmp_dir)
+    fuzzbench_path = os.path.join(tmp_dir, 'fuzzbench')
+    subprocess.run([
+        'git', 'clone', 'https://github.com/google/fuzzbench', '--depth', '1',
+        fuzzbench_path
+    ],
+                   check=True)
+    run_args.extend([
+        '-v',
+        f'{args.project.out}:/out',
+        '-v',
+        f'{fuzzbench_path}:{fuzzbench_path}',
+        '-e',
+        f'FUZZBENCH_PATH={fuzzbench_path}',
+        f'aixcc-afc/{args.project.name}',
+        'fuzzbench_run_fuzzer',
+        args.fuzzer_name,
+    ] + args.fuzzer_args)
+
+    return docker_run(run_args, architecture=args.architecture)
+
+
+def fuzzbench_measure(args):
+  """Measure results from fuzzing with fuzzbench."""
+  if not check_project_exists(args.project):
+    return False
+
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    tmp_dir = os.path.abspath(tmp_dir)
+    fuzzbench_path = os.path.join(tmp_dir, 'fuzzbench')
+    subprocess.run([
+        'git', 'clone', 'https://github.com/google/fuzzbench', '--depth', '1',
+        fuzzbench_path
+    ],
+                   check=True)
+    run_args = [
+        '-v', f'{args.project.out}:/out', '-v',
+        f'{fuzzbench_path}:{fuzzbench_path}', '-e',
+        f'FUZZBENCH_PATH={fuzzbench_path}', '-e', 'EXPERIMENT_TYPE=bug', '-e',
+        f'FUZZ_TARGET={args.fuzz_target_name}', '-e',
+        f'FUZZER={args.engine_name}', '-e', f'BENCHMARK={args.project.name}',
+        f'aixcc-afc/{args.project.name}', 'fuzzbench_measure'
+    ]
+
+    return docker_run(run_args, 'x86_64')
+
+
+def reproduce(args):
+  """Reproduces a specific test case from a specific project."""
+  return reproduce_impl(args.project, args.fuzzer_name, args.valgrind, args.e,
+                        args.fuzzer_args, args.testcase_path, args.architecture, 
+                        args.propagate_exit_codes, args.err_result, 
+                        privileged=args.privileged, timeout=args.timeout)
+
+
+def reproduce_impl(  # pylint: disable=too-many-arguments
+    project,
+    fuzzer_name,
+    valgrind,
+    env_to_add,
+    fuzzer_args,
+    testcase_path,
+    architecture='x86_64',
+    propagate_exit_codes=False,
+    err_result=1,
+    run_function=docker_run,
+    privileged=True,
+    timeout=None):
+  """Reproduces a testcase in the container."""
+
+  if not check_project_exists(project):
+    return err_result if propagate_exit_codes else False
+
+  if not _check_fuzzer_exists(project, fuzzer_name, architecture):
+    return err_result if propagate_exit_codes else False
+
+  debugger = ''
+  env = ['HELPER=True', 'ARCHITECTURE=' + architecture]
+  image_name = 'base-runner'
+
+  if valgrind:
+    debugger = 'valgrind --tool=memcheck --track-origins=yes --leak-check=full'
+
+  if debugger:
+    image_name = 'base-runner-debug'
+    env += ['DEBUGGER=' + debugger]
+
+  if env_to_add:
+    env += env_to_add
+
+  run_args = _env_to_docker_args(env) + [
+      '-v',
+      '%s:/out' % project.out,
+      '-v',
+      '%s:/testcase' % _get_absolute_path(testcase_path),
+      '-t',
+      'ghcr.io/aixcc-finals/%s%s' % (image_name, BASE_IMAGE_TAG),
+      'reproduce',
+      fuzzer_name,
+      '-runs=100',
+  ] + fuzzer_args
+
+  return run_function(run_args, architecture=architecture, propagate_exit_codes=propagate_exit_codes, privileged=privileged, timeout=timeout)
+
+
+def _validate_project_name(project_name):
+  """Validates |project_name| is a valid OSS-Fuzz project name."""
+  if len(project_name) > MAX_PROJECT_NAME_LENGTH:
+    logger.error(
+        'Project name needs to be less than or equal to %d characters.',
+        MAX_PROJECT_NAME_LENGTH)
+    return False
+
+  if not VALID_PROJECT_NAME_REGEX.match(project_name):
+    logger.info('Invalid project name: %s.', project_name)
+    return False
+
+  return True
+
+
+def _validate_language(language):
+  if not LANGUAGE_REGEX.match(language):
+    logger.error('Invalid project language %s.', language)
+    return False
+
+  return True
+
+
+def _create_build_integration_directory(directory):
+  """Returns True on successful creation of a build integration directory.
+  Suitable for OSS-Fuzz and external projects."""
+  try:
+    os.makedirs(directory)
+  except OSError as error:
+    if error.errno != errno.EEXIST:
+      raise
+    logger.error('%s already exists.', directory)
+    return False
+  return True
+
+
+def _template_project_file(filename, template, template_args, directory):
+  """Templates |template| using |template_args| and writes the result to
+  |directory|/|filename|. Sets the file to executable if |filename| is
+  build.sh."""
+  file_path = os.path.join(directory, filename)
+  with open(file_path, 'w') as file_handle:
+    file_handle.write(template % template_args)
+
+  if filename == 'build.sh':
+    os.chmod(file_path, 0o755)
+
+
+def generate(args):
+  """Generates empty project files."""
+  return _generate_impl(args.project, args.language)
+
+
+def _get_current_datetime():
+  """Returns this year. Needed for mocking."""
+  return datetime.datetime.now()
+
+
+def _base_builder_from_language(language):
+  """Returns the base builder for the specified language."""
+  return LANGUAGE_TO_BASE_BUILDER_IMAGE[language]
+
+
+def _generate_impl(project, language):
+  """Implementation of generate(). Useful for testing."""
+  if project.is_external:
+    # External project.
+    project_templates = templates.EXTERNAL_TEMPLATES
+  else:
+    # Internal project.
+    if not _validate_project_name(project.name):
+      return False
+    project_templates = templates.TEMPLATES
+
+  if not _validate_language(language):
+    return False
+
+  directory = project.build_integration_path
+  if not _create_build_integration_directory(directory):
+    return False
+
+  logger.info('Writing new files to: %s.', directory)
+
+  template_args = {
+      'project_name': project.name,
+      'base_builder': _base_builder_from_language(language),
+      'language': language,
+      'year': _get_current_datetime().year
+  }
+  for filename, template in project_templates.items():
+    _template_project_file(filename, template, template_args, directory)
+  return True
+
+
+def shell(args):
+  """Runs a shell within a docker image."""
+  if not build_image_impl(args.project):
+    return False
+
+  env = [
+      'FUZZING_ENGINE=' + args.engine,
+      'SANITIZER=' + args.sanitizer,
+      'ARCHITECTURE=' + args.architecture,
+      'HELPER=True',
+  ]
+
+  if args.project.name != 'base-runner-debug':
+    env.append('FUZZING_LANGUAGE=' + args.project.language)
+
+  if args.e:
+    env += args.e
+
+  if is_base_image(args.project.name):
+    image_project = 'aixcc-finals'
+    project_full = 'ghcr.io/%s/%s%s' % (image_project, args.project.name, BASE_IMAGE_TAG)
+    out_dir = _get_out_dir()
+  else:
+    image_project = 'aixcc-afc'
+    project_full = '%s/%s:%s' % (image_project, args.project.name, args.docker_image_tag)
+    out_dir = args.project.out
+
+  run_args = _env_to_docker_args(env)
+  if args.source_path:
+    workdir = _workdir_from_dockerfile(args.project)
+    run_args.extend([
+        '-v',
+        '%s:%s' % (_get_absolute_path(args.source_path), workdir),
+    ])
+
+
+  run_args.extend([
+      '-v',
+      '%s:/out' % out_dir, '-v',
+      '%s:/work' % args.project.work, '-t',
+      '%s' % (project_full), '/bin/bash'
+  ])
+
+  docker_run(run_args, architecture=args.architecture)
+  return True
+
+
+def pull_images(language=None):
+  """Pulls base images used to build projects in language lang (or all if lang
+  is None)."""
+  for base_image_lang, base_images in BASE_IMAGES.items():
+    if (language is None or base_image_lang == 'generic' or
+        base_image_lang == language):
+      for base_image in base_images:
+        if not docker_pull(base_image):
+          return False
+
+  return True
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/manifest.py

@@ -0,0 +1,61 @@
+#! /usr/bin/env python3
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Script for pushing manifest files to docker that point to AMD64 and ARM
+images."""
+import logging
+import subprocess
+import sys
+
+
+def push_manifest(image):
+  """Pushes a manifest file in place of |image| for ARM and AMD64 versions of
+  that image."""
+  subprocess.run(['docker', 'pull', image], check=True)
+  amd64_image = f'{image}:manifest-amd64'
+  subprocess.run(['docker', 'tag', image, amd64_image], check=True)
+  subprocess.run(['docker', 'push', amd64_image], check=True)
+
+  arm_version = f'{image}-testing-arm'
+  subprocess.run(['docker', 'pull', arm_version], check=True)
+  arm64_image = f'{image}:manifest-arm64v8'
+  subprocess.run(['docker', 'tag', arm_version, arm64_image], check=True)
+
+  subprocess.run([
+      'docker', 'manifest', 'create', image, '--amend', arm64_image, '--amend',
+      amd64_image
+  ],
+                 check=True)
+  subprocess.run(['docker', 'manifest', 'push', image], check=True)
+  return True
+
+
+def main():
+  """Sets up manifests for base-builder and base-runner so they can be used for
+  ARM builds."""
+  logging.info('Doing simple gcloud command to ensure 2FA passes. '
+               'Otherwise docker push fails.')
+  subprocess.run(['gcloud', 'projects', 'list', '--limit=1'], check=True)
+
+  images = [
+      'ghcr.io/aixcc-finals/base-builder', 'ghcr.io/aixcc-finals/base-runner'
+  ]
+  results = [push_manifest(image) for image in images]
+  return 0 if all(results) else 1
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/pr_helper.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python
+# 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.
+#
+################################################################################
+"""Adds comments for PR to provide more information for approvers."""
+import base64
+import json
+import os
+import subprocess
+
+import requests
+import yaml
+
+OWNER = 'google'
+REPO = 'oss-fuzz'
+GITHUB_URL = 'https://github.com/'
+GITHUB_NONREF_URL = f'https://www.github.com/{OWNER}/{REPO}'  # Github URL that doesn't send emails on linked issues.
+API_URL = 'https://api.github.com'
+BASE_URL = f'{API_URL}/repos/{OWNER}/{REPO}'
+BRANCH = 'master'
+CRITICALITY_SCORE_PATH = '/home/runner/go/bin/criticality_score'
+COMMITS_LIMIT = 50  # Only process the most recent 50 commits.
+
+
+def get_criticality_score(repo_url):
+  """Gets the criticality score of the project."""
+  # Criticality score does not support repo url ends with '.git'
+  if repo_url.endswith('.git'):
+    repo_url = repo_url[:-4]
+  report = subprocess.run([
+      CRITICALITY_SCORE_PATH, '--format', 'json',
+      '-gcp-project-id=clusterfuzz-external', '-depsdev-disable', repo_url
+  ],
+                          capture_output=True,
+                          text=True)
+
+  try:
+    report_dict = json.loads(report.stdout)
+  except:
+    print(f'Criticality score failed with stdout: {report.stdout}')
+    print(f'Criticality score failed with stderr: {report.stderr}')
+    return 'N/A'
+  return report_dict.get('default_score', 'N/A')
+
+
+def is_known_contributor(content, email):
+  """Checks if the author is in the contact list."""
+  return (email == content.get('primary_contact') or
+          email in content.get('vendor_ccs', []) or
+          email in content.get('auto_ccs', []))
+
+
+def save_env(message, is_ready_for_merge, is_internal=False):
+  """Saves the outputs as environment variables."""
+  with open(os.environ['GITHUB_ENV'], 'a') as github_env:
+    github_env.write(f'MESSAGE={message}\n')
+    github_env.write(f'IS_READY_FOR_MERGE={is_ready_for_merge}\n')
+    github_env.write(f'IS_INTERNAL={is_internal}')
+
+
+def main():
+  """Verifies if a PR is ready to merge."""
+  github = GithubHandler()
+
+  # Bypasses PRs of the internal members.
+  if github.is_author_internal_member():
+    save_env(None, None, True)
+    return
+
+  message = ''
+  is_ready_for_merge = True
+  pr_author = github.get_pr_author()
+  # Gets all modified projects path.
+  projects_path = github.get_projects_path()
+  verified, email = github.get_author_email()
+
+  for project_path in projects_path:
+    project_url = f'{GITHUB_URL}/{OWNER}/{REPO}/tree/{BRANCH}/{project_path}'
+    content_dict = github.get_project_yaml(project_path)
+
+    # Gets information for the new integrating project.
+    if not content_dict:
+      is_ready_for_merge = False
+      new_project = github.get_integrated_project_info()
+      repo_url = new_project.get('main_repo')
+      if repo_url is None:
+        message += (f'{pr_author} is integrating a new project, '
+                    'but the `main_repo` is missing. '
+                    'The criticality score cannot be computed.<br/>')
+      else:
+        message += (f'{pr_author} is integrating a new project:<br/>'
+                    f'- Main repo: {repo_url}<br/> - Criticality score: '
+                    f'{get_criticality_score(repo_url)}<br/>')
+      continue
+
+    # Checks if the author is in the contact list.
+    if email:
+      if is_known_contributor(content_dict, email):
+        # Checks if the email is verified.
+        verified_marker = ' (verified)' if verified else ''
+        message += (
+            f'{pr_author}{verified_marker} is either the primary contact or '
+            f'is in the CCs list of [{project_path}]({project_url}).<br/>')
+        if verified:
+          continue
+
+    # Checks the previous commits.
+    commit_sha = github.has_author_modified_project(project_path)
+    if commit_sha is None:
+      history_message = ''
+      contributors = github.get_past_contributors(project_path)
+      if contributors:
+        history_message = 'The past contributors are: '
+        history_message += ', '.join(contributors)
+      message += (
+          f'{pr_author} is a new contributor to '
+          f'[{project_path}]({project_url}). The PR must be approved by known '
+          f'contributors before it can be merged. {history_message}<br/>')
+      is_ready_for_merge = False
+      continue
+
+    # If the previous commit is not associated with a pull request.
+    pr_message = (f'{pr_author} has previously contributed to '
+                  f'[{project_path}]({project_url}). The previous commit was '
+                  f'{GITHUB_NONREF_URL}/commit/{commit_sha}<br/>')
+
+    previous_pr_number = github.get_pull_request_number(commit_sha)
+    if previous_pr_number is not None:
+      pr_message = (f'{pr_author} has previously contributed to '
+                    f'[{project_path}]({project_url}). '
+                    f'The previous PR was [#{previous_pr_number}]'
+                    f'({GITHUB_NONREF_URL}/pull/{previous_pr_number})<br/>')
+    message += pr_message
+
+  save_env(message, is_ready_for_merge, False)
+
+
+class GithubHandler:
+  """Github requests handler."""
+
+  def __init__(self):
+    self._pr_author = os.environ['PRAUTHOR']
+    self._token = os.environ['GITHUBTOKEN']
+    self._pr_number = os.environ['PRNUMBER']
+    self._headers = {
+        'Authorization': f'Bearer {self._token}',
+        'X-GitHub-Api-Version': '2022-11-28'
+    }
+    self._maintainers = set()
+    os.environ['GITHUB_AUTH_TOKEN'] = self._token
+
+  def get_pr_author(self):
+    """Gets the pr author user name."""
+    return self._pr_author
+
+  def get_projects_path(self):
+    """Gets the current project path."""
+    response = requests.get(f'{BASE_URL}/pulls/{self._pr_number}/files',
+                            headers=self._headers)
+    if not response.ok:
+      return []
+
+    projects_path = set()
+    for file in response.json():
+      file_path = file['filename']
+      dir_path = file_path.split(os.sep)
+      if len(dir_path) > 1 and dir_path[0] == 'projects':
+        projects_path.add(os.sep.join(dir_path[0:2]))
+    return list(projects_path)
+
+  def get_author_email(self):
+    """Retrieves the author's email address for a pull request,
+    including non-public emails."""
+    user_response = requests.get(f'{API_URL}/users/{self._pr_author}')
+    if user_response.ok:
+      email = user_response.json()['email']
+      if email:
+        return True, email
+
+    commits_response = requests.get(
+        f'{BASE_URL}/pulls/{self._pr_number}/commits', headers=self._headers)
+    if not commits_response.ok:
+      return False, None
+    email = commits_response.json()[0]['commit']['author']['email']
+    verified = commits_response.json()[0]['commit']['verification']['verified']
+    return verified, email
+
+  def get_project_yaml(self, project_path):
+    """Gets the project yaml file."""
+    contents_url = f'{BASE_URL}/contents/{project_path}/project.yaml'
+    return self.get_yaml_file_content(contents_url)
+
+  def get_yaml_file_content(self, contents_url):
+    """Gets yaml file content."""
+    response = requests.get(contents_url, headers=self._headers)
+    if not response.ok:
+      return {}
+    content = base64.b64decode(response.json()['content']).decode('UTF-8')
+    return yaml.safe_load(content)
+
+  def get_integrated_project_info(self):
+    """Gets the new integrated project."""
+    response = requests.get(f'{BASE_URL}/pulls/{self._pr_number}/files',
+                            headers=self._headers)
+
+    for file in response.json():
+      file_path = file['filename']
+      if 'project.yaml' in file_path:
+        return self.get_yaml_file_content(file['contents_url'])
+
+    return {}
+
+  def get_pull_request_number(self, commit):
+    """Gets the pull request number."""
+    pr_response = requests.get(f'{BASE_URL}/commits/{commit}/pulls',
+                               headers=self._headers)
+    if not pr_response.ok:
+      return None
+    return pr_response.json()[0]['number']
+
+  def get_past_contributors(self, project_path):
+    """Returns a list of past contributors of a certain project."""
+    commits_response = requests.get(f'{BASE_URL}/commits?path={project_path}',
+                                    headers=self._headers)
+
+    if not commits_response.ok:
+      return []
+    commits = commits_response.json()
+    contributors: dict[str, bool] = {}
+    for i, commit in enumerate(commits):
+      if i >= COMMITS_LIMIT:
+        break
+
+      if not commit['author'] or not commit['commit']:
+        continue
+
+      login = commit['author']['login']
+      verified = commit['commit']['verification']['verified']
+      if login in self._maintainers:
+        continue
+      if login not in contributors:
+        contributors[login] = verified
+      if verified:
+        # Override previous verification bit.
+        contributors[login] = True
+
+    all_contributors = []
+    for login, verified in contributors.items():
+      login_verify = login if verified else f'{login} (unverified)'
+      all_contributors.append(login_verify)
+
+    return all_contributors
+
+  def get_maintainers(self):
+    """Get a list of internal members."""
+    if self._maintainers:
+      return self._maintainers
+
+    response = requests.get(f'{BASE_URL}/contents/infra/MAINTAINERS.csv',
+                            headers=self._headers)
+    if not response.ok:
+      return self._maintainers
+
+    maintainers_file = base64.b64decode(
+        response.json()['content']).decode('UTF-8')
+    for line in maintainers_file.split(os.linesep):
+      self._maintainers.add(line.split(',')[2])
+    return self._maintainers
+
+  def is_author_internal_member(self):
+    """Returns if the author is an internal member."""
+    return self._pr_author in self.get_maintainers()
+
+  def has_author_modified_project(self, project_path):
+    """Checks if the author has modified this project before."""
+    commits_response = requests.get(
+        f'{BASE_URL}/commits?path={project_path}&author={self._pr_author}',
+        headers=self._headers)
+
+    if not commits_response.ok or not commits_response.json():
+      return None
+
+    commit = commits_response.json()[0]
+    return commit['sha']
+
+
+if __name__ == '__main__':
+  main()

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/retry.py

@@ -0,0 +1,106 @@
+# 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.
+"""Retry decorator. Copied from ClusterFuzz source."""
+
+import functools
+import inspect
+import logging
+import sys
+import time
+
+# pylint: disable=too-many-arguments,broad-except
+
+
+def sleep(seconds):
+  """Invoke time.sleep. This is to avoid the flakiness of time.sleep. See:
+    crbug.com/770375"""
+  time.sleep(seconds)
+
+
+def get_delay(num_try, delay, backoff):
+  """Compute backoff delay."""
+  return delay * (backoff**(num_try - 1))
+
+
+def wrap(retries,
+         delay,
+         backoff=2,
+         exception_type=Exception,
+         retry_on_false=False):
+  """Retry decorator for a function."""
+
+  assert delay > 0
+  assert backoff >= 1
+  assert retries >= 0
+
+  def decorator(func):
+    """Decorator for the given function."""
+    tries = retries + 1
+    is_generator = inspect.isgeneratorfunction(func)
+    function_with_type = func.__qualname__
+    if is_generator:
+      function_with_type += ' (generator)'
+
+    def handle_retry(num_try, exception=None):
+      """Handle retry."""
+      if (exception is None or
+          isinstance(exception, exception_type)) and num_try < tries:
+        logging.info('Retrying on %s failed with %s. Retrying again.',
+                     function_with_type,
+                     sys.exc_info()[1])
+        sleep(get_delay(num_try, delay, backoff))
+        return True
+
+      logging.error('Retrying on %s failed with %s. Raise.', function_with_type,
+                    sys.exc_info()[1])
+      return False
+
+    @functools.wraps(func)
+    def _wrapper(*args, **kwargs):
+      """Regular function wrapper."""
+      for num_try in range(1, tries + 1):
+        try:
+          result = func(*args, **kwargs)
+          if retry_on_false and not result:
+            if not handle_retry(num_try):
+              return result
+
+            continue
+          return result
+        except Exception as error:
+          if not handle_retry(num_try, exception=error):
+            raise
+
+    @functools.wraps(func)
+    def _generator_wrapper(*args, **kwargs):
+      """Generator function wrapper."""
+      # This argument is not applicable for generator functions.
+      assert not retry_on_false
+      already_yielded_element_count = 0
+      for num_try in range(1, tries + 1):
+        try:
+          for index, result in enumerate(func(*args, **kwargs)):
+            if index >= already_yielded_element_count:
+              yield result
+              already_yielded_element_count += 1
+          break
+        except Exception as error:
+          if not handle_retry(num_try, exception=error):
+            raise
+
+    if is_generator:
+      return _generator_wrapper
+    return _wrapper
+
+  return decorator

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/run_fuzzers.Dockerfile

@@ -0,0 +1,31 @@
+# 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.
+#
+################################################################################
+# Docker image for running fuzzers on CIFuzz (the run_fuzzers action on GitHub
+# actions).
+
+FROM ghcr.io/aixcc-finals/cifuzz-base
+
+# Python file to execute when the docker container starts up.
+# We can't use the env var $OSS_FUZZ_ROOT here. Since it's a constant env var,
+# just expand to '/opt/oss-fuzz'.
+ENTRYPOINT ["python3", "/opt/oss-fuzz/infra/cifuzz/run_fuzzers_entrypoint.py"]
+
+WORKDIR ${OSS_FUZZ_ROOT}/infra
+
+# Copy infra source code.
+ADD . ${OSS_FUZZ_ROOT}/infra
+
+RUN python3 -m pip install -r ${OSS_FUZZ_ROOT}/infra/cifuzz/requirements.txt

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/templates.py

@@ -0,0 +1,119 @@
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Templates for OSS-Fuzz project files."""
+
+PROJECT_YAML_TEMPLATE = """\
+homepage: "<your_project_homepage>"
+language: %(language)s
+primary_contact: "<primary_contact_email>"
+main_repo: "https://path/to/main/repo.git"
+file_github_issue: true
+"""
+
+DOCKER_TEMPLATE = """\
+# Copyright %(year)d Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+FROM ghcr.io/aixcc-finals/%(base_builder)s
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+RUN git clone --depth 1 <git_url> %(project_name)s     # or use other version control
+WORKDIR %(project_name)s
+COPY build.sh $SRC/
+"""
+
+EXTERNAL_DOCKER_TEMPLATE = """\
+FROM ghcr.io/aixcc-finals/%(base_builder)s:v1
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+COPY . $SRC/%(project_name)s
+WORKDIR %(project_name)s
+COPY .clusterfuzzlite/build.sh $SRC/
+"""
+
+BUILD_TEMPLATE = """\
+#!/bin/bash -eu
+# Copyright %(year)d 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 project
+# e.g.
+# ./autogen.sh
+# ./configure
+# make -j$(nproc) all
+
+# build fuzzers
+# e.g.
+# $CXX $CXXFLAGS -std=c++11 -Iinclude \\
+#     /path/to/name_of_fuzzer.cc -o $OUT/name_of_fuzzer \\
+#     $LIB_FUZZING_ENGINE /path/to/library.a
+"""
+
+EXTERNAL_BUILD_TEMPLATE = """\
+#!/bin/bash -eu
+
+# build project
+# e.g.
+# ./autogen.sh
+# ./configure
+# make -j$(nproc) all
+
+# build fuzzers
+# e.g.
+# $CXX $CXXFLAGS -std=c++11 -Iinclude \\
+#     /path/to/name_of_fuzzer.cc -o $OUT/name_of_fuzzer \\
+#     $LIB_FUZZING_ENGINE /path/to/library.a
+"""
+
+EXTERNAL_PROJECT_YAML_TEMPLATE = """\
+language: %(language)s
+"""
+
+TEMPLATES = {
+    'build.sh': BUILD_TEMPLATE,
+    'Dockerfile': DOCKER_TEMPLATE,
+    'project.yaml': PROJECT_YAML_TEMPLATE
+}
+
+EXTERNAL_TEMPLATES = {
+    'build.sh': EXTERNAL_BUILD_TEMPLATE,
+    'Dockerfile': EXTERNAL_DOCKER_TEMPLATE,
+    'project.yaml': EXTERNAL_PROJECT_YAML_TEMPLATE
+}

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/test

@@ -0,0 +1 @@
+