Add files using upload-large-folder tool

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/actions/build_fuzzers/action.yml

@@ -0,0 +1,55 @@
+# action.yml
+name: 'build-fuzzers'
+description: "Builds an OSS-Fuzz project's fuzzers."
+inputs:
+  oss-fuzz-project-name:
+    description: 'Name of the corresponding OSS-Fuzz project.'
+    required: true
+  language:
+    description: 'Programming language project is written in.'
+    required: false
+    default: 'c++'
+  dry-run:
+    description: 'If set, run the action without actually reporting a failure.'
+    default: false
+  allowed-broken-targets-percentage:
+    description: 'The percentage of broken targets allowed in bad_build_check.'
+    required: false
+  sanitizer:
+    description: 'The sanitizer to build the fuzzers with.'
+    default: 'address'
+  architecture:
+    description: 'The architecture used to build the fuzzers.'
+    default: 'x86_64'
+  project-src-path:
+    description: "The path to the project's source code checkout."
+    required: false
+  bad-build-check:
+    description: "Whether or not OSS-Fuzz's check for bad builds should be done."
+    required: false
+    default: true
+  keep-unaffected-fuzz-targets:
+    description: "Whether to keep unaffected fuzzers or delete them."
+    required: false
+    default: false
+  output-sarif:
+    description: "Whether to output fuzzing results to SARIF."
+    required: false
+    default: false
+runs:
+  using: 'docker'
+  image: '../../../build_fuzzers.Dockerfile'
+  env:
+    OSS_FUZZ_PROJECT_NAME: ${{ inputs.oss-fuzz-project-name }}
+    LANGUAGE: ${{ inputs.language }}
+    DRY_RUN: ${{ inputs.dry-run}}
+    ALLOWED_BROKEN_TARGETS_PERCENTAGE: ${{ inputs.allowed-broken-targets-percentage}}
+    SANITIZER: ${{ inputs.sanitizer }}
+    ARCHITECTURE: ${{ inputs.architecture }}
+    PROJECT_SRC_PATH: ${{ inputs.project-src-path }}
+    LOW_DISK_SPACE: 'True'
+    BAD_BUILD_CHECK: ${{ inputs.bad-build-check }}
+    CIFUZZ_DEBUG: 'True'
+    CFL_PLATFORM: 'github'
+    KEEP_UNAFFECTED_FUZZ_TARGETS: ${{ inputs.keep-unaffected-fuzz-targets }}
+    OUTPUT_SARIF: ${{ inputs.output-sarif }}

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/cifuzz-base/Dockerfile

@@ -0,0 +1,44 @@
+# 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.
+#
+################################################################################
+
+FROM ghcr.io/aixcc-finals/base-runner
+
+RUN apt-get update && \
+    apt-get install -y systemd && \
+    wget https://download.docker.com/linux/ubuntu/dists/focal/pool/stable/amd64/docker-ce-cli_20.10.8~3-0~ubuntu-focal_amd64.deb -O /tmp/docker-ce.deb && \
+    dpkg -i /tmp/docker-ce.deb && \
+    rm /tmp/docker-ce.deb
+
+ENV PATH=/opt/gcloud/google-cloud-sdk/bin/:$PATH
+ENV OSS_FUZZ_ROOT=/opt/oss-fuzz
+
+# Do this step before copying to make rebuilding faster when developing.
+COPY ./infra/cifuzz/requirements.txt /tmp/requirements.txt
+RUN python3 -m pip install -r /tmp/requirements.txt && rm /tmp/requirements.txt
+
+ADD . ${OSS_FUZZ_ROOT}
+# Don't use the default npm location since jazzer.js can break us.
+# This means javascript needed by cifuzz/clusterfuzzlite must be executed in
+# OSS_FUZZ_ROOT.
+RUN cd ${OSS_FUZZ_ROOT} && npm install ${OSS_FUZZ_ROOT}/infra/cifuzz
+
+
+ENV PYTHONUNBUFFERED=1
+
+# Python file to execute when the docker container starts up.
+# We can't use the env var $OSS_FUZZ_ROOT here. Since it's a constant env var,
+# just expand to '/opt/oss-fuzz'.
+ENTRYPOINT ["python3", "/opt/oss-fuzz/infra/cifuzz/cifuzz_combined_entrypoint.py"]

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/filestore/filesystem/__init__.py

@@ -0,0 +1,107 @@
+# 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.
+"""Filestore implementation using a filesystem directory."""
+import logging
+import os
+import shutil
+import subprocess
+import sys
+
+from distutils import dir_util
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(
+    os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir,
+                 os.pardir, os.pardir))
+import filestore
+
+
+def recursive_list_dir(directory):
+  """Returns list of all files in |directory|, including those in
+  subdirectories."""
+  files = []
+  for root, _, filenames in os.walk(directory):
+    for filename in filenames:
+      files.append(os.path.join(root, filename))
+  return files
+
+
+class FilesystemFilestore(filestore.BaseFilestore):
+  """Filesystem implementation using a filesystem directory."""
+  BUILD_DIR = 'build'
+  CRASHES_DIR = 'crashes'
+  CORPUS_DIR = 'corpus'
+  COVERAGE_DIR = 'coverage'
+
+  def __init__(self, config):
+    super().__init__(config)
+    self._filestore_root_dir = self.config.platform_conf.filestore_root_dir
+
+  def _get_filestore_path(self, name, prefix_dir):
+    """Returns the filesystem path in the filestore for |name| and
+    |prefix_dir|."""
+    return os.path.join(self._filestore_root_dir, prefix_dir, name)
+
+  def _upload_directory(self, name, directory, prefix, delete=False):
+    filestore_path = self._get_filestore_path(name, prefix)
+    if os.path.exists(filestore_path):
+      initial_files = set(recursive_list_dir(filestore_path))
+    else:
+      initial_files = set()
+
+    # Make directory and any parents.
+    os.makedirs(filestore_path, exist_ok=True)
+    copied_files = set(dir_util.copy_tree(directory, filestore_path))
+    if not delete:
+      return True
+
+    files_to_delete = initial_files - copied_files
+    for file_path in files_to_delete:
+      os.remove(file_path)
+    return True
+
+  def _download_directory(self, name, dst_directory, prefix):
+    filestore_path = self._get_filestore_path(name, prefix)
+    return dir_util.copy_tree(filestore_path, dst_directory)
+
+  def upload_crashes(self, name, directory):
+    """Uploads the crashes at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.CRASHES_DIR)
+
+  def upload_corpus(self, name, directory, replace=False):
+    """Uploads the crashes at |directory| to |name|."""
+    return self._upload_directory(name,
+                                  directory,
+                                  self.CORPUS_DIR,
+                                  delete=replace)
+
+  def upload_build(self, name, directory):
+    """Uploads the build located at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.BUILD_DIR)
+
+  def upload_coverage(self, name, directory):
+    """Uploads the coverage report at |directory| to |name|."""
+    return self._upload_directory(name, directory, self.COVERAGE_DIR)
+
+  def download_corpus(self, name, dst_directory):
+    """Downloads the corpus located at |name| to |dst_directory|."""
+    return self._download_directory(name, dst_directory, self.CORPUS_DIR)
+
+  def download_build(self, name, dst_directory):
+    """Downloads the build with |name| to |dst_directory|."""
+    return self._download_directory(name, dst_directory, self.BUILD_DIR)
+
+  def download_coverage(self, name, dst_directory):
+    """Downloads the latest project coverage report."""
+    return self._download_directory(name, dst_directory, self.COVERAGE_DIR)

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/filestore/github_actions/__init__.py

@@ -0,0 +1,179 @@
+# 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.
+"""Implementation of a filestore using Github actions artifacts."""
+import logging
+import os
+import shutil
+import sys
+import tarfile
+import tempfile
+
+# pylint: disable=wrong-import-position,import-error
+INFRA_DIR = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir,
+                 os.path.pardir))
+sys.path.append(INFRA_DIR)
+OSS_FUZZ_ROOT_DIR = os.path.dirname(INFRA_DIR)
+
+import utils
+import http_utils
+import filestore
+from filestore.github_actions import github_api
+
+UPLOAD_JS = os.path.join(os.path.dirname(__file__), 'upload.js')
+
+
+def tar_directory(directory, archive_path):
+  """Tars a |directory| and stores archive at |archive_path|. |archive_path|
+  must end in .tar"""
+  assert archive_path.endswith('.tar')
+  # Do this because make_archive will append the extension to archive_path.
+  archive_path = os.path.splitext(archive_path)[0]
+
+  root_directory = os.path.abspath(directory)
+  shutil.make_archive(archive_path,
+                      'tar',
+                      root_dir=root_directory,
+                      base_dir='./')
+
+
+class GithubActionsFilestore(filestore.BaseFilestore):
+  """Implementation of BaseFilestore using Github actions artifacts. Relies on
+  github_actions_toolkit for using the GitHub actions API and the github_api
+  module for using GitHub's standard API. We need to use both because the GitHub
+  actions API is the only way to upload an artifact but it does not support
+  downloading artifacts from other runs. The standard GitHub API does support
+  this however."""
+
+  ARTIFACT_PREFIX = 'cifuzz-'
+  BUILD_PREFIX = 'build-'
+  CRASHES_PREFIX = 'crashes-'
+  CORPUS_PREFIX = 'corpus-'
+  COVERAGE_PREFIX = 'coverage-'
+
+  def __init__(self, config):
+    super().__init__(config)
+    self.github_api_http_headers = github_api.get_http_auth_headers(config)
+
+  def _get_artifact_name(self, name):
+    """Returns |name| prefixed with |self.ARITFACT_PREFIX| if it isn't already
+    prefixed. Otherwise returns |name|."""
+    if name.startswith(self.ARTIFACT_PREFIX):
+      return name
+    return f'{self.ARTIFACT_PREFIX}{name}'
+
+  def _upload_directory(self, name, directory):  # pylint: disable=no-self-use
+    """Uploads |directory| as artifact with |name|."""
+    name = self._get_artifact_name(name)
+    with tempfile.TemporaryDirectory() as temp_dir:
+      archive_path = os.path.join(temp_dir, name + '.tar')
+      tar_directory(directory, archive_path)
+      _raw_upload_directory(name, temp_dir)
+
+  def upload_crashes(self, name, directory):
+    """Uploads the crashes at |directory| to |name|."""
+    return _raw_upload_directory(self.CRASHES_PREFIX + name, directory)
+
+  def upload_corpus(self, name, directory, replace=False):
+    """Uploads the corpus at |directory| to |name|."""
+    # Not applicable as the the entire corpus is uploaded under a single
+    # artifact name.
+    del replace
+    return self._upload_directory(self.CORPUS_PREFIX + name, directory)
+
+  def upload_build(self, name, directory):
+    """Uploads the build at |directory| to |name|."""
+    return self._upload_directory(self.BUILD_PREFIX + name, directory)
+
+  def upload_coverage(self, name, directory):
+    """Uploads the coverage report at |directory| to |name|."""
+    return self._upload_directory(self.COVERAGE_PREFIX + name, directory)
+
+  def download_corpus(self, name, dst_directory):  # pylint: disable=unused-argument,no-self-use
+    """Downloads the corpus located at |name| to |dst_directory|."""
+    return self._download_artifact(self.CORPUS_PREFIX + name, dst_directory)
+
+  def _find_artifact(self, name):
+    """Finds an artifact using the GitHub API and returns it."""
+    logging.debug('Listing artifacts.')
+    artifacts = self._list_artifacts()
+    artifact = github_api.find_artifact(name, artifacts)
+    logging.debug('Artifact: %s.', artifact)
+    return artifact
+
+  def _download_artifact(self, name, dst_directory):
+    """Downloads artifact with |name| to |dst_directory|. Returns True on
+    success."""
+    name = self._get_artifact_name(name)
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+      if not self._raw_download_artifact(name, temp_dir):
+        logging.warning('Could not download artifact: %s.', name)
+        return False
+
+      artifact_tarfile_path = os.path.join(temp_dir, name + '.tar')
+      if not os.path.exists(artifact_tarfile_path):
+        logging.error('Artifact zip did not contain a tarfile.')
+        return False
+
+      # TODO(jonathanmetzman): Replace this with archive.unpack from
+      # libClusterFuzz so we can avoid path traversal issues.
+      with tarfile.TarFile(artifact_tarfile_path) as artifact_tarfile:
+        artifact_tarfile.extractall(dst_directory)
+    return True
+
+  def _raw_download_artifact(self, name, dst_directory):
+    """Downloads the artifact with |name| to |dst_directory|. Returns True on
+    success. Does not do any untarring or adding prefix to |name|."""
+    artifact = self._find_artifact(name)
+    if not artifact:
+      logging.warning('Could not find artifact: %s.', name)
+      return False
+    download_url = artifact['archive_download_url']
+    return http_utils.download_and_unpack_zip(
+        download_url, dst_directory, headers=self.github_api_http_headers)
+
+  def _list_artifacts(self):
+    """Returns a list of artifacts."""
+    return github_api.list_artifacts(self.config.project_repo_owner,
+                                     self.config.project_repo_name,
+                                     self.github_api_http_headers)
+
+  def download_build(self, name, dst_directory):
+    """Downloads the build with name |name| to |dst_directory|."""
+    return self._download_artifact(self.BUILD_PREFIX + name, dst_directory)
+
+  def download_coverage(self, name, dst_directory):
+    """Downloads the latest project coverage report."""
+    return self._download_artifact(self.COVERAGE_PREFIX + name, dst_directory)
+
+
+def _upload_artifact_with_upload_js(name, artifact_paths, directory):
+  """Uploads the artifacts in |artifact_paths| that are located in |directory|
+  to |name|, using the upload.js script."""
+  command = [UPLOAD_JS, name, directory] + artifact_paths
+  _, _, retcode = utils.execute(command, location=OSS_FUZZ_ROOT_DIR)
+  return retcode == 0
+
+
+def _raw_upload_directory(name, directory):
+  """Uploads the artifacts located in |directory| to |name|. Does not do any
+  tarring or adding prefixes to |name|."""
+  # Get file paths.
+  artifact_paths = []
+  for root, _, curr_file_paths in os.walk(directory):
+    for file_path in curr_file_paths:
+      artifact_paths.append(os.path.join(root, file_path))
+  logging.debug('Artifact paths: %s.', artifact_paths)
+  return _upload_artifact_with_upload_js(name, artifact_paths, directory)

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/filestore/github_actions/github_api_test.py

@@ -0,0 +1,41 @@
+# 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 github_api."""
+import os
+import sys
+import unittest
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(
+    os.path.abspath(
+        os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir,
+                     os.path.pardir)))
+
+from filestore.github_actions import github_api
+import test_helpers
+
+
+class GetHttpAuthHeaders(unittest.TestCase):
+  """Tests for get_http_auth_headers."""
+
+  def test_get_http_auth_headers(self):
+    """Tests that get_http_auth_headers returns the correct result."""
+    token = 'example githubtoken'
+    run_config = test_helpers.create_run_config(token=token)
+    expected_headers = {
+        'Authorization': f'token {token}',
+        'Accept': 'application/vnd.github.v3+json',
+    }
+    self.assertEqual(expected_headers,
+                     github_api.get_http_auth_headers(run_config))

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/filestore/github_actions/upload.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// 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 uploading an artifact. Returns 0 on success.
+// Usage: upload.js <artifactName> <rootDirectory> <file 1>...<file N>
+
+const fs = require('fs');
+const { DefaultArtifactClient } = require('@actions/artifact');
+
+const artifactClient = new DefaultArtifactClient();
+const artifactName = process.argv[2];
+const rootDirectory = process.argv[3]
+const files = process.argv.slice(4);
+const options = {
+    continueOnError: true
+};
+
+async function uploadArtifact() {
+    try {
+        const uploadResult = await artifactClient.uploadArtifact(artifactName, files, rootDirectory, options);
+        console.log(uploadResult);
+        if (uploadResult.failedItems.length > 0) {
+            return 1;
+        }
+        return 0;
+    } catch (error) {
+        console.error('Error uploading artifact:', error);
+        return 1;
+    }
+}
+
+uploadArtifact().then(exitCode => {
+    process.exit(exitCode);
+});

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

@@ -0,0 +1,124 @@
+# 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 getting the configuration CIFuzz needs to run."""
+import logging
+import os
+
+import environment
+
+
+class BasePlatformConfig:
+  """Base class for PlatformConfig subclasses."""
+
+  @property
+  def project_src_path(self):
+    """Returns the manually checked out path of the project's source if
+    specified or None."""
+    path = os.getenv('PROJECT_SRC_PATH')
+    if not path:
+      logging.debug('No PROJECT_SRC_PATH.')
+      return path
+
+    logging.debug('PROJECT_SRC_PATH: %s.', path)
+    return path
+
+  @property
+  def workspace(self):
+    """Returns the workspace."""
+    return os.getenv('WORKSPACE')
+
+  # Optional config variables.
+
+  @property
+  def git_sha(self):
+    """Returns the Git SHA to checkout and fuzz. This is used only by GitHub
+    projects when commit fuzzing. It is not used when PR fuzzing. It is
+    definitely needed by OSS-Fuzz on GitHub since they have no copy of the repo
+    on the host and the repo on the builder image is a clone from main/master.
+    Right now it is needed by external on GitHub because we need to clone a new
+    repo because the copy they give us doesn't work for diffing.
+
+    TODO(metzman): Try to eliminate the need for this by 1. Making the clone
+    from external github projects usable. 2. Forcing OSS-Fuzz on Github to clone
+    before starting CIFuzz."""
+    return None
+
+  @property
+  def base_commit(self):
+    """Returns the base commit to diff against (commit fuzzing)."""
+    # TODO(metzman) Rename base_commit to git_base_commit.
+    return os.getenv('GIT_BASE_COMMIT')
+
+  @property
+  def base_ref(self):
+    """Returns the base branch to diff against (pr fuzzing)."""
+    # TODO(metzman) Rename base_ref to git_base_ref.
+    return os.getenv('GIT_BASE_REF')
+
+  @property
+  def pr_ref(self):
+    """Returns the pull request to checkout and fuzz. This is used only by
+    GitHub projects when PR fuzzing. It is not used when commit fuzzing. It is
+    definitely needed by OSS-Fuzz on GitHub since they have no copy of the repo
+    on the host and the repo on the builder image is a clone from main/master.
+    Right now it is needed by external on GitHub because we need to clone a new
+    repo because the copy they give us doesn't work for diffing.
+
+    TODO(metzman): Try to eliminate the need for this by 1. Making the clone
+    from external github projects usable. 2. Forcing OSS-Fuzz on Github to clone
+    before starting CIFuzz."""
+    return None
+
+  @property
+  def project_repo_owner(self):
+    """Returns the project repo owner (githubism)."""
+    return None
+
+  @property
+  def project_repo_name(self):
+    """Returns the project repo name."""
+    return os.environ.get('REPOSITORY')
+
+  @property
+  def actor(self):
+    """Name of the actor for the CI."""
+    return None
+
+  @property
+  def token(self):
+    """Returns the CI API token."""
+    return None
+
+  @property
+  def docker_in_docker(self):
+    """Returns whether or not CFL is running using Docker in Docker."""
+    return environment.get_bool('DOCKER_IN_DOCKER', False)
+
+  @property
+  def filestore(self):
+    """Returns the filestore used to store persistent data."""
+    return os.environ.get('FILESTORE')
+
+  @property
+  def git_url(self):
+    """Returns the repo URL. This is only used by GitHub users. Right now it is
+    needed by external on GitHub because we need to clone a new repo because the
+    copy they give us doesn't work for diffing. It isn't used by OSS-Fuzz on
+    github users since the Git URL is determined using repo detection.
+
+    TODO(metzman): Try to eliminate the need for this by making the clone
+    from external github projects usable.
+    TODO(metzman): As an easier goal, maybe make OSS-Fuzz GitHub use this too
+    for: 1. Consistency 2. Maybe it will allow use on forks."""
+    return None

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

@@ -0,0 +1,40 @@
+# 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 getting the configuration CIFuzz needs to run on Github."""
+import logging
+import os
+
+import platform_config
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+  """CI environment for Google Cloud Build."""
+
+  @property
+  def project_src_path(self):
+    """Returns the manually checked out path of the project's source if
+    specified or the default."""
+    project_src_path = os.getenv('PROJECT_SRC_PATH', '/workspace')
+    logging.debug('PROJECT_SRC_PATH: %s.', project_src_path)
+    return project_src_path
+
+  @property
+  def workspace(self):
+    """Returns the workspace."""
+    return os.getenv('WORKSPACE', '/builder/home')
+
+  @property
+  def filestore(self):
+    """Returns the filestore used to store persistent data."""
+    return os.environ.get('FILESTORE', 'gsutil')

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

@@ -0,0 +1,146 @@
+# 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 getting the configuration CIFuzz needs to run on Github."""
+import json
+import logging
+import os
+
+import platform_config
+
+
+def _get_github_event_path():
+  return os.getenv('GITHUB_EVENT_PATH')
+
+
+def _get_event_data():
+  """Returns the GitHub event data."""
+  github_event_path = _get_github_event_path()
+  with open(github_event_path, encoding='utf-8') as file_handle:
+    return json.load(file_handle)
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+  """CI environment for GitHub."""
+
+  def __init__(self):
+    self._event_data = _get_event_data()
+    self._event = os.getenv('GITHUB_EVENT_NAME')
+
+  @property
+  def workspace(self):
+    """Returns the workspace."""
+    return os.getenv('GITHUB_WORKSPACE')
+
+  @property
+  def git_sha(self):
+    """Returns the Git SHA to checkout and fuzz. This is used only by GitHub
+    projects when commit fuzzing. It is not used when PR fuzzing. It is
+    definitely needed by OSS-Fuzz on GitHub since they have no copy of the repo
+    on the host and the repo on the builder image is a clone from main/master.
+    Right now it is needed by external on GitHub because we need to clone a new
+    repo because the copy they give us doesn't work for diffing.
+
+    TODO(metzman): Try to eliminate the need for this by 1. Making the clone
+    from external github projects usable. 2. Forcing OSS-Fuzz on Github to clone
+    before starting CIFuzz."""
+    return os.getenv('GITHUB_SHA')
+
+  @property
+  def actor(self):
+    """Name of the actor for the CI."""
+    return os.getenv('GITHUB_ACTOR')
+
+  @property
+  def token(self):
+    """Returns the CI API token."""
+    return os.getenv('GITHUB_TOKEN')
+
+  @property
+  def project_src_path(self):
+    """Returns the manually checked out path of the project's source if
+    specified or None. The path returned is relative to |self.workspace| since
+    on github the checkout will be relative to there."""
+    project_src_path = super().project_src_path
+    if project_src_path is None:
+      # Not set for internal GitHub users.
+      return project_src_path
+    # On GitHub (external users), this path is relative to |workspace|.
+    return os.path.join(self.workspace, project_src_path)
+
+  @property
+  def _project_repo_owner_and_name(self):
+    """Returns a tuple containing the project repo owner and the name of the
+    repo."""
+    # On GitHub this includes owner and repo name.
+    repository = os.getenv('GITHUB_REPOSITORY')
+    # Use os.path.split to split owner from repo.
+    return os.path.split(repository)
+
+  @property
+  def project_repo_owner(self):
+    """Returns the project repo owner (githubism)."""
+    return self._project_repo_owner_and_name[0]
+
+  @property
+  def project_repo_name(self):
+    """Returns the project repo name."""
+    return self._project_repo_owner_and_name[1]
+
+  @property
+  def git_url(self):
+    """Returns the repo URL. This is only used by GitHub users. Right now it is
+    needed by external on GitHub because we need to clone a new repo because the
+    copy they give us doesn't work for diffing. It isn't used by OSS-Fuzz on
+    github users since the Git URL is determined using repo detection.
+
+    TODO(metzman): Try to eliminate the need for this by making the clone
+    from external github projects usable.
+    TODO(metzman): As an easier goal, maybe make OSS-Fuzz GitHub use this too
+    for: 1. Consistency 2. Maybe it will allow use on forks."""
+    repository = os.getenv('GITHUB_REPOSITORY')
+    github_server_url = os.getenv('GITHUB_SERVER_URL', 'https://github.com')
+    # TODO(metzman): Probably need to change this to github.server_url.
+    return os.path.join(github_server_url, repository)
+
+  @property
+  def base_commit(self):
+    """Returns the base commit to diff against (commit fuzzing)."""
+    base_commit = None
+    if self._event == 'push':
+      base_commit = self._event_data['before']
+    logging.debug('base_commit: %s', base_commit)
+    return base_commit
+
+  @property
+  def pr_ref(self):
+    """Returns the pull request to checkout and fuzz. This is used only by
+    GitHub projects when PR fuzzing. It is not used when commit fuzzing. It is
+    definitely needed by OSS-Fuzz on GitHub since they have no copy of the repo
+    on the host and the repo on the builder image is a clone from main/master.
+    Right now it is needed by external on GitHub because we need to clone a new
+    repo because the copy they give us doesn't work for diffing.
+
+    TODO(metzman): Try to eliminate the need for this by 1. Making the clone
+    from external github projects usable. 2. Forcing OSS-Fuzz on Github to clone
+    before starting CIFuzz."""
+    if self._event == 'pull_request':
+      pr_ref = f'refs/pull/{self._event_data["pull_request"]["number"]}/merge'
+      logging.debug('pr_ref: %s', pr_ref)
+      return pr_ref
+    return None
+
+  @property
+  def base_ref(self):
+    """Returns the base branch to diff against (pr fuzzing)."""
+    return os.getenv('GITHUB_BASE_REF')

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

@@ -0,0 +1,78 @@
+# 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.
+"""Module for getting the configuration CIFuzz needs to run on GitLab."""
+import logging
+import os
+
+import environment
+import platform_config
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+  """CI environment for GitLab."""
+
+  @property
+  def workspace(self):
+    """Returns the workspace."""
+    return os.path.join(os.getenv('CI_BUILDS_DIR'), os.getenv('CI_JOB_ID'))
+
+  @property
+  def git_sha(self):
+    """Returns the Git SHA to checkout and fuzz."""
+    return os.getenv('CI_COMMIT_SHA')
+
+  @property
+  def project_src_path(self):
+    """Returns the directory with the source of the project"""
+    return os.getenv('CI_PROJECT_DIR')
+
+  @property
+  def token(self):
+    """Returns the job token"""
+    return os.getenv('CI_JOB_TOKEN')
+
+  @property
+  def project_repo_name(self):
+    """Returns the project's name"""
+    return os.getenv('CI_PROJECT_NAME')
+
+  @property
+  def base_commit(self):
+    """Returns the previous commit sha for commit-fuzzing"""
+    base_commit = None
+    if os.getenv('CI_PIPELINE_SOURCE') == 'push':
+      base_commit = os.getenv('CI_COMMIT_BEFORE_SHA')
+    logging.debug('base_commit: %s.', base_commit)
+    return base_commit
+
+  @property
+  def base_ref(self):
+    """Returns the base commit sha for a merge request"""
+    # Could also be CI_MERGE_REQUEST_TARGET_BRANCH_NAME.
+    return os.getenv('CI_MERGE_REQUEST_DIFF_BASE_SHA')
+
+  @property
+  def filestore(self):
+    """Returns the filestore used to store persistent data."""
+    return os.environ.get('FILESTORE', 'gitlab')
+
+  @property
+  def artifacts_dir(self):
+    """Gitlab: returns the directory to put artifacts"""
+    return environment.get('CFL_ARTIFACTS_DIR', 'artifacts')
+
+  @property
+  def cache_dir(self):
+    """Gitlab: returns the directory to use as cache"""
+    return environment.get('CFL_CACHE_DIR', 'cache')

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

@@ -0,0 +1,82 @@
+# 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 platform_config."""
+import os
+import unittest
+
+import platform_config
+import test_helpers
+
+
+class GetProjectRepoOwnerAndNameTest(unittest.TestCase):
+  """Tests for get_project_repo_owner and get_project_repo_name."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+    self.repo_owner = 'repo-owner'
+    self.repo_name = 'repo-name'
+    self.env = platform_config.BasePlatformConfig()
+
+  def test_unset_repository(self):
+    """Tests that the correct result is returned when repository is not set."""
+    self.assertIsNone(self.env.project_repo_name)
+
+  def test_owner(self):
+    """Tests that the correct result is returned for owner."""
+    self.assertIsNone(self.env.project_repo_owner)
+
+  def test_empty_repository(self):
+    """Tests that the correct result is returned when repository is an empty
+    string."""
+    os.environ['REPOSITORY'] = ''
+    self.assertEqual(self.env.project_repo_name, '')
+
+  def test_repository(self):
+    """Tests that the correct result is returned when repository contains the
+    just the repo name (as it does outside of GitHub)."""
+    os.environ['REPOSITORY'] = self.repo_name
+    self.assertEqual(self.env.project_repo_name, self.repo_name)
+
+
+class ProjectSrcPathTest(unittest.TestCase):
+  """Tests for project_src_path."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+
+  def test_not_github(self):
+    """Tests that project_src_path returns the correct result not on
+    GitHub."""
+    project_src_path = 'project-src'
+    os.environ['PROJECT_SRC_PATH'] = project_src_path
+    generic_ci_env = platform_config.BasePlatformConfig()
+    self.assertEqual(generic_ci_env.project_src_path, project_src_path)
+
+
+class GetGitUrlTest(unittest.TestCase):
+  """Tests for BasePlatformConfig.git_url."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+    self.env = platform_config.BasePlatformConfig()
+
+  def test_unset_repository(self):
+    """Tests that the correct result is returned when repository is not set."""
+    self.assertEqual(self.env.git_url, None)
+
+  def test_repository(self):
+    """Tests that the correct result is returned when GITHUB_REPOSITORY is
+    set."""
+    os.environ['GITHUB_REPOSITORY'] = 'repo/owner'
+    self.assertIsNone(self.env.git_url)

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

@@ -0,0 +1,64 @@
+# 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 getting the configuration CIFuzz needs to run on prow."""
+import logging
+import os
+
+import platform_config
+
+# pylint: disable=too-few-public-methods
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+  """CI environment for Prow."""
+
+  @property
+  def project_src_path(self):
+    """Returns the manually checked out path of the project's source if
+    specified or the current directory if not. Prow will run ClusterfuzzLite
+    at the directory head for the repo."""
+    project_src_path = os.getenv('PROJECT_SRC_PATH', os.getcwd())
+    logging.debug('PROJECT_SRC_PATH: %s.', project_src_path)
+    return project_src_path
+
+  @property
+  def workspace(self):
+    """Returns the workspace."""
+    # Let Prow user override workspace, but default to using artifacts dir
+    return os.getenv('WORKSPACE', os.getenv('ARTIFACTS'))
+
+  @property
+  def base_ref(self):
+    """Returns the base branch to diff against (pr fuzzing)."""
+    return os.getenv('PULL_BASE_REF')
+
+  @property
+  def project_repo_name(self):
+    """Returns the project repo name."""
+    return os.getenv('REPO_NAME')
+
+  @property
+  def base_commit(self):
+    """Returns the base commit to diff against (commit fuzzing)."""
+    return os.getenv('PULL_BASE_SHA')
+
+  @property
+  def docker_in_docker(self):
+    """Returns True if using Docker in Docker."""
+    return True
+
+  @property
+  def filestore(self):
+    """Returns the filestore used to store persistent data."""
+    return os.environ.get('FILESTORE', 'gsutil')

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

@@ -0,0 +1,33 @@
+# 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.
+"""Module for getting the configuration CIFuzz needs to run standalone."""
+import os
+
+import platform_config
+
+# pylint: disable=too-few-public-methods
+
+
+class PlatformConfig(platform_config.BasePlatformConfig):
+  """CI environment for Standalone."""
+
+  @property
+  def filestore(self):
+    """Returns the filestore used to store persistent data."""
+    return os.environ.get('FILESTORE', 'filesystem')
+
+  @property
+  def filestore_root_dir(self):
+    """Returns the filestore used to store persistent data."""
+    return os.environ['FILESTORE_ROOT_DIR']

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/test_data/msan_crash_fuzzer_bug_summary.txt

@@ -0,0 +1,22 @@
+MemorySanitizer: use-of-uninitialized-value
+#0 0x52675f in LLVMFuzzerTestOneInput /src/cifuzz-example/do_stuff_fuzzer.cpp:13:7
+#1 0x45a431 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:599:15
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+#7 0x41eab8 in _start (out/do_stuff_fuzzer+0x41eab8)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&)
+Uninitialized value was created by a heap allocation
+#0 0x4d57ad in malloc /src/llvm-project/compiler-rt/lib/msan/msan_interceptors.cpp:901:3
+#1 0x437c07 in operator new(unsigned long) (out/do_stuff_fuzzer+0x437c07)
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+DEDUP_TOKEN: malloc--operator new(unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&)
+
+SUMMARY:

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/test_data/msan_crash_fuzzer_output.txt

@@ -0,0 +1,39 @@
+Dictionary: 3 entries
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 1 modules   (184 inline 8-bit counters): 184 [0x829300, 0x8293b8), 
+INFO: Loaded 1 PC tables (184 PCs): 184 [0x5dc910,0x5dd490), 
+INFO:        5 files found in /tmp/do_stuff_fuzzer_corpus
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
+==13==WARNING: MemorySanitizer: use-of-uninitialized-value
+#0 0x52675f in LLVMFuzzerTestOneInput /src/cifuzz-example/do_stuff_fuzzer.cpp:13:7
+#1 0x45a431 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:599:15
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+#7 0x41eab8 in _start (out/do_stuff_fuzzer+0x41eab8)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&)
+Uninitialized value was created by a heap allocation
+#0 0x4d57ad in malloc /src/llvm-project/compiler-rt/lib/msan/msan_interceptors.cpp:901:3
+#1 0x437c07 in operator new(unsigned long) (out/do_stuff_fuzzer+0x437c07)
+#2 0x45ba46 in fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:792:3
+#3 0x45bed9 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:845:3
+#4 0x44a4bc in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:906:6
+#5 0x474432 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+#6 0x7eff5562683f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2083f)
+DEDUP_TOKEN: malloc--operator new(unsigned long)--fuzzer::Fuzzer::ReadAndExecuteSeedCorpora(std::__Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&)
+
+SUMMARY: MemorySanitizer: use-of-uninitialized-value /src/cifuzz-example/do_stuff_fuzzer.cpp:13:7 in LLVMFuzzerTestOneInput
+Unique heap origins: 65
+Stack depot allocated bytes: 4424
+Unique origin histories: 29
+History depot allocated bytes: 696
+Exiting
+MS: 0 ; base unit: 0000000000000000000000000000000000000000
+
+
+artifact_prefix='./'; Test unit written to ./crash-da39a3ee5e6b4b0d3255bfef95601890afd80709
+Base64: 

local-test-tika-delta-04/fuzz-tooling/infra/cifuzz/test_data/sarif_utils_msan_stack.txt

@@ -0,0 +1,62 @@
+Dictionary: 3 entries
+2024-05-07 18:49:02,343 - root - INFO - Fuzzer: do_stuff_fuzzer. Detected bug.
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 1337
+INFO: Loaded 1 modules   (83 inline 8-bit counters): 83 [0x563ff0e03e98, 0x563ff0e03eeb), 
+INFO: Loaded 1 PC tables (83 PCs): 83 [0x563ff0e03ef0,0x563ff0e04420), 
+INFO:        0 files found in /github/workspace/cifuzz-corpus/do_stuff_fuzzer
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
+INFO: A corpus is not provided, starting from an empty corpus
+#2	INITED cov: 2 ft: 2 corp: 1/1b exec/s: 0 rss: 69Mb
+#4	NEW    cov: 3 ft: 3 corp: 2/3b lim: 4096 exec/s: 0 rss: 69Mb L: 2/2 MS: 2 ChangeBit-InsertByte-
+==23==WARNING: MemorySanitizer: use-of-uninitialized-value
+    #0 0x563ff0d278f0 in LLVMFuzzerTestOneInput /src/cifuzz-external-example/do_stuff_fuzzer.cpp:24:1
+    #1 0x563ff0c24340 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:614:13
+    #2 0x563ff0c23b65 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:516:7
+    #3 0x563ff0c25335 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:760:19
+    #4 0x563ff0c26125 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile>>&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:905:5
+    #5 0x563ff0c14436 in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:914:6
+    #6 0x563ff0c40962 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+    #7 0x7f4c156ed082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 87b331c034a6458c64ce09c03939e947212e18ce)
+    #8 0x563ff0c055ad in _start (build-out/do_stuff_fuzzer+0x4a5ad)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*)
+  Uninitialized value was stored to memory at
+    #0 0x563ff0d278e9 in LLVMFuzzerTestOneInput /src/cifuzz-external-example/do_stuff_fuzzer.cpp
+    #1 0x563ff0c24340 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:614:13
+    #2 0x563ff0c23b65 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:516:7
+    #3 0x563ff0c25335 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:760:19
+    #4 0x563ff0c26125 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile>>&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:905:5
+    #5 0x563ff0c14436 in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:914:6
+    #6 0x563ff0c40962 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+    #7 0x7f4c156ed082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 87b331c034a6458c64ce09c03939e947212e18ce)
+
+DEDUP_TOKEN: LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)--fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*)
+  Uninitialized value was created by a heap deallocation
+    #0 0x563ff0cc7480 in free /src/llvm-project/compiler-rt/lib/msan/msan_interceptors.cpp:218:3
+    #1 0x563ff0d27800 in LLVMFuzzerTestOneInput /src/cifuzz-external-example/do_stuff_fuzzer.cpp:21:5
+    #2 0x563ff0c24340 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:614:13
+    #3 0x563ff0c23b65 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool, bool*) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:516:7
+    #4 0x563ff0c25335 in fuzzer::Fuzzer::MutateAndTestOne() /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:760:19
+    #5 0x563ff0c26125 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector<fuzzer::SizedFile, std::__Fuzzer::allocator<fuzzer::SizedFile>>&) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:905:5
+    #6 0x563ff0c14436 in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:914:6
+    #7 0x563ff0c40962 in main /src/llvm-project/compiler-rt/lib/fuzzer/FuzzerMain.cpp:20:10
+    #8 0x7f4c156ed082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082) (BuildId: 87b331c034a6458c64ce09c03939e947212e18ce)
+
+DEDUP_TOKEN: __interceptor_free--LLVMFuzzerTestOneInput--fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long)
+SUMMARY: MemorySanitizer: use-of-uninitialized-value /src/cifuzz-external-example/do_stuff_fuzzer.cpp:24:1 in LLVMFuzzerTestOneInput
+Unique heap origins: 201
+Stack depot allocated bytes: 9764880
+Unique origin histories: 181
+History depot allocated bytes: 196608
+Exiting
+MS: 5 ShuffleBytes-CopyPart-InsertByte-CopyPart-ManualDict- DE: "bar"-; base unit: adc83b19e793491b1c6ea0fd8b46cd9f32e592fc
+0xa,0x62,0x61,0x72,0xa,
+\012bar\012
+artifact_prefix='/tmp/tmp1tc5b3m2/'; Test unit written to /tmp/tmp1tc5b3m2/crash-c935b6724d7e27401ac9af3773700ca86ac38dea
+Base64: CmJhcgo=
+stat::number_of_executed_units: 159
+stat::average_exec_per_sec:     0
+stat::new_units_added:          1
+stat::slowest_unit_time_sec:    0
+stat::peak_rss_mb:              69

local-test-tika-delta-04/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/Dockerfile

@@ -0,0 +1,32 @@
+# 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.
+#
+# Build and run the proof of error in pytorch-lightning.
+
+FROM ghcr.io/aixcc-finals/base-builder-python
+
+RUN apt update && \
+  apt install -y vim && \
+  git clone \
+    --depth 1 \
+    --branch 1.5.10 \
+    https://github.com/PyTorchLightning/pytorch-lightning.git
+
+COPY ./build.sh $SRC
+RUN  ./build.sh
+
+COPY . $SRC
+RUN make SystemSan
+
+CMD ["make", "run"]

local-test-tika-delta-04/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/Makefile

@@ -0,0 +1,12 @@
+.POSIX:
+CXX     = clang++
+CFLAGS = -std=c++17 -Wall -Wextra -O3 -g3
+
+SystemSan: SystemSan.cpp
+	$(CXX) $(CFLAGS) -lpthread -o $@ $^
+
+run: clean SystemSan fuzz_pytorch_lightning.py
+	./SystemSan ./fuzz_pytorch_lightning.py -dict=vuln.dict
+
+clean:
+	rm -f SystemSan /tmp/tripwire

local-test-tika-delta-04/fuzz-tooling/infra/experimental/chronos/build_cache_local.sh

@@ -0,0 +1,163 @@
+#!/bin/bash -eu
+# 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.
+#
+################################################################################
+
+_PROJECT=$1
+_FUZZING_LANGUAGE=$2
+_SANITIZER=${3:-address}
+
+BASE=$PWD
+
+# Final image is either ccache or replay script, depending on which worked.
+FINAL_IMAGE_NAME=us-central1-docker.pkg.dev/oss-fuzz/oss-fuzz-gen/${_PROJECT}-ofg-cached-${_SANITIZER}
+
+# Always build an image with ccache.
+CCACHE_IMAGE_NAME=us-central1-docker.pkg.dev/oss-fuzz/oss-fuzz-gen/${_PROJECT}-ofg-ccache-${_SANITIZER}
+
+# Step 1: build the base image
+cd projects/${_PROJECT}
+docker build -t gcr.io/oss-fuzz/${_PROJECT} .
+
+
+# Step 2: create a container where `compile` has run which enables ccaching
+#         and also generates a replay build script.
+cd ${BASE}
+mkdir -p ccaches/${_PROJECT}
+mkdir -p build/out/${_PROJECT}
+B_START=$SECONDS
+
+docker container rm -f ${_PROJECT}-origin-${_SANITIZER}
+
+docker run \
+  --env=SANITIZER=${_SANITIZER} \
+  --env=CCACHE_DIR=/workspace/ccache \
+  --env=FUZZING_LANGUAGE=${_FUZZING_LANGUAGE} \
+  --env=CAPTURE_REPLAY_SCRIPT=1 \
+  --name=${_PROJECT}-origin-${_SANITIZER} \
+  -v=$PWD/ccaches/${_PROJECT}/ccache:/workspace/ccache \
+  -v=$PWD/build/out/${_PROJECT}/:/out/ \
+  gcr.io/oss-fuzz/${_PROJECT} \
+  /bin/bash -c \
+  "export PATH=/ccache/bin:\$PATH && compile"
+B_TIME=$(($SECONDS - $B_START))
+
+# Step 3: save (commit, locally) the cached container as an image
+docker container commit -c "ENV REPLAY_ENABLED=1" -c "ENV CAPTURE_REPLAY_SCRIPT=" ${_PROJECT}-origin-${_SANITIZER} $FINAL_IMAGE_NAME
+
+# Step 4: save the list of executables created from a vanilla build. This is
+#         needed for validating if replay and ccaching works.
+# notes: run a shell the container with e.g.
+# `docker run --entrypoint /bin/bash  -it local/ossfuzz/htslib-origin-address`
+executables_vanilla="$(find ./build/out/${_PROJECT} -executable -type f | sort)"
+
+
+# Step 5: Build with replay enabled, and validate the executables are the same
+# in terms of naming.
+# Note that an important step is removing everything in $OUT/ which is done
+# in the docker command.
+R_START=$SECONDS
+docker run \
+  --rm \
+  --env=SANITIZER=${_SANITIZER} \
+  --env=FUZZING_LANGUAGE=${_FUZZING_LANGUAGE} \
+  -v=$PWD/build/out/${_PROJECT}/:/out/ \
+  --name=${_PROJECT}-origin-${_SANITIZER}-replay-recached \
+  $FINAL_IMAGE_NAME \
+  /bin/bash -c \
+  "export PATH=/ccache/bin:\$PATH && rm -rf /out/* && compile"
+R_TIME=$(($SECONDS - $R_START))
+
+# Step 6: Extract the newly build executables
+executables_replay="$(find ./build/out/${_PROJECT}/ -executable -type f | sort)"
+
+echo "Executables vanilla: "
+echo ${executables_vanilla}
+
+echo "------------------------------------------------------"
+echo "Executables replay: "
+echo ${executables_replay}
+
+REPLAY_WORKED=
+
+# Step 7: match executables from vanilla builds and replay builds.
+#         If this step is successful, then the process can exit as it's ready.
+if [[ "$executables_replay" == "$executables_vanilla" ]]
+then
+  REPLAY_WORKED=1
+
+  if [ -z "${RUN_ALL+1}" ]; then
+    echo "${_PROJECT}: Replay worked."
+    echo "${_PROJECT}: Compile times: Vanilla=${B_TIME}; Replay=${R_TIME};"
+    exit 0
+  fi
+else
+  echo "${_PROJECT}: Replay did not work"
+  R_TIME="N/A"
+fi
+
+# Step 8: prepare Dockerfile for ccache
+cp -rf ccaches/${_PROJECT}/ccache ./projects/${_PROJECT}/ccache-cache
+
+infra/experimental/chronos/prepare-ccache ${_PROJECT}
+
+cd projects/${_PROJECT}
+
+# Step 9: Build an image with CCache's new items (modifications are done on the
+#         dockerfile)
+docker build -t $CCACHE_IMAGE_NAME .
+
+cd ${BASE}
+
+# Step 10: Run a `compile` with ccache's image.
+# Run the ccache build
+A_START=$SECONDS
+docker run \
+  --rm \
+  --env=SANITIZER=${_SANITIZER} \
+  --env=FUZZING_LANGUAGE=${_FUZZING_LANGUAGE} \
+  --name=${_PROJECT}-origin-${_SANITIZER}-recached \
+  -v=$PWD/build/out/${_PROJECT}/:/out/ \
+  $CCACHE_IMAGE_NAME \
+  /bin/bash -c \
+  "export PATH=/ccache/bin:\$PATH && rm -rf /out/* && compile"
+A_TIME=$(($SECONDS - $A_START))
+
+# Step 11: extract the executables from the ccache build
+executables_ccache="$(find ./build/out/${_PROJECT}/ -executable -type f | sort)"
+
+
+# Step 12: validate the ccache builds are successful
+if [[ "$executables_ccache" == "$executables_vanilla" ]]
+then
+  echo "${_PROJECT}: Compile times: Vanilla=${B_TIME}; Replay=${R_TIME}; CCache=${A_TIME};"
+
+  if [[ -z "${REPLAY_WORKED}" || ${R_TIME} -gt ${A_TIME} ]]; then
+    if [ ${R_TIME} -gt ${A_TIME} ]; then
+      echo "Replay was slower than ccache."
+    fi
+
+    # Replay didn't work or was slower, so make the default "cached" image use the ccache one.
+    docker image tag \
+      $CCACHE_IMAGE_NAME \
+      $FINAL_IMAGE_NAME
+  fi
+
+  exit 0
+else
+  echo "${_PROJECT}: Replay and ccaching did not work."
+  exit 1
+fi
+

local-test-tika-delta-04/fuzz-tooling/infra/experimental/sanitizers/ExecSan/README.md

@@ -0,0 +1,3 @@
+# Moved
+
+This has moved to <https://github.com/google/oss-fuzz/tree/master/infra/experimental/SystemSan>.