Add files using upload-large-folder tool

local-test-commons-compress-delta-02/fuzz-tooling/docs/.gitignore

@@ -0,0 +1,5 @@
+_site
+.bundle
+.sass-cache
+.jekyll-metadata
+vendor

local-test-commons-compress-delta-02/fuzz-tooling/docs/404.html

@@ -0,0 +1,23 @@
+---
+layout: default
+---
+
+<style type="text/css" media="screen">
+  .container {
+    margin: 10px auto;
+    max-width: 600px;
+    text-align: center;
+  }
+  h1 {
+    margin: 30px 0;
+    font-size: 4em;
+    line-height: 1;
+    letter-spacing: -1px;
+  }
+</style>
+
+<div class="container">
+  <h1>404</h1>
+
+  <p><strong>Page not found :(</strong></p>
+</div>

local-test-commons-compress-delta-02/fuzz-tooling/docs/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+gem 'github-pages', group: :jekyll_plugins
+
+gem "webrick", "~> 1.8"

local-test-commons-compress-delta-02/fuzz-tooling/docs/glossary.md

@@ -0,0 +1 @@
+This page has moved [here](https://google.github.io/oss-fuzz/reference/glossary/)

local-test-commons-compress-delta-02/fuzz-tooling/docs/ideal_integration.md

@@ -0,0 +1 @@
+This page has moved [here](https://google.github.io/oss-fuzz/advanced-topics/ideal-integration)

local-test-commons-compress-delta-02/fuzz-tooling/docs/reproducing.md

@@ -0,0 +1 @@
+This page has moved [here](https://google.github.io/oss-fuzz/advanced-topics/reproducing)

local-test-commons-compress-delta-02/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-delta-02/fuzz-tooling/infra/bisector_test.py

@@ -0,0 +1,70 @@
+# 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 perepo_managerissions and
+# limitations under the License.
+"""Test the functionality of bisection module:
+1) Test a known case where an error appears in a regression range.
+2) Bisect can handle incorrect inputs.
+
+IMPORTANT: This test needs to be run with root privileges.
+"""
+
+import os
+import unittest
+
+import bisector
+import build_specified_commit
+import test_repos
+
+# Necessary because __file__ changes with os.chdir
+TEST_DIR_PATH = os.path.dirname(os.path.realpath(__file__))
+
+
+@unittest.skip('Test is too long to be run with presubmit.')
+class BisectIntegrationTests(unittest.TestCase):
+  """Class to test the functionality of bisection method."""
+
+  BISECT_TYPE = 'regressed'
+
+  def test_bisect_invalid_repo(self):
+    """Test the bisection method on a project that does not exist."""
+    test_repo = test_repos.INVALID_REPO
+    build_data = build_specified_commit.BuildData(
+        project_name=test_repo.project_name,
+        engine='libfuzzer',
+        sanitizer='address',
+        architecture='x86_64')
+    with self.assertRaises(ValueError):
+      bisector.bisect(self.BISECT_TYPE, test_repo.old_commit,
+                      test_repo.new_commit, test_repo.testcase_path,
+                      test_repo.fuzz_target, build_data)
+
+  def test_bisect(self):
+    """Test the bisect method on example projects."""
+    for test_repo in test_repos.TEST_REPOS:
+      if test_repo.new_commit:
+        build_data = build_specified_commit.BuildData(
+            project_name=test_repo.project_name,
+            engine='libfuzzer',
+            sanitizer='address',
+            architecture='x86_64')
+        result = bisector.bisect(self.BISECT_TYPE, test_repo.old_commit,
+                                 test_repo.new_commit, test_repo.testcase_path,
+                                 test_repo.fuzz_target, build_data)
+        self.assertEqual(result.commit, test_repo.intro_commit)
+
+
+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-delta-02/fuzz-tooling/infra/build_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 to run fuzzers for 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/build_fuzzers_entrypoint.py"]
+
+WORKDIR ${OSS_FUZZ_ROOT}/infra
+
+# Update 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-delta-02/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-delta-02/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-delta-02/fuzz-tooling/infra/helper_test.py

@@ -0,0 +1,239 @@
+# 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 helper.py"""
+
+import datetime
+import os
+import tempfile
+import unittest
+from unittest import mock
+
+from pyfakefs import fake_filesystem_unittest
+
+import constants
+import helper
+import templates
+
+# pylint: disable=no-self-use,protected-access
+
+
+class ShellTest(unittest.TestCase):
+  """Tests 'shell' command."""
+
+  @mock.patch('helper.docker_run')
+  @mock.patch('helper.build_image_impl')
+  def test_base_runner_debug(self, _, __):
+    """Tests that shell base-runner-debug works as intended."""
+    image_name = 'base-runner-debug'
+    unparsed_args = ['shell', image_name]
+    parser = helper.get_parser()
+    args = helper.parse_args(parser, unparsed_args)
+    args.sanitizer = 'address'
+    result = helper.shell(args)
+    self.assertTrue(result)
+
+
+class BuildImageImplTest(unittest.TestCase):
+  """Tests for build_image_impl."""
+
+  @mock.patch('helper.docker_build')
+  def test_no_cache(self, mock_docker_build):
+    """Tests that cache=False is handled properly."""
+    image_name = 'base-image'
+    helper.build_image_impl(helper.Project(image_name), cache=False)
+    self.assertIn('--no-cache', mock_docker_build.call_args_list[0][0][0])
+
+  @mock.patch('helper.docker_build')
+  @mock.patch('helper.pull_images')
+  def test_pull(self, mock_pull_images, _):
+    """Tests that pull=True is handled properly."""
+    image_name = 'base-image'
+    project = helper.Project(image_name, is_external=True)
+    self.assertTrue(helper.build_image_impl(project, pull=True))
+    mock_pull_images.assert_called_with('c++')
+
+  @mock.patch('helper.docker_build')
+  def test_base_image(self, mock_docker_build):
+    """Tests that build_image_impl works as intended with a base-image."""
+    image_name = 'base-image'
+    self.assertTrue(helper.build_image_impl(helper.Project(image_name)))
+    build_dir = os.path.join(helper.OSS_FUZZ_DIR,
+                             'infra/base-images/base-image')
+    mock_docker_build.assert_called_with([
+        '-t', 'ghcr.io/aixcc-finals/base-image', '--file',
+        os.path.join(build_dir, 'Dockerfile'), build_dir
+    ])
+
+  @mock.patch('helper.docker_build')
+  def test_oss_fuzz_project(self, mock_docker_build):
+    """Tests that build_image_impl works as intended with an OSS-Fuzz
+    project."""
+    project_name = 'example'
+    self.assertTrue(helper.build_image_impl(helper.Project(project_name)))
+    build_dir = os.path.join(helper.OSS_FUZZ_DIR, 'projects', project_name)
+    mock_docker_build.assert_called_with([
+        '-t', 'gcr.io/oss-fuzz/example', '--file',
+        os.path.join(build_dir, 'Dockerfile'), build_dir
+    ])
+
+  @mock.patch('helper.docker_build')
+  def test_external_project(self, mock_docker_build):
+    """Tests that build_image_impl works as intended with a non-OSS-Fuzz
+    project."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+      project_src_path = os.path.join(temp_dir, 'example')
+      os.mkdir(project_src_path)
+      build_integration_path = 'build-integration'
+      project = helper.Project(project_src_path,
+                               is_external=True,
+                               build_integration_path=build_integration_path)
+      self.assertTrue(helper.build_image_impl(project))
+      mock_docker_build.assert_called_with([
+          '-t', 'gcr.io/oss-fuzz/example', '--file',
+          os.path.join(project_src_path, build_integration_path, 'Dockerfile'),
+          project_src_path
+      ])
+
+
+class GenerateImplTest(fake_filesystem_unittest.TestCase):
+  """Tests for _generate_impl."""
+  PROJECT_NAME = 'newfakeproject'
+  PROJECT_LANGUAGE = 'python'
+
+  def setUp(self):
+    self.maxDiff = None  # pylint: disable=invalid-name
+    self.setUpPyfakefs()
+    self.fs.add_real_directory(helper.OSS_FUZZ_DIR)
+
+  def _verify_templated_files(self, template_dict, directory, language):
+    template_args = {
+        'project_name': self.PROJECT_NAME,
+        'year': 2021,
+        'base_builder': helper._base_builder_from_language(language),
+        'language': language,
+    }
+    for filename, template in template_dict.items():
+      file_path = os.path.join(directory, filename)
+      with open(file_path, 'r') as file_handle:
+        contents = file_handle.read()
+      self.assertEqual(contents, template % template_args)
+
+  @mock.patch('helper._get_current_datetime',
+              return_value=datetime.datetime(year=2021, month=1, day=1))
+  def test_generate_oss_fuzz_project(self, _):
+    """Tests that the correct files are generated for an OSS-Fuzz project."""
+    helper._generate_impl(helper.Project(self.PROJECT_NAME),
+                          self.PROJECT_LANGUAGE)
+    self._verify_templated_files(
+        templates.TEMPLATES,
+        os.path.join(helper.OSS_FUZZ_DIR, 'projects', self.PROJECT_NAME),
+        self.PROJECT_LANGUAGE)
+
+  def test_generate_external_project(self):
+    """Tests that the correct files are generated for a non-OSS-Fuzz project."""
+    build_integration_path = '/newfakeproject/build-integration'
+    helper._generate_impl(
+        helper.Project('/newfakeproject/',
+                       is_external=True,
+                       build_integration_path=build_integration_path),
+        self.PROJECT_LANGUAGE)
+    self._verify_templated_files(templates.EXTERNAL_TEMPLATES,
+                                 build_integration_path, self.PROJECT_LANGUAGE)
+
+  @mock.patch('helper._get_current_datetime',
+              return_value=datetime.datetime(year=2021, month=1, day=1))
+  def test_generate_swift_project(self, _):
+    """Tests that the swift project uses the correct base image."""
+    helper._generate_impl(helper.Project(self.PROJECT_NAME), 'swift')
+    self._verify_templated_files(
+        templates.TEMPLATES,
+        os.path.join(helper.OSS_FUZZ_DIR, 'projects', self.PROJECT_NAME),
+        'swift')
+
+
+class ProjectTest(fake_filesystem_unittest.TestCase):
+  """Tests for Project class."""
+
+  def setUp(self):
+    self.project_name = 'project'
+    self.internal_project = helper.Project(self.project_name)
+    self.external_project_path = os.path.join('/path', 'to', self.project_name)
+    self.external_project = helper.Project(self.external_project_path,
+                                           is_external=True)
+    self.setUpPyfakefs()
+
+  def test_init_external_project(self):
+    """Tests __init__ method for external projects."""
+    self.assertEqual(self.external_project.name, self.project_name)
+    self.assertEqual(self.external_project.path, self.external_project_path)
+    self.assertEqual(
+        self.external_project.build_integration_path,
+        os.path.join(self.external_project_path,
+                     constants.DEFAULT_EXTERNAL_BUILD_INTEGRATION_PATH))
+
+  def test_init_internal_project(self):
+    """Tests __init__ method for internal projects."""
+    self.assertEqual(self.internal_project.name, self.project_name)
+    path = os.path.join(helper.OSS_FUZZ_DIR, 'projects', self.project_name)
+    self.assertEqual(self.internal_project.path, path)
+    self.assertEqual(self.internal_project.build_integration_path, path)
+
+  def test_dockerfile_path_internal_project(self):
+    """Tests that dockerfile_path works as intended."""
+    self.assertEqual(
+        self.internal_project.dockerfile_path,
+        os.path.join(helper.OSS_FUZZ_DIR, 'projects', self.project_name,
+                     'Dockerfile'))
+
+  def test_dockerfile_path_external_project(self):
+    """Tests that dockerfile_path works as intended."""
+    self.assertEqual(
+        self.external_project.dockerfile_path,
+        os.path.join(self.external_project_path,
+                     constants.DEFAULT_EXTERNAL_BUILD_INTEGRATION_PATH,
+                     'Dockerfile'))
+
+  def test_out(self):
+    """Tests that out works as intended."""
+    out_dir = self.internal_project.out
+    self.assertEqual(
+        out_dir,
+        os.path.join(helper.OSS_FUZZ_DIR, 'build', 'out', self.project_name))
+    self.assertTrue(os.path.exists(out_dir))
+
+  def test_work(self):
+    """Tests that work works as intended."""
+    work_dir = self.internal_project.work
+    self.assertEqual(
+        work_dir,
+        os.path.join(helper.OSS_FUZZ_DIR, 'build', 'work', self.project_name))
+    self.assertTrue(os.path.exists(work_dir))
+
+  def test_corpus(self):
+    """Tests that corpus works as intended."""
+    corpus_dir = self.internal_project.corpus
+    self.assertEqual(
+        corpus_dir,
+        os.path.join(helper.OSS_FUZZ_DIR, 'build', 'corpus', self.project_name))
+    self.assertTrue(os.path.exists(corpus_dir))
+
+  def test_language_internal_project(self):
+    """Tests that language works as intended for an internal project."""
+    project_yaml_path = os.path.join(self.internal_project.path, 'project.yaml')
+    self.fs.create_file(project_yaml_path, contents='language: python')
+    self.assertEqual(self.internal_project.language, 'python')
+
+  def test_language_external_project(self):
+    """Tests that language works as intended for an external project."""
+    self.assertEqual(self.external_project.language, 'c++')

local-test-commons-compress-delta-02/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-delta-02/fuzz-tooling/infra/presubmit.py

@@ -0,0 +1,549 @@
+#!/usr/bin/env python3
+# 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.
+#
+################################################################################
+"""Checks code for common issues before submitting."""
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+import unittest
+import yaml
+
+import constants
+
+_SRC_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+VALID_PROJECT_REGEX_STR = '^[a-z0-9_-]+$'
+VALID_PROJECT_REGEX = re.compile(VALID_PROJECT_REGEX_STR)
+
+
+def _is_project_file(actual_path, expected_filename):
+  """Returns True if actual_path's name is |expected_filename| and is a file
+  that exists and is in in projects/."""
+  if os.path.basename(actual_path) != expected_filename:
+    return False
+
+  if os.path.basename(os.path.dirname(
+      os.path.dirname(actual_path))) != 'projects':
+    return False
+
+  return os.path.exists(actual_path)
+
+
+# TODO: Check for -fsanitize=fuzzer in files as well.
+
+
+def _check_one_lib_fuzzing_engine(build_sh_file):
+  """Returns False if |build_sh_file| contains -lFuzzingEngine.
+  This is deprecated behavior. $LIB_FUZZING_ENGINE should be used instead
+  so that -fsanitize=fuzzer is used."""
+  if not _is_project_file(build_sh_file, 'build.sh'):
+    return True
+
+  with open(build_sh_file) as build_sh:
+    build_sh_lines = build_sh.readlines()
+  for line_num, line in enumerate(build_sh_lines):
+    uncommented_code = line.split('#')[0]
+    if '-lFuzzingEngine' in uncommented_code:
+      print('Error: build.sh contains deprecated "-lFuzzingEngine" on line: '
+            f'{line_num}. Please use "$LIB_FUZZING_ENGINE" instead.')
+      return False
+  return True
+
+
+def check_lib_fuzzing_engine(paths):
+  """Calls _check_one_lib_fuzzing_engine on each path in |paths|. Returns True
+  if the result of every call is True."""
+  return all(_check_one_lib_fuzzing_engine(path) for path in paths)
+
+
+class ProjectYamlChecker:
+  """Checks for a project.yaml file."""
+
+  # Sections in a project.yaml and the constant values that they are allowed
+  # to have.
+  SECTIONS_AND_CONSTANTS = {
+      'sanitizers': constants.SANITIZERS,
+      'architectures': constants.ARCHITECTURES,
+      'fuzzing_engines': constants.ENGINES,
+  }
+
+  # Note: this list must be updated when we allow new sections.
+  VALID_SECTION_NAMES = [
+      'architectures',
+      'auto_ccs',
+      'blackbox',
+      'builds_per_day',
+      'coverage_extra_args',
+      'disabled',
+      'fuzzing_engines',
+      'help_url',
+      'homepage',
+      'language',
+      'labels',  # For internal use only, hard to lint as it uses fuzzer names.
+      'main_repo',
+      'primary_contact',
+      'run_tests',
+      'sanitizers',
+      'selective_unpack',
+      'vendor_ccs',
+      'view_restrictions',
+      'file_github_issue',
+  ]
+
+  REQUIRED_SECTIONS = ['main_repo']
+
+  def __init__(self, filename):
+    self.filename = filename
+    with open(filename) as file_handle:
+      self.data = yaml.safe_load(file_handle)
+
+    self.success = True
+
+  def do_checks(self):
+    """Does all project.yaml checks. Returns True if they pass."""
+    if self.is_disabled():
+      return True
+
+    checks = [
+        self.check_project_yaml_constants,
+        self.check_required_sections,
+        self.check_valid_section_names,
+        self.check_valid_emails,
+        self.check_valid_language,
+        self.check_valid_project_name,
+    ]
+    for check_function in checks:
+      check_function()
+    return self.success
+
+  def is_disabled(self):
+    """Returns True if this project is disabled."""
+    return self.data.get('disabled', False)
+
+  def error(self, message):
+    """Prints an error message and sets self.success to False."""
+    self.success = False
+    print(f'Error in {self.filename}: {message}')
+
+  def check_valid_project_name(self):
+    """Checks that the project has a valid name."""
+    banned_names = ['google', 'g00gle']
+    project_name = os.path.basename(os.path.dirname(self.filename))
+    for banned_name in banned_names:
+      if banned_name in project_name:
+        self.error('Projects can\'t have \'google\' in the name.')
+    if not VALID_PROJECT_REGEX.match(project_name):
+      self.error(f'Projects must conform to regex {VALID_PROJECT_REGEX_STR}')
+
+  def check_project_yaml_constants(self):
+    """Returns True if certain sections only have certain constant values."""
+    for section, allowed_constants in self.SECTIONS_AND_CONSTANTS.items():
+      if section not in self.data:
+        continue
+      actual_constants = self.data[section]
+      allowed_constants_str = ', '.join(allowed_constants)
+      for constant in actual_constants:
+        if isinstance(constant, str):
+          if constant not in allowed_constants:
+            self.error(f'{constant} (in {section} section) is not a valid '
+                       f'constant ({allowed_constants_str}).')
+        elif isinstance(constant, dict):
+          # The only alternative value allowed is the experimental flag, i.e.
+          # `constant == {'memory': {'experimental': True}}`. Do not check the
+          # experimental flag, but assert that the sanitizer is a valid one.
+          if (len(constant.keys()) > 1 or
+              list(constant.keys())[0] not in allowed_constants):
+            self.error(f'Not allowed value in the project.yaml: {constant}')
+        else:
+          self.error(f'Not allowed value in the project.yaml: {constant}')
+
+  def check_valid_section_names(self):
+    """Returns True if all section names are valid."""
+    for name in self.data:
+      if name not in self.VALID_SECTION_NAMES:
+        self.error(
+            f'{name} is not a valid section name ({self.VALID_SECTION_NAMES})')
+
+  def check_required_sections(self):
+    """Returns True if all required sections are in |self.data|."""
+    for section in self.REQUIRED_SECTIONS:
+      if section not in self.data:
+        self.error(f'{section} section is missing.')
+
+  def check_valid_emails(self):
+    """Returns True if emails are valid looking.."""
+    # Get email addresses.
+    email_addresses = []
+    primary_contact = self.data.get('primary_contact')
+    if primary_contact:
+      email_addresses.append(primary_contact)
+    auto_ccs = self.data.get('auto_ccs')
+    if auto_ccs:
+      email_addresses.extend(auto_ccs)
+
+    # Check that email addresses seem normal.
+    for email_address in email_addresses:
+      if '@' not in email_address or '.' not in email_address:
+        self.error(f'{email_address} is an invalid email address.')
+
+  def check_valid_language(self):
+    """Returns True if the language is specified and valid."""
+    language = self.data.get('language')
+    if not language:
+      self.error('Missing "language" attribute in project.yaml.')
+    elif language not in constants.LANGUAGES:
+      self.error(
+          f'"language: {language}" is not supported ({constants.LANGUAGES}).')
+
+
+def _check_one_project_yaml(project_yaml_filename):
+  """Does checks on the project.yaml file. Returns True on success."""
+  if _is_project_file(project_yaml_filename, 'project.yml'):
+    print(project_yaml_filename, 'must be named project.yaml.')
+    return False
+
+  if not _is_project_file(project_yaml_filename, 'project.yaml'):
+    return True
+
+  checker = ProjectYamlChecker(project_yaml_filename)
+  return checker.do_checks()
+
+
+def check_project_yaml(paths):
+  """Calls _check_one_project_yaml on each path in |paths|. Returns True if the
+  result of every call is True."""
+  return all([_check_one_project_yaml(path) for path in paths])
+
+
+def _check_one_seed_corpus(path):
+  """Returns False and prints error if |path| is a seed corpus."""
+  if os.path.basename(os.path.dirname(os.path.dirname(path))) != 'projects':
+    return True
+
+  if os.path.splitext(path)[1] == '.zip':
+    print('Don\'t commit seed corpora into the ClusterFuzz repo,'
+          'they bloat it forever.')
+    return False
+
+  return True
+
+
+def check_seed_corpus(paths):
+  """Calls _check_one_seed_corpus on each path in |paths|. Returns True if the
+  result of every call is True."""
+  return all([_check_one_seed_corpus(path) for path in paths])
+
+
+def _check_one_apt_update(path):
+  """Checks that a Dockerfile uses apt-update before apt-install"""
+  if os.path.basename(os.path.dirname(os.path.dirname(path))) != 'projects':
+    return True
+
+  if os.path.basename(path) != 'Dockerfile':
+    return True
+
+  with open(path, 'r') as file:
+    dockerfile = file.read()
+    if 'RUN apt install' in dockerfile or 'RUN apt-get install' in dockerfile:
+      print('Please add an "apt-get update" before "apt-get install". '
+            'Otherwise, a cached and outdated RUN layer may lead to install '
+            'failures in file %s.' % str(path))
+      return False
+
+  return True
+
+
+def check_apt_update(paths):
+  """Checks that all Dockerfile use apt-update before apt-install"""
+  return all([_check_one_apt_update(path) for path in paths])
+
+
+def do_checks(changed_files):
+  """Runs all presubmit checks. Returns False if any fails."""
+  checks = [
+      check_license,
+      yapf,
+      check_project_yaml,
+      check_lib_fuzzing_engine,
+      check_seed_corpus,
+      check_apt_update,
+  ]
+  # Use a list comprehension here and in other cases where we use all() so that
+  # we don't quit early on failure. This is more user-friendly since the more
+  # errors we spit out at once, the less frequently the less check-fix-check
+  # cycles they need to do.
+  return all([check(changed_files) for check in checks])
+
+
+_CHECK_LICENSE_FILENAMES = ['Dockerfile']
+_CHECK_LICENSE_EXTENSIONS = [
+    '.bash',
+    '.c',
+    '.cc',
+    '.cpp',
+    '.css',
+    '.Dockerfile',
+    '.go',
+    '.h',
+    '.htm',
+    '.html',
+    '.java',
+    '.js',
+    '.proto',
+    '.py',
+    '.rs',
+    '.sh',
+    '.ts',
+]
+THIRD_PARTY_DIR_NAME = 'third_party'
+
+_LICENSE_STRING = 'http://www.apache.org/licenses/LICENSE-2.0'
+
+
+def check_license(paths):
+  """Validates license header."""
+  if not paths:
+    return True
+
+  success = True
+  for path in paths:
+    path_parts = str(path).split(os.sep)
+    if any(path_part == THIRD_PARTY_DIR_NAME for path_part in path_parts):
+      continue
+    filename = os.path.basename(path)
+    extension = os.path.splitext(path)[1]
+    if (filename not in _CHECK_LICENSE_FILENAMES and
+        extension not in _CHECK_LICENSE_EXTENSIONS):
+      continue
+
+    with open(path) as file_handle:
+      if _LICENSE_STRING not in file_handle.read():
+        print('Missing license header in file %s.' % str(path))
+        success = False
+
+  return success
+
+
+def bool_to_returncode(success):
+  """Returns 0 if |success|. Otherwise returns 1."""
+  if success:
+    print('Success.')
+    return 0
+
+  print('Failed.')
+  return 1
+
+
+def is_nonfuzzer_python(path):
+  """Returns True if |path| ends in .py."""
+  return os.path.splitext(path)[1] == '.py' and '/projects/' not in path
+
+
+def lint(_=None):
+  """Runs python's linter on infra. Returns False if it fails linting."""
+
+  # Use --score no to make linting quieter.
+  command = ['python3', '-m', 'pylint', '--score', 'no', '-j', '0', 'infra']
+  returncode = subprocess.run(command, check=False).returncode
+  return returncode == 0
+
+
+def yapf(paths, validate=True):
+  """Does yapf on |path| if it is Python file. Only validates format if
+  |validate|. Otherwise, formats the file. Returns False if validation or
+  formatting fails."""
+  paths = [path for path in paths if is_nonfuzzer_python(path)]
+  if not paths:
+    return True
+
+  validate_argument = '-d' if validate else '-i'
+  command = ['yapf', validate_argument, '-p']
+  command.extend(paths)
+
+  returncode = subprocess.run(command, check=False).returncode
+  return returncode == 0
+
+
+def get_changed_files():
+  """Returns a list of absolute paths of files changed in this git branch."""
+  branch_commit_hash = subprocess.check_output(
+      ['git', 'merge-base', 'HEAD', 'origin/HEAD']).strip().decode()
+
+  diff_commands = [
+      # Return list of modified files in the commits on this branch.
+      ['git', 'diff', '--name-only', branch_commit_hash + '..'],
+      # Return list of modified files from uncommitted changes.
+      ['git', 'diff', '--name-only']
+  ]
+
+  changed_files = set()
+  for command in diff_commands:
+    file_paths = subprocess.check_output(command).decode().splitlines()
+    for file_path in file_paths:
+      if not os.path.isfile(file_path):
+        continue
+      changed_files.add(file_path)
+  print(f'Changed files: {" ".join(changed_files)}')
+  return [os.path.abspath(f) for f in changed_files]
+
+
+def run_build_tests():
+  """Runs build tests because they can't be run in parallel."""
+  suite_list = [
+      unittest.TestLoader().discover(os.path.join(_SRC_ROOT, 'infra', 'build'),
+                                     pattern='*_test.py'),
+  ]
+  suite = unittest.TestSuite(suite_list)
+  print('Running build tests.')
+  result = unittest.TextTestRunner().run(suite)
+  return not result.failures and not result.errors
+
+
+def run_nonbuild_tests(parallel):
+  """Runs all tests but build tests. Does them in parallel if |parallel|. The
+  reason why we exclude build tests is because they use an emulator that
+  prevents them from being used in parallel."""
+  # We look for all project directories because otherwise pytest won't run tests
+  # that are not in valid modules (e.g. "base-images").
+  relevant_dirs = set()
+  all_files = get_all_files()
+  for file_path in all_files:
+    directory = os.path.dirname(file_path)
+    relevant_dirs.add(directory)
+
+  # Use ignore-glob because ignore doesn't seem to work properly with the way we
+  # pass directories to pytest.
+  command = [
+      'pytest',
+      '--ignore-glob=infra/build/*',
+      '--ignore-glob=projects/*',
+  ]
+  if parallel:
+    command.extend(['-n', 'auto'])
+  command += list(relevant_dirs)
+  print('Running non-build tests.')
+
+  # TODO(metzman): Get rid of this once config_utils stops using it.
+  env = os.environ.copy()
+  env['CIFUZZ_TEST'] = '1'
+
+  return subprocess.run(command, check=False, env=env).returncode == 0
+
+
+def run_tests(_=None, parallel=False, build_tests=True, nonbuild_tests=True):
+  """Runs all unit tests."""
+  build_success = True
+  nonbuild_success = True
+  if nonbuild_tests:
+    nonbuild_success = run_nonbuild_tests(parallel)
+  else:
+    print('Skipping nonbuild tests as specified.')
+
+  if build_tests:
+    build_success = run_build_tests()
+  else:
+    print('Skipping build tests as specified.')
+
+  return nonbuild_success and build_success
+
+
+def run_systemsan_tests(_=None):
+  """Runs SystemSan unit tests."""
+  command = ['make', 'test']
+  return subprocess.run(command,
+                        cwd='infra/experimental/SystemSan',
+                        check=False).returncode == 0
+
+
+def get_all_files():
+  """Returns a list of absolute paths of files in this repo."""
+  get_all_files_command = ['git', 'ls-files']
+  output = subprocess.check_output(get_all_files_command).decode().splitlines()
+  return [os.path.abspath(path) for path in output if os.path.isfile(path)]
+
+
+def main():
+  """Check changes on a branch for common issues before submitting."""
+  # Get program arguments.
+  parser = argparse.ArgumentParser(description='Presubmit script for oss-fuzz.')
+  parser.add_argument(
+      'command',
+      choices=['format', 'lint', 'license', 'infra-tests', 'systemsan-tests'],
+      nargs='?')
+  parser.add_argument('-a',
+                      '--all-files',
+                      action='store_true',
+                      help='Run presubmit check(s) on all files',
+                      default=False)
+  parser.add_argument('-p',
+                      '--parallel',
+                      action='store_true',
+                      help='Run tests in parallel.',
+                      default=False)
+  parser.add_argument('-s',
+                      '--skip-build-tests',
+                      action='store_true',
+                      help='Skip build tests which are slow and must run '
+                      'sequentially.',
+                      default=False)
+  parser.add_argument('-n',
+                      '--skip-nonbuild-tests',
+                      action='store_true',
+                      help='Only do build tests.',
+                      default=False)
+  args = parser.parse_args()
+
+  if args.all_files:
+    relevant_files = get_all_files()
+  else:
+    relevant_files = get_changed_files()
+
+  os.chdir(_SRC_ROOT)
+
+  # Do one specific check if the user asked for it.
+  if args.command == 'format':
+    success = yapf(relevant_files, False)
+    return bool_to_returncode(success)
+
+  if args.command == 'lint':
+    success = lint()
+    return bool_to_returncode(success)
+
+  if args.command == 'license':
+    success = check_license(relevant_files)
+    return bool_to_returncode(success)
+
+  if args.command == 'infra-tests':
+    success = run_tests(relevant_files,
+                        parallel=args.parallel,
+                        build_tests=(not args.skip_build_tests),
+                        nonbuild_tests=(not args.skip_nonbuild_tests))
+    return bool_to_returncode(success)
+
+  if args.command == 'systemsan-tests':
+    success = run_systemsan_tests(relevant_files)
+    return bool_to_returncode(success)
+
+  # Do all the checks (but no tests).
+  success = do_checks(relevant_files)
+
+  return bool_to_returncode(success)
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-commons-compress-delta-02/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-delta-02/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-delta-02/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-delta-02/fuzz-tooling/infra/test

@@ -0,0 +1 @@
+

local-test-commons-compress-delta-02/fuzz-tooling/infra/test_repos.py

@@ -0,0 +1,84 @@
+# 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.
+"""This module contains a list of test repository's used in unit/integration
+tests.
+
+Note: If you notice tests failing for unexpected reasons, make sure the data
+in the test repos are correct. This is because the test repos are dynamic and
+may change.
+
+Note: This should be removed when a better method of testing is established.
+"""
+
+import collections
+import os
+
+ExampleRepo = collections.namedtuple('ExampleRepo', [
+    'project_name', 'oss_repo_name', 'git_repo_name', 'image_location',
+    'git_url', 'new_commit', 'old_commit', 'intro_commit', 'fuzz_target',
+    'testcase_path'
+])
+
+TEST_DIR_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                             'testcases')
+
+# WARNING: Tests are dependent upon the following repos existing and the
+# specified commits existing.
+# TODO(metzman): Fix this problem.
+# TODO(metzman): The testcases got deleted here because the test that used them
+# was skipped. Probably worth deleting the test.
+TEST_REPOS = [
+    ExampleRepo(project_name='curl',
+                oss_repo_name='curl',
+                git_repo_name='curl',
+                image_location='/src',
+                git_url='https://github.com/curl/curl.git',
+                old_commit='df26f5f9c36e19cd503c0e462e9f72ad37b84c82',
+                new_commit='dda418266c99ceab368d723facb52069cbb9c8d5',
+                intro_commit='df26f5f9c36e19cd503c0e462e9f72ad37b84c82',
+                fuzz_target='curl_fuzzer_ftp',
+                testcase_path=os.path.join(TEST_DIR_PATH, 'curl_test_data')),
+    ExampleRepo(project_name='libarchive',
+                oss_repo_name='libarchive',
+                git_repo_name='libarchive',
+                image_location='/src',
+                git_url='https://github.com/libarchive/libarchive.git',
+                old_commit='5bd2a9b6658a3a6efa20bb9ad75bd39a44d71da6',
+                new_commit='458e49358f17ec58d65ab1c45cf299baaf3c98d1',
+                intro_commit='840266712006de5e737f8052db920dfea2be4260',
+                fuzz_target='libarchive_fuzzer',
+                testcase_path=os.path.join(TEST_DIR_PATH,
+                                           'libarchive_test_data')),
+    ExampleRepo(project_name='gonids',
+                oss_repo_name='gonids',
+                git_repo_name='gonids',
+                image_location='/root/go/src/github.com/google/',
+                git_url='https://github.com/google/gonids',
+                old_commit='',
+                new_commit='',
+                intro_commit='',
+                fuzz_target='',
+                testcase_path='')
+]
+
+INVALID_REPO = ExampleRepo(project_name='notaproj',
+                           oss_repo_name='notarepo',
+                           git_repo_name='notarepo',
+                           git_url='invalid.git',
+                           image_location='/src',
+                           old_commit='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                           new_commit='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                           intro_commit='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                           fuzz_target='NONEFUZZER',
+                           testcase_path='not/a/path')

local-test-commons-compress-delta-02/fuzz-tooling/infra/utils.py

@@ -0,0 +1,205 @@
+# 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.
+"""Utilities for OSS-Fuzz infrastructure."""
+
+import logging
+import os
+import posixpath
+import re
+import shlex
+import stat
+import subprocess
+import sys
+
+import helper
+
+ALLOWED_FUZZ_TARGET_EXTENSIONS = ['', '.exe']
+FUZZ_TARGET_SEARCH_STRING = 'LLVMFuzzerTestOneInput'
+VALID_TARGET_NAME_REGEX = re.compile(r'^[a-zA-Z0-9_-]+$')
+BLOCKLISTED_TARGET_NAME_REGEX = re.compile(r'^(jazzer_driver.*)$')
+
+# Location of google cloud storage for latest OSS-Fuzz builds.
+GCS_BASE_URL = 'https://storage.googleapis.com/'
+
+
+def chdir_to_root():
+  """Changes cwd to OSS-Fuzz root directory."""
+  # Change to oss-fuzz main directory so helper.py runs correctly.
+  if os.getcwd() != helper.OSS_FUZZ_DIR:
+    os.chdir(helper.OSS_FUZZ_DIR)
+
+
+def command_to_string(command):
+  """Returns the stringfied version of |command| a list representing a binary to
+  run and arguments to pass to it or a string representing a binary to run."""
+  if isinstance(command, str):
+    return command
+  return shlex.join(command)
+
+
+def execute(command,
+            env=None,
+            location=None,
+            check_result=False,
+            log_command=True):
+  """Runs a shell command in the specified directory location.
+
+  Args:
+    command: The command as a list to be run.
+    env: (optional) an environment to pass to Popen to run the command in.
+    location (optional): The directory to run command in.
+    check_result (optional): Should an exception be thrown on failure.
+
+  Returns:
+    stdout, stderr, returncode.
+
+  Raises:
+    RuntimeError: running a command resulted in an error.
+  """
+
+  if not location:
+    location = os.getcwd()
+  process = subprocess.Popen(command,
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE,
+                             cwd=location,
+                             env=env)
+  out, err = process.communicate()
+  out = out.decode('utf-8', errors='ignore')
+  err = err.decode('utf-8', errors='ignore')
+
+  if log_command:
+    command_str = command_to_string(command)
+    display_err = err
+  else:
+    command_str = 'redacted'
+    display_err = 'redacted'
+
+  if err:
+    logging.debug('Stderr of command "%s" is: %s.', command_str, display_err)
+  if check_result and process.returncode:
+    raise RuntimeError('Executing command "{0}" failed with error: {1}.'.format(
+        command_str, display_err))
+  return out, err, process.returncode
+
+
+def get_fuzz_targets(path):
+  """Gets fuzz targets in a directory.
+
+  Args:
+    path: A path to search for fuzz targets in.
+
+  Returns:
+    A list of paths to fuzzers or an empty list if None.
+  """
+  if not os.path.exists(path):
+    return []
+  fuzz_target_paths = []
+  for root, _, fuzzers in os.walk(path):
+    for fuzzer in fuzzers:
+      file_path = os.path.join(root, fuzzer)
+      if is_fuzz_target_local(file_path):
+        fuzz_target_paths.append(file_path)
+
+  return fuzz_target_paths
+
+
+def get_container_name():
+  """Gets the name of the current docker container you are in.
+
+  Returns:
+    Container name or None if not in a container.
+  """
+  result = subprocess.run(  # pylint: disable=subprocess-run-check
+      ['systemd-detect-virt', '-c'],
+      stdout=subprocess.PIPE).stdout
+  if b'docker' not in result:
+    return None
+  with open('/etc/hostname') as file_handle:
+    return file_handle.read().strip()
+
+
+def is_executable(file_path):
+  """Returns True if |file_path| is an exectuable."""
+  return os.path.exists(file_path) and os.access(file_path, os.X_OK)
+
+
+def is_fuzz_target_local(file_path):
+  """Returns whether |file_path| is a fuzz target binary (local path).
+  Copied from clusterfuzz src/python/bot/fuzzers/utils.py
+  with slight modifications.
+  """
+  # pylint: disable=too-many-return-statements
+  filename, file_extension = os.path.splitext(os.path.basename(file_path))
+  if not VALID_TARGET_NAME_REGEX.match(filename):
+    # Check fuzz target has a valid name (without any special chars).
+    return False
+
+  if BLOCKLISTED_TARGET_NAME_REGEX.match(filename):
+    # Check fuzz target an explicitly disallowed name (e.g. binaries used for
+    # jazzer-based targets).
+    return False
+
+  if file_extension not in ALLOWED_FUZZ_TARGET_EXTENSIONS:
+    # Ignore files with disallowed extensions (to prevent opening e.g. .zips).
+    return False
+
+  if not is_executable(file_path):
+    return False
+
+  if filename.endswith('_fuzzer'):
+    return True
+
+  if os.path.exists(file_path) and not stat.S_ISREG(os.stat(file_path).st_mode):
+    return False
+
+  with open(file_path, 'rb') as file_handle:
+    return file_handle.read().find(FUZZ_TARGET_SEARCH_STRING.encode()) != -1
+
+
+def binary_print(string):
+  """Prints string. Can print a binary string."""
+  if isinstance(string, bytes):
+    string += b'\n'
+  else:
+    string += '\n'
+  sys.stdout.buffer.write(string)
+  sys.stdout.flush()
+
+
+def url_join(*url_parts):
+  """Joins URLs together using the POSIX join method.
+
+  Args:
+    url_parts: Sections of a URL to be joined.
+
+  Returns:
+    Joined URL.
+  """
+  return posixpath.join(*url_parts)
+
+
+def gs_url_to_https(url):
+  """Converts |url| from a GCS URL (beginning with 'gs://') to an HTTPS one."""
+  return url_join(GCS_BASE_URL, remove_prefix(url, 'gs://'))
+
+
+def remove_prefix(string, prefix):
+  """Returns |string| without the leading substring |prefix|."""
+  # Match behavior of removeprefix from python3.9:
+  # https://www.python.org/dev/peps/pep-0616/
+  if string.startswith(prefix):
+    return string[len(prefix):]
+
+  return string