Add files using upload-large-folder tool

local-test-commons-compress-full-01-vuln_1/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-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/base_runner_utils.py

@@ -0,0 +1,33 @@
+# 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.
+"""Utilities for scripts from ghcr.io/aixcc-finals/base-runner."""
+
+import os
+
+import config_utils
+
+
+def get_env(config, workspace):
+  """Returns a dictionary containing the current environment with additional env
+  vars set to values needed to run a fuzzer."""
+  env = os.environ.copy()
+  env['SANITIZER'] = config.sanitizer
+  env['FUZZING_LANGUAGE'] = config.language
+  env['OUT'] = workspace.out
+  env['CIFUZZ'] = 'True'
+  env['FUZZING_ENGINE'] = config_utils.DEFAULT_ENGINE
+  env['ARCHITECTURE'] = config.architecture
+  # Do this so we don't fail in tests.
+  env['FUZZER_ARGS'] = '-rss_limit_mb=2560 -timeout=25'
+  return env

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/build-images.sh

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

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

@@ -0,0 +1,40 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Builds fuzzers and runs fuzzers. Entrypoint used for external users"""
+import logging
+import sys
+
+import build_fuzzers_entrypoint
+import run_fuzzers_entrypoint
+
+
+def main():
+  """Builds and runs fuzzers for CI tools.
+
+  NOTE: Any crash report will be in the filepath: $WORKSPACE/out/testcase
+  This can be used with GitHub's upload-artifact action to surface the logs.
+
+  Required environment variables:
+  Returns:
+    0 on success or 1 on failure.
+  """
+  logging.debug("Using cifuzz_combined_entrypoint.")
+  result = build_fuzzers_entrypoint.build_fuzzers_entrypoint()
+  if result != 0:
+    return result
+  return run_fuzzers_entrypoint.run_fuzzers_entrypoint()
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-commons-compress-full-01-vuln_1/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-commons-compress-full-01-vuln_1/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-commons-compress-full-01-vuln_1/fuzz-tooling/infra/cifuzz/requirements.txt

@@ -0,0 +1,4 @@
+clusterfuzz==2.5.9
+requests==2.28.0
+protobuf==3.20.2
+gsutil==5.20

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/uploader/Dockerfile

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

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

@@ -0,0 +1,80 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {println} from '../logger';
+import {commandHistory} from '../commandUtils';
+import {
+  hasOssFuzzInWorkspace,
+  getOssFuzzWorkspaceProjectName,
+  setStatusText,
+} from '../utils';
+import {buildFuzzersFromWorkspace} from '../ossfuzzWrappers';
+
+export async function cmdInputCollectorBuildFuzzersFromWorkspace() {
+  let ossFuzzProjectName = '';
+  // First determine if we have a name in the workspace
+  if (await hasOssFuzzInWorkspace()) {
+    /**
+     * The fuzzers are in the workspace, as opposed to e.g. the oss-fuzz dirctory.
+     */
+    ossFuzzProjectName = await getOssFuzzWorkspaceProjectName();
+  } else {
+    // If we did not have that, ask the user.
+
+    const ossFuzzProjectNameInput = await vscode.window.showInputBox({
+      value: '',
+      placeHolder: 'The OSS-Fuzz project name',
+    });
+    if (!ossFuzzProjectNameInput) {
+      println('Did not get a ossFuzzTargetProject');
+      return false;
+    }
+    ossFuzzProjectName = ossFuzzProjectNameInput.toString();
+  }
+
+  // Create an history object
+  const args = new Object({
+    projectName: ossFuzzProjectName,
+    sanitizer: '',
+    toClean: false,
+  });
+
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.WSBuildFuzzers',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchBuildFuzzersFromWorkspace,
+  });
+  console.log('L1: ' + commandHistory.length);
+  commandHistory.push(commandObject);
+
+  await cmdDispatchBuildFuzzersFromWorkspace(args);
+  return true;
+}
+
+async function cmdDispatchBuildFuzzersFromWorkspace(args: any) {
+  await setStatusText('Building fuzzers: starting');
+  const res = await buildFuzzersFromWorkspace(
+    args.projectName,
+    args.sanitizer,
+    args.toClean
+  );
+  if (res) {
+    await setStatusText('Building fuzzers: finished');
+  } else {
+    await setStatusText('Building fuzzers: failed');
+  }
+}

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

@@ -0,0 +1,38 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Command for generating template fuzzers. This is a short-cut for rapid
+ * prototyping as well as an archive for inspiration.
+ */
+import * as vscode from 'vscode';
+import {setStatusText} from '../utils';
+
+import {setupProjectInitialFiles} from '../projectIntegrationHelper';
+
+export async function cmdDispatcherGenerateClusterfuzzLite(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _context: vscode.ExtensionContext
+) {
+  await setStatusText('Creating OSS-Fuzz setup: starting');
+  const res = await setupProjectInitialFiles(true);
+  if (res) {
+    await setStatusText('Creating OSS-Fuzz setup: finished');
+  } else {
+    await setStatusText('Creating OSS-Fuzz setup: failed');
+  }
+  return;
+}

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

@@ -0,0 +1,192 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+const fs = require('fs');
+import {println} from '../logger';
+import {commandHistory} from '../commandUtils';
+import {buildFuzzersFromWorkspace, runFuzzerHandler} from '../ossfuzzWrappers';
+import {listFuzzersForProject, systemSync, setStatusText} from '../utils';
+import {
+  compareLocalToRemoteCoverage,
+  loadCoverageIntoWorkspace,
+} from '../coverageHelper';
+import {extensionConfig} from '../config';
+
+/**
+ * Performs the activities:
+ * 1) Build a project using address sanitizer
+ * 2) Run each fuzzer of the project, saving corpus
+ * 3) Build project using coverage sanitizer
+ * 4) Collect coverage
+ * @param context
+ * @returns
+ */
+export async function runEndToEndAndGetCoverage(
+  context: vscode.ExtensionContext
+) {
+  println('Getting code coverage');
+  await setStatusText('end-to-end coverage: getting input');
+  const ossFuzzProjectNameInput = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'The OSS-Fuzz project name',
+  });
+  if (!ossFuzzProjectNameInput) {
+    println('Did not get a ossFuzzTargetProject');
+    return;
+  }
+  const secondsToRunEachFuzzer = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'Seconds to run each fuzzer',
+  });
+  if (!secondsToRunEachFuzzer) {
+    println('Did not get number of seconds to run each fuzzer');
+    return;
+  }
+
+  // Create an history object
+  const args = new Object({
+    projectName: ossFuzzProjectNameInput.toString(),
+    secondsToRun: secondsToRunEachFuzzer.toString(),
+    vsContext: context,
+  });
+
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.cmdDispatchEndToEndRun',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchEndToEndRun,
+  });
+  console.log('L1: ' + commandHistory.length);
+  commandHistory.push(commandObject);
+
+  await cmdDispatchEndToEndRun(args);
+  return;
+}
+
+async function cmdDispatchEndToEndRun(args: any) {
+  await setStatusText('end-to-end coverage: starting');
+  const res = await endToEndRun(
+    args.projectName,
+    args.secondsToRun,
+    args.vsContext
+  );
+  if (res) {
+    await setStatusText('end-to-end coverage: finished succesfully');
+  } else {
+    await setStatusText('end-to-end coverage: failed');
+  }
+  return;
+}
+
+async function endToEndRun(
+  ossFuzzProjectNameInput: string,
+  secondsToRunEachFuzzer: string,
+  context: vscode.ExtensionContext
+) {
+  await setStatusText('end-to-end coverage: build with ASAN');
+  vscode.window.showInformationMessage(
+    'Building project: ' + ossFuzzProjectNameInput.toString()
+  );
+  if (
+    (await buildFuzzersFromWorkspace(
+      ossFuzzProjectNameInput.toString(),
+      '',
+      true
+    )) === false
+  ) {
+    println('Failed to build project');
+    return false;
+  }
+  println('Build projects');
+
+  // List all of the fuzzers in the project
+  const fuzzersInProject = await listFuzzersForProject(
+    ossFuzzProjectNameInput,
+    extensionConfig.ossFuzzPepositoryWorkPath
+  );
+
+  // Run all of the fuzzers in the project
+  await setStatusText('end-to-end coverage: collecting corpus');
+  println('Fuzzers found in project: ' + fuzzersInProject.toString());
+  println('Running each of the fuzzers to collect a corpus');
+  for (const fuzzName of fuzzersInProject) {
+    println('Running fuzzer: ' + fuzzName);
+    await setStatusText('end-to-end coverage: collecting corpus: ' + fuzzName);
+    // Corpus directory
+    const fuzzerCorpusPath =
+      extensionConfig.ossFuzzPepositoryWorkPath +
+      '/build/corpus/' +
+      ossFuzzProjectNameInput +
+      '/' +
+      fuzzName;
+
+    await systemSync('mkdir', ['-p', fuzzerCorpusPath]);
+
+    await runFuzzerHandler(
+      ossFuzzProjectNameInput,
+      fuzzName,
+      secondsToRunEachFuzzer.toString(),
+      fuzzerCorpusPath
+    );
+  }
+
+  // Build with code coverage
+  println('Building project with coverage sanitizer');
+  await setStatusText('end-to-end coverage: building with coverage');
+  await buildFuzzersFromWorkspace(
+    ossFuzzProjectNameInput.toString(),
+    'coverage',
+    true
+  );
+
+  // Run coverage command
+  println('Collecting code coverage');
+  await setStatusText('end-to-end coverage: collecting coverage');
+  const args: Array<string> = [
+    extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+    'coverage',
+    '--port',
+    '',
+    '--no-corpus-download',
+    ossFuzzProjectNameInput.toString(),
+  ];
+  await systemSync('python3', args);
+  await setStatusText('end-to-end coverage: finished collecting coverage');
+  println('Load coverage report with the command:');
+  println(
+    'python3 -m http.server 8008 --directory /tmp/oss-fuzz/build/out/' +
+      ossFuzzProjectNameInput.toString() +
+      '/report/'
+  );
+
+  println('Trying to load code coverage in IDE');
+  const allCovPath =
+    extensionConfig.ossFuzzPepositoryWorkPath +
+    '/build/out/' +
+    ossFuzzProjectNameInput.toString() +
+    '/textcov_reports/all_cov.json';
+  if (fs.existsSync(allCovPath)) {
+    const generatedCodeCoverageFile = vscode.Uri.file(allCovPath);
+    await loadCoverageIntoWorkspace(context, generatedCodeCoverageFile);
+  }
+
+  await compareLocalToRemoteCoverage(
+    context,
+    ossFuzzProjectNameInput.toString()
+  );
+
+  return true;
+}

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

@@ -0,0 +1,35 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {commandHistory} from '../commandUtils';
+
+/**
+ * Rerun the latest command
+ */
+export async function cmdDispatcherRe() {
+  if (commandHistory.length === 0) {
+    console.log('command history is empty');
+    return false;
+  }
+
+  const commandObj: any = commandHistory[commandHistory.length - 1];
+
+  console.log('Redoing');
+  console.log(commandObj.commandType);
+  await commandObj.dispatcherFunc(commandObj.Arguments);
+  //await commandObj.dispatcherFunc(commandObj.args);
+  return true;
+}

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

@@ -0,0 +1,167 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+const fs = require('fs');
+import {println} from '../logger';
+import {commandHistory} from '../commandUtils';
+import {systemSyncLogIfFailure} from '../utils';
+import {buildFuzzersFromWorkspace} from '../ossfuzzWrappers';
+import {extensionConfig} from '../config';
+const readline = require('readline');
+
+export async function cmdInputCollectorReproduceTestcase() {
+  // Runs a fuzzer from a given project.
+  const crashFileInput = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'The ID of the testcase.',
+  });
+  if (!crashFileInput) {
+    return;
+  }
+  // Create an history object and append it to the command history.
+  const args = new Object({
+    crashFile: crashFileInput.toString(),
+  });
+
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.ReproduceFuzzer',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchReproduceTestcase,
+  });
+  commandHistory.push(commandObject);
+
+  await cmdDispatchReproduceTestcase(args);
+  return true;
+}
+
+async function cmdDispatchReproduceTestcase(args: any) {
+  await reproduceTestcase(args.crashFile);
+}
+
+export async function reproduceTestcase(crashInfoFileInput: string) {
+  println('Reproducing testcase for ' + crashInfoFileInput);
+  println('Checking directory: ' + extensionConfig.crashesDirectory);
+
+  const crashInfoFile =
+    extensionConfig.crashesDirectory + '/' + crashInfoFileInput + '.info';
+  println(crashInfoFile);
+  try {
+    if (fs.existsSync(crashInfoFile)) {
+      println('File exists');
+    } else {
+      println('Crash file does not exist');
+      return;
+    }
+  } catch (err) {
+    console.error(err);
+    return;
+  }
+
+  // At this point the file exists
+  const r = readline.createInterface({
+    input: fs.createReadStream(crashInfoFile),
+  });
+
+  let targetProject = 'N/A';
+  let targetFuzzer = 'N/A';
+  // Logic for passing the file. This is based off of clusterfuzz monorail reports,
+  // and the intention is the file needs to be a copy of:
+  //
+  // Project: project-name
+  // Fuzzing Engine: libFuzzer
+  // Fuzz Target: fuzzer-name
+  //
+  // Example:
+  // The following URL: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=59747
+  // has the bug information:
+  // """
+  // Project: my-fuzzing-project
+  // Fuzzing Engine: libFuzzer
+  // Fuzz Target: the-fuzzer-name-fuzz-parseXX
+  // Job Type: libfuzzer_asan_my-fuzzing-project
+  // Platform Id: linux
+  // """
+  // and a link to a reproducer test case:
+  // https://oss-fuzz.com/download?testcase_id=5009071179431936
+  // which, when accessed will download the file
+  // clusterfuzz-testcase-minimized-flb-it-fuzz-config_map_fuzzer_OSSFUZZ-5009071179431936
+  //
+  // To enable reproducing of this issue we need to:
+  // - 1) Download the crash file and place it in the directory given in config.ts
+  //      and "crashesDirectory" variable.
+  // - 2) create a file "5009071179431936.info" and paste the information above
+  //      (Project:... Fuzz Target: ...) into the file. This information is
+  //      needed because we need to know project name and fuzzer name in order
+  //      to reproduce the crash.
+  // - 3) the reproducer can now be reproduced using the reproduce command
+  //      with argument "5009071179431936" as argument.
+  r.on('line', (text: string) => {
+    println(text);
+    if (text.startsWith('Project: ')) {
+      println('Starts with project');
+      println(text.split('Project: ').toString());
+      targetProject = text.split('Project: ')[1];
+    } else if (text.startsWith('Fuzzing Engine: ')) {
+      println('Starts with fuzzing engine');
+    } else if (text.startsWith('Fuzz Target:')) {
+      println('Starts with Fuzz Target');
+      targetFuzzer = text.split('Fuzz Target: ')[1];
+    } else if (text.startsWith('Job Type:')) {
+      println('Starts with Job Type');
+    }
+  });
+
+  r.on('close', async () => {
+    println('Target project: ' + targetProject);
+    println('Target fuzzer: ' + targetFuzzer);
+
+    // Build a fresh version of the project.
+    const buildResult: boolean = await buildFuzzersFromWorkspace(
+      targetProject,
+      '',
+      true
+    );
+    if (!buildResult) {
+      println('Failed to build fuzzers');
+      return false;
+    }
+
+    // We have a fresh build of the project, proceed to reproduce the testcase.
+    const crashInputTestCase =
+      extensionConfig.crashesDirectory +
+      '/' +
+      'clusterfuzz-testcase-minimized-' +
+      targetFuzzer +
+      '-' +
+      crashInfoFileInput;
+    // Run reproduce command against the target file
+    // Build the fuzzers using OSS-Fuzz infrastructure.
+    const cmdToExec = 'python3';
+    const args = [
+      extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+      'reproduce',
+      targetProject,
+      targetFuzzer,
+      crashInputTestCase,
+    ];
+    if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+      println('Failed to reproduce testcase');
+    }
+
+    return true;
+  });
+}

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

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

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

@@ -0,0 +1,83 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {println} from '../logger';
+import {commandHistory} from '../commandUtils';
+import {runFuzzerHandler} from '../ossfuzzWrappers';
+
+export async function cmdInputCollectorRunSpecificFuzzer() {
+  let projectNameArg = '';
+  let fuzzerName = '';
+  let secondsToRun = '';
+
+  // Runs a fuzzer from a given project.
+  const projectNameFromPrompt = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'Type a project name',
+  });
+  if (!projectNameFromPrompt) {
+    println('Failed to get project name');
+    return;
+  }
+  projectNameArg = projectNameFromPrompt.toString();
+  const fuzzerNameFromPrompt = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'Type a fuzzer name',
+  });
+  if (!fuzzerNameFromPrompt) {
+    println('Failed to get fuzzer name');
+    return;
+  }
+  fuzzerName = fuzzerNameFromPrompt.toString();
+  const secondsToRunInp = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'Type the number of seconds to run the fuzzer',
+  });
+  if (!secondsToRunInp) {
+    return;
+  }
+  secondsToRun = secondsToRunInp.toString();
+
+  // Create an history object
+  const args = new Object({
+    projectName: projectNameArg,
+    fuzzerName: fuzzerName,
+    secondsToRun: secondsToRun,
+    fuzzerCorpusPath: '',
+  });
+
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.RunFuzzer',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchRunFuzzerHandler,
+  });
+  console.log('L1: ' + commandHistory.length);
+  commandHistory.push(commandObject);
+
+  await cmdDispatchRunFuzzerHandler(args);
+  return true;
+}
+
+async function cmdDispatchRunFuzzerHandler(args: any) {
+  await runFuzzerHandler(
+    args.projectName,
+    args.fuzzerName,
+    args.secondsToRun,
+    args.fuzzerCorpusPath
+  );
+  return;
+}

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

@@ -0,0 +1,87 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {println} from '../logger';
+import {determineWorkspaceLanguage} from '../utils';
+import {cifuzzGenerator} from '../cifuzz';
+
+export async function setupCIFuzzHandler() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return false;
+  }
+
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+
+  /**
+   * Go through GitHub workflows to find potential traces of CIFuzz
+   */
+  const githubWorkflowsPath = vscode.Uri.file(wsPath + '/.github/workflows');
+  try {
+    await vscode.workspace.fs.readDirectory(githubWorkflowsPath);
+  } catch {
+    println('Did not find a workflows path.');
+    return false;
+  }
+
+  for (const [name, type] of await vscode.workspace.fs.readDirectory(
+    githubWorkflowsPath
+  )) {
+    // Skip directories.
+    if (type === 2) {
+      continue;
+    }
+
+    // Read the files.
+    println('Is a file');
+    const workflowFile = vscode.Uri.file(wsPath + '/.github/workflows/' + name);
+    const doc = await vscode.workspace.openTextDocument(workflowFile);
+    if (doc.getText().includes('cifuzz')) {
+      println('Found existing CIFuzz, will not continue.');
+      return false;
+    }
+  }
+
+  println('Did not find CIFuzz, creating one.');
+  const projectName = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'OSS-Fuzz project name',
+  });
+  if (!projectName) {
+    println('Failed to get project name');
+    return false;
+  }
+
+  /*
+   * There is no CIFuzz found, so we create one.
+   */
+  // Determine the language of the workspace.
+  const targetLanguage = await determineWorkspaceLanguage();
+  println('Target language: ' + targetLanguage);
+
+  // Generate a CIFuzz workflow text.
+  const cifuzzWorkflowText = cifuzzGenerator(targetLanguage, projectName, 30);
+
+  // Create the CIFuzz .yml file and write the contents to it to path
+  // .github/workflows/cifuzz.yml
+  const cifuzzYml = vscode.Uri.file(wsPath + '/.github/workflows/cifuzz.yml');
+  const wsedit = new vscode.WorkspaceEdit();
+  wsedit.createFile(cifuzzYml, {ignoreIfExists: true});
+  wsedit.insert(cifuzzYml, new vscode.Position(0, 0), cifuzzWorkflowText);
+  vscode.workspace.applyEdit(wsedit);
+  return true;
+}

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

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

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

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

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

@@ -0,0 +1,227 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+
+import {clearCoverage} from './coverageHelper';
+import {println} from './logger';
+
+// Import the command dispatcher functions
+import {cmdInputCollectorRunSpecificFuzzer} from './commands/cmdRunFuzzer';
+import {cmdInputCollectorBuildFuzzersFromWorkspace} from './commands/cmdBuildFuzzerFromWorkspace';
+import {cmdInputCollectorBuildFuzzersFromWorkspaceCFLite} from './commands/cmdBuildFuzzerFromWorkspaceCFLite';
+import {cmdInputCollectorTestFuzzerCFLite} from './commands/cmdTestFuzzerCFLite';
+import {cmdDispatcherRe} from './commands/cmdRedo';
+import {setupCIFuzzHandler} from './commands/cmdSetupCIFuzz';
+import {cmdInputCollectorTestFuzzer} from './commands/cmdTestFuzzer';
+import {displayCodeCoverageFromOssFuzz} from './commands/cmdDisplayCoverage';
+import {createOssFuzzSetup} from './commands/cmdCreateOSSFuzzSetup';
+import {runEndToEndAndGetCoverage} from './commands/cmdEndToEndCoverage';
+import {listFuzzersHandler} from './commands/cmdListFuzzers';
+import {cmdInputCollectorReproduceTestcase} from './commands/cmdReproduceTestcase';
+import {cmdDispatcherTemplate} from './commands/cmdTemplate';
+import {runGetOptimalTargetsHandler} from './commands/cmdFIGetOptimalTargets';
+import {setUpFuzzIntrospectorHandler} from './commands/cmdSetupFI';
+import {runFuzzIntrospectorHandler} from './commands/cmdRunFI';
+import {cmdDispatcherGenerateClusterfuzzLite} from './commands/cmdDispatcherGenerateClusterfuzzLite';
+import {setUpOssFuzzHandler} from './commands/cmdSetupOSSFuzz';
+import {setOssFuzzPath} from './commands/cmdSetOSSFuzzPath';
+import {extensionConfig} from './config';
+
+/**
+ * Extension entrypoint. Activate the extension and register the commands.
+ */
+export function activate(context: vscode.ExtensionContext) {
+  console.log('Activating extension)');
+  extensionConfig.printConfig();
+  println('OSS-Fuzz extension is now active!');
+
+  // Command registration
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.SetUp', async () => {
+      println('CMD start: SetUp');
+      await setUpOssFuzzHandler();
+      println('CMD end: SetUp');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.RunFuzzer', async () => {
+      println('CMD start: Run Fuzzer');
+      //await runFuzzerHandler('', '', '', '');
+      cmdInputCollectorRunSpecificFuzzer();
+      println('CMD end: Run Fuzzer');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.ListFuzzers', async () => {
+      println('CMD start: ListFuzzers');
+      await listFuzzersHandler();
+      println('CMD end: ListFuzzers');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.SetOSSFuzzPath', async () => {
+      println('CMD start: SetOSSFuzzPath');
+      await setOssFuzzPath();
+      println('CMD end: SetOSSFuzzPath');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.GetCodeCoverage', async () => {
+      println('CMD start: GetCodeCoverage');
+      await displayCodeCoverageFromOssFuzz(context);
+      println('CMD end: GetCodeCoverage');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.ClearCodeCoverage', async () => {
+      println('CMD start: ClearCodeCoverage');
+      await clearCoverage();
+      println('CMD end: ClearCodeCoverage');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.CreateOSSFuzzSetup', async () => {
+      println('CMD start: CreateOSSFuzzSetup');
+      await createOssFuzzSetup();
+      println('CMD end: CreateOSSFuzzSetup');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.WSBuildFuzzers', async () => {
+      println('CMD start: WSBuildFuzzers3');
+      await cmdInputCollectorBuildFuzzersFromWorkspace();
+      println('CMD end: WSBuildFuzzers4');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.SetupCIFuzz', async () => {
+      println('CMD start: SetupCIFuzz');
+      await setupCIFuzzHandler();
+      println('CMD end: SetupCIFuzz');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.testFuzzer', async () => {
+      println('CMD start: testFuzzer');
+      await cmdInputCollectorTestFuzzer();
+      println('CMD end: testFuzzer');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.testCodeCoverage', async () => {
+      println('CMD start: testCodeCoverage');
+      await runEndToEndAndGetCoverage(context);
+      println('CMD end: testCodeCoverage');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.Reproduce', async () => {
+      println('CMD start: Reproduce');
+      await cmdInputCollectorReproduceTestcase();
+      println('CMD end: Reproduce');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.Redo', async () => {
+      println('CMD start: Re');
+      await cmdDispatcherRe();
+      println('CMD end: Re');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.Template', async () => {
+      println('CMD start: remplate');
+      await cmdDispatcherTemplate(context);
+      println('CMD end: template');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      'oss-fuzz.GenerateClusterfuzzLite',
+      async () => {
+        println('CMD start: GenerateClusterfuzzLite');
+        await cmdDispatcherGenerateClusterfuzzLite(context);
+        println('CMD end: GenerateClusterfuzzLite');
+      }
+    )
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      'oss-fuzz.WSBuildFuzzersCFLite',
+      async () => {
+        println('CMD start: WSBuildFuzzersCFLite');
+        await cmdInputCollectorBuildFuzzersFromWorkspaceCFLite();
+        println('CMD end: WSBuildFuzzersCFLite');
+      }
+    )
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.testFuzzerCFLite', async () => {
+      println('CMD start: testFuzzerCFLite');
+      await cmdInputCollectorTestFuzzerCFLite();
+      println('CMD end: testFuzzerCFLite');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      'oss-fuzz.setupFuzzIntrospector',
+      async () => {
+        println('CMD start: setup FI');
+        await setUpFuzzIntrospectorHandler();
+      }
+    )
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      'oss-fuzz.runFuzzIntrospector',
+      async () => {
+        println('CMD start: run Fuzz Introspector');
+        await runFuzzIntrospectorHandler();
+      }
+    )
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.GetOptimalTargets', async () => {
+      println('CMD start: run GetOptimalTargets');
+      await runGetOptimalTargetsHandler();
+    })
+  );
+}
+
+// This method is called when your extension is deactivated
+export function deactivate() {
+  println('Deactivating the extension');
+}