Add files using upload-large-folder tool

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/base-images/aixcc_build_all.sh

@@ -0,0 +1,59 @@
+#!/bin/bash -eux
+
+if [ "$1" = "--cache-from" ]; then
+    PULL_CACHE=1
+    shift
+    CACHE_TAG="${1//\//-}"  # s/\//-/g -> for branch names that contain slashes
+    shift
+elif [ "$1" = "--cache-to" ]; then
+    PUSH_CACHE=1
+    shift
+    CACHE_TAG="${1//\//-}"  # s/\//-/g -> for branch names that contain slashes
+    shift
+fi
+
+ARG_TAG="$1"
+shift
+
+BASE_IMAGES=(
+    "ghcr.io/aixcc-finals/base-image            infra/base-images/base-image"
+    "ghcr.io/aixcc-finals/base-clang            infra/base-images/base-clang"
+    "ghcr.io/aixcc-finals/base-builder          infra/base-images/base-builder"
+    "ghcr.io/aixcc-finals/base-builder-go       infra/base-images/base-builder-go"
+    "ghcr.io/aixcc-finals/base-builder-jvm      infra/base-images/base-builder-jvm"
+    "ghcr.io/aixcc-finals/base-builder-python   infra/base-images/base-builder-python"
+    "ghcr.io/aixcc-finals/base-builder-rust     infra/base-images/base-builder-rust"
+    "ghcr.io/aixcc-finals/base-builder-ruby     infra/base-images/base-builder-ruby"
+    "ghcr.io/aixcc-finals/base-builder-swift    infra/base-images/base-builder-swift"
+    "ghcr.io/aixcc-finals/base-runner           infra/base-images/base-runner"
+    "ghcr.io/aixcc-finals/base-runner-debug     infra/base-images/base-runner-debug"
+)
+
+for tuple in "${BASE_IMAGES[@]}"; do
+    read -r image path <<< "$tuple"
+
+    if [ "${PULL_CACHE+x}" ]; then
+
+        docker buildx build \
+            --build-arg IMG_TAG="${ARG_TAG}" \
+            --cache-from=type=registry,ref="${image}:${CACHE_TAG}" \
+            --tag "${image}:${ARG_TAG}" --push "$@" "${path}"
+
+    elif [ "${PUSH_CACHE+x}" ]; then
+
+        docker buildx build \
+            --build-arg IMG_TAG="${ARG_TAG}" \
+            --cache-from=type=registry,ref="${image}:${CACHE_TAG}" \
+            --cache-to=type=registry,ref="${image}:${CACHE_TAG}",mode=max \
+            --tag "${image}:${ARG_TAG}" --push "$@" "${path}"
+
+    else
+
+        docker buildx build \
+            --build-arg IMG_TAG="${ARG_TAG}" \
+            --tag "${image}:${ARG_TAG}" --push "$@" "${path}"
+
+    fi
+
+done
+

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/base-images/all.sh

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

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/ci/build.py

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

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/ci/build_test.py

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

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/affected_fuzz_targets.py

@@ -0,0 +1,113 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for dealing with fuzz targets affected by the change-under-test
+(CUT)."""
+import logging
+import os
+import sys
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import utils
+
+
+def remove_unaffected_fuzz_targets(clusterfuzz_deployment, out_dir,
+                                   files_changed, repo_path):
+  """Removes all non affected fuzz targets in the out directory.
+
+  Args:
+    clusterfuzz_deployment: The ClusterFuzz deployment object.
+    out_dir: The location of the fuzz target binaries.
+    files_changed: A list of files changed compared to HEAD.
+    repo_path: The location of the OSS-Fuzz repo in the docker image.
+
+  This function will not delete fuzz targets unless it knows that the fuzz
+  targets are unaffected. For example, this means that fuzz targets which don't
+  have coverage data on will not be deleted.
+  """
+  if not files_changed:
+    # Don't remove any fuzz targets if there is no difference from HEAD.
+    logging.info('No files changed compared to HEAD.')
+    return
+
+  logging.info('Files changed in PR: %s', files_changed)
+
+  fuzz_target_paths = utils.get_fuzz_targets(out_dir)
+  if not fuzz_target_paths:
+    # Nothing to remove.
+    logging.error('No fuzz targets found in out dir.')
+    return
+
+  coverage = clusterfuzz_deployment.get_coverage(repo_path)
+  if not coverage:
+    # Don't remove any fuzz targets unless we have data.
+    logging.error('Could not find latest coverage report.')
+    return
+
+  affected_fuzz_targets = get_affected_fuzz_targets(coverage, fuzz_target_paths,
+                                                    files_changed)
+
+  if not affected_fuzz_targets:
+    logging.info('No affected fuzz targets detected, keeping all as fallback.')
+    return
+
+  logging.info('Using affected fuzz targets: %s.', affected_fuzz_targets)
+  unaffected_fuzz_targets = set(fuzz_target_paths) - affected_fuzz_targets
+  logging.info('Removing unaffected fuzz targets: %s.', unaffected_fuzz_targets)
+
+  # Remove all the targets that are not affected.
+  for fuzz_target_path in unaffected_fuzz_targets:
+    try:
+      os.remove(fuzz_target_path)
+    except OSError as error:
+      logging.error('%s occurred while removing file %s', error,
+                    fuzz_target_path)
+
+
+def is_fuzz_target_affected(coverage, fuzz_target_path, files_changed):
+  """Returns True if a fuzz target (|fuzz_target_path|) is affected by
+  |files_changed|."""
+  fuzz_target = os.path.basename(fuzz_target_path)
+  covered_files = coverage.get_files_covered_by_target(fuzz_target)
+  if not covered_files:
+    # Assume a fuzz target is affected if we can't get its coverage from
+    # OSS-Fuzz.
+    # TODO(metzman): Figure out what we should do if covered_files is [].
+    # Should we act as if we couldn't get the coverage?
+    logging.info('Could not get coverage for %s. Treating as affected.',
+                 fuzz_target)
+    return True
+
+  covered_files = [
+      os.path.normpath(covered_file) for covered_file in covered_files
+  ]
+  logging.info('Fuzz target %s is affected by: %s', fuzz_target, covered_files)
+  for filename in files_changed:
+    if filename in covered_files:
+      logging.info('Fuzz target %s is affected by changed file: %s',
+                   fuzz_target, filename)
+      return True
+
+  logging.info('Fuzz target %s is not affected.', fuzz_target)
+  return False
+
+
+def get_affected_fuzz_targets(coverage, fuzz_target_paths, files_changed):
+  """Returns a list of paths of affected targets."""
+  affected_fuzz_targets = set()
+  for fuzz_target_path in fuzz_target_paths:
+    if is_fuzz_target_affected(coverage, fuzz_target_path, files_changed):
+      affected_fuzz_targets.add(fuzz_target_path)
+
+  return affected_fuzz_targets

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/build_fuzzers_entrypoint.py

@@ -0,0 +1,60 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Builds a specific OSS-Fuzz project's fuzzers for CI tools."""
+import logging
+import sys
+
+import build_fuzzers
+import logs
+import config_utils
+
+# pylint: disable=c-extension-no-member
+# pylint gets confused because of the relative import of cifuzz.
+
+logs.init()
+
+
+def build_fuzzers_entrypoint():
+  """Builds OSS-Fuzz project's fuzzers for CI tools."""
+  config = config_utils.BuildFuzzersConfig()
+
+  if config.dry_run:
+    # Sets the default return code on error to success.
+    returncode = 0
+  else:
+    # The default return code when an error occurs.
+    returncode = 1
+
+  if not build_fuzzers.build_fuzzers(config):
+    logging.error('Error building fuzzers for (commit: %s, pr_ref: %s).',
+                  config.git_sha, config.pr_ref)
+    return returncode
+
+  return 0
+
+
+def main():
+  """Builds OSS-Fuzz project's fuzzers for CI tools.
+
+  Note: The resulting fuzz target binaries of this build are placed in
+  the directory: ${GITHUB_WORKSPACE}/out
+
+  Returns:
+    0 on success or nonzero on failure.
+  """
+  return build_fuzzers_entrypoint()
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/clusterfuzz_deployment.py

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

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/continuous_integration.py

@@ -0,0 +1,375 @@
+# 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.
+"""Implementations for various CI systems."""
+
+import os
+import collections
+import sys
+import logging
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import build_specified_commit
+import docker
+import helper
+import repo_manager
+import retry
+import utils
+import workspace_utils
+
+# pylint: disable=too-few-public-methods
+
+BuildPreparationResult = collections.namedtuple(
+    'BuildPreparationResult', ['success', 'image_repo_path', 'repo_manager'])
+
+_IMAGE_BUILD_TRIES = 3
+_IMAGE_BUILD_BACKOFF = 2
+
+
+def fix_git_repo_for_diff(repo_manager_obj):
+  """Fixes git repos cloned by the "checkout" action so that diffing works on
+  them."""
+  command = [
+      'git', 'symbolic-ref', 'refs/remotes/origin/HEAD',
+      'refs/remotes/origin/master'
+  ]
+  return utils.execute(command, location=repo_manager_obj.repo_dir)
+
+
+class BaseCi:
+  """Class representing common CI functionality."""
+
+  def __init__(self, config):
+    self.config = config
+    self.workspace = workspace_utils.Workspace(config)
+    self._repo_dir = None
+
+  @property
+  def repo_dir(self):
+    """Returns the source repo path, if it has been checked out. None is
+    returned otherwise."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def prepare_for_fuzzer_build(self):
+    """Builds the fuzzer builder image and gets the source code we need to
+    fuzz."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def get_diff_base(self):
+    """Returns the base to diff against with git to get the change under
+    test."""
+    if self.config.base_ref:
+      logging.debug('Diffing against base_ref: %s.', self.config.base_ref)
+      return self.config.base_ref
+    if self.config.base_commit:
+      logging.debug('Diffing against base_commit: %s.', self.config.base_commit)
+      return self.config.base_commit
+    # TODO(metzman): Do we want this at all? What purpose does it serve? I guess
+    # it is a decent fallback when there is no base_commit or base_ref.
+    logging.debug('Diffing against origin.')
+    return 'origin'
+
+  def get_changed_code_under_test(self, repo_manager_obj):
+    """Returns the changed files that need to be tested."""
+    if self.config.base_ref:
+      repo_manager_obj.fetch_branch(self.config.base_ref)
+    fix_git_repo_for_diff(repo_manager_obj)
+    base = self.get_diff_base()
+    logging.info('Diffing against %s.', base)
+    # git diff <commit>... is equivalent to
+    # git diff $(git merge-base <commit> HEAD)
+    return repo_manager_obj.get_git_diff(base + '...')
+
+  def get_build_command(self, host_repo_path, image_repo_path):
+    """Returns the command for building the project that is run inside the
+    project builder container."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def _build_external_project_docker_image(self, manager):
+    """Helper for child classes that builds an external project's docker image.
+    Returns a BuildPreparationResult indicating failure or success."""
+    build_integration_abs_path = os.path.join(
+        manager.repo_dir, self.config.build_integration_path)
+    if not build_external_project_docker_image(manager.repo_dir,
+                                               build_integration_abs_path):
+      logging.error('Failed to build external project.')
+      return get_build_preparation_failure()
+    image_repo_path = os.path.join('/src', self.config.project_repo_name)
+    return BuildPreparationResult(success=True,
+                                  image_repo_path=image_repo_path,
+                                  repo_manager=manager)
+
+  def _make_repo_storage_dir(self):
+    os.makedirs(self.workspace.repo_storage, exist_ok=True)
+
+  def _clone_repo_and_checkout(self, repo_url, repo_name):
+    """Helper for child classes that clones the git repo specified by |repo_url|
+    to |repo_name|, checks out the specified commit, and returns the
+    |manager|."""
+    self._make_repo_storage_dir()
+    # Checkout project's repo in the shared volume.
+    manager = repo_manager.clone_repo_and_get_manager(
+        repo_url,
+        self.workspace.repo_storage,
+        repo_name=repo_name,
+        username=self.config.actor,
+        password=self.config.token)
+    self._checkout_specified_commit(manager)
+    return manager
+
+  def _checkout_specified_commit(self, manager):
+    checkout_specified_commit(manager, self.config.pr_ref, self.config.git_sha)
+
+  def _detect_main_repo(self):
+    """Helper for child classes that detects the main repo and returns a tuple
+    containing the inffered url and path to the repo in the image."""
+    inferred_url, image_repo_path = build_specified_commit.detect_main_repo(
+        self.config.oss_fuzz_project_name,
+        repo_name=self.config.project_repo_name)
+    if not inferred_url or not image_repo_path:
+      logging.error('Could not detect repo.')
+    return inferred_url, image_repo_path
+
+  def _create_repo_manager_for_project_src_path(self):
+    """Returns a repo manager for |project_src_path|."""
+    return repo_manager.RepoManager(self.config.project_src_path)
+
+
+def get_build_command():
+  """Returns the command to build the project inside the project builder
+  container."""
+  return 'compile'
+
+
+def get_replace_repo_and_build_command(host_repo_path, image_repo_path):
+  """Returns the command to replace the repo located at |image_repo_path| with
+  |host_repo_path| and build the project inside the project builder
+  container."""
+  rm_path = os.path.join(image_repo_path, '*')
+  image_src_path = os.path.dirname(image_repo_path)
+  build_command = get_build_command()
+  command = (f'cd / && rm -rf {rm_path} && cp -r {host_repo_path} '
+             f'{image_src_path} && cd - && {build_command}')
+  return command
+
+
+def get_ci(config):
+  """Determines what kind of CI is being used and returns the object
+  representing that system."""
+
+  if config.platform == config.Platform.EXTERNAL_GENERIC_CI:
+    # Non-OSS-Fuzz projects must bring their own source and their own build
+    # integration (which is relative to that source).
+    return ExternalGeneric(config)
+  if config.platform == config.Platform.EXTERNAL_GITHUB:
+    # Non-OSS-Fuzz projects must bring their own source and their own build
+    # integration (which is relative to that source).
+    return ExternalGithub(config)
+
+  if config.platform == config.Platform.INTERNAL_GENERIC_CI:
+    # Builds of OSS-Fuzz projects not hosted on Github must bring their own
+    # source since the checkout logic CIFuzz implements is github-specific.
+    # TODO(metzman): Consider moving Github-actions builds of OSS-Fuzz projects
+    # to this system to reduce implementation complexity.
+    return InternalGeneric(config)
+
+  return InternalGithub(config)
+
+
+def checkout_specified_commit(repo_manager_obj, pr_ref, git_sha):
+  """Checks out the specified commit or pull request using
+  |repo_manager_obj|."""
+  try:
+    if pr_ref:
+      repo_manager_obj.checkout_pr(pr_ref)
+    else:
+      repo_manager_obj.checkout_commit(git_sha)
+  except (RuntimeError, ValueError):
+    logging.error(
+        'Can not check out requested state %s. '
+        'Using current repo state.', pr_ref or git_sha)
+
+
+class GithubCiMixin:
+  """Mixin for Github based CI systems."""
+
+  def __init__(self, config):
+    super().__init__(config)
+    # Unlike in other classes, here _repo_dir is the parent directory of the
+    # repo, not its actual directory.
+    self._repo_dir = self.workspace.repo_storage
+
+  @property
+  def repo_dir(self):
+    """Returns the source repo path, if it has been checked out. None is
+    returned otherwise."""
+    if not os.path.exists(self._repo_dir):
+      logging.warning('Repo dir: %s does not exist.', self._repo_dir)
+      return None
+
+    # Note: this assumes there is only one repo checked out here.
+    listing = os.listdir(self._repo_dir)
+    if len(listing) != 1:
+      raise RuntimeError('Invalid repo directory.')
+
+    repo_path = os.path.join(self._repo_dir, listing[0])
+    if not os.path.isdir(repo_path):
+      raise RuntimeError('Repo is not a directory.')
+
+    return repo_path
+
+
+class InternalGithub(GithubCiMixin, BaseCi):
+  """Class representing CI for an OSS-Fuzz project on Github Actions."""
+
+  def _copy_repo_from_image(self, image_repo_path):
+    self._make_repo_storage_dir()
+    repo_name = os.path.basename(image_repo_path)
+    host_repo_path = os.path.join(self._repo_dir, repo_name)
+    bash_command = f'cp -r {image_repo_path} {host_repo_path}'
+    docker_args, _ = docker.get_base_docker_run_args(
+        self.workspace, self.config.sanitizer, self.config.language,
+        self.config.architecture, self.config.docker_in_docker)
+    docker_args.extend([
+        docker.get_project_image_name(self.config.oss_fuzz_project_name),
+        '/bin/bash', '-c', bash_command
+    ])
+    if not helper.docker_run(docker_args):
+      raise RuntimeError('Failed to copy repo.')
+    return repo_manager.RepoManager(host_repo_path)
+
+  def prepare_for_fuzzer_build(self):
+    """Builds the fuzzer builder image, checks out the pull request/commit and
+    returns the BuildPreparationResult."""
+    logging.info('InternalGithub: preparing for fuzzer build.')
+    assert self.config.pr_ref or self.config.git_sha
+    # _detect_main_repo builds the image as a side effect.
+    _, image_repo_path = self._detect_main_repo()
+    if not image_repo_path:
+      return get_build_preparation_failure()
+
+    # Use the same name used in the docker image so we can overwrite it.
+    manager = self._copy_repo_from_image(image_repo_path)
+    self._checkout_specified_commit(manager)
+    return BuildPreparationResult(success=True,
+                                  image_repo_path=image_repo_path,
+                                  repo_manager=manager)
+
+  def get_build_command(self, host_repo_path, image_repo_path):  # pylint: disable=no-self-use
+    """Returns the command for building the project that is run inside the
+    project builder container. Command also replaces |image_repo_path| with
+    |host_repo_path|."""
+    return get_replace_repo_and_build_command(host_repo_path, image_repo_path)
+
+
+def get_build_preparation_failure():
+  """Returns a BuildPreparationResult indicating failure."""
+  return BuildPreparationResult(success=False,
+                                image_repo_path=None,
+                                repo_manager=None)
+
+
+class InternalGeneric(BaseCi):
+  """Class representing CI for an OSS-Fuzz project on a CI other than Github
+  actions."""
+
+  def __init__(self, config):
+    super().__init__(config)
+    self._repo_dir = config.project_src_path
+
+  @property
+  def repo_dir(self):
+    """Returns the source repo path, if it has been checked out. None is
+    returned otherwise."""
+    return self._repo_dir
+
+  def prepare_for_fuzzer_build(self):
+    """Builds the project builder image for an OSS-Fuzz project outside of
+    GitHub actions. Returns the repo_manager. Does not checkout source code
+    since external projects are expected to bring their own source code to
+    CIFuzz."""
+    logging.info('InternalGeneric: preparing for fuzzer build.')
+    # detect_main_repo builds the image as a side effect.
+    _, image_repo_path = self._detect_main_repo()
+
+    if not image_repo_path:
+      return get_build_preparation_failure()
+
+    manager = self._create_repo_manager_for_project_src_path()
+    return BuildPreparationResult(success=True,
+                                  image_repo_path=image_repo_path,
+                                  repo_manager=manager)
+
+  def get_build_command(self, host_repo_path, image_repo_path):  # pylint: disable=no-self-use
+    """Returns the command for building the project that is run inside the
+    project builder container. Command also replaces |image_repo_path| with
+    |host_repo_path|."""
+    return get_replace_repo_and_build_command(host_repo_path, image_repo_path)
+
+
+@retry.wrap(_IMAGE_BUILD_TRIES, _IMAGE_BUILD_BACKOFF)
+def build_external_project_docker_image(project_src, build_integration_path):
+  """Builds the project builder image for an external (non-OSS-Fuzz) project.
+  Returns True on success."""
+  dockerfile_path = os.path.join(build_integration_path, 'Dockerfile')
+  command = [
+      '-t', docker.EXTERNAL_PROJECT_IMAGE, '-f', dockerfile_path, project_src
+  ]
+  return helper.docker_build(command)
+
+
+class ExternalGeneric(BaseCi):
+  """CI implementation for generic CI for external (non-OSS-Fuzz) projects."""
+
+  def __init__(self, config):
+    super().__init__(config)
+    self._repo_dir = config.project_src_path
+
+  @property
+  def repo_dir(self):
+    """Returns the source repo path, if it has been checked out. None is
+    returned otherwise."""
+    return self._repo_dir
+
+  def prepare_for_fuzzer_build(self):
+    logging.info('ExternalGeneric: preparing for fuzzer build.')
+    manager = self._create_repo_manager_for_project_src_path()
+    return self._build_external_project_docker_image(manager)
+
+  def get_build_command(self, host_repo_path, image_repo_path):  # pylint: disable=no-self-use
+    """Returns the command for building the project that is run inside the
+    project builder container."""
+    return get_build_command()
+
+
+class ExternalGithub(GithubCiMixin, BaseCi):
+  """Class representing CI for a non-OSS-Fuzz project on Github Actions."""
+
+  def prepare_for_fuzzer_build(self):
+    """Builds the project builder image for a non-OSS-Fuzz project on GitHub
+    actions. Sets the repo manager. Does not checkout source code since external
+    projects are expected to bring their own source code to CIFuzz. Returns True
+    on success."""
+    logging.info('ExternalGithub: preparing for fuzzer build.')
+    # Checkout before building, so we don't need to rely on copying the source
+    # from the image.
+    # TODO(metzman): Figure out if we want second copy at all.
+    manager = self._clone_repo_and_checkout(self.config.git_url,
+                                            self.config.project_repo_name)
+    return self._build_external_project_docker_image(manager)
+
+  def get_build_command(self, host_repo_path, image_repo_path):  # pylint: disable=no-self-use
+    """Returns the command for building the project that is run inside the
+    project builder container."""
+    return get_build_command()

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/continuous_integration_test.py

@@ -0,0 +1,88 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for continuous_integration_module."""
+import os
+import sys
+import unittest
+from unittest import mock
+
+import continuous_integration
+import docker
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import repo_manager
+
+# pylint: disable=no-self-use
+
+
+class FixGitRepoForDiffTest(unittest.TestCase):
+  """Tests for fix_git_repo_for_diff."""
+
+  @mock.patch('utils.execute')
+  def test_fix_git_repo_for_diff(self, mock_execute):
+    """Tests that fix_git_repo_for_diff works as intended."""
+    repo_dir = '/dir'
+    repo_manager_obj = repo_manager.RepoManager(repo_dir)
+    continuous_integration.fix_git_repo_for_diff(repo_manager_obj)
+    expected_command = [
+        'git', 'symbolic-ref', 'refs/remotes/origin/HEAD',
+        'refs/remotes/origin/master'
+    ]
+
+    mock_execute.assert_called_with(expected_command, location=repo_dir)
+
+
+class GetBuildCommand(unittest.TestCase):
+  """Tests for get_build_command."""
+
+  def test_build_command(self):
+    """Tests that get_build_command works as intended."""
+    self.assertEqual(continuous_integration.get_build_command(), 'compile')
+
+
+class GetReplaceRepoAndBuildCommand(unittest.TestCase):
+  """Tests for get_replace_repo_and_build_command."""
+
+  def test_get_replace_repo_and_build_command(self):
+    """Tests that get_replace_repo_and_build_command works as intended."""
+    host_repo_path = '/path/on/host/to/repo'
+    image_repo_path = '/src/repo'
+    command = continuous_integration.get_replace_repo_and_build_command(
+        host_repo_path, image_repo_path)
+    expected_command = ('cd / && rm -rf /src/repo/* && '
+                        'cp -r /path/on/host/to/repo /src && cd - '
+                        '&& compile')
+    self.assertEqual(command, expected_command)
+
+
+class BuildExternalProjetDockerImage(unittest.TestCase):
+  """Tests for build_external_project_docker_image."""
+
+  @mock.patch('helper.docker_build')
+  def test_build_external_project_docker_image(self, mock_docker_build):
+    """Tests that build_external_project_docker_image works as intended."""
+    build_integration_path = '.clusterfuzzlite'
+    project_src = '/path/to/project/src'
+    continuous_integration.build_external_project_docker_image(
+        project_src, build_integration_path)
+
+    mock_docker_build.assert_called_with([
+        '-t', docker.EXTERNAL_PROJECT_IMAGE, '-f',
+        os.path.join('.clusterfuzzlite', 'Dockerfile'), project_src
+    ])
+
+
+# TODO(metzman): Write tests for the rest of continuous_integration.py.

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/fuzz_target.py

@@ -0,0 +1,408 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""A module to handle running a fuzz target for a specified amount of time."""
+import collections
+import logging
+import multiprocessing
+import os
+import shutil
+import stat
+import tempfile
+from typing import Optional
+
+import clusterfuzz.environment
+import clusterfuzz.fuzz
+
+import config_utils
+import logs
+
+logs.init()
+
+# Use len_control=0 since we don't have enough time fuzzing for len_control to
+# make sense (probably).
+LIBFUZZER_OPTIONS_BATCH = ['-len_control=0']
+# Use a fixed seed for determinism for code change fuzzing.
+LIBFUZZER_OPTIONS_CODE_CHANGE = LIBFUZZER_OPTIONS_BATCH + ['-seed=1337']
+LIBFUZZER_OPTIONS_NO_REPORT_OOM = ['-rss_limit_mb=0']
+
+# The number of reproduce attempts for a crash.
+REPRODUCE_ATTEMPTS = 10
+
+DEFAULT_REPRODUCE_TIME_SECONDS = 30
+PER_LANGUAGE_REPRODUCE_TIMEOUTS = {
+    'python': 30 * 4  # Python takes a bit longer on startup.
+}
+MINIMIZE_TIME_SECONDS = 60 * 4
+
+# Seconds on top of duration until a timeout error is raised.
+BUFFER_TIME = 10
+
+# Log message if we can't check if crash reproduces on an recent build.
+COULD_NOT_TEST_ON_CLUSTERFUZZ_MESSAGE = (
+    'Could not run previous build of target to determine if this code change '
+    '(pr/commit) introduced crash. Assuming crash was newly introduced.')
+
+FuzzResult = collections.namedtuple('FuzzResult',
+                                    ['testcase', 'stacktrace', 'corpus_path'])
+
+
+def get_libfuzzer_parallel_options():
+  """Returns a list containing options to pass to libFuzzer to fuzz using all
+  available cores."""
+  return ['-jobs=' + str(multiprocessing.cpu_count())]
+
+
+class ReproduceError(Exception):
+  """Error for when we can't attempt to reproduce a crash."""
+
+
+def get_fuzz_target_corpus_dir(workspace, target_name):
+  """Returns the directory for storing |target_name|'s corpus in |workspace|."""
+  return os.path.join(workspace.corpora, target_name)
+
+
+def get_fuzz_target_pruned_corpus_dir(workspace, target_name):
+  """Returns the directory for storing |target_name|'s puned corpus in
+  |workspace|."""
+  return os.path.join(workspace.pruned_corpora, target_name)
+
+
+class FuzzTarget:  # pylint: disable=too-many-instance-attributes
+  """A class to manage a single fuzz target.
+
+  Attributes:
+    target_name: The name of the fuzz target.
+    duration: The length of time in seconds that the target should run.
+    target_path: The location of the fuzz target binary.
+    workspace: The workspace for storing things related to fuzzing.
+  """
+
+  # pylint: disable=too-many-arguments
+  def __init__(self, target_path, duration, workspace, clusterfuzz_deployment,
+               config):
+    """Represents a single fuzz target.
+
+    Args:
+      target_path: The location of the fuzz target binary.
+      duration: The length of time  in seconds the target should run.
+      workspace: The path used for storing things needed for fuzzing.
+      clusterfuzz_deployment: The object representing the ClusterFuzz
+          deployment.
+      config: The config of this project.
+    """
+    self.target_path = target_path
+    self.target_name = os.path.basename(self.target_path)
+    self.duration = int(duration)
+    self.workspace = workspace
+    self.clusterfuzz_deployment = clusterfuzz_deployment
+    self.config = config
+    self.latest_corpus_path = get_fuzz_target_corpus_dir(
+        self.workspace, self.target_name)
+    os.makedirs(self.latest_corpus_path, exist_ok=True)
+    self.pruned_corpus_path = get_fuzz_target_pruned_corpus_dir(
+        self.workspace, self.target_name)
+    os.makedirs(self.pruned_corpus_path, exist_ok=True)
+
+  def _download_corpus(self):
+    """Downloads the corpus for the target from ClusterFuzz and returns the path
+    to the corpus. An empty directory is provided if the corpus can't be
+    downloaded or is empty."""
+    self.clusterfuzz_deployment.download_corpus(self.target_name,
+                                                self.latest_corpus_path)
+    return self.latest_corpus_path
+
+  def _target_artifact_path(self):
+    """Target artifact path."""
+    artifact_path = os.path.join(self.workspace.artifacts, self.target_name,
+                                 self.config.sanitizer)
+    os.makedirs(artifact_path, exist_ok=True)
+    return artifact_path
+
+  def _save_crash(self, crash):
+    """Add stacktraces to crashes."""
+    target_reproducer_path = os.path.join(self._target_artifact_path(),
+                                          os.path.basename(crash.input_path))
+    shutil.copy(crash.input_path, target_reproducer_path)
+    bug_summary_artifact_path = target_reproducer_path + '.summary'
+    with open(bug_summary_artifact_path, 'w') as handle:
+      handle.write(crash.stacktrace)
+
+    # Set permissions of testcase to be the same as summary so that we're sure
+    # it can be read by necessary users.
+    permissions_mode = os.stat(bug_summary_artifact_path).st_mode
+    os.chmod(target_reproducer_path, permissions_mode & 0o777)
+    return target_reproducer_path
+
+  def prune(self):
+    """Prunes the corpus and returns the result."""
+    self._download_corpus()
+    with clusterfuzz.environment.Environment(config_utils.DEFAULT_ENGINE,
+                                             self.config.sanitizer,
+                                             self.target_path):
+      engine_impl = clusterfuzz.fuzz.get_engine(config_utils.DEFAULT_ENGINE)
+      result = engine_impl.minimize_corpus(self.target_path, [],
+                                           [self.latest_corpus_path],
+                                           self.pruned_corpus_path,
+                                           self._target_artifact_path(),
+                                           self.duration)
+
+    print(result.logs)
+    return FuzzResult(None, result.logs, self.pruned_corpus_path)
+
+  def fuzz(self, batch=False) -> Optional[FuzzResult]:
+    """Starts the fuzz target run for the length of time specified by duration.
+
+    Returns:
+      FuzzResult namedtuple with stacktrace and testcase if applicable.
+    """
+    logging.info('Running fuzzer: %s.', self.target_name)
+
+    self._download_corpus()
+    corpus_path = self.latest_corpus_path
+
+    logging.info('Starting fuzzing')
+    with tempfile.TemporaryDirectory() as artifacts_dir:
+      with clusterfuzz.environment.Environment(config_utils.DEFAULT_ENGINE,
+                                               self.config.sanitizer,
+                                               self.target_path) as env:
+        engine_impl = clusterfuzz.fuzz.get_engine(config_utils.DEFAULT_ENGINE)
+        options = engine_impl.prepare(corpus_path, env.target_path,
+                                      env.build_dir)
+        options.merge_back_new_testcases = False
+        options.analyze_dictionary = False
+        if batch:
+          options.arguments.extend(LIBFUZZER_OPTIONS_BATCH)
+        else:
+          options.arguments.extend(LIBFUZZER_OPTIONS_CODE_CHANGE)
+
+        if not self.config.report_ooms:
+          options.arguments.extend(LIBFUZZER_OPTIONS_NO_REPORT_OOM)
+
+        if self.config.parallel_fuzzing:
+          if self.config.sanitizer == 'memory':
+            # TODO(https://github.com/google/oss-fuzz/issues/11915): Don't gate
+            # this after jobs is fixed for MSAN.
+            logging.info('Not using jobs because it breaks MSAN.')
+          else:
+            options.arguments.extend(get_libfuzzer_parallel_options())
+
+        result = engine_impl.fuzz(self.target_path, options, artifacts_dir,
+                                  self.duration)
+        print(f'Fuzzing logs:\n{result.logs}')
+
+      if not result.crashes:
+        # Libfuzzer max time was reached.
+        logging.info('Fuzzer %s finished with no crashes discovered.',
+                     self.target_name)
+        return FuzzResult(None, None, self.latest_corpus_path)
+
+      if result.timed_out:
+        logging.info('Not reporting crash in %s because process timed out.',
+                     self.target_name)
+        return FuzzResult(None, None, self.latest_corpus_path)
+
+      # Only report first crash.
+      crash = result.crashes[0]
+      logging.info('Fuzzer: %s. Detected bug.', self.target_name)
+
+      is_reportable = self.is_crash_reportable(crash.input_path,
+                                               crash.reproduce_args,
+                                               batch=batch)
+      if is_reportable or self.config.upload_all_crashes:
+        logging.info('SAVING CRASH')
+        fuzzer_logs = result.logs
+        testcase_path = self._save_crash(crash)
+        if is_reportable and self.config.minimize_crashes:
+          # TODO(metzman): We don't want to minimize unreproducible crashes.
+          # Use is_reportable to decide this even though reportable crashes
+          # are a subset of reproducible ones.
+          self.minimize_testcase(testcase_path)
+        else:
+          logging.info('NOT MINIMIZED')
+      else:
+        fuzzer_logs = None
+        testcase_path = None
+
+    return FuzzResult(testcase_path, fuzzer_logs, self.latest_corpus_path)
+
+  def minimize_testcase(self, testcase_path):
+    """Minimizes the testcase located at |testcase_path|."""
+    with clusterfuzz.environment.Environment(config_utils.DEFAULT_ENGINE,
+                                             self.config.sanitizer,
+                                             self.target_path):
+      engine_impl = clusterfuzz.fuzz.get_engine(config_utils.DEFAULT_ENGINE)
+      minimized_testcase_path = testcase_path + '-minimized'
+      return engine_impl.minimize_testcase(self.target_path, [],
+                                           testcase_path,
+                                           minimized_testcase_path,
+                                           max_time=MINIMIZE_TIME_SECONDS)
+
+  def free_disk_if_needed(self, delete_fuzz_target=True):
+    """Deletes things that are no longer needed from fuzzing this fuzz target to
+    save disk space if needed."""
+    if not self.config.low_disk_space:
+      logging.info('Not freeing disk space after running fuzz target.')
+      return
+    logging.info('Deleting corpus and seed corpus of %s to save disk.',
+                 self.target_name)
+
+    # Delete the seed corpus, corpus, and fuzz target.
+    for corpus_path in [self.latest_corpus_path, self.pruned_corpus_path]:
+      # Use ignore_errors=True to fix
+      # https://github.com/google/oss-fuzz/issues/5383.
+      shutil.rmtree(corpus_path, ignore_errors=True)
+
+    target_seed_corpus_path = self.target_path + '_seed_corpus.zip'
+    if os.path.exists(target_seed_corpus_path):
+      os.remove(target_seed_corpus_path)
+
+    if delete_fuzz_target:
+      logging.info('Deleting fuzz target: %s.', self.target_name)
+      os.remove(self.target_path)
+    logging.info('Done deleting.')
+
+  def is_reproducible(self, testcase, target_path, reproduce_args):
+    """Checks if the testcase reproduces.
+
+      Args:
+        testcase: The path to the testcase to be tested.
+        target_path: The path to the fuzz target to be tested
+        reproduce_args: The arguments to pass to the target to reproduce the
+          crash.
+
+      Returns:
+        True if crash is reproducible and we were able to run the
+        binary.
+
+      Raises:
+        ReproduceError if we can't attempt to reproduce the crash.
+    """
+    if not os.path.exists(target_path):
+      logging.info('Target: %s does not exist.', target_path)
+      raise ReproduceError(f'Target {target_path} not found.')
+
+    os.chmod(target_path, stat.S_IRWXO)
+
+    logging.info('Trying to reproduce crash using: %s.', testcase)
+    with clusterfuzz.environment.Environment(config_utils.DEFAULT_ENGINE,
+                                             self.config.sanitizer,
+                                             target_path):
+      reproduce_time_seconds = PER_LANGUAGE_REPRODUCE_TIMEOUTS.get(
+          self.config.language, DEFAULT_REPRODUCE_TIME_SECONDS)
+      for _ in range(REPRODUCE_ATTEMPTS):
+        engine_impl = clusterfuzz.fuzz.get_engine(config_utils.DEFAULT_ENGINE)
+        try:
+          result = engine_impl.reproduce(target_path,
+                                         testcase,
+                                         arguments=reproduce_args,
+                                         max_time=reproduce_time_seconds)
+        except TimeoutError as error:
+          logging.error('%s.', error)
+          return False
+
+        if result.return_code != 0:
+          logging.info('Reproduce command returned: %s. Reproducible on %s.',
+                       result.return_code, target_path)
+
+          return True
+
+    logging.info('Reproduce command returned: 0. Not reproducible on %s.',
+                 target_path)
+    return False
+
+  def is_crash_reportable(self, testcase, reproduce_args, batch=False):
+    """Returns True if a crash is reportable. This means the crash is
+    reproducible but not reproducible on a build from the ClusterFuzz deployment
+    (meaning the crash was introduced by this PR/commit/code change).
+
+    Args:
+      testcase: The path to the testcase that triggered the crash.
+      reproduce_args: The arguments to pass to the target to reproduce the
+      crash.
+
+    Returns:
+      True if the crash was introduced by the current pull request.
+
+    Raises:
+      ReproduceError if we can't attempt to reproduce the crash on the PR build.
+    """
+
+    if not self.is_crash_type_reportable(testcase):
+      return False
+
+    if not os.path.exists(testcase):
+      raise ReproduceError(f'Testcase {testcase} not found.')
+
+    try:
+      reproducible_on_code_change = self.is_reproducible(
+          testcase, self.target_path, reproduce_args)
+    except ReproduceError as error:
+      logging.error('Could not check for crash reproducibility.'
+                    'Please file an issue:'
+                    'https://github.com/google/oss-fuzz/issues/new.')
+      raise error
+
+    if not reproducible_on_code_change:
+      logging.info('Crash is not reproducible.')
+      return self.config.report_unreproducible_crashes
+
+    logging.info('Crash is reproducible.')
+    if batch:
+      # We don't need to check if the crash is novel for batch fuzzing.
+      return True
+
+    return self.is_crash_novel(testcase, reproduce_args)
+
+  def is_crash_type_reportable(self, testcase):
+    """Returns True if |testcase| is an actual crash. If crash is a timeout or
+    OOM then returns True if config says we should report those."""
+    # TODO(metzman): Use a less hacky method.
+    testcase = os.path.basename(testcase)
+    if testcase.startswith('oom-'):
+      return self.config.report_ooms
+    if testcase.startswith('timeout-'):
+      return self.config.report_timeouts
+    return True
+
+  def is_crash_novel(self, testcase, reproduce_args):
+    """Returns whether or not the crash is new. A crash is considered new if it
+    can't be reproduced on an older ClusterFuzz build of the target."""
+    if not os.path.exists(testcase):
+      raise ReproduceError('Testcase %s not found.' % testcase)
+    clusterfuzz_build_dir = self.clusterfuzz_deployment.download_latest_build()
+    if not clusterfuzz_build_dir:
+      # Crash is reproducible on PR build and we can't test on a recent
+      # ClusterFuzz/OSS-Fuzz build.
+      logging.info(COULD_NOT_TEST_ON_CLUSTERFUZZ_MESSAGE)
+      return True
+
+    clusterfuzz_target_path = os.path.join(clusterfuzz_build_dir,
+                                           self.target_name)
+
+    try:
+      reproducible_on_clusterfuzz_build = self.is_reproducible(
+          testcase, clusterfuzz_target_path, reproduce_args)
+    except ReproduceError:
+      # This happens if the project has ClusterFuzz builds, but the fuzz target
+      # is not in it (e.g. because the fuzz target is new).
+      logging.info(COULD_NOT_TEST_ON_CLUSTERFUZZ_MESSAGE)
+      return True
+
+    if reproducible_on_clusterfuzz_build:
+      logging.info('The crash is reproducible on previous build. '
+                   'Code change (pr/commit) did not introduce crash.')
+      return False
+    logging.info('The crash is not reproducible on previous build. '
+                 'Code change (pr/commit) introduced crash.')
+    return True

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/http_utils_test.py

@@ -0,0 +1,71 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for http_utils.py"""
+
+import unittest
+from unittest import mock
+
+from pyfakefs import fake_filesystem_unittest
+
+import http_utils
+
+mock_get_response = mock.MagicMock(status_code=200, content=b'')
+
+
+class DownloadUrlTest(unittest.TestCase):
+  """Tests that download_url works."""
+  URL = 'https://example.com/file'
+  FILE_PATH = '/tmp/file'
+
+  @mock.patch('time.sleep')
+  @mock.patch('requests.get', return_value=mock_get_response)
+  def test_download_url_no_error(self, mock_urlretrieve, _):
+    """Tests that download_url works when there is no error."""
+    self.assertTrue(http_utils.download_url(self.URL, self.FILE_PATH))
+    self.assertEqual(1, mock_urlretrieve.call_count)
+
+  @mock.patch('time.sleep')
+  @mock.patch('logging.error')
+  @mock.patch('requests.get',
+              return_value=mock.MagicMock(status_code=404, content=b''))
+  def test_download_url_http_error(self, mock_get, mock_error, _):
+    """Tests that download_url doesn't retry when there is an HTTP error."""
+    self.assertFalse(http_utils.download_url(self.URL, self.FILE_PATH))
+    mock_error.assert_called_with(
+        'Unable to download from: %s. Code: %d. Content: %s.', self.URL, 404,
+        b'')
+    self.assertEqual(1, mock_get.call_count)
+
+  @mock.patch('time.sleep')
+  @mock.patch('requests.get', side_effect=ConnectionResetError)
+  def test_download_url_connection_error(self, mock_get, mock_sleep):
+    """Tests that download_url doesn't retry when there is an HTTP error."""
+    self.assertFalse(http_utils.download_url(self.URL, self.FILE_PATH))
+    self.assertEqual(4, mock_get.call_count)
+    self.assertEqual(3, mock_sleep.call_count)
+
+
+class DownloadAndUnpackZipTest(fake_filesystem_unittest.TestCase):
+  """Tests download_and_unpack_zip."""
+
+  def setUp(self):
+    self.setUpPyfakefs()
+
+  @mock.patch('requests.get', return_value=mock_get_response)
+  def test_bad_zip_download(self, _):
+    """Tests download_and_unpack_zip returns none when a bad zip is passed."""
+    self.fs.create_file('/url_tmp.zip', contents='Test file.')
+    self.assertFalse(
+        http_utils.download_and_unpack_zip('/not/a/real/url',
+                                           '/extract-directory'))

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/run_cifuzz.py

@@ -0,0 +1,89 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Script for running CIFuzz end-to-end. This is meant to work outside any
+docker image. This cannot depend on any CIFuzz code or third party packages."""
+import os
+import subprocess
+import sys
+import tempfile
+import logging
+
+INFRA_DIR = os.path.dirname(os.path.dirname(__file__))
+DEFAULT_ENVS = [('DRY_RUN', '0'), ('SANITIZER', 'address')]
+BASE_CIFUZZ_DOCKER_TAG = 'ghcr.io/aixcc-finals'
+
+
+def set_default_env_var_if_unset(env_var, default_value):
+  """Sets the value of |env_var| in the environment to |default_value| if it was
+  not already set."""
+  if env_var not in os.environ:
+    os.environ[env_var] = default_value
+
+
+def docker_run(name, workspace, project_src_path):
+  """Runs a CIFuzz docker container with |name|."""
+  command = [
+      'docker', 'run', '--name', name, '--rm', '-e', 'PROJECT_SRC_PATH', '-e',
+      'OSS_FUZZ_PROJECT_NAME', '-e', 'WORKSPACE', '-e', 'REPOSITORY', '-e',
+      'DRY_RUN', '-e', 'CI', '-e', 'SANITIZER', '-e', 'GIT_SHA', '-e',
+      'FILESTORE', '-e', 'NO_CLUSTERFUZZ_DEPLOYMENT'
+  ]
+  if project_src_path:
+    command += ['-v', f'{project_src_path}:{project_src_path}']
+  command += [
+      '-v', '/var/run/docker.sock:/var/run/docker.sock', '-v',
+      f'{workspace}:{workspace}', f'{BASE_CIFUZZ_DOCKER_TAG}/{name}'
+  ]
+  print('Running docker command:', command)
+  subprocess.run(command, check=True)
+
+
+def docker_build(image):
+  """Builds the CIFuzz |image|. Only suitable for building CIFuzz images."""
+  command = [
+      'docker', 'build', '-t', f'{BASE_CIFUZZ_DOCKER_TAG}/{image}', '--file',
+      f'{image}.Dockerfile', '.'
+  ]
+  subprocess.run(command, check=True, cwd=INFRA_DIR)
+
+
+def main():
+  """Builds and runs fuzzers using CIFuzz."""
+  for env_var, default_value in DEFAULT_ENVS:
+    set_default_env_var_if_unset(env_var, default_value)
+
+  repository = os.getenv('REPOSITORY')
+  assert repository
+
+  project_src_path = os.getenv('PROJECT_SRC_PATH')
+
+  with tempfile.TemporaryDirectory() as temp_dir:
+    if 'WORKSPACE' not in os.environ:
+      os.environ['WORKSPACE'] = temp_dir
+
+    workspace = os.environ['WORKSPACE']
+
+    docker_build('build_fuzzers')
+    docker_run('build_fuzzers', workspace, project_src_path)
+    docker_build('run_fuzzers')
+    try:
+      docker_run('run_fuzzers', workspace, project_src_path)
+    except subprocess.CalledProcessError:
+      logging.error('run_fuzzers failed.')
+      return 1
+    return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/run_fuzzers_entrypoint.py

@@ -0,0 +1,97 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Runs a specific OSS-Fuzz project's fuzzers for CI tools."""
+import logging
+import sys
+
+import config_utils
+import docker
+import logs
+import run_fuzzers
+
+# pylint: disable=c-extension-no-member
+# pylint gets confused because of the relative import of cifuzz.
+
+logs.init()
+
+
+def delete_unneeded_docker_images(config):
+  """Deletes unneeded docker images if running in an environment with low
+  disk space."""
+  if not config.low_disk_space:
+    return
+  logging.info('Deleting builder docker images to save disk space.')
+  project_image = docker.get_project_image_name(config.oss_fuzz_project_name)
+  images = [
+      project_image,
+      docker.BASE_BUILDER_TAG,
+      docker.BASE_BUILDER_TAG + '-go',
+      docker.BASE_BUILDER_TAG + '-javascript',
+      docker.BASE_BUILDER_TAG + '-jvm',
+      docker.BASE_BUILDER_TAG + '-python',
+      docker.BASE_BUILDER_TAG + '-rust',
+      docker.BASE_BUILDER_TAG + '-ruby',
+      docker.BASE_BUILDER_TAG + '-swift',
+  ]
+  docker.delete_images(images)
+
+
+def run_fuzzers_entrypoint():
+  """This is the entrypoint for the run_fuzzers github action.
+  This action can be added to any OSS-Fuzz project's workflow that uses
+  Github."""
+  config = config_utils.RunFuzzersConfig()
+  # The default return code when an error occurs.
+  returncode = 1
+  if config.dry_run:
+    # Sets the default return code on error to success.
+    returncode = 0
+
+  delete_unneeded_docker_images(config)
+  # Run the specified project's fuzzers from the build.
+  result = run_fuzzers.run_fuzzers(config)
+  if result == run_fuzzers.RunFuzzersResult.ERROR:
+    logging.error('Error occurred while running in workspace %s.',
+                  config.workspace)
+    return returncode
+  if result == run_fuzzers.RunFuzzersResult.BUG_FOUND:
+    logging.info('Bug found.')
+    if not config.dry_run:
+      # Return 2 when a bug was found by a fuzzer causing the CI to fail.
+      return 2
+  return 0
+
+
+def main():
+  """Runs project's fuzzers for CI tools.
+  This is the entrypoint for the run_fuzzers github action.
+
+  NOTE: libFuzzer binaries must be located in the $WORKSPACE/build-out
+  directory in order for this action to be used. This action will only fuzz the
+  binaries that are located in that directory. It is recommended that you add
+  the build_fuzzers action preceding this one.
+
+  NOTE: Any crash report will be in the filepath:
+  ${GITHUB_WORKSPACE}/out/testcase
+  This can be used in parallel with the upload-artifact action to surface the
+  logs.
+
+  Returns:
+    0 on success or nonzero on failure.
+  """
+  return run_fuzzers_entrypoint()
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/sarif_utils.py

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

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/test_helpers.py

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

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/workspace_utils.py

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

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/tools/hold_back_images.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Script for pinning builder images for projects that break on upgrades. Works
+with projects that use language builders."""
+import argparse
+import logging
+import os
+import re
+import sys
+import subprocess
+
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+PROJECTS_DIR = os.path.join(ROOT_DIR, 'projects')
+
+IMAGE_DIGEST_REGEX = re.compile(r'\[(.+)\]\n')
+FROM_LINE_REGEX = re.compile(
+    r'FROM (ghcr.io\/aixcc-finals\/base-builder[\-a-z0-9]*)(\@?.*)')
+
+
+def get_latest_docker_image_digest(image):
+  """Returns a pinnable version of the latest |image|. This version will have a
+  SHA."""
+  subprocess.run(['docker', 'pull', image], check=True)
+  subprocess.run(['docker', 'pull', image], stdout=subprocess.PIPE, check=True)
+
+  command = [
+      'docker', 'image', 'inspect', '--format', '{{.RepoDigests}}', image
+  ]
+  output = subprocess.run(command, check=True,
+                          stdout=subprocess.PIPE).stdout.decode('utf-8')
+  return IMAGE_DIGEST_REGEX.match(output).groups(1)[0]
+
+
+def get_args():
+  """Returns parsed arguments."""
+  parser = argparse.ArgumentParser(sys.argv[0],
+                                   description='Hold back builder images.')
+  parser.add_argument('projects', help='Projects.', nargs='+')
+
+  parser.add_argument('--hold-image-digest',
+                      required=False,
+                      nargs='?',
+                      default=None,
+                      help='Image to hold on to.')
+
+  parser.add_argument('--update-held',
+                      action='store_true',
+                      default=False,
+                      help='Update held images.')
+
+  parser.add_argument('--issue-number',
+                      required=False,
+                      nargs='?',
+                      default=None,
+                      help='Issue to reference.')
+
+  args = parser.parse_args()
+  return args
+
+
+def get_hold_image_digest(line, hold_image_digest, update_held):
+  """Returns the image digest for the |line| we want to pin. If the image is
+  already pinned then it is only updated if |update_held. If |hold_image_digest
+  is specified then it is returned, otherwise the latest pinnable version is
+  returned."""
+  matches = FROM_LINE_REGEX.match(line).groups()
+  if matches[1] and not update_held:
+    return None, False
+  initial_image = matches[0]
+  if hold_image_digest:
+    return hold_image_digest, True
+  return get_latest_docker_image_digest(initial_image), True
+
+
+def hold_image(project, hold_image_digest, update_held, issue_number):
+  """Rewrites the Dockerfile of |project| to pin the base-builder image on
+  upgrade."""
+  dockerfile_path = os.path.join(PROJECTS_DIR, project, 'Dockerfile')
+  with open(dockerfile_path, 'r') as dockerfile_handle:
+    dockerfile = dockerfile_handle.readlines()
+  for idx, line in enumerate(dockerfile[:]):
+    if not line.startswith('FROM ghcr.io/aixcc-finals/base-builder'):
+      continue
+
+    hold_image_digest, should_hold = get_hold_image_digest(
+        line.strip(), hold_image_digest, update_held)
+    if not should_hold:
+      logging.error('Not holding back %s.', project)
+      break
+    dockerfile[idx] = f'FROM {hold_image_digest}\n'
+    if issue_number:
+      comment = ('# Held back because of github.com/google/oss-fuzz/pull/'
+                 f'{issue_number}\n# Please fix failure and upgrade.\n')
+      dockerfile.insert(idx, comment)
+    break
+  else:
+    # This path is taken when we don't break out of the loop.
+    assert None, f'Could not find FROM line in {project}'
+  dockerfile = ''.join(dockerfile)
+  with open(dockerfile_path, 'w') as dockerfile_handle:
+    dockerfile_handle.write(dockerfile)
+
+
+def main():
+  """Script for pinning builder images for projects that break on upgrades."""
+  args = get_args()
+  for project in args.projects:
+    hold_image(project, args.hold_image_digest, args.update_held,
+               args.issue_number)
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/tools/vscode-extension/src/commands/cmdBuildFuzzerFromWorkspaceCFLite.ts

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {commandHistory} from '../commandUtils';
+import {setStatusText} from '../utils';
+import {buildFuzzersFromWorkspaceClusterfuzzLite} from '../ossfuzzWrappers';
+
+export async function cmdInputCollectorBuildFuzzersFromWorkspaceCFLite() {
+  // Create an history object
+  const args = new Object({
+    toClean: false,
+  });
+
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.WSBuildFuzzers',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchbuildFuzzersFromWorkspaceClusterfuzzLite,
+  });
+  console.log('L1: ' + commandHistory.length);
+  commandHistory.push(commandObject);
+
+  await cmdDispatchbuildFuzzersFromWorkspaceClusterfuzzLite(args);
+  return true;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function cmdDispatchbuildFuzzersFromWorkspaceClusterfuzzLite(_args: any) {
+  await setStatusText('[CFLite] Building fuzzers: starting');
+  const res = await buildFuzzersFromWorkspaceClusterfuzzLite();
+  if (res) {
+    await setStatusText('[CFLite] Building fuzzers: finished');
+  } else {
+    await setStatusText('[CFLite] Building fuzzers: failed');
+  }
+}

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/tools/vscode-extension/src/commands/cmdTestFuzzer.ts

@@ -0,0 +1,90 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {println} from '../logger';
+import {runFuzzerHandler, buildFuzzersFromWorkspace} from '../ossfuzzWrappers';
+import {setStatusText} from '../utils';
+import {commandHistory} from '../commandUtils';
+import {extensionConfig} from '../config';
+
+/**
+ * Does an end-to-end test of a project/fuzzer. This is done by
+ * first building the project and then running the fuzzer.
+ * @param context
+ * @returns
+ */
+
+export async function cmdInputCollectorTestFuzzer() {
+  setStatusText('Testing specific fuzzer: getting input');
+  // Get the project name and fuzzer name to test.
+  const ossFuzzProjectNameInput = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'The OSS-Fuzz project name',
+  });
+  if (!ossFuzzProjectNameInput) {
+    println('Did not get a ossFuzzTargetProject');
+    return;
+  }
+  println('Project name: ' + ossFuzzProjectNameInput);
+
+  // Get the fuzzer to run
+  const fuzzerNameInput = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'Type a fuzzer name',
+  });
+  if (!fuzzerNameInput) {
+    println('Failed to get fuzzer name');
+    return;
+  }
+
+  // Create the args object for the dispatcher
+  const args = new Object({
+    projectName: ossFuzzProjectNameInput.toString(),
+    fuzzerName: fuzzerNameInput.toString(),
+  });
+
+  // Create a dispatcher object.
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.TestFuzzer',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchTestFuzzerHandler,
+  });
+  commandHistory.push(commandObject);
+
+  await cmdDispatchTestFuzzerHandler(args);
+}
+
+async function cmdDispatchTestFuzzerHandler(args: any) {
+  // Build the project
+  setStatusText('Test specific fuzzer: building fuzzers in workspace');
+  if (!(await buildFuzzersFromWorkspace(args.projectName, '', false))) {
+    println('Build projects');
+    return;
+  }
+
+  // Run the fuzzer for 10 seconds
+  println('Running fuzzer');
+  setStatusText('Test specific fuzzer: running fuzzer ' + args.fuzzerName);
+  await runFuzzerHandler(
+    args.projectName,
+    args.fuzzerName,
+    extensionConfig.numberOfSecondsForTestRuns.toString(),
+    ''
+  );
+  setStatusText('Test specific fuzzer: test completed of ' + args.fuzzerName);
+  return;
+}