Add files using upload-large-folder tool

local-test-tika-delta-04/fuzz-tooling/infra/base-images/README.md

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

local-test-tika-delta-04/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-tika-delta-04/fuzz-tooling/infra/ci/build.py

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

local-test-tika-delta-04/fuzz-tooling/infra/ci/requirements.txt

@@ -0,0 +1,9 @@
+# Requirements for submitting code changes to infra/ (needed by presubmit.py).
+parameterized==0.7.4
+pyfakefs==4.5.6
+pylint==2.5.3
+pytest==7.1.2
+pytest-xdist==2.5.0
+PyYAML==6.0
+requests==2.31.0
+yapf==0.32.0

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/build-images.sh

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

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/build_fuzzers_entrypoint.py

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

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/clusterfuzz_deployment.py

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

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

@@ -0,0 +1,25 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Log helpers."""
+
+import logging
+import os
+
+
+def init():
+  """Initialize logging."""
+  log_level = logging.DEBUG if os.getenv('CIFUZZ_DEBUG') else logging.INFO
+  logging.basicConfig(
+      format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+      level=log_level)

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/sarif_utils.py

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

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/workspace_utils.py

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

local-test-tika-delta-04/fuzz-tooling/infra/tools/hold_back_images.py

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

local-test-tika-delta-04/fuzz-tooling/infra/uploader/Dockerfile

@@ -0,0 +1,7 @@
+from ubuntu:16.04
+
+RUN apt-get update && apt-get upgrade -y
+RUN apt-get install -y curl
+
+ENTRYPOINT ["curl", "--retry", "5", "-X", "PUT", "-T"]
+

local-test-tika-delta-04/fuzz-tooling/tools/vscode-extension/src/commands/cmdBuildFuzzerFromWorkspace.ts

@@ -0,0 +1,80 @@
+// 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 {commandHistory} from '../commandUtils';
+import {
+  hasOssFuzzInWorkspace,
+  getOssFuzzWorkspaceProjectName,
+  setStatusText,
+} from '../utils';
+import {buildFuzzersFromWorkspace} from '../ossfuzzWrappers';
+
+export async function cmdInputCollectorBuildFuzzersFromWorkspace() {
+  let ossFuzzProjectName = '';
+  // First determine if we have a name in the workspace
+  if (await hasOssFuzzInWorkspace()) {
+    /**
+     * The fuzzers are in the workspace, as opposed to e.g. the oss-fuzz dirctory.
+     */
+    ossFuzzProjectName = await getOssFuzzWorkspaceProjectName();
+  } else {
+    // If we did not have that, ask the user.
+
+    const ossFuzzProjectNameInput = await vscode.window.showInputBox({
+      value: '',
+      placeHolder: 'The OSS-Fuzz project name',
+    });
+    if (!ossFuzzProjectNameInput) {
+      println('Did not get a ossFuzzTargetProject');
+      return false;
+    }
+    ossFuzzProjectName = ossFuzzProjectNameInput.toString();
+  }
+
+  // Create an history object
+  const args = new Object({
+    projectName: ossFuzzProjectName,
+    sanitizer: '',
+    toClean: false,
+  });
+
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.WSBuildFuzzers',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchBuildFuzzersFromWorkspace,
+  });
+  console.log('L1: ' + commandHistory.length);
+  commandHistory.push(commandObject);
+
+  await cmdDispatchBuildFuzzersFromWorkspace(args);
+  return true;
+}
+
+async function cmdDispatchBuildFuzzersFromWorkspace(args: any) {
+  await setStatusText('Building fuzzers: starting');
+  const res = await buildFuzzersFromWorkspace(
+    args.projectName,
+    args.sanitizer,
+    args.toClean
+  );
+  if (res) {
+    await setStatusText('Building fuzzers: finished');
+  } else {
+    await setStatusText('Building fuzzers: failed');
+  }
+}

local-test-tika-delta-04/fuzz-tooling/tools/vscode-extension/src/commands/cmdRunFI.ts

@@ -0,0 +1,24 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {runFuzzIntrospector} from '../fuzzIntrospectorHelper';
+
+/**
+ * Function for setting up Fuzz Introspector by way of a Python virtual env.
+ */
+export async function runFuzzIntrospectorHandler() {
+  runFuzzIntrospector();
+}

local-test-tika-delta-04/fuzz-tooling/tools/vscode-extension/src/commands/cmdSetupCIFuzz.ts

@@ -0,0 +1,87 @@
+// 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 {determineWorkspaceLanguage} from '../utils';
+import {cifuzzGenerator} from '../cifuzz';
+
+export async function setupCIFuzzHandler() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return false;
+  }
+
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+
+  /**
+   * Go through GitHub workflows to find potential traces of CIFuzz
+   */
+  const githubWorkflowsPath = vscode.Uri.file(wsPath + '/.github/workflows');
+  try {
+    await vscode.workspace.fs.readDirectory(githubWorkflowsPath);
+  } catch {
+    println('Did not find a workflows path.');
+    return false;
+  }
+
+  for (const [name, type] of await vscode.workspace.fs.readDirectory(
+    githubWorkflowsPath
+  )) {
+    // Skip directories.
+    if (type === 2) {
+      continue;
+    }
+
+    // Read the files.
+    println('Is a file');
+    const workflowFile = vscode.Uri.file(wsPath + '/.github/workflows/' + name);
+    const doc = await vscode.workspace.openTextDocument(workflowFile);
+    if (doc.getText().includes('cifuzz')) {
+      println('Found existing CIFuzz, will not continue.');
+      return false;
+    }
+  }
+
+  println('Did not find CIFuzz, creating one.');
+  const projectName = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'OSS-Fuzz project name',
+  });
+  if (!projectName) {
+    println('Failed to get project name');
+    return false;
+  }
+
+  /*
+   * There is no CIFuzz found, so we create one.
+   */
+  // Determine the language of the workspace.
+  const targetLanguage = await determineWorkspaceLanguage();
+  println('Target language: ' + targetLanguage);
+
+  // Generate a CIFuzz workflow text.
+  const cifuzzWorkflowText = cifuzzGenerator(targetLanguage, projectName, 30);
+
+  // Create the CIFuzz .yml file and write the contents to it to path
+  // .github/workflows/cifuzz.yml
+  const cifuzzYml = vscode.Uri.file(wsPath + '/.github/workflows/cifuzz.yml');
+  const wsedit = new vscode.WorkspaceEdit();
+  wsedit.createFile(cifuzzYml, {ignoreIfExists: true});
+  wsedit.insert(cifuzzYml, new vscode.Position(0, 0), cifuzzWorkflowText);
+  vscode.workspace.applyEdit(wsedit);
+  return true;
+}

local-test-tika-delta-04/fuzz-tooling/tools/vscode-extension/src/commands/cmdTemplate.ts

@@ -0,0 +1,357 @@
+// 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.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Command for generating template fuzzers. This is a short-cut for rapid
+ * prototyping as well as an archive for inspiration.
+ */
+import * as vscode from 'vscode';
+import {println} from '../logger';
+
+export const cLangSimpleStringFuzzer = `#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+int 
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    char *new_str = (char *)malloc(size+1);
+    if (new_str == NULL){
+        return 0;
+    }
+    memcpy(new_str, data, size);
+    new_str[size] = '\\0';
+
+    // Insert fuzzer contents here 
+    // fuzz data in new_str
+
+    // end of fuzzer contents
+
+    free(new_str);
+    return 0;
+}`;
+
+const cLangFileInputFuzzer = `int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+	char filename[256];
+	sprintf(filename, "/tmp/libfuzzer.%d", getpid());
+
+  // Create a file on the filesystem with fuzzer data in it
+	FILE *fp = fopen(filename, "wb");
+	if (!fp) {
+		return 0;
+  }
+	fwrite(data, size, 1, fp);
+	fclose(fp);
+
+	// Fuzzer logic here. Use the file as a source of data.
+
+	// Fuzzer logic end
+
+  // Clean up the file.
+	unlink(filename);
+
+	return 0;
+}`;
+
+const cLangBareTemplateFuzzer = `int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+	return 0;
+}`;
+
+const cppLangBareTemplateFuzzer = `extern "C" int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+	return 0;
+}`;
+
+const cppLangStdStringTemplateFuzzer = `extern "C" int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+  std::string input(reinterpret_cast<const char*>(data), size);
+
+  return 0;
+}`;
+
+export const cppLangFDPTemplateFuzzer = `#include <fuzzer/FuzzedDataProvider.h>
+
+#include <string>
+
+extern "C" int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+  FuzzedDataProvider fdp(data, size);
+
+  // Extract higher level data types used for fuzzing, e.g.
+  // int ran_int = fdp.ConsumeIntegralInRange<int>(1, 1024);
+  // std::string s = fdp.ConsumeRandomLengthString();
+
+  return 0;
+}`;
+
+const cppLangFileInputFuzzer = `extern "C" int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+	char filename[256];
+	sprintf(filename, "/tmp/libfuzzer.%d", getpid());
+
+	FILE *fp = fopen(filename, "wb");
+	if (!fp) {
+		return 0;
+  }
+	fwrite(data, size, 1, fp);
+	fclose(fp);
+
+	// Fuzzer logic here
+
+	// Fuzzer logic end
+
+	unlink(filename);
+}`;
+
+const pythonLangBareTemplate = `import sys
+import atheris
+
+
+def TestOneInput(fuzz_bytes):
+    return
+
+
+def main():
+    atheris.Setup(sys.argv, TestOneInput)
+    atheris.Fuzz()
+
+
+if __name__ == "__main__":
+    main()`;
+
+export const pythonLangFileInputFuzzer = `import sys
+import atheris
+
+@atheris.instrument_func
+def TestOneInput(data):
+  # Write fuzz data to a file
+  with open('/tmp/fuzz_input.b') as f:
+    f.write(data)
+  
+  # Use '/tmp/fuzz_input.b' as input to file handling logic.
+
+  
+def main():
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, TestOneInput)
+  atheris.Fuzz()
+
+
+if __name__ == "__main__":
+  main()`;
+
+const pythonLongFdpTemplate = `import sys
+import atheris
+
+def TestOneInput(fuzz_bytes):
+    fdp = atheris.FuzzedDataProvider(fuzz_bytes)
+    return
+
+def main():
+    atheris.Setup(sys.argv, TestOneInput)
+    atheris.Fuzz()
+
+if __name__ == "__main__":
+    main()`;
+
+export const javaLangBareTemplate = `import com.code_intelligence.jazzer.api.FuzzedDataProvider;
+public class SampleFuzzer {
+  public static void fuzzerTestOneInput(FuzzedDataProvider fdp) {
+    // Use fdp to create arbitrary types seeded with fuzz data
+  }
+}
+`;
+
+/**
+ * C templates
+ */
+async function cTemplates() {
+  let template = '';
+  const result = await vscode.window.showQuickPick(
+    ['Bare template', 'Null-terminated string input', 'File input'],
+    {
+      placeHolder: 'Pick which template',
+    }
+  );
+  vscode.window.showInformationMessage(`Got: ${result}`);
+
+  if (result === 'Null-terminated string input') {
+    template = cLangSimpleStringFuzzer;
+  } else if (result === 'File input') {
+    template = cLangFileInputFuzzer;
+  } else if (result === 'Bare template') {
+    template = cLangBareTemplateFuzzer;
+  } else {
+    template = 'empty';
+  }
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return;
+  }
+
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+
+  const cifuzzYml = vscode.Uri.file(wsPath + '/oss-fuzz-template.c');
+  const wsedit = new vscode.WorkspaceEdit();
+  wsedit.createFile(cifuzzYml, {ignoreIfExists: true});
+  wsedit.insert(cifuzzYml, new vscode.Position(0, 0), template);
+  vscode.workspace.applyEdit(wsedit);
+  return;
+}
+
+/**
+ * CPP templates
+ */
+async function cppTemplates() {
+  let template = '';
+  const result = await vscode.window.showQuickPick(
+    [
+      'Bare template',
+      'Simple CPP string',
+      'File input fuzzer',
+      'Fuzzed data provider',
+    ],
+    {
+      placeHolder: 'Pick which template',
+    }
+  );
+  vscode.window.showInformationMessage(`Got: ${result}`);
+
+  if (result === 'Bare template') {
+    template = cppLangBareTemplateFuzzer;
+  } else if (result === 'Simple CPP string') {
+    template = cppLangStdStringTemplateFuzzer;
+  } else if (result === 'File input fuzzer') {
+    template = cppLangFileInputFuzzer;
+  } else if (result === 'Fuzzed data provider') {
+    template = cppLangFDPTemplateFuzzer;
+  } else {
+    template = 'empty';
+  }
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return;
+  }
+
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+
+  const cifuzzYml = vscode.Uri.file(wsPath + '/oss-fuzz-template.cpp');
+  const wsedit = new vscode.WorkspaceEdit();
+  wsedit.createFile(cifuzzYml, {ignoreIfExists: true});
+  wsedit.insert(cifuzzYml, new vscode.Position(0, 0), template);
+  vscode.workspace.applyEdit(wsedit);
+  return;
+}
+
+/**
+ * Python templates
+ */
+async function pythonTepmlates() {
+  let template = '';
+  const result = await vscode.window.showQuickPick(
+    ['Bare template', 'Fuzzed Data Provider', 'File input fuzzer'],
+    {
+      placeHolder: 'Pick which template',
+    }
+  );
+  vscode.window.showInformationMessage(`Got: ${result}`);
+
+  if (result === 'Fuzzed Data Provider') {
+    template = pythonLongFdpTemplate;
+  } else if (result === 'Bare template') {
+    template = pythonLangBareTemplate;
+  } else if (result === 'File input fuzzer') {
+    template = pythonLangFileInputFuzzer;
+  } else {
+    template = 'empty';
+  }
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return;
+  }
+
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+
+  const cifuzzYml = vscode.Uri.file(wsPath + '/oss-fuzz-template.py');
+  const wsedit = new vscode.WorkspaceEdit();
+  wsedit.createFile(cifuzzYml, {ignoreIfExists: true});
+  wsedit.insert(cifuzzYml, new vscode.Position(0, 0), template);
+  vscode.workspace.applyEdit(wsedit);
+  return;
+}
+
+/**
+ * Java templates
+ */
+async function javaTemplates() {
+  let template = '';
+  const result = await vscode.window.showQuickPick(['Bare template'], {
+    placeHolder: 'Pick which template',
+  });
+  vscode.window.showInformationMessage(`Got: ${result}`);
+
+  if (result === 'Bare template') {
+    template = javaLangBareTemplate;
+  } else {
+    template = 'empty';
+  }
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return;
+  }
+
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+
+  const cifuzzYml = vscode.Uri.file(wsPath + '/oss-fuzz-template.java');
+  const wsedit = new vscode.WorkspaceEdit();
+  wsedit.createFile(cifuzzYml, {ignoreIfExists: true});
+  wsedit.insert(cifuzzYml, new vscode.Position(0, 0), template);
+  vscode.workspace.applyEdit(wsedit);
+  return;
+}
+
+export async function cmdDispatcherTemplate(context: vscode.ExtensionContext) {
+  println('Creating template');
+  const options: {
+    [key: string]: (context: vscode.ExtensionContext) => Promise<void>;
+  } = {
+    C: cTemplates,
+    CPP: cppTemplates,
+    Python: pythonTepmlates,
+    Java: javaTemplates,
+  };
+
+  const quickPick = vscode.window.createQuickPick();
+  quickPick.items = Object.keys(options).map(label => ({label}));
+  quickPick.onDidChangeSelection(selection => {
+    if (selection[0]) {
+      options[selection[0].label](context).catch(console.error);
+    }
+  });
+  quickPick.onDidHide(() => quickPick.dispose());
+  quickPick.placeholder = 'Pick language';
+  quickPick.show();
+
+  return;
+}

local-test-tika-delta-04/fuzz-tooling/tools/vscode-extension/src/commands/cmdTestFuzzerCFLite.ts

@@ -0,0 +1,89 @@
+// 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 path = require('path');
+import * as vscode from 'vscode';
+import {println} from '../logger';
+import {
+  runFuzzerHandlerCFLite,
+  buildFuzzersFromWorkspaceClusterfuzzLite,
+} 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 cmdInputCollectorTestFuzzerCFLite() {
+  setStatusText('Testing specific fuzzer: getting input');
+  // 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({
+    fuzzerName: fuzzerNameInput.toString(),
+  });
+
+  // Create a dispatcher object.
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.TestFuzzerCFLite',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchTestFuzzerHandlerCFLite,
+  });
+  commandHistory.push(commandObject);
+
+  await cmdDispatchTestFuzzerHandlerCFLite(args);
+}
+
+async function cmdDispatchTestFuzzerHandlerCFLite(args: any) {
+  // Build the project
+  setStatusText('Test specific fuzzer: building fuzzers in workspace');
+  if (!(await buildFuzzersFromWorkspaceClusterfuzzLite())) {
+    println('Build projects');
+    return;
+  }
+
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return;
+  }
+
+  const pathOfLocal = workspaceFolder[0].uri.path;
+  println('path of local: ' + pathOfLocal);
+
+  // Run the fuzzer for 10 seconds
+  println('Running fuzzer');
+  setStatusText('Test specific fuzzer: running fuzzer ' + args.fuzzerName);
+  await runFuzzerHandlerCFLite(
+    pathOfLocal,
+    args.fuzzerName,
+    extensionConfig.numberOfSecondsForTestRuns.toString()
+  );
+  setStatusText('Test specific fuzzer: test completed of ' + args.fuzzerName);
+  return;
+}