Add files using upload-large-folder tool

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

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

local-test-libxml2-delta-02/fuzz-tooling/docs/faq.md

@@ -0,0 +1,237 @@
+---
+layout: default
+title: FAQ
+nav_order: 7
+permalink: /faq/
+---
+
+# Frequently Asked Questions
+
+- TOC
+{:toc}
+---
+
+## Where can I learn more about fuzzing?
+
+We recommend reading [libFuzzer tutorial] and the other docs in [google/fuzzing]
+repository. These and some other resources are listed on the
+[useful links]({{ site.baseurl }}/reference/useful-links/#tutorials) page.
+
+[google/fuzzing]: https://github.com/google/fuzzing/tree/master/docs
+[libFuzzer tutorial]: https://github.com/google/fuzzing/blob/master/tutorial/libFuzzerTutorial.md
+
+## What kind of projects are you accepting?
+
+We accept established projects that have a critical impact on infrastructure and
+user security. We will consider each request on a case-by-case basis, but some
+things we keep in mind are:
+
+  - Exposure to remote attacks (e.g. libraries that are used to process
+    untrusted input).
+  - Number of users/other projects depending on this project.
+
+We hope to relax this requirement in the future though, so keep an eye out even
+if we are not able to accept your project at this time!
+
+## How can I find potential fuzz targets in my open source project?
+
+You should look for places in your code that:
+
+  - consume un-trusted data from users or from the network.
+  - consume complex input data even if it's 'trusted'.
+  - use an algorithm that has two or more implementations
+    (to verify their equivalence).
+  - look for existing fuzz target [examples](https://github.com/google/oss-fuzz/tree/master/projects)
+    and find similarities.
+
+## Where can I store fuzz target sources and the build script if it's not yet accepted upstream?
+
+Fuzz target sources as well as the build script may temporarily live inside the
+`projects/<your_project>` directory in the OSS-Fuzz repository. Note that we do
+not accept integrations that rely on forked repositories. Refer to the
+[ideal integration guide] for the preferred long term solution.
+
+## My project is not open source. Can I use OSS-Fuzz?
+
+You cannot use OSS-Fuzz, but you can use [ClusterFuzz] which OSS-Fuzz is based
+on. ClusterFuzz is an open-source fuzzing infrastructure that you can deploy in
+your own environment and run continuously at scale.
+
+OSS-Fuzz is a production instance of ClusterFuzz, plus the code living in
+[OSS-Fuzz repository]: build scripts, `project.yaml` files with contacts, etc.
+
+[OSS-Fuzz repository]: https://github.com/google/oss-fuzz
+
+## Why do you use a [different issue tracker](https://bugs.chromium.org/p/oss-fuzz/issues/list) for reporting bugs in OSS projects?
+
+Security access control is important for the kind of issues that OSS-Fuzz detects,
+hence why by default issues are only opened on the OSS-Fuzz tracker.
+You can opt-in to have them on Github as well by adding the `file_github_issue`
+attribute to your `project.yaml` file. Note that this is only for visibility's
+purpose, and that the actual details can be found by following the link to the
+OSS-Fuzz tracker.
+
+## Why do you require a Google account for authentication?
+
+Our [ClusterFuzz]({{ site.baseurl }}/further-reading/clusterfuzz) fuzzing
+infrastructure and [issue tracker](https://bugs.chromium.org/p/oss-fuzz/issues/list)
+require a Google account for authentication. Note that an alternate email
+address associated with a Google account does not work due to appengine api
+limitations.
+
+## Why do you use Docker?
+
+Building fuzzers requires building your project with a fresh Clang compiler and
+special compiler flags.  An easy-to-use Docker image is provided to simplify
+toolchain distribution. This also simplifies our support for a variety of Linux
+distributions and provides a reproducible environment for fuzzer
+building and execution.
+
+## How do you handle timeouts and OOMs?
+
+If a single input to a [fuzz target]({{ site.baseurl }}/reference/glossary/#fuzz-target)
+requires more than **~25 seconds** or more than **2.5GB RAM** to process, we
+report this as a timeout or an OOM (out-of-memory) bug
+(examples: [timeouts](https://bugs.chromium.org/p/oss-fuzz/issues/list?can=1&q=%22Crash+Type%3A+Timeout%22),
+[OOMs](https://bugs.chromium.org/p/oss-fuzz/issues/list?can=1&q="Crash+Type%3A+Out-of-memory")).
+This may or may not be considered as a real bug by the project owners,
+but nevertheless we treat all timeouts and OOMs as bugs
+since they significantly reduce the efficiency of fuzzing.
+
+Remember that fuzzing is executed with AddressSanitizer or other
+sanitizers which introduces a certain overhead in RAM and CPU.
+
+We currently do not have a good way to deduplicate timeout or OOM bugs.
+So, we report only one timeout and only one OOM bug per fuzz target.
+Once that bug is fixed, we will file another one, and so on.
+
+Currently we do not offer ways to change the memory and time limits.
+
+## Can I launch an additional process (e.g. a daemon) from my fuzz target?
+
+No. In order to get all the benefits of in-process, coverage-guided fuzz testing,
+it is required to run everything inside a single process. Any child processes
+created outside the main process introduces heavy launch overhead and is not
+monitored for code coverage.
+
+Another rule of thumb is: "the smaller fuzz target is, the better it is". It is
+expected that your project will have many fuzz targets to test different
+components, instead of a single fuzz target trying to cover everything.
+Think of fuzz target as a unit test, though it is much more powerful since it
+helps to test millions of data permutations rather than just one.
+
+## What if my fuzz target finds a bug in another project (dependency) ?
+
+Every bug report has a crash stack-trace that shows where the crash happened.
+Using that, you can debug the root cause and see which category the bug falls in:
+
+- If this is a bug is due to an incorrect usage of the dependent project's API
+in your project, then you need to fix your usage to call the API correctly.
+- If this is a real bug in the dependent project, then you should CC the
+maintainers of that project on the bug. Once CCed, they will get automatic
+access to all the information necessary to reproduce the issue. If this project
+is maintained in OSS-Fuzz, you can search for contacts in the respective
+project.yaml file.
+
+## What if my fuzzer does not find anything?
+
+If your fuzz target is running for many days and does not find bugs or new
+coverage, it may mean several things:
+- We've covered all reachable code. In order to cover more code we need more
+  fuzz targets.
+- The [seed corpus]({{ site.baseurl }}/getting-started/new-project-guide#seed-corpus) is not good enough and the
+  fuzzing engine(s) are not able to go deeper based on the existing seeds.
+  Need to add more seeds.
+- There is some crypto/crc stuff in the code that will prevent any fuzzing
+  engine from going deeper, in which case the crypto should be disabled in
+  [fuzzing mode](https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode).
+  Examples: [openssl](https://github.com/openssl/openssl/tree/master/fuzz#reproducing-issues),
+  [boringssl](https://boringssl.googlesource.com/boringssl/+/HEAD/FUZZING.md#Fuzzer-mode)
+- It is also possible that the fuzzer is running too slow
+  (you may check the speed of your targets at https://oss-fuzz.com/)
+
+In either case, look at the
+[coverage reports]({{ site.baseurl }}/further-reading/clusterfuzz#coverage-reports)
+for your target(s) and figure out why some parts of the code are not covered.
+
+## What if my fuzzer does not find new coverage or bugs after a while?
+
+It is common for fuzzers to plateau and stop finding new coverage or bugs.
+[Fuzz Introspector](https://github.com/ossf/fuzz-introspector) helps you
+evaluate your fuzzers' performance.
+It can help you identify bottlenecks causing your fuzzers to plateau.
+It provides aggregated and individual fuzzer reachability and coverage reports.
+Developers can either introduce a new fuzz target or modify an existing one to
+reach previously unreachable code.
+Here are
+[case studies](https://github.com/ossf/fuzz-introspector/blob/main/doc/CaseStudies.md)
+where Fuzz Introspector helped developers improve fuzzing of a project.
+Fuzz Introspector reports are available on the [OSS-Fuzz homepage](https://oss-fuzz.com/)
+or through this [index](http://oss-fuzz-introspector.storage.googleapis.com/index.html).
+
+Developers can also use Fuzz Introspector on their local machines.
+Detailed instructions are available
+[here](https://github.com/ossf/fuzz-introspector/tree/main/oss_fuzz_integration#build-fuzz-introspector-with-oss-fuzz).
+
+## Why are code coverage reports public?
+
+We work with open source projects and try to keep as much information public as
+possible. We believe that public code coverage reports do not put users at risk,
+as they do not indicate the presence of bugs or lack thereof.
+
+## Why is the coverage command complaining about format compatibility issues?
+
+This may happen if the Docker images fetched locally become out of sync. Make
+sure you run the following command to pull the most recent images:
+
+```bash
+$ python infra/helper.py pull_images
+```
+
+Please refer to
+[code coverage]({{ site.baseurl }}/advanced-topics/code-coverage/) for detailed
+information on code coverage generation.
+
+## What happens when I rename a fuzz target ?
+
+If you rename your fuzz targets, the existing bugs for those targets will get
+closed and fuzzing will start from scratch from a fresh corpora
+(seed corpus only). Similar corpora will get accumulated over time depending on
+the number of cpu cycles that original fuzz target has run. If this is not
+desirable, make sure to copy the accumulated corpora from the original fuzz
+target (instructions to download
+[here]({{ site.baseurl }}/advanced-topics/corpora/#downloading-the-corpus)) and
+restore it to the new GCS location later (instruction to find the
+new location [here]({{ site.baseurl }}/advanced-topics/corpora/#viewing-the-corpus-for-a-fuzz-target)).
+
+## Does OSS-Fuzz support AFL or honggfuzz or Centipede?
+
+OSS-Fuzz *uses* the following
+[fuzzing engines]({{ site.baseurl }}/reference/glossary/#fuzzing-engine):
+
+1. [libFuzzer](https://llvm.org/docs/LibFuzzer.html).
+1. [AFL++](https://github.com/AFLplusplus/AFLplusplus), an improved and
+   well-maintained version of [AFL](https://lcamtuf.coredump.cx/afl/).
+1. [Honggfuzz](https://github.com/google/honggfuzz).
+1. [Centipede (Experimental)](https://github.com/google/centipede).
+
+Follow the [new project guide] and OSS-Fuzz will use all its fuzzing engines
+on your code.
+
+## What are the specs on your machines?
+
+OSS-Fuzz builders have 32CPU/28.8GB RAM.
+
+Fuzzing machines only have a single core and fuzz targets should not use more
+than 2.5GB of RAM.
+
+## Are there any restrictions on using test cases / corpora generated by OSS-Fuzz?
+
+No, you can freely use (i.e. share, add to your repo, etc.) the test cases and
+corpora generated by OSS-Fuzz. OSS-Fuzz infrastructure is fully open source
+(including [ClusterFuzz], various fuzzing engines, and other dependencies). We
+have no intent to restrict the use of the artifacts produced by OSS-Fuzz.
+
+[ClusterFuzz]: https://github.com/google/clusterfuzz
+[new project guide]: {{ site.baseurl }}/getting-started/new-project-guide/
+[ideal integration guide]: {{ site.baseurl }}/getting-started/new-project-guide/

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

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

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

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

local-test-libxml2-delta-02/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-libxml2-delta-02/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-libxml2-delta-02/fuzz-tooling/infra/cifuzz/CHANGELOG

@@ -0,0 +1,3 @@
+	Next Release:
+
+	Improve detection of changed files better by fixing https://github.com/google/oss-fuzz/issues/7011

local-test-libxml2-delta-02/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-libxml2-delta-02/fuzz-tooling/infra/cifuzz/clusterfuzz_deployment_test.py

@@ -0,0 +1,268 @@
+# 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 clusterfuzz_deployment.py"""
+
+import os
+import unittest
+from unittest import mock
+
+import parameterized
+from pyfakefs import fake_filesystem_unittest
+
+import clusterfuzz_deployment
+import config_utils
+import test_helpers
+import workspace_utils
+
+# NOTE: This integration test relies on
+# https://github.com/google/oss-fuzz/tree/master/projects/example project.
+EXAMPLE_PROJECT = 'example'
+
+# An example fuzzer that triggers an error.
+EXAMPLE_FUZZER = 'example_crash_fuzzer'
+
+WORKSPACE = '/workspace'
+EXPECTED_LATEST_BUILD_PATH = os.path.join(WORKSPACE, 'cifuzz-prev-build')
+
+# pylint: disable=unused-argument
+
+
+def _create_config(**kwargs):
+  """Creates a config object and then sets every attribute that is a key in
+  |kwargs| to the corresponding value. Asserts that each key in |kwargs| is an
+  attribute of Config."""
+  defaults = {
+      'cfl_platform': 'github',
+      'oss_fuzz_project_name': EXAMPLE_PROJECT,
+      'workspace': WORKSPACE,
+  }
+  for default_key, default_value in defaults.items():
+    if default_key not in kwargs:
+      kwargs[default_key] = default_value
+
+  return test_helpers.create_run_config(**kwargs)
+
+
+def _create_deployment(**kwargs):
+  config = _create_config(**kwargs)
+  workspace = workspace_utils.Workspace(config)
+  return clusterfuzz_deployment.get_clusterfuzz_deployment(config, workspace)
+
+
+class OSSFuzzTest(fake_filesystem_unittest.TestCase):
+  """Tests OSSFuzz."""
+
+  def setUp(self):
+    self.setUpPyfakefs()
+    self.deployment = _create_deployment()
+    self.corpus_dir = os.path.join(self.deployment.workspace.corpora,
+                                   EXAMPLE_FUZZER)
+
+  @mock.patch('http_utils.download_and_unpack_zip', return_value=True)
+  def test_download_corpus(self, mock_download_and_unpack_zip):
+    """Tests that we can download a corpus for a valid project."""
+    self.deployment.download_corpus(EXAMPLE_FUZZER, self.corpus_dir)
+    expected_url = ('https://storage.googleapis.com/example-backup.'
+                    'clusterfuzz-external.appspot.com/corpus/libFuzzer/'
+                    'example_crash_fuzzer/public.zip')
+    call_args, _ = mock_download_and_unpack_zip.call_args
+    self.assertEqual(call_args, (expected_url, self.corpus_dir))
+    self.assertTrue(os.path.exists(self.corpus_dir))
+
+  @mock.patch('http_utils.download_and_unpack_zip', return_value=False)
+  def test_download_corpus_fail(self, _):
+    """Tests that when downloading fails, an empty corpus directory is still
+    returned."""
+    self.deployment.download_corpus(EXAMPLE_FUZZER, self.corpus_dir)
+    self.assertEqual(os.listdir(self.corpus_dir), [])
+
+  def test_get_latest_build_name(self):
+    """Tests that the latest build name can be retrieved from GCS."""
+    latest_build_name = self.deployment.get_latest_build_name()
+    self.assertTrue(latest_build_name.endswith('.zip'))
+    self.assertTrue('address' in latest_build_name)
+
+  @parameterized.parameterized.expand([
+      ('upload_build', ('commit',),
+       'Not uploading latest build because on OSS-Fuzz.'),
+      ('upload_corpus', ('target', 'corpus-dir'),
+       'Not uploading corpus because on OSS-Fuzz.'),
+      ('upload_crashes', tuple(), 'Not uploading crashes because on OSS-Fuzz.'),
+  ])
+  def test_noop_methods(self, method, method_args, expected_message):
+    """Tests that certain methods are noops for OSS-Fuzz."""
+    with mock.patch('logging.info') as mock_info:
+      method = getattr(self.deployment, method)
+      self.assertIsNone(method(*method_args))
+      mock_info.assert_called_with(expected_message)
+
+  @mock.patch('http_utils.download_and_unpack_zip', return_value=True)
+  def test_download_latest_build(self, mock_download_and_unpack_zip):
+    """Tests that downloading the latest build works as intended under normal
+    circumstances."""
+    self.assertEqual(self.deployment.download_latest_build(),
+                     EXPECTED_LATEST_BUILD_PATH)
+    expected_url = ('https://storage.googleapis.com/clusterfuzz-builds/example/'
+                    'example-address-202008030600.zip')
+    mock_download_and_unpack_zip.assert_called_with(expected_url,
+                                                    EXPECTED_LATEST_BUILD_PATH)
+
+  @mock.patch('http_utils.download_and_unpack_zip', return_value=False)
+  def test_download_latest_build_fail(self, _):
+    """Tests that download_latest_build returns None when it fails to download a
+    build."""
+    self.assertIsNone(self.deployment.download_latest_build())
+
+
+class ClusterFuzzLiteTest(fake_filesystem_unittest.TestCase):
+  """Tests for ClusterFuzzLite."""
+
+  def setUp(self):
+    self.setUpPyfakefs()
+    self.deployment = _create_deployment(mode='batch',
+                                         oss_fuzz_project_name='',
+                                         cloud_bucket='gs://bucket')
+    self.corpus_dir = os.path.join(self.deployment.workspace.corpora,
+                                   EXAMPLE_FUZZER)
+
+  @mock.patch('filestore.github_actions.GithubActionsFilestore.download_corpus',
+              return_value=True)
+  def test_download_corpus(self, mock_download_corpus):
+    """Tests that download_corpus works for a valid project."""
+    self.deployment.download_corpus(EXAMPLE_FUZZER, self.corpus_dir)
+    mock_download_corpus.assert_called_with('example_crash_fuzzer',
+                                            self.corpus_dir)
+    self.assertTrue(os.path.exists(self.corpus_dir))
+
+  @mock.patch('filestore.github_actions.GithubActionsFilestore.download_corpus',
+              side_effect=Exception)
+  def test_download_corpus_fail(self, _):
+    """Tests that when downloading fails, an empty corpus directory is still
+    returned."""
+    self.deployment.download_corpus(EXAMPLE_FUZZER, self.corpus_dir)
+    self.assertEqual(os.listdir(self.corpus_dir), [])
+
+  @mock.patch('filestore.github_actions.GithubActionsFilestore.download_build',
+              side_effect=[False, True])
+  @mock.patch('repo_manager.RepoManager.get_commit_list',
+              return_value=['commit1', 'commit2'])
+  @mock.patch('continuous_integration.GithubCiMixin.repo_dir',
+              return_value='/path/to/repo')
+  def test_download_latest_build(self, mock_repo_dir, mock_get_commit_list,
+                                 mock_download_build):
+    """Tests that downloading the latest build works as intended under normal
+    circumstances."""
+    self.assertEqual(self.deployment.download_latest_build(),
+                     EXPECTED_LATEST_BUILD_PATH)
+    expected_artifact_name = 'address-commit2'
+    mock_download_build.assert_called_with(expected_artifact_name,
+                                           EXPECTED_LATEST_BUILD_PATH)
+
+  @mock.patch('filestore.github_actions.GithubActionsFilestore.download_build',
+              side_effect=Exception)
+  @mock.patch('repo_manager.RepoManager.get_commit_list',
+              return_value=['commit1', 'commit2'])
+  @mock.patch('continuous_integration.GithubCiMixin.repo_dir',
+              return_value='/path/to/repo')
+  def test_download_latest_build_fail(self, mock_repo_dir, mock_get_commit_list,
+                                      _):
+    """Tests that download_latest_build returns None when it fails to download a
+    build."""
+    self.assertIsNone(self.deployment.download_latest_build())
+
+  @mock.patch('filestore.github_actions.GithubActionsFilestore.upload_build')
+  def test_upload_build(self, mock_upload_build):
+    """Tests that upload_build works as intended."""
+    self.deployment.upload_build('commit')
+    mock_upload_build.assert_called_with('address-commit',
+                                         '/workspace/build-out')
+
+
+class NoClusterFuzzDeploymentTest(fake_filesystem_unittest.TestCase):
+  """Tests for NoClusterFuzzDeployment."""
+
+  def setUp(self):
+    self.setUpPyfakefs()
+    config = test_helpers.create_run_config(workspace=WORKSPACE,
+                                            cfl_platform='other',
+                                            filestore='no_filestore',
+                                            no_clusterfuzz_deployment=True)
+    workspace = workspace_utils.Workspace(config)
+    self.deployment = clusterfuzz_deployment.get_clusterfuzz_deployment(
+        config, workspace)
+
+    self.corpus_dir = os.path.join(workspace.corpora, EXAMPLE_FUZZER)
+
+  @mock.patch('logging.info')
+  def test_download_corpus(self, mock_info):
+    """Tests that download corpus returns the path to the empty corpus
+    directory."""
+    self.deployment.download_corpus(EXAMPLE_FUZZER, self.corpus_dir)
+    mock_info.assert_called_with(
+        'Not downloading corpus because no ClusterFuzz deployment.')
+    self.assertTrue(os.path.exists(self.corpus_dir))
+
+  @parameterized.parameterized.expand([
+      ('upload_build', ('commit',),
+       'Not uploading latest build because no ClusterFuzz deployment.'),
+      ('upload_corpus', ('target', 'corpus-dir'),
+       'Not uploading corpus because no ClusterFuzz deployment.'),
+      ('upload_crashes', tuple(),
+       'Not uploading crashes because no ClusterFuzz deployment.'),
+      ('download_latest_build', tuple(),
+       'Not downloading latest build because no ClusterFuzz deployment.')
+  ])
+  def test_noop_methods(self, method, method_args, expected_message):
+    """Tests that certain methods are noops for NoClusterFuzzDeployment."""
+    with mock.patch('logging.info') as mock_info:
+      method = getattr(self.deployment, method)
+      self.assertIsNone(method(*method_args))
+      mock_info.assert_called_with(expected_message)
+
+
+class GetClusterFuzzDeploymentTest(unittest.TestCase):
+  """Tests for get_clusterfuzz_deployment."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+    os.environ['GITHUB_REPOSITORY'] = 'owner/myproject'
+
+  @parameterized.parameterized.expand([
+      (config_utils.BaseConfig.Platform.INTERNAL_GENERIC_CI,
+       clusterfuzz_deployment.OSSFuzz),
+      (config_utils.BaseConfig.Platform.INTERNAL_GITHUB,
+       clusterfuzz_deployment.OSSFuzz),
+      (config_utils.BaseConfig.Platform.EXTERNAL_GENERIC_CI,
+       clusterfuzz_deployment.ClusterFuzzLite),
+      (config_utils.BaseConfig.Platform.EXTERNAL_GITHUB,
+       clusterfuzz_deployment.ClusterFuzzLite),
+  ])
+  def test_get_clusterfuzz_deployment(self, platform, expected_deployment_cls):
+    """Tests that get_clusterfuzz_deployment returns the correct value."""
+    with mock.patch('config_utils.BaseConfig.platform',
+                    return_value=platform,
+                    new_callable=mock.PropertyMock):
+      with mock.patch('filestore_utils.get_filestore', return_value=None):
+        with mock.patch('platform_config.github._get_event_data',
+                        return_value={}):
+          config = _create_config()
+          workspace = workspace_utils.Workspace(config)
+
+          self.assertIsInstance(
+              clusterfuzz_deployment.get_clusterfuzz_deployment(
+                  config, workspace), expected_deployment_cls)
+
+
+if __name__ == '__main__':
+  unittest.main()

local-test-libxml2-delta-02/fuzz-tooling/infra/cifuzz/config_utils_test.py

@@ -0,0 +1,200 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for config_utils."""
+import os
+import unittest
+from unittest import mock
+
+import config_utils
+import constants
+import test_helpers
+
+# pylint: disable=no-self-use,protected-access
+
+
+class BaseConfigTest(unittest.TestCase):
+  """Tests for BaseConfig."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+
+  def _create_config(self):
+    return config_utils.BuildFuzzersConfig()
+
+  def test_language_default(self):
+    """Tests that the correct default language is set."""
+    config = self._create_config()
+    self.assertEqual(config.language, 'c++')
+
+  def test_language(self):
+    """Tests that the correct language is set."""
+    language = 'python'
+    os.environ['LANGUAGE'] = language
+    config = self._create_config()
+    self.assertEqual(config.language, language)
+
+  def test_is_coverage(self):
+    """Tests that is_coverage is set correctly."""
+    # Test it is set when it is supposed to be.
+    os.environ['SANITIZER'] = 'coverage'
+    config = self._create_config()
+    self.assertTrue(config.is_coverage)
+
+    # Test it is not set when it is not supposed to be.
+    os.environ['SANITIZER'] = 'address'
+    config = self._create_config()
+    self.assertFalse(config.is_coverage)
+
+  @mock.patch('logging.error')
+  def test_validate_no_workspace(self, mock_error):
+    """Tests that validate returns False if GITHUB_WORKSPACE isn't set."""
+    os.environ['OSS_FUZZ_PROJECT_NAME'] = 'example'
+    config = self._create_config()
+    self.assertFalse(config.validate())
+    mock_error.assert_called_with('Must set WORKSPACE.')
+
+  @mock.patch('logging.error')
+  def test_validate_invalid_language(self, mock_error):
+    """Tests that validate returns False if GITHUB_WORKSPACE isn't set."""
+    os.environ['OSS_FUZZ_PROJECT_NAME'] = 'example'
+    os.environ['WORKSPACE'] = '/workspace'
+    os.environ['LANGUAGE'] = 'invalid-language'
+    config = self._create_config()
+    self.assertFalse(config.validate())
+    mock_error.assert_called_with('Invalid LANGUAGE: %s. Must be one of: %s.',
+                                  os.environ['LANGUAGE'], constants.LANGUAGES)
+
+  @mock.patch('logging.error')
+  def test_validate_invalid_sanitizer(self, mock_error):
+    """Tests that validate returns False if GITHUB_WORKSPACE isn't set."""
+    os.environ['OSS_FUZZ_PROJECT_NAME'] = 'example'
+    os.environ['WORKSPACE'] = '/workspace'
+    os.environ['SANITIZER'] = 'invalid-sanitizer'
+    config = self._create_config()
+    self.assertFalse(config.validate())
+    mock_error.assert_called_with('Invalid SANITIZER: %s. Must be one of: %s.',
+                                  os.environ['SANITIZER'],
+                                  config_utils.SANITIZERS)
+
+  def test_validate(self):
+    """Tests that validate returns True if config is valid."""
+    os.environ['OSS_FUZZ_PROJECT_NAME'] = 'example'
+    os.environ['WORKSPACE'] = '/workspace'
+    os.environ['REPOSITORY'] = 'repo'
+    config = self._create_config()
+    self.assertTrue(config.validate())
+
+
+class BuildFuzzersConfigTest(unittest.TestCase):
+  """Tests for BuildFuzzersConfig."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+
+  def _create_config(self):
+    return config_utils.BuildFuzzersConfig()
+
+  @mock.patch('platform_config.github._get_event_data', return_value={})
+  def test_github_base_ref(self, _):
+    """Tests that base_ref is set properly."""
+    expected_base_ref = 'expected_base_ref'
+    os.environ['GITHUB_BASE_REF'] = expected_base_ref
+    os.environ['CFL_PLATFORM'] = 'github'
+    os.environ['GITHUB_REPOSITORY'] = 'owner/repo'
+    config = self._create_config()
+    self.assertEqual(config.base_ref, expected_base_ref)
+
+  def test_base_ref(self):
+    """Tests that base_ref is set properly."""
+    expected_base_ref = 'expected_base_ref'
+    os.environ['GIT_BASE_REF'] = expected_base_ref
+    config = self._create_config()
+    self.assertEqual(config.base_ref, expected_base_ref)
+
+  def test_keep_unaffected_defaults_to_true(self):
+    """Tests that keep_unaffected_fuzz_targets defaults to true."""
+    config = self._create_config()
+    self.assertTrue(config.keep_unaffected_fuzz_targets)
+
+  def test_keep_unaffected_defaults_to_false_when_pr(self):
+    """Tests that keep_unaffected_fuzz_targets defaults to false when from a
+    pr."""
+    os.environ['GIT_BASE_REF'] = 'base-ref'
+    config = self._create_config()
+    self.assertFalse(config.keep_unaffected_fuzz_targets)
+
+
+class RunFuzzersConfigTest(unittest.TestCase):
+  """Tests for RunFuzzersConfig."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+
+  def _create_config(self):
+    return config_utils.RunFuzzersConfig()
+
+  def test_coverage(self):
+    """Tests that mode is overriden properly based on is_coverage."""
+    # Test that it is overriden when it is supposed to be.
+    os.environ['SANITIZER'] = 'coverage'
+    os.environ['MODE'] = 'code-change'
+    config = self._create_config()
+    self.assertEqual(config.mode, 'coverage')
+
+    # Test that it isn't overriden when it isn't supposed to be.
+    os.environ['SANITIZER'] = 'address'
+    mode = 'code-change'
+    os.environ['MODE'] = mode
+    config = self._create_config()
+    self.assertEqual(config.mode, mode)
+
+  def test_run_config_validate(self):
+    """Tests that _run_config_validate returns True when the config is valid."""
+    self.assertTrue(self._create_config()._run_config_validate())
+
+  @mock.patch('logging.error')
+  def test_run_config_invalid_mode(self, mock_error):
+    """Tests that _run_config_validate returns False when mode is invalid."""
+    fake_mode = 'fake-mode'
+    os.environ['MODE'] = fake_mode
+    self.assertFalse(self._create_config()._run_config_validate())
+    mock_error.assert_called_with('Invalid MODE: %s. Must be one of %s.',
+                                  fake_mode,
+                                  config_utils.RunFuzzersConfig.MODES)
+
+
+class GetSanitizerTest(unittest.TestCase):
+  """Tests for _get_sanitizer."""
+
+  def setUp(self):
+    test_helpers.patch_environ(self)
+    self.sanitizer = 'memory'
+
+  def test_default_value(self):
+    """Tests that the default value returned by _get_sanitizer is correct."""
+    self.assertEqual(config_utils._get_sanitizer(), 'address')
+
+  def test_normal_case(self):
+    """Tests that _get_sanitizer returns the correct value in normal cases."""
+    os.environ['SANITIZER'] = self.sanitizer
+    self.assertEqual(config_utils._get_sanitizer(), self.sanitizer)
+
+  def test_capitalization(self):
+    """Tests that that _get_sanitizer handles capitalization properly."""
+    os.environ['SANITIZER'] = self.sanitizer.upper()
+    self.assertEqual(config_utils._get_sanitizer(), self.sanitizer)
+
+
+if __name__ == '__main__':
+  unittest.main()

local-test-libxml2-delta-02/fuzz-tooling/infra/cifuzz/continuous_integration.py

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

local-test-libxml2-delta-02/fuzz-tooling/infra/cifuzz/docker_test.py

@@ -0,0 +1,119 @@
+# 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 the functionality of the docker module."""
+import unittest
+from unittest import mock
+
+import docker
+import test_helpers
+import workspace_utils
+
+CONTAINER_NAME = 'example-container'
+config = test_helpers.create_run_config(oss_fuzz_project_name='project',
+                                        workspace='/workspace')
+config.workspace = '/workspace'
+WORKSPACE = workspace_utils.Workspace(config)
+SANITIZER = 'example-sanitizer'
+LANGUAGE = 'example-language'
+
+
+class GetProjectImageTest(unittest.TestCase):
+  """Tests for get_project_image."""
+
+  def test_get_project_image(self):
+    """Tests that get_project_image_name works as intended."""
+    project = 'my-project'
+    self.assertEqual(docker.get_project_image_name(project),
+                     'gcr.io/oss-fuzz/my-project')
+
+
+class GetDeleteImagesTest(unittest.TestCase):
+  """Tests for delete_images."""
+
+  @mock.patch('utils.execute')
+  def test_delete_images(self, mock_execute):  # pylint: disable=no-self-use
+    """Tests that get_project_image_name works as intended."""
+    images = ['image']
+    docker.delete_images(images)
+    expected_calls = [
+        mock.call(['docker', 'rmi', '-f'] + images),
+        mock.call(['docker', 'builder', 'prune', '-f'])
+    ]
+
+    mock_execute.assert_has_calls(expected_calls)
+
+
+class GetBaseDockerRunArgsTest(unittest.TestCase):
+  """Tests get_base_docker_run_args."""
+
+  @mock.patch('utils.get_container_name', return_value=CONTAINER_NAME)
+  def test_get_base_docker_run_args_container(self, _):
+    """Tests that get_base_docker_run_args works as intended when inside a
+    container."""
+    docker_args, docker_container = docker.get_base_docker_run_args(
+        WORKSPACE, SANITIZER, LANGUAGE)
+    self.assertEqual(docker_container, CONTAINER_NAME)
+    expected_docker_args = []
+    expected_docker_args = [
+        '-e',
+        'FUZZING_ENGINE=libfuzzer',
+        '-e',
+        'CIFUZZ=True',
+        '-e',
+        f'SANITIZER={SANITIZER}',
+        '-e',
+        'ARCHITECTURE=x86_64',
+        '-e',
+        f'FUZZING_LANGUAGE={LANGUAGE}',
+        '-e',
+        f'OUT={WORKSPACE.out}',
+        '--volumes-from',
+        CONTAINER_NAME,
+    ]
+    self.assertEqual(docker_args, expected_docker_args)
+
+  @mock.patch('utils.get_container_name', return_value=None)
+  def test_get_base_docker_run_args_no_container(self, _):
+    """Tests that get_base_docker_run_args works as intended when not inside a
+    container."""
+    docker_args, docker_container = docker.get_base_docker_run_args(
+        WORKSPACE, SANITIZER, LANGUAGE)
+    self.assertEqual(docker_container, None)
+    expected_docker_args = [
+        '-e', 'FUZZING_ENGINE=libfuzzer', '-e', 'CIFUZZ=True', '-e',
+        f'SANITIZER={SANITIZER}', '-e', 'ARCHITECTURE=x86_64', '-e',
+        f'FUZZING_LANGUAGE={LANGUAGE}', '-e', f'OUT={WORKSPACE.out}', '-v',
+        f'{WORKSPACE.workspace}:{WORKSPACE.workspace}'
+    ]
+    self.assertEqual(docker_args, expected_docker_args)
+
+
+class GetBaseDockerRunCommandTest(unittest.TestCase):
+  """Tests get_base_docker_run_args."""
+
+  @mock.patch('utils.get_container_name', return_value=None)
+  def test_get_base_docker_run_command_no_container(self, _):
+    """Tests that get_base_docker_run_args works as intended when not inside a
+    container."""
+    docker_args, docker_container = docker.get_base_docker_run_command(
+        WORKSPACE, SANITIZER, LANGUAGE)
+    self.assertEqual(docker_container, None)
+    expected_docker_command = [
+        'docker', 'run', '--rm', '--privileged', '-e',
+        'FUZZING_ENGINE=libfuzzer', '-e', 'CIFUZZ=True', '-e',
+        f'SANITIZER={SANITIZER}', '-e', 'ARCHITECTURE=x86_64', '-e',
+        f'FUZZING_LANGUAGE={LANGUAGE}', '-e', f'OUT={WORKSPACE.out}', '-v',
+        f'{WORKSPACE.workspace}:{WORKSPACE.workspace}'
+    ]
+    self.assertEqual(docker_args, expected_docker_command)

local-test-libxml2-delta-02/fuzz-tooling/infra/cifuzz/filestore_utils.py

@@ -0,0 +1,48 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""External filestore interface. Cannot be depended on by filestore code."""
+import filestore
+import filestore.filesystem
+import filestore.git
+import filestore.github_actions
+import filestore.gsutil
+import filestore.no_filestore
+import filestore.gitlab
+
+FILESTORE_MAPPING = {
+    'filesystem': filestore.filesystem.FilesystemFilestore,
+    'gsutil': filestore.gsutil.GSUtilFilestore,
+    'github-actions': filestore.github_actions.GithubActionsFilestore,
+    'git': filestore.git.GitFilestore,
+    # TODO(metzman): Change to "no-filestore"
+    'no_filestore': filestore.no_filestore.NoFilestore,
+    'gitlab': filestore.gitlab.GitlabFilestore,
+}
+
+
+def get_filestore(config):
+  """Returns the correct filestore object based on the platform in |config|.
+  Raises an exception if there is no correct filestore for the platform."""
+  if config.platform == config.Platform.EXTERNAL_GITHUB:
+    ci_filestore = filestore.github_actions.GithubActionsFilestore(config)
+    if not config.git_store_repo:
+      return ci_filestore
+
+    return filestore.git.GitFilestore(config, ci_filestore)
+
+  filestore_cls = FILESTORE_MAPPING.get(config.filestore)
+  if filestore_cls is None:
+    raise filestore.FilestoreError(
+        f'Filestore: {config.filestore} doesn\'t exist.')
+  return filestore_cls(config)

local-test-libxml2-delta-02/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-libxml2-delta-02/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-libxml2-delta-02/fuzz-tooling/infra/cifuzz/run_cifuzz.py

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

local-test-libxml2-delta-02/fuzz-tooling/infra/cifuzz/run_fuzzers_test.py

@@ -0,0 +1,475 @@
+# 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 running fuzzers."""
+import json
+import os
+import shutil
+import stat
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+import parameterized
+from pyfakefs import fake_filesystem_unittest
+
+import build_fuzzers
+import fuzz_target
+import run_fuzzers
+
+# pylint: disable=wrong-import-position
+INFRA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(INFRA_DIR)
+
+import helper
+import test_helpers
+
+# NOTE: This integration test relies on
+# https://github.com/google/oss-fuzz/tree/master/projects/example project.
+EXAMPLE_PROJECT = 'example'
+
+# Location of files used for testing.
+TEST_DATA_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                              'test_data')
+
+MEMORY_FUZZER_DIR = os.path.join(TEST_DATA_PATH, 'memory')
+MEMORY_FUZZER = 'curl_fuzzer_memory'
+
+UNDEFINED_FUZZER_DIR = os.path.join(TEST_DATA_PATH, 'undefined')
+UNDEFINED_FUZZER = 'curl_fuzzer_undefined'
+
+FUZZ_SECONDS = 10
+
+
+class RunFuzzerIntegrationTestMixin:  # pylint: disable=too-few-public-methods,invalid-name
+  """Mixin for integration test classes that runbuild_fuzzers on builds of a
+  specific sanitizer."""
+  # These must be defined by children.
+  FUZZER_DIR = None
+  FUZZER = None
+
+  def setUp(self):
+    """Patch the environ so that we can execute runner scripts."""
+    test_helpers.patch_environ(self, runner=True)
+
+  def _test_run_with_sanitizer(self, fuzzer_dir, sanitizer):
+    """Calls run_fuzzers on fuzzer_dir and |sanitizer| and asserts
+    the run succeeded and that no bug was found."""
+    with test_helpers.temp_dir_copy(fuzzer_dir) as fuzzer_dir_copy:
+      config = test_helpers.create_run_config(fuzz_seconds=FUZZ_SECONDS,
+                                              workspace=fuzzer_dir_copy,
+                                              oss_fuzz_project_name='curl',
+                                              sanitizer=sanitizer)
+      result = run_fuzzers.run_fuzzers(config)
+    self.assertEqual(result, run_fuzzers.RunFuzzersResult.NO_BUG_FOUND)
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class RunMemoryFuzzerIntegrationTest(RunFuzzerIntegrationTestMixin,
+                                     unittest.TestCase):
+  """Integration test for build_fuzzers with an MSAN build."""
+  FUZZER_DIR = MEMORY_FUZZER_DIR
+  FUZZER = MEMORY_FUZZER
+
+  def test_run_with_memory_sanitizer(self):
+    """Tests run_fuzzers with a valid MSAN build."""
+    self._test_run_with_sanitizer(self.FUZZER_DIR, 'memory')
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class RunUndefinedFuzzerIntegrationTest(RunFuzzerIntegrationTestMixin,
+                                        unittest.TestCase):
+  """Integration test for build_fuzzers with an UBSAN build."""
+  FUZZER_DIR = UNDEFINED_FUZZER_DIR
+  FUZZER = UNDEFINED_FUZZER
+
+  def test_run_with_undefined_sanitizer(self):
+    """Tests run_fuzzers with a valid UBSAN build."""
+    self._test_run_with_sanitizer(self.FUZZER_DIR, 'undefined')
+
+
+class BaseFuzzTargetRunnerTest(unittest.TestCase):
+  """Tests BaseFuzzTargetRunner."""
+
+  def _create_runner(self, **kwargs):  # pylint: disable=no-self-use
+    defaults = {
+        'fuzz_seconds': FUZZ_SECONDS,
+        'oss_fuzz_project_name': EXAMPLE_PROJECT
+    }
+    for default_key, default_value in defaults.items():
+      if default_key not in kwargs:
+        kwargs[default_key] = default_value
+
+    config = test_helpers.create_run_config(**kwargs)
+    return run_fuzzers.BaseFuzzTargetRunner(config)
+
+  def _test_initialize_fail(self, expected_error_args, **create_runner_kwargs):
+    with mock.patch('logging.error') as mock_error:
+      runner = self._create_runner(**create_runner_kwargs)
+      self.assertFalse(runner.initialize())
+      mock_error.assert_called_with(*expected_error_args)
+
+  @parameterized.parameterized.expand([(0,), (None,), (-1,)])
+  def test_initialize_invalid_fuzz_seconds(self, fuzz_seconds):
+    """Tests initialize fails with an invalid fuzz seconds."""
+    expected_error_args = ('Fuzz_seconds argument must be greater than 1, '
+                           'but was: %s.', fuzz_seconds)
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      out_path = os.path.join(tmp_dir, 'build-out')
+      os.mkdir(out_path)
+      with mock.patch('utils.get_fuzz_targets') as mock_get_fuzz_targets:
+        mock_get_fuzz_targets.return_value = [
+            os.path.join(out_path, 'fuzz_target')
+        ]
+        self._test_initialize_fail(expected_error_args,
+                                   fuzz_seconds=fuzz_seconds,
+                                   workspace=tmp_dir)
+
+  def test_initialize_no_out_dir(self):
+    """Tests initialize fails with no out dir."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      out_path = os.path.join(tmp_dir, 'build-out')
+      expected_error_args = ('Out directory: %s does not exist.', out_path)
+      self._test_initialize_fail(expected_error_args, workspace=tmp_dir)
+
+  def test_initialize_nonempty_artifacts(self):
+    """Tests initialize with a file artifacts path."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      out_path = os.path.join(tmp_dir, 'build-out')
+      os.mkdir(out_path)
+      os.makedirs(os.path.join(tmp_dir, 'out'))
+      artifacts_path = os.path.join(tmp_dir, 'out', 'artifacts')
+      with open(artifacts_path, 'w') as artifacts_handle:
+        artifacts_handle.write('fake')
+      expected_error_args = (
+          'Artifacts path: %s exists and is not an empty directory.',
+          artifacts_path)
+      self._test_initialize_fail(expected_error_args, workspace=tmp_dir)
+
+  def test_initialize_bad_artifacts(self):
+    """Tests initialize with a non-empty artifacts path."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      out_path = os.path.join(tmp_dir, 'build-out')
+      os.mkdir(out_path)
+      artifacts_path = os.path.join(tmp_dir, 'out', 'artifacts')
+      os.makedirs(artifacts_path)
+      artifact_path = os.path.join(artifacts_path, 'artifact')
+      with open(artifact_path, 'w') as artifact_handle:
+        artifact_handle.write('fake')
+      expected_error_args = (
+          'Artifacts path: %s exists and is not an empty directory.',
+          artifacts_path)
+      self._test_initialize_fail(expected_error_args, workspace=tmp_dir)
+
+  @mock.patch('utils.get_fuzz_targets')
+  @mock.patch('logging.error')
+  def test_initialize_empty_artifacts(self, mock_log_error,
+                                      mock_get_fuzz_targets):
+    """Tests initialize with an empty artifacts dir."""
+    mock_get_fuzz_targets.return_value = ['fuzz-target']
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      out_path = os.path.join(tmp_dir, 'build-out')
+      os.mkdir(out_path)
+      artifacts_path = os.path.join(tmp_dir, 'out', 'artifacts')
+      os.makedirs(artifacts_path)
+      runner = self._create_runner(workspace=tmp_dir)
+      self.assertTrue(runner.initialize())
+      mock_log_error.assert_not_called()
+      self.assertTrue(os.path.isdir(artifacts_path))
+
+  @mock.patch('utils.get_fuzz_targets')
+  @mock.patch('logging.error')
+  def test_initialize_no_artifacts(self, mock_log_error, mock_get_fuzz_targets):
+    """Tests initialize with no artifacts dir (the expected setting)."""
+    mock_get_fuzz_targets.return_value = ['fuzz-target']
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      out_path = os.path.join(tmp_dir, 'build-out')
+      os.mkdir(out_path)
+      runner = self._create_runner(workspace=tmp_dir)
+      self.assertTrue(runner.initialize())
+      mock_log_error.assert_not_called()
+      self.assertTrue(os.path.isdir(os.path.join(tmp_dir, 'out', 'artifacts')))
+
+  def test_initialize_no_fuzz_targets(self):
+    """Tests initialize with no fuzz targets."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      out_path = os.path.join(tmp_dir, 'build-out')
+      os.makedirs(out_path)
+      expected_error_args = ('No fuzz targets were found in out directory: %s.',
+                             out_path)
+      self._test_initialize_fail(expected_error_args, workspace=tmp_dir)
+
+
+class CiFuzzTargetRunnerTest(fake_filesystem_unittest.TestCase):
+  """Tests that CiFuzzTargetRunner works as intended."""
+
+  def setUp(self):
+    self.setUpPyfakefs()
+
+  @mock.patch('clusterfuzz_deployment.OSSFuzz.upload_crashes')
+  @mock.patch('utils.get_fuzz_targets')
+  @mock.patch('run_fuzzers.CiFuzzTargetRunner.run_fuzz_target')
+  @mock.patch('run_fuzzers.CiFuzzTargetRunner.create_fuzz_target_obj')
+  def test_run_fuzz_targets_quits(self, mock_create_fuzz_target_obj,
+                                  mock_run_fuzz_target, mock_get_fuzz_targets,
+                                  mock_upload_crashes):
+    """Tests that run_fuzz_targets quits on the first crash it finds."""
+    workspace = 'workspace'
+    out_path = os.path.join(workspace, 'build-out')
+    self.fs.create_dir(out_path)
+    config = test_helpers.create_run_config(
+        fuzz_seconds=FUZZ_SECONDS,
+        workspace=workspace,
+        oss_fuzz_project_name=EXAMPLE_PROJECT)
+    runner = run_fuzzers.CiFuzzTargetRunner(config)
+
+    mock_get_fuzz_targets.return_value = ['target1', 'target2']
+    runner.initialize()
+    testcase = os.path.join(workspace, 'testcase')
+    self.fs.create_file(testcase)
+    stacktrace = 'stacktrace'
+    corpus_dir = 'corpus'
+    self.fs.create_dir(corpus_dir)
+    mock_run_fuzz_target.return_value = fuzz_target.FuzzResult(
+        testcase, stacktrace, corpus_dir)
+    magic_mock = mock.MagicMock()
+    magic_mock.target_name = 'target1'
+    mock_create_fuzz_target_obj.return_value = magic_mock
+    self.assertTrue(runner.run_fuzz_targets())
+    self.assertEqual(mock_run_fuzz_target.call_count, 1)
+    self.assertEqual(mock_upload_crashes.call_count, 1)
+
+
+class BatchFuzzTargetRunnerTest(fake_filesystem_unittest.TestCase):
+  """Tests that BatchFuzzTargetRunnerTest works as intended."""
+  WORKSPACE = 'workspace'
+  STACKTRACE = 'stacktrace'
+  CORPUS_DIR = 'corpus'
+
+  def setUp(self):
+    self.setUpPyfakefs()
+    out_dir = os.path.join(self.WORKSPACE, 'build-out')
+    self.fs.create_dir(out_dir)
+    self.testcase1 = os.path.join(out_dir, 'testcase-aaa')
+    self.fs.create_file(self.testcase1)
+    self.testcase2 = os.path.join(out_dir, 'testcase-bbb')
+    self.fs.create_file(self.testcase2)
+    self.config = test_helpers.create_run_config(fuzz_seconds=FUZZ_SECONDS,
+                                                 workspace=self.WORKSPACE,
+                                                 cfl_platform='github')
+
+  @mock.patch('utils.get_fuzz_targets', return_value=['target1', 'target2'])
+  @mock.patch('clusterfuzz_deployment.ClusterFuzzLite.upload_crashes')
+  @mock.patch('run_fuzzers.BatchFuzzTargetRunner.run_fuzz_target')
+  @mock.patch('run_fuzzers.BatchFuzzTargetRunner.create_fuzz_target_obj')
+  def test_run_fuzz_targets_quits(self, mock_create_fuzz_target_obj,
+                                  mock_run_fuzz_target, mock_upload_crashes, _):
+    """Tests that run_fuzz_targets doesn't quit on the first crash it finds."""
+    runner = run_fuzzers.BatchFuzzTargetRunner(self.config)
+    runner.initialize()
+
+    call_count = 0
+
+    def mock_run_fuzz_target_impl(_):
+      nonlocal call_count
+      if call_count == 0:
+        testcase = self.testcase1
+      elif call_count == 1:
+        testcase = self.testcase2
+      assert call_count != 2
+      call_count += 1
+      if not os.path.exists(self.CORPUS_DIR):
+        self.fs.create_dir(self.CORPUS_DIR)
+      return fuzz_target.FuzzResult(testcase, self.STACKTRACE, self.CORPUS_DIR)
+
+    mock_run_fuzz_target.side_effect = mock_run_fuzz_target_impl
+    magic_mock = mock.MagicMock()
+    magic_mock.target_name = 'target1'
+    mock_create_fuzz_target_obj.return_value = magic_mock
+    self.assertTrue(runner.run_fuzz_targets())
+    self.assertEqual(mock_run_fuzz_target.call_count, 2)
+    self.assertEqual(mock_upload_crashes.call_count, 1)
+
+
+class GetCoverageTargetsTest(unittest.TestCase):
+  """Tests for get_coverage_fuzz_targets."""
+
+  def test_get_fuzz_targets(self):
+    """Tests that get_coverage_fuzz_targets returns expected targets."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+      # Setup.
+      fuzz_target_path = os.path.join(temp_dir, 'fuzz-target')
+      with open(fuzz_target_path, 'w') as file_handle:
+        file_handle.write('')
+      fuzz_target_st = os.stat(fuzz_target_path)
+      os.chmod(fuzz_target_path, fuzz_target_st.st_mode | stat.S_IEXEC)
+      non_fuzz_target1 = os.path.join(temp_dir, 'non-fuzz-target1')
+      with open(non_fuzz_target1, 'w') as file_handle:
+        file_handle.write('LLVMFuzzerTestOneInput')
+      subdir = os.path.join(temp_dir, 'subdir')
+      os.mkdir(subdir)
+      non_fuzz_target2 = os.path.join(subdir, 'non-fuzz-target1')
+      with open(non_fuzz_target2, 'w') as file_handle:
+        file_handle.write('LLVMFuzzerTestOneInput')
+
+      self.assertEqual(run_fuzzers.get_coverage_fuzz_targets(temp_dir),
+                       [fuzz_target_path])
+
+
+@unittest.skip('TODO(metzman): Fix this test')
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class CoverageReportIntegrationTest(unittest.TestCase):
+  """Integration tests for coverage reports."""
+  SANITIZER = 'coverage'
+
+  def setUp(self):
+    test_helpers.patch_environ(self, runner=True)
+
+  @mock.patch('filestore.github_actions._upload_artifact_with_upload_js')
+  def test_coverage_report(self, _):
+    """Tests generation of coverage reports end-to-end, from building to
+    generation."""
+
+    with test_helpers.docker_temp_dir() as temp_dir:
+      shared = os.path.join(temp_dir, 'shared')
+      os.mkdir(shared)
+      copy_command = ('cp -r /opt/code_coverage /shared && '
+                      'cp $(which llvm-profdata) /shared && '
+                      'cp $(which llvm-cov) /shared')
+      assert helper.docker_run([
+          '-v', f'{shared}:/shared', 'ghcr.io/aixcc-finals/base-runner', 'bash',
+          '-c', copy_command
+      ])
+
+      os.environ['CODE_COVERAGE_SRC'] = os.path.join(shared, 'code_coverage')
+      os.environ['PATH'] += os.pathsep + shared
+      # Do coverage build.
+      build_config = test_helpers.create_build_config(
+          oss_fuzz_project_name=EXAMPLE_PROJECT,
+          project_repo_name='oss-fuzz',
+          workspace=temp_dir,
+          git_sha='0b95fe1039ed7c38fea1f97078316bfc1030c523',
+          base_commit='da0746452433dc18bae699e355a9821285d863c8',
+          sanitizer=self.SANITIZER,
+          cfl_platform='github',
+          # Needed for test not to fail because of permissions issues.
+          bad_build_check=False)
+      self.assertTrue(build_fuzzers.build_fuzzers(build_config))
+
+      # TODO(metzman): Get rid of this here and make 'compile' do this.
+      chmod_command = ('chmod -R +r /out && '
+                       'find /out -type d -exec chmod +x {} +')
+
+      assert helper.docker_run([
+          '-v', f'{os.path.join(temp_dir, "build-out")}:/out',
+          'ghcr.io/aixcc-finals/base-builder', 'bash', '-c', chmod_command
+      ])
+
+      # Generate report.
+      run_config = test_helpers.create_run_config(fuzz_seconds=FUZZ_SECONDS,
+                                                  workspace=temp_dir,
+                                                  sanitizer=self.SANITIZER,
+                                                  mode='coverage',
+                                                  cfl_platform='github')
+      result = run_fuzzers.run_fuzzers(run_config)
+      self.assertEqual(result, run_fuzzers.RunFuzzersResult.NO_BUG_FOUND)
+      expected_summary_path = os.path.join(
+          TEST_DATA_PATH, 'example_coverage_report_summary.json')
+      with open(expected_summary_path) as file_handle:
+        expected_summary = json.loads(file_handle.read())
+        actual_summary_path = os.path.join(temp_dir, 'cifuzz-coverage',
+                                           'report', 'linux', 'summary.json')
+      with open(actual_summary_path) as file_handle:
+        actual_summary = json.loads(file_handle.read())
+      self.assertEqual(expected_summary, actual_summary)
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class RunAddressFuzzersIntegrationTest(RunFuzzerIntegrationTestMixin,
+                                       unittest.TestCase):
+  """Integration tests for build_fuzzers with an ASAN build."""
+
+  BUILD_DIR_NAME = 'cifuzz-latest-build'
+
+  def test_new_bug_found(self):
+    """Tests run_fuzzers with a valid ASAN build."""
+    # Set the first return value to True, then the second to False to
+    # emulate a bug existing in the current PR but not on the downloaded
+    # OSS-Fuzz build.
+    with mock.patch('fuzz_target.FuzzTarget.is_reproducible',
+                    side_effect=[True, False]):
+      with tempfile.TemporaryDirectory() as tmp_dir:
+        workspace = os.path.join(tmp_dir, 'workspace')
+        shutil.copytree(TEST_DATA_PATH, workspace)
+        config = test_helpers.create_run_config(
+            fuzz_seconds=FUZZ_SECONDS,
+            workspace=workspace,
+            oss_fuzz_project_name=EXAMPLE_PROJECT)
+        result = run_fuzzers.run_fuzzers(config)
+        self.assertEqual(result, run_fuzzers.RunFuzzersResult.BUG_FOUND)
+
+  @mock.patch('fuzz_target.FuzzTarget.is_reproducible',
+              side_effect=[True, True])
+  def test_old_bug_found(self, _):
+    """Tests run_fuzzers with a bug found in OSS-Fuzz before."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      workspace = os.path.join(tmp_dir, 'workspace')
+      shutil.copytree(TEST_DATA_PATH, workspace)
+      config = test_helpers.create_run_config(
+          fuzz_seconds=FUZZ_SECONDS,
+          workspace=workspace,
+          oss_fuzz_project_name=EXAMPLE_PROJECT)
+      result = run_fuzzers.run_fuzzers(config)
+      self.assertEqual(result, run_fuzzers.RunFuzzersResult.NO_BUG_FOUND)
+
+  def test_invalid_build(self):
+    """Tests run_fuzzers with an invalid ASAN build."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      out_path = os.path.join(tmp_dir, 'build-out')
+      os.mkdir(out_path)
+      config = test_helpers.create_run_config(
+          fuzz_seconds=FUZZ_SECONDS,
+          workspace=tmp_dir,
+          oss_fuzz_project_name=EXAMPLE_PROJECT)
+      result = run_fuzzers.run_fuzzers(config)
+    self.assertEqual(result, run_fuzzers.RunFuzzersResult.ERROR)
+
+
+class GetFuzzTargetRunnerTest(unittest.TestCase):
+  """Tests for get_fuzz_fuzz_target_runner."""
+
+  @parameterized.parameterized.expand([
+      ('batch', run_fuzzers.BatchFuzzTargetRunner),
+      ('code-change', run_fuzzers.CiFuzzTargetRunner),
+      ('coverage', run_fuzzers.CoverageTargetRunner)
+  ])
+  def test_get_fuzz_target_runner(self, mode, fuzz_target_runner_cls):
+    """Tests that get_fuzz_target_runner returns the correct runner based on the
+    specified mode."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      run_config = test_helpers.create_run_config(
+          fuzz_seconds=FUZZ_SECONDS,
+          workspace=tmp_dir,
+          oss_fuzz_project_name='example',
+          mode=mode)
+      runner = run_fuzzers.get_fuzz_target_runner(run_config)
+      self.assertTrue(isinstance(runner, fuzz_target_runner_cls))
+
+
+if __name__ == '__main__':
+  unittest.main()

local-test-libxml2-delta-02/fuzz-tooling/infra/templates.py

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

local-test-libxml2-delta-02/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"]
+