Add files using upload-large-folder tool

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/getting-started/new-project-guide/bazel.md

@@ -0,0 +1,97 @@
+---
+layout: default
+title: Integrating a Bazel project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 5
+permalink: /getting-started/new-project-guide/bazel/
+---
+
+# Integrating a Bazel project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+## Bazel projects
+
+The process of integrating a project using the [Bazel](https://bazel.build/)
+build system with OSS-Fuzz is very similar to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Bazel project are outlined below.
+
+## Fuzzing support in Bazel
+
+For Bazel-based projects, we recommend using the
+[`rules_fuzzing`](https://github.com/bazelbuild/rules_fuzzing) extension library
+for defining fuzz tests. `rules_fuzzing` provides support for building and running
+fuzz tests under
+[multiple sanitizer and fuzzing engine configurations][rules-fuzzing-usage].
+It also supports specifying corpora and dictionaries as part of the fuzz test
+definition.
+
+The fuzzing rules provide out-of-the-box support for building and packaging fuzz
+test artifacts in the OSS-Fuzz format. Each `//path/to:fuzz_test` fuzz test
+target automatically has a `//path/to:fuzz_test_oss_fuzz` packaging target that
+(a) builds the fuzz test using the instrumentation and engine library specified
+in the OSS-Fuzz environment variables, and (b) generates an archive containing
+the binary and its associated artifacts (corpus, dictionary, etc.). Moreover,
+OSS-Fuzz provides a standard tool to automatically process these targets,
+substantially simplifying the `build.sh` script (see below).
+
+[rules-fuzzing-usage]: https://github.com/bazelbuild/rules_fuzzing#using-the-rules-in-your-project
+
+## Project files
+
+This section explains how to integrate the fuzz tests written using the
+`rules_fuzzing` library with OSS-Fuzz. You can also see a complete example in the
+[`bazel-rules-fuzzing-test`](https://github.com/google/oss-fuzz/tree/master/projects/bazel-rules-fuzzing-test)
+project.
+
+The structure of the project directory in the OSS-Fuzz repository does not
+differ for Bazel-based projects. The project files have the following specific
+aspects.
+
+### project.yaml
+
+Only C++ projects are currently supported.
+
+Since the OSS-Fuzz target builds the fuzz test using the instrumentation and
+engine specified in the OSS-Fuzz environment variables, all the engine and
+sanitizer configurations supported in the `project.yaml` file are automatically
+supported by the fuzzing rules.
+
+### Dockerfile
+
+There is no need to install Bazel in your Docker image. The OSS-Fuzz builder
+image provides the `bazel` executable through the
+[Bazelisk](https://github.com/bazelbuild/bazelisk) launcher, which will fetch
+and use the latest Bazel release. If your project requires a particular Bazel
+version, create a
+[`.bazelversion`](https://docs.bazel.build/versions/master/updating-bazel.html)
+file in your repository root with the desired version string.
+
+### build.sh
+
+Your `build.sh` script essentially needs to perform three steps: (1) selecting
+which fuzz tests to build, (2) building their OSS-Fuzz package targets in the
+right configuration, and (3) copying the build artifacts to the `${OUT}/`
+destination.
+
+OSS-Fuzz provides a
+[`bazel_build_fuzz_tests`](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/bazel_build_fuzz_tests)
+tool that implements these steps in a standard way, so in most cases your
+build script only needs to invoke this command with no arguments.
+
+If necessary, the behavior of the tool can be customized through a set of
+environment variables. The most common are:
+
+* `BAZEL_EXTRA_BUILD_FLAGS` are extra build flags passed on the Bazel command
+   line.
+* `BAZEL_FUZZ_TEST_TAG` and `BAZEL_FUZZ_TEST_EXCLUDE_TAG` can be overridden to
+  specify which target tags to use when determining what fuzz tests to include.
+  By default, the tool selects all the fuzz tests except for those tagged as
+  `"no-oss-fuzz"`.
+* `BAZEL_FUZZ_TEST_QUERY` overrides the Bazel query the tool uses to identify
+  the fuzz tests to build, if the tag-based approach is not sufficient.

local-test-commons-compress-full-01-vuln_1/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-commons-compress-full-01-vuln_1/fuzz-tooling/tools/vscode-extension/.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+insert_final_newline = true

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

@@ -0,0 +1,6 @@
+out
+build
+dist
+node_modules
+.vscode-test/
+*.vsix

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/tools/vscode-extension/.prettierrc.js

@@ -0,0 +1,18 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+module.exports = {
+  ...require('gts/.prettierrc.json')
+}

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

@@ -0,0 +1,70 @@
+// 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 {println} from './logger';
+
+/**
+ * Creates a CIFuzz template
+ * @param language
+ * @param projectName
+ * @param secondToRun
+ * @returns
+ */
+export function cifuzzGenerator(
+  language: string,
+  projectName: string,
+  secondToRun: Number
+) {
+  println('Exporting cifuzz logic ' + language);
+
+  const cifuzzTemplate = `name: CIFuzz
+on: [pull_request]
+permissions: {}
+jobs:
+    Fuzzing:
+    runs-on: ubuntu-latest
+    permissions:
+        security-events: write
+    steps:
+    - name: Build Fuzzers
+        id: build
+        uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+        with:
+        oss-fuzz-project-name: '${projectName}'
+        language: ${language}
+    - name: Run Fuzzers
+        uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+        with:
+        oss-fuzz-project-name: '${projectName}'
+        language: ${language}
+        fuzz-seconds: ${secondToRun}
+        output-sarif: true
+    - name: Upload Crash
+        uses: actions/upload-artifact@v3
+        if: failure() && steps.build.outcome == 'success'
+        with:
+        name: artifacts
+        path: ./out/artifacts
+    - name: Upload Sarif
+        if: always() && steps.build.outcome == 'success'
+        uses: github/codeql-action/upload-sarif@v2
+        with:
+        # Path to SARIF file relative to the root of the repository
+        sarif_file: cifuzz-sarif/results.sarif
+        checkout_path: cifuzz-sarif`;
+
+  return cifuzzTemplate;
+}

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

@@ -0,0 +1,17 @@
+// 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.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+export const commandHistory: any[] = [];

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

@@ -0,0 +1,71 @@
+// 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 {loadCoverageIntoWorkspace} from '../coverageHelper';
+import {println} from '../logger';
+import {getApi, FileDownloader} from '@microsoft/vscode-file-downloader-api';
+
+/*
+ * Displays code coverage from OSS-Fuzz.
+ *
+ * Downloads a code coverage report from the OSS-Fuzz online storage, and then overlays
+ * the relevant source files with the coverage information.
+ */
+export async function displayCodeCoverageFromOssFuzz(
+  context: vscode.ExtensionContext
+) {
+  const projectName = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: "The project you'd like to get code coverage for.",
+  });
+  if (!projectName) {
+    return;
+  }
+  println('Getting code coverage for ' + projectName);
+
+  const fileDownloader: FileDownloader = await getApi();
+
+  const currentDate = new Date();
+  const yesterday = new Date(currentDate);
+  yesterday.setDate(yesterday.getDate() - 1);
+
+  const day = yesterday.getDate();
+  const month = yesterday.getMonth();
+  const year = yesterday.getFullYear();
+
+  try {
+    const codeCoverageFile: vscode.Uri = await fileDownloader.downloadFile(
+      vscode.Uri.parse(
+        'https://storage.googleapis.com/oss-fuzz-coverage/' +
+          projectName +
+          '/textcov_reports/' +
+          year.toString() +
+          month.toString() +
+          day.toString() +
+          '/all_cov.json'
+      ),
+      'all_cov.json',
+      context
+    );
+    await loadCoverageIntoWorkspace(context, codeCoverageFile);
+  } catch (err) {
+    println(
+      'Could not get the URL. Currently, this feature is only supported for Python projects'
+    );
+    return;
+  }
+}

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

@@ -0,0 +1,21 @@
+// Copyright 2025 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 {getOptimalTargetsFromIntrospector} from '../fuzzIntrospectorHelper';
+
+export async function runGetOptimalTargetsHandler() {
+  getOptimalTargetsFromIntrospector();
+}

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

@@ -0,0 +1,42 @@
+// 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 {listFuzzersForProject} from '../utils';
+import {println} from '../logger';
+import {extensionConfig} from '../config';
+
+/**
+ * Lists all the fuzzers for a project.
+ */
+export async function listFuzzersHandler() {
+  // Lists all of the fuzzers from a project.
+  const projectName = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'Type a project name',
+  });
+  if (!projectName) {
+    console.log('Failed to get project name');
+    return;
+  }
+  println('Listing fuzzers for project ' + projectName);
+
+  await listFuzzersForProject(
+    projectName?.toString(),
+    extensionConfig.ossFuzzPepositoryWorkPath
+  );
+}

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

@@ -0,0 +1,59 @@
+// 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 {extensionConfig} from '../config';
+
+// Set the oss-fuzz path.
+export async function setOssFuzzPath() {
+  println('Setting path');
+  const newOssFuzzPath = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'Type path',
+  });
+  if (!newOssFuzzPath) {
+    println('Failed getting path');
+    return;
+  }
+
+  const fpathh = vscode.Uri.file(newOssFuzzPath);
+  let isValid = false;
+  try {
+    if (await vscode.workspace.fs.readDirectory(fpathh)) {
+      println('Is a directory');
+      const helperPathURI = vscode.Uri.file(
+        newOssFuzzPath + '/infra/helper.py'
+      );
+      if (await vscode.workspace.fs.readFile(helperPathURI)) {
+        println('Found helper file');
+        isValid = true;
+      }
+      isValid = true;
+    } else {
+      isValid = false;
+    }
+  } catch {
+    isValid = false;
+  }
+
+  if (isValid) {
+    extensionConfig.ossFuzzPepositoryWorkPath = newOssFuzzPath;
+  } else {
+    println('Not setting OSS-Fuzz path');
+  }
+}

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/tools/vscode-extension/src/commands/cmdSetupFI.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 {setUpFuzzIntrospector} from '../fuzzIntrospectorHelper';
+
+/**
+ * Function for setting up Fuzz Introspector by way of a Python virtual env.
+ */
+export async function setUpFuzzIntrospectorHandler() {
+  setUpFuzzIntrospector();
+}

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

@@ -0,0 +1,53 @@
+// 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 {println} from '../logger';
+import {extensionConfig} from '../config';
+import {isPathValidOssFuzzPath} from '../ossfuzzWrappers';
+import {systemSync} from '../utils';
+
+/**
+ * Function for setting up oss-fuzz. This clones the relevant directory
+ * and sets the oss-fuzz variable accordingly.
+ */
+export async function setUpOssFuzzHandler() {
+  println('Setting up oss-fuzz in /tmp/');
+
+  // First check if we already have an OSS-Fuzz path
+  const tmpOssFuzzRepositoryPath = '/tmp/oss-fuzz';
+
+  if ((await isPathValidOssFuzzPath(tmpOssFuzzRepositoryPath)) === true) {
+    println('OSS-Fuzz already exists in /tmp/oss-fuzz');
+    extensionConfig.ossFuzzPepositoryWorkPath = tmpOssFuzzRepositoryPath;
+    return;
+  }
+
+  const cmdToExec = 'git';
+  const args: Array<string> = [
+    'clone',
+    'https://github.com/google/oss-fuzz',
+    tmpOssFuzzRepositoryPath,
+  ];
+  const [res, output] = await systemSync(cmdToExec, args);
+  if (res === false) {
+    println('Failed to clone oss-fuzz');
+    println(output);
+    return;
+  }
+  println('Finished cloning oss-fuzz');
+
+  extensionConfig.ossFuzzPepositoryWorkPath = tmpOssFuzzRepositoryPath;
+}

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

@@ -0,0 +1,37 @@
+// 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 {println} from './logger';
+
+export class ExtensionConfig {
+  /** Path to the repository that will be used. */
+  ossFuzzPepositoryWorkPath: string = '/tmp/oss-fuzz';
+
+  /** The directory where crash info is stored. */
+  crashesDirectory = process.env.HOME + '/oss-fuzz-crashes';
+
+  /** Number of seconds used for running quick test fuzzers */
+  numberOfSecondsForTestRuns = 20;
+
+  async printConfig() {
+    println('Config:');
+    println('- OSS-Fuzz repository path: ' + this.ossFuzzPepositoryWorkPath);
+    println('- Crashes directory: ' + this.crashesDirectory);
+    println('- numberOfSecondsForTestRuns: ' + this.numberOfSecondsForTestRuns);
+  }
+}
+
+export const extensionConfig = new ExtensionConfig();

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

@@ -0,0 +1,300 @@
+// 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 {Uri} from 'vscode';
+import {println} from './logger';
+import {
+  getOSSFuzzCloudURL,
+  getLocalOutBuildDir,
+  downloadRemoteURL,
+} from './utils';
+
+const path = require('path');
+let isCodeCoverageEnabled = false;
+
+// create a decorator type that we use to decorate small numbers
+const codeCoveredLineDecorationType =
+  vscode.window.createTextEditorDecorationType({
+    backgroundColor: '#184916',
+    overviewRulerColor: 'blue',
+    overviewRulerLane: vscode.OverviewRulerLane.Right,
+    light: {
+      // this color will be used in light color themes
+      borderColor: 'darkblue',
+    },
+    dark: {
+      // this color will be used in dark color themes
+      borderColor: 'lightblue',
+    },
+  });
+
+const missingLineDecorationType = vscode.window.createTextEditorDecorationType({
+  backgroundColor: '#6C2B34',
+  overviewRulerColor: 'blue',
+  overviewRulerLane: vscode.OverviewRulerLane.Right,
+  light: {
+    // this color will be used in light color themes
+    borderColor: 'darkblue',
+  },
+  dark: {
+    // this color will be used in dark color themes
+    borderColor: 'lightblue',
+  },
+});
+
+export async function loadSummaryJsonCoverage(
+  context: vscode.ExtensionContext,
+  codeCoverageFile: Uri
+) {
+  const coverageSummaryRawJson = await vscode.workspace.openTextDocument(
+    codeCoverageFile
+  );
+  const jsonCodeCoverage = JSON.parse(coverageSummaryRawJson.getText());
+  return jsonCodeCoverage;
+}
+
+export async function compareLocalToRemoteCoverage(
+  context: vscode.ExtensionContext,
+  projectName: string
+) {
+  println('Checking the file matching');
+  /* Get the coverage from the remote server */
+  const urlString =
+    (await getOSSFuzzCloudURL(projectName)) + '/linux/summary.json';
+
+  println('URL: ' + urlString);
+  const codeCoverageFile: false | vscode.Uri = await downloadRemoteURL(
+    urlString,
+    'summary.json',
+    context
+  );
+  if (!codeCoverageFile) {
+    println('Could not get the coverage summary file');
+    return;
+  }
+  const remoteCoverage = await loadSummaryJsonCoverage(
+    context,
+    codeCoverageFile
+  );
+
+  /* Get the local coverage report */
+  // Compare the local coverage to the upstream coverage
+  const localSummaryCovPath =
+    (await getLocalOutBuildDir(projectName)) + '/report/linux/summary.json';
+  const localCodeCoverage = await loadSummaryJsonCoverage(
+    context,
+    vscode.Uri.file(localSummaryCovPath)
+  );
+
+  for (let i = 0; i < localCodeCoverage.data[0].files.length; i++) {
+    for (let j = 0; j < remoteCoverage.data[0].files.length; j++) {
+      // Get the file dictionary
+      const localFileData = localCodeCoverage.data[0].files[i];
+      const remoteFileData = remoteCoverage.data[0].files[j];
+
+      // If the filepaths are the same, then we match coverage data
+      if (localFileData.filename === remoteFileData.filename) {
+        const remoteFuncCount = remoteFileData.summary.functions.count;
+        const localFuncCount = localFileData.summary.functions.count;
+
+        if (localFuncCount > remoteFuncCount) {
+          println(
+            'Coverage improved in :' +
+              localFileData.filename +
+              ' [' +
+              localFuncCount +
+              ' : ' +
+              remoteFuncCount +
+              ']'
+          );
+        }
+      }
+    }
+  }
+}
+
+/**
+ *
+ * @param context Adds visualisation to the editor based on reading a code coverage file.
+ * @param codeCoverageFile
+ */
+export async function loadCoverageIntoWorkspace(
+  context: vscode.ExtensionContext,
+  codeCoverageFile: Uri
+) {
+  isCodeCoverageEnabled = true;
+
+  const doc3 = await vscode.workspace.openTextDocument(codeCoverageFile);
+  const jsonCodeCoverageObj3 = JSON.parse(doc3.getText());
+
+  const codeCoverageMappingWithCoverage = new Map();
+  const codeCoverageMapMissingCoverage = new Map();
+
+  Object.entries(jsonCodeCoverageObj3['files']).forEach(entry => {
+    const [key, value] = entry;
+    println(key);
+    const filename = path.parse(key).base;
+    println('Filename base: ' + filename);
+    const objectDictionary: any = value as any;
+    const linesWithCodeCoverage: unknown[] = [];
+    println(objectDictionary['executed_lines']);
+    Object.entries(objectDictionary['executed_lines']).forEach(entryInner => {
+      const lineNumber = entryInner[1];
+      //println("executed line: " + lineNumber);
+      linesWithCodeCoverage.push(lineNumber);
+    });
+    codeCoverageMappingWithCoverage.set(filename, linesWithCodeCoverage);
+
+    const linesMissingCodeCoverage: unknown[] = [];
+    Object.entries(objectDictionary['missing_lines']).forEach(entryInner => {
+      const lineNumber = entryInner[1];
+      //println("executed line: " + line_numb);
+      linesMissingCodeCoverage.push(lineNumber);
+    });
+    codeCoverageMapMissingCoverage.set(filename, linesMissingCodeCoverage);
+  });
+  println('=========>');
+
+  println('Enabling code coverage decorator');
+  println('decorator sample is activated');
+
+  let timeout: NodeJS.Timer | undefined = undefined;
+
+  // create a decorator type that we use to decorate large numbers
+
+  let activeEditor = vscode.window.activeTextEditor;
+
+  function updateDecorations(
+    linesWithCodeCoverage: any,
+    linesWithoNoCodeCoverage: any
+  ) {
+    if (!isCodeCoverageEnabled) {
+      return;
+    }
+    if (!activeEditor) {
+      return;
+    }
+    println('Filename');
+    println(activeEditor.document.fileName);
+
+    // Current file opened in the editor.
+    const nameOfCurrentFile = path.parse(activeEditor.document.fileName).base;
+
+    println('Base filename: ' + nameOfCurrentFile);
+    println('Done filename');
+    const lineNumbersWithCoverage: vscode.DecorationOptions[] = [];
+    const missingLineNumbers: vscode.DecorationOptions[] = [];
+
+    if (linesWithCodeCoverage.has(nameOfCurrentFile)) {
+      println('Has this file');
+      const elemWithCov = linesWithCodeCoverage.get(nameOfCurrentFile);
+      for (let idx = 0; idx < elemWithCov.length; idx++) {
+        const lineNo = elemWithCov[idx];
+        println('Setting up: ' + lineNo);
+        lineNumbersWithCoverage.push({
+          range: new vscode.Range(lineNo - 1, 0, lineNo, 0),
+        });
+      }
+
+      const elemNoCov = linesWithoNoCodeCoverage.get(nameOfCurrentFile);
+      for (let idx = 0; idx < elemNoCov.length; idx++) {
+        const lineNo = elemNoCov[idx];
+        println('Setting up: ' + lineNo);
+        missingLineNumbers.push({
+          range: new vscode.Range(lineNo - 1, 0, lineNo, 0),
+        });
+      }
+    } else {
+      println('Does not have this file');
+    }
+
+    activeEditor.setDecorations(
+      codeCoveredLineDecorationType,
+      lineNumbersWithCoverage
+    );
+    activeEditor.setDecorations(missingLineDecorationType, missingLineNumbers);
+    //activeEditor.setDecorations(largeNumberDecorationType, largeNumbers);
+  }
+
+  function triggerUpdateDecorations(
+    throttle = false,
+    covMap: any,
+    covMisMap: any
+  ) {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = undefined;
+    }
+    if (throttle) {
+      //timeout = setTimeout(updateDecorations, 500);
+      updateDecorations(covMap, covMisMap);
+    } else {
+      updateDecorations(covMap, covMisMap);
+    }
+  }
+
+  if (activeEditor) {
+    triggerUpdateDecorations(
+      false,
+      codeCoverageMappingWithCoverage,
+      codeCoverageMapMissingCoverage
+    );
+  }
+
+  vscode.window.onDidChangeActiveTextEditor(
+    editor => {
+      activeEditor = editor;
+      if (editor) {
+        triggerUpdateDecorations(
+          false,
+          codeCoverageMappingWithCoverage,
+          codeCoverageMapMissingCoverage
+        );
+      }
+    },
+    null,
+    context.subscriptions
+  );
+
+  vscode.workspace.onDidChangeTextDocument(
+    event => {
+      if (activeEditor && event.document === activeEditor.document) {
+        triggerUpdateDecorations(
+          true,
+          codeCoverageMappingWithCoverage,
+          codeCoverageMapMissingCoverage
+        );
+      }
+    },
+    null,
+    context.subscriptions
+  );
+}
+
+/**
+ * Removes the values from the mappings used to track code coverage. As a
+ * result, the visualisation disappears.
+ */
+export async function clearCoverage() {
+  // Set global indicator.
+  const activeEditor = vscode.window.activeTextEditor;
+  isCodeCoverageEnabled = false;
+  if (activeEditor) {
+    activeEditor.setDecorations(codeCoveredLineDecorationType, []);
+    activeEditor.setDecorations(missingLineDecorationType, []);
+  }
+}

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

@@ -0,0 +1,117 @@
+// Copyright 2025 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 {extensionConfig} from './config';
+import {isPathValidOssFuzzPath} from './ossfuzzWrappers';
+import {systemSync} from './utils';
+
+const fs = require('fs');
+
+export async function setUpFuzzIntrospector() {
+  println('Setting up oss-fuzz in /tmp/');
+
+  // First check if we already have Fuzz Introspector installed.
+  const tmpOssFuzzRepositoryPath = '/tmp/fi-tmp-env';
+
+  if ((await isPathValidOssFuzzPath(tmpOssFuzzRepositoryPath)) === true) {
+    println('Fuzz Introspector virtual env already exists in /tmp/fi-tmp-env');
+    extensionConfig.ossFuzzPepositoryWorkPath = tmpOssFuzzRepositoryPath;
+    return;
+  }
+
+  const cmdToExec = 'python3.11';
+  const args: Array<string> = ['-m', 'virtualenv', tmpOssFuzzRepositoryPath];
+  const [res, output] = await systemSync(cmdToExec, args);
+  if (res === false) {
+    println('Failed to create virtual environment');
+    println(output);
+    return;
+  }
+
+  const cmdToExec2 = '/tmp/fi-tmp-env/bin/python3.11';
+  const args2: Array<string> = [
+    '-m',
+    'pip',
+    'install',
+    'fuzz-introspector==0.1.6',
+  ];
+  const [res2, output2] = await systemSync(cmdToExec2, args2);
+  if (res2 === false) {
+    println('Failed to create virtual environment');
+    println(output2);
+    return;
+  }
+}
+
+export async function runFuzzIntrospector() {
+  println('Setting up oss-fuzz in /tmp/');
+
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return;
+  }
+  const pathOfLocal = workspaceFolder[0].uri.fsPath;
+  println('path of local: ' + pathOfLocal);
+
+  // First check if we already have Fuzz Introspector installed.
+  const tmpOssFuzzRepositoryPath = '/tmp/fi-tmp-env';
+
+  if ((await isPathValidOssFuzzPath(tmpOssFuzzRepositoryPath)) === true) {
+    println('Fuzz Introspector virtual env already exists in /tmp/fi-tmp-env');
+    extensionConfig.ossFuzzPepositoryWorkPath = tmpOssFuzzRepositoryPath;
+    return;
+  }
+
+  await systemSync('mkdir', ['-p', '/tmp/out-fi/']);
+
+  const cmdToExec = '/tmp/fi-tmp-env/bin/fuzz-introspector';
+  const args: Array<string> = [
+    'full',
+    '--target_dir=' + pathOfLocal,
+    '--out-dir=/tmp/out-fi',
+  ];
+  const [res, output] = await systemSync(cmdToExec, args);
+  if (res === false) {
+    println('Failed run FI');
+    println(output);
+    return;
+  }
+}
+
+export async function getOptimalTargetsFromIntrospector() {
+  if (!fs.existsSync('/tmp/out-fi/summary.json')) {
+    println('There are no introspector reports. Please run introspector first');
+  }
+  const json_data = fs.readFileSync('/tmp/out-fi/summary.json');
+  // println(json_data);
+
+  const jsonCodeCoverage = JSON.parse(json_data);
+
+  println('Optimal targets');
+  Object.entries(jsonCodeCoverage['analyses']['OptimalTargets']).forEach(
+    entry => {
+      const [key, value] = entry;
+      const objectDictionary: any = value as any;
+      println(JSON.stringify(objectDictionary, null, 2));
+    }
+  );
+  println('--------------------------');
+
+  return;
+}

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

@@ -0,0 +1,31 @@
+// 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';
+export const vscodeOutputChannel =
+  vscode.window.createOutputChannel('oss-fuzz');
+
+export function println(line: string) {
+  vscodeOutputChannel.appendLine(line);
+}
+
+export function printRaw(line: string) {
+  vscodeOutputChannel.append(line);
+}
+
+export function debugPrintln(line: string) {
+  console.log(line);
+}

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

@@ -0,0 +1,385 @@
+// 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.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+const fs = require('fs');
+import * as vscode from 'vscode';
+import {
+  hasOssFuzzInWorkspace,
+  getOssFuzzWorkspaceProjectName,
+  listFuzzersForProject,
+  systemSyncLogIfFailure,
+} from './utils';
+import {println} from './logger';
+import {extensionConfig} from './config';
+
+export async function buildFuzzersFromWorkspaceClusterfuzzLite() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    println('No workspace folder, exiting');
+    return false;
+  }
+
+  // Build the fuzzers using OSS-Fuzz infrastructure.
+  const cmdToExec = 'python3';
+  const args = [
+    extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+    'build_fuzzers',
+  ];
+
+  args.push('--external');
+  args.push(workspaceFolder[0].uri.path);
+  println('Building fuzzers');
+  if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+    println('Failed to build fuzzers');
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Builds the fuzzers for a given workspace.
+ *
+ * There are two options:
+ *  1) The fuzzers are build using the OSS-Fuzz set up in the folder
+ *  2) The fuzzers are build using the workspace and then copies that over.
+ */
+export async function buildFuzzersFromWorkspace(
+  projectNameArg: string,
+  sanitizer: string,
+  toClean: boolean
+) {
+  // println('Building fuzzers locally');
+
+  // Check if there is an OSS-Fuzz set up, and exit if not.
+  if (
+    (await isPathValidOssFuzzPath(
+      extensionConfig.ossFuzzPepositoryWorkPath
+    )) === false
+  ) {
+    println('No valid oss-fuzz path');
+    return false;
+  }
+
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    println('No workspace folder, exiting');
+    return false;
+  }
+
+  let ossFuzzProjectName = '';
+  if (await hasOssFuzzInWorkspace()) {
+    /**
+     * The fuzzers are in the workspace, as opposed to e.g. the oss-fuzz dirctory.
+     */
+    ossFuzzProjectName = await getOssFuzzWorkspaceProjectName();
+
+    /**
+     * The workspace has an OSS-Fuzz directory. We use this for the build.
+     * This is done by copying over the relevant files to the oss-fuzz repository
+     * folder. Notice that we will do a forceful copy overwriting the existing
+     * project foler if it exists.
+     */
+    println('Found project folder: ' + ossFuzzProjectName);
+
+    // Copy over the workspace oss-fuzz set up to the oss-fuzz folder.
+    let cmdToExec = 'cp';
+    let args: Array<string> = [
+      '-rfT',
+      workspaceFolder[0].uri.path + '/OSS-Fuzz/' + ossFuzzProjectName,
+      extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/',
+    ];
+
+    if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+      println('Failed to copy project');
+      return false;
+    }
+
+    // Build the fuzzers using OSS-Fuzz infrastructure.
+    cmdToExec = 'python3';
+    args = [
+      extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+      'build_fuzzers',
+    ];
+    println('DECIDING ABOUT SANITIZER');
+    if (sanitizer !== '') {
+      println('ADDING CODE COVERAGE SANITIZER');
+      args.push('--sanitizer=' + sanitizer);
+    }
+
+    if (toClean) {
+      args.push('--clean');
+    }
+
+    args.push(ossFuzzProjectName);
+    println('Building fuzzers');
+    if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+      println('Failed to build fuzzers');
+      return false;
+    }
+  } else {
+    ossFuzzProjectName = projectNameArg;
+
+    const targetOssFuzzProject = vscode.Uri.file(
+      extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName
+    );
+    // Check if the folder exists.
+    let projectHasOssFuzzFolder = false;
+    try {
+      await vscode.workspace.fs.readDirectory(targetOssFuzzProject);
+      projectHasOssFuzzFolder = true;
+    } catch {
+      projectHasOssFuzzFolder = false;
+    }
+
+    /**
+     * The workspace does not have a OSS-Fuzz specific folder but has
+     * a folder in the OSS-Fuzz/projects/* directory. As such, we build
+     * the project using that build.sh set up, but, instead of cloning
+     * the repository we mount the workspace root onto what would normally
+     * be cloned.
+     */
+    if (projectHasOssFuzzFolder) {
+      // println('Found a target directory');
+
+      // Build the fuzzers using OSS-Fuzz infrastructure.
+      // First, Set up a temporary workpath that will be cleanup after
+      const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+      const cmdToExec2 = 'cp';
+      const temporaryProjectPath =
+        extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/temporary-project';
+
+      const args2: Array<string> = [
+        '-rfT',
+        wsPath.toString(),
+        temporaryProjectPath,
+      ];
+
+      if (!(await systemSyncLogIfFailure(cmdToExec2, args2))) {
+        println('Failed to build fuzzers');
+        return false;
+      }
+
+      //const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+      const temporaryDockerPath =
+        extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/Dockerfile';
+      const temporaryDockerPath2 =
+        extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/Dockerfile2';
+
+      const args3: Array<string> = [temporaryDockerPath, temporaryDockerPath2];
+      if (!(await systemSyncLogIfFailure('cp', args3))) {
+        println('Failed to copy Dockerfile');
+        return false;
+      }
+
+      // Append COPY command to Dockerfile
+      fs.appendFileSync(
+        temporaryDockerPath,
+        'COPY temporary-project /src/' + ossFuzzProjectName
+      );
+
+      // Second, build the actual fuzzers using the temporarily created project path for mount.
+      const cmdToExec = 'python3';
+      const args = [
+        extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+        'build_fuzzers', // command
+      ];
+
+      // Add sanitizer if needed.
+      if (sanitizer !== '') {
+        args.push('--sanitizer=' + sanitizer);
+      }
+
+      // Add clean flag if needed.
+      if (toClean) {
+        args.push('--clean');
+      }
+
+      args.push(ossFuzzProjectName);
+      /*
+      Previously we used OSS-Fuzz logic that supports mounting paths for getting
+      the workspace into the Dockerfile.
+      This approach, however, has limitations in that most builds will modify
+      the contents of the folder they're working in. This can cause issues and also
+      make it not possible to build several versions of the project with changing
+      sanitizers in a sequence. As such, we disbanded.
+      */
+      println('Building fuzzers');
+      if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+        println('Failed to copy Dockerfile');
+        // Move back the modified Dockerfile
+        const args5: Array<string> = [
+          temporaryDockerPath2,
+          temporaryDockerPath,
+        ];
+        if (!(await systemSyncLogIfFailure('mv', args5))) {
+          println('Failed to copy back Dockerfile');
+          return false;
+        }
+        return false;
+      }
+
+      // Move back the modified Dockerfile
+      const args5: Array<string> = [temporaryDockerPath2, temporaryDockerPath];
+      if (!(await systemSyncLogIfFailure('mv', args5))) {
+        println('Failed to copy back Dockerfile');
+        return false;
+      }
+    } else {
+      println('OSS-Fuzz does not have the relevant project folder');
+      return false;
+    }
+  }
+
+  // If we go to here we successfully build the project. Give information.
+  vscode.window.showInformationMessage('Successfully build project');
+
+  // List the fuzzers build
+  await listFuzzersForProject(
+    ossFuzzProjectName,
+    extensionConfig.ossFuzzPepositoryWorkPath
+  );
+  return true;
+}
+
+/**
+ * Runs the fuzzer for a given CFLite project
+ */
+export async function runFuzzerHandlerCFLite(
+  projectNameArg: string,
+  fuzzerNameArg: string,
+  secondsToRunArg: string
+) {
+  // The fuzzer is run by way of OSS-Fuzz's helper.py so we use python3 to launch
+  // this script.
+  const cmdToExec = 'python3';
+
+  // Set the arguments correctly. The ordering here is important for compatibility
+  // with the underlying argparse used by OSS-Fuzz helper.py.
+  const args: Array<string> = [
+    extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+    'run_fuzzer',
+  ];
+
+  args.push('--external');
+  args.push(projectNameArg);
+  args.push(fuzzerNameArg);
+  args.push('--');
+  args.push('-max_total_time=' + secondsToRunArg);
+
+  println(
+    'Running fuzzer' +
+      fuzzerNameArg +
+      ' from project ' +
+      projectNameArg +
+      ' for ' +
+      secondsToRunArg +
+      ' seconds.'
+  );
+
+  // Run the actual command
+  if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+    println('Failed to run fuzzer');
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Runs the fuzzer for a given project.
+ */
+export async function runFuzzerHandler(
+  projectNameArg: string,
+  fuzzerNameArg: string,
+  secondsToRunArg: string,
+  fuzzerCorpusPath: string
+) {
+  // Check there is a valid OSS-Fuzz path. If not, bail out.
+  if (
+    (await isPathValidOssFuzzPath(
+      extensionConfig.ossFuzzPepositoryWorkPath
+    )) === false
+  ) {
+    println('Missing valid OSS-Fuzz path.');
+    return;
+  }
+  // The fuzzer is run by way of OSS-Fuzz's helper.py so we use python3 to launch
+  // this script.
+  const cmdToExec = 'python3';
+
+  // Set the arguments correctly. The ordering here is important for compatibility
+  // with the underlying argparse used by OSS-Fuzz helper.py.
+  const args: Array<string> = [
+    extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+    'run_fuzzer',
+  ];
+  if (fuzzerCorpusPath !== '') {
+    args.push('--corpus-dir');
+    args.push(fuzzerCorpusPath);
+  }
+  args.push(projectNameArg);
+  args.push(fuzzerNameArg);
+  args.push('--');
+  args.push('-max_total_time=' + secondsToRunArg);
+
+  println(
+    'Running fuzzer' +
+      fuzzerNameArg +
+      ' from project ' +
+      projectNameArg +
+      ' for ' +
+      secondsToRunArg +
+      ' seconds.'
+  );
+
+  // Run the actual command
+  if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+    println('Failed to run fuzzer');
+    return false;
+  }
+  return true;
+}
+
+// Validates if a directory is a valid oss-fuzz path.
+export async function isPathValidOssFuzzPath(path: string) {
+  try {
+    if (await vscode.workspace.fs.readDirectory(vscode.Uri.file(path))) {
+      // println('Is a directory');
+      // const helperPath = vscode.Uri.file(path + '/infra/helper.py');
+      const helperPath = path + '/infra/helper.py';
+      //console.log('Checking ' + helperPath.toString());
+      if (fs.existsSync(helperPath.toString())) {
+        return true;
+      }
+    }
+  } catch {
+    /* empty */
+  }
+  return false;
+}

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

@@ -0,0 +1,761 @@
+// 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 path = require('path');
+import {println} from './logger';
+import * as fuzzTemplate from './commands/cmdTemplate';
+
+export async function setupProjectInitialFiles(isClusterfuzzLite: boolean) {
+  const wsedit = new vscode.WorkspaceEdit();
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  let projectGithubRepository = '';
+
+  const isOssFuzz = isClusterfuzzLite === false;
+
+  // Get the repository if this is not ClusterfuzzLite
+  if (isOssFuzz) {
+    const tmpProjectGithubRepository = await vscode.window.showInputBox({
+      value: '',
+      placeHolder: 'Github repository for the project.',
+    });
+    if (!tmpProjectGithubRepository) {
+      return false;
+    }
+    projectGithubRepository = tmpProjectGithubRepository;
+  }
+
+  const projectNameFromRepo = path
+    .parse(projectGithubRepository)
+    .base.toLocaleLowerCase();
+
+  let pathOfLocal = '';
+  if (workspaceFolder) {
+    pathOfLocal = path
+      .parse(workspaceFolder[0].uri.fsPath)
+      .base.toLocaleLowerCase();
+    println('path of local: ' + pathOfLocal);
+  }
+  if (isOssFuzz) {
+    println('Derived project name: ' + projectNameFromRepo);
+  }
+
+  const pythonFiles = await vscode.workspace.findFiles('**/*.py');
+  const cppFiles = await vscode.workspace.findFiles('**/*.c++');
+  const cppFiles2 = await vscode.workspace.findFiles('**/*.cpp');
+  const cppFiles3 = await vscode.workspace.findFiles('**/*.cc');
+  const cfiles = await vscode.workspace.findFiles('**/*.c');
+  const hfiles = await vscode.workspace.findFiles('**/*.h');
+  const rustFiles = await vscode.workspace.findFiles('**/*.rust');
+  const golangFiles = await vscode.workspace.findFiles('**/*.go');
+  const javaFiles = await vscode.workspace.findFiles('**/*.java');
+
+  println('Number of python files: ' + pythonFiles.length);
+  println('Number of C++ files: ' + cppFiles.length + cppFiles2.length);
+  println('Number of C files: ' + cfiles.length);
+  println('Number of rustFiles files: ' + rustFiles.length);
+  println('Number of golangFiles files: ' + golangFiles.length);
+  println('Number of H files: ' + hfiles.length);
+
+  const cppFilesCount = cppFiles.length + cppFiles2.length + cppFiles3.length;
+
+  const maxCount = Math.max(
+    pythonFiles.length,
+    cppFilesCount,
+    cfiles.length,
+    rustFiles.length,
+    golangFiles.length,
+    javaFiles.length
+  );
+  let target = '';
+  if (maxCount > 0) {
+    if (maxCount === pythonFiles.length) {
+      target = 'python';
+    } else if (maxCount === cppFilesCount) {
+      target = 'cpp';
+    } else if (maxCount === cfiles.length) {
+      target = 'c';
+    } else if (maxCount === javaFiles.length) {
+      target = 'java';
+    } else {
+      println('Target is not implemented');
+      return true;
+    }
+  } else {
+    if (hfiles.length > 0) {
+      target = 'cpp';
+    } else {
+      return true;
+    }
+  }
+
+  println('Target language: ' + target);
+
+  let baseFolder = '.clusterfuzzlite';
+  if (isOssFuzz) {
+    baseFolder = 'OSS-Fuzz';
+  }
+
+  if (workspaceFolder) {
+    const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+
+    // Create workflow file for ClusterFuzzLite
+    if (isOssFuzz === false) {
+      println('Creating the workflow file');
+      const clusterfuzzWorkflowFile = vscode.Uri.file(
+        wsPath + '/' + '.github' + '/' + 'workflows/cflite_pr.yml'
+      );
+
+      let tmp_target = target;
+      if (tmp_target === 'cpp') {
+        tmp_target = 'c++';
+      }
+
+      //println('Workflow pth: ' + clusterfuzzWorkflowFile);
+
+      const cflite_workflow_yaml = `name: ClusterFuzzLite PR fuzzing
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [ main ]
+permissions: read-all
+jobs:
+  PR:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        sanitizer: [address]
+    steps:
+    - name: Build Fuzzers (\${{ matrix.sanitizer }})
+      id: build
+      uses: google/clusterfuzzlite/actions/build_fuzzers@v1
+      with:
+        sanitizer: \${{ matrix.sanitizer }}
+        language: ${tmp_target}
+        bad-build-check: false
+    - name: Run Fuzzers (\${{ matrix.sanitizer }})
+      id: run
+      uses: google/clusterfuzzlite/actions/run_fuzzers@v1
+      with:
+        github-token: \${{ secrets.GITHUB_TOKEN }}
+        fuzz-seconds: 100
+        mode: 'code-change'
+        report-unreproducible-crashes: false
+        sanitizer: \${{ matrix.sanitizer }}
+`;
+
+      // Create the file and add the contents
+      if (fs.existsSync(clusterfuzzWorkflowFile.path) === false) {
+        wsedit.createFile(clusterfuzzWorkflowFile, {ignoreIfExists: true});
+        wsedit.insert(
+          clusterfuzzWorkflowFile,
+          new vscode.Position(0, 0),
+          cflite_workflow_yaml
+        );
+      }
+    }
+
+    const ossfuzzDockerFilepath = vscode.Uri.file(
+      wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/Dockerfile'
+    );
+
+    vscode.window.showInformationMessage(ossfuzzDockerFilepath.toString());
+    //wsedit.createFile(ossfuzzDockerFilepath, {ignoreIfExists: true});
+
+    if (target === 'python') {
+      await setupPythonProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        pathOfLocal,
+        isOssFuzz
+      );
+    }
+    if (target === 'cpp') {
+      await setupCPPProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        pathOfLocal,
+        isOssFuzz
+      );
+    }
+    if (target === 'c') {
+      await setupCProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        pathOfLocal,
+        isOssFuzz
+      );
+    }
+    if (target === 'java') {
+      await setupJavaProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        isOssFuzz
+      );
+    }
+    vscode.workspace.applyEdit(wsedit);
+    vscode.window.showInformationMessage('Created a new file: hello/world.md');
+  }
+  return true;
+}
+
+function createProjectYamlContent(
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  isOssFuzz: boolean,
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  language: string
+) {
+  const projectYamlFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/project.yaml'
+  );
+  if (fs.existsSync(projectYamlFilepath.path) === false) {
+    vscode.window.showInformationMessage(projectYamlFilepath.toString());
+    wsedit.createFile(projectYamlFilepath, {ignoreIfExists: true});
+    const projectYamlTemplate = `homepage: "${projectGithubRepository}"
+language: ${language}
+primary_contact: "<primary_contact_email>"
+main_repo: "${projectGithubRepository}"
+file_github_issue: true
+    `;
+
+    const projectYamlTemplateCFLite = `language: ${language}`;
+
+    const yamlContentToWrite = isOssFuzz
+      ? projectYamlTemplate
+      : projectYamlTemplateCFLite;
+
+    wsedit.insert(
+      projectYamlFilepath,
+      new vscode.Position(0, 0),
+      yamlContentToWrite
+    );
+  }
+}
+
+function getLicenseHeader() {
+  const todaysDate = new Date();
+  const currentYear = todaysDate.getFullYear();
+
+  const licenseHeader = `# Copyright ${currentYear} 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.
+#
+################################################################################
+`;
+
+  return licenseHeader;
+}
+
+function getBaseDockerFile(language: string) {
+  const languageToBasebuilder: {[id: string]: string} = {
+    java: 'ghcr.io/aixcc-finals/base-builder-jvm',
+    cpp: 'ghcr.io/aixcc-finals/base-builder',
+    c: 'ghcr.io/aixcc-finals/base-builder',
+    python: 'ghcr.io/aixcc-finals/base-builder-python',
+  };
+  let dockerFileContent = getLicenseHeader();
+  dockerFileContent += '\n' + 'FROM ' + languageToBasebuilder[language] + '\n';
+
+  return dockerFileContent;
+}
+
+function createReadmeFile(
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  isOssFuzz: boolean
+) {
+  const readmeFile = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + '/README.md'
+  );
+  //vscode.window.showInformationMessage(readmeFile.toString());
+  if (fs.existsSync(readmeFile.path) === false) {
+    const readmeContents = `# OSS-Fuzz set up
+This folder is the OSS-Fuzz set up.
+    `;
+
+    const readmeContentsCFLite = `# ClusterFuzzLite set up
+This folder contains a fuzzing set for [ClusterFuzzLite](https://google.github.io/clusterfuzzlite).
+        `;
+
+    const readmeContentsToWrite = isOssFuzz
+      ? readmeContents
+      : readmeContentsCFLite;
+
+    wsedit.createFile(readmeFile, {ignoreIfExists: true});
+
+    wsedit.insert(readmeFile, new vscode.Position(0, 0), readmeContentsToWrite);
+  }
+}
+
+async function setupJavaProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  isOssFuzz: boolean
+) {
+  // Dockerfile
+  const dockerfileTemplate =
+    getBaseDockerFile('java') +
+    ` 
+RUN curl -L https://archive.apache.org/dist/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.zip -o maven.zip && \\
+    unzip maven.zip -d $SRC/maven && \\
+    rm -rf maven.zip
+
+ENV MVN $SRC/maven/apache-maven-3.6.3/bin/mvn
+RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+WORKDIR ${projectNameFromRepo}
+COPY build.sh *.java $SRC/`;
+  wsedit.insert(
+    ossfuzzDockerFilepath,
+    new vscode.Position(0, 0),
+    dockerfileTemplate
+  );
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+  wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+  const buildTemplate =
+    `#!/bin/bash -eu
+  ` +
+    getLicenseHeader() +
+    `
+# Supply build instructions
+# Copy all fuzzer executables to $OUT/
+`;
+  wsedit.insert(ossfuzzBuildFilepath, new vscode.Position(0, 0), buildTemplate);
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'jvm'
+  );
+
+  /* Sample template fuzzer */
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath +
+      '/' +
+      baseFolder +
+      '/' +
+      projectNameFromRepo +
+      '/fuzzer_example.java'
+  );
+
+  wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+  const sampleFuzzFileContents = fuzzTemplate.javaLangBareTemplate;
+
+  wsedit.insert(
+    sampleFuzzFile,
+    new vscode.Position(0, 0),
+    sampleFuzzFileContents
+  );
+
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}
+
+async function setupCProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  baseName: string,
+  isOssFuzz: boolean
+) {
+  // Dockerfile
+  if (fs.existsSync(ossfuzzDockerFilepath.path) === false) {
+    const dockerfileTemplate =
+      getBaseDockerFile('cpp') +
+      `
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+WORKDIR ${projectNameFromRepo}
+COPY build.sh *.cpp $SRC/`;
+
+    const dockerfileTemplateClusterfuzzLite = `FROM ghcr.io/aixcc-finals/base-builder
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+
+COPY . $SRC/${baseName}
+COPY .clusterfuzzlite/build.sh $SRC/build.sh
+WORKDIR $SRC/${baseName}`;
+
+    const contentToWrite = isOssFuzz
+      ? dockerfileTemplate
+      : dockerfileTemplateClusterfuzzLite;
+
+    // Create the file and add the contents
+    wsedit.createFile(ossfuzzDockerFilepath, {ignoreIfExists: true});
+    wsedit.insert(
+      ossfuzzDockerFilepath,
+      new vscode.Position(0, 0),
+      contentToWrite
+    );
+  }
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  // Only create the build file if it doesn't exist
+  if (fs.existsSync(ossfuzzBuildFilepath.path) === false) {
+    vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+    wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+    const buildTemplate =
+      `#!/bin/bash -eu
+  ` +
+      getLicenseHeader() +
+      `
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CXX $CFLAGS $LIB_FUZZING_ENGINE $SRC/fuzzer_example.c -o $OUT/fuzzer_example
+`;
+
+    const buildTemplateClusterfuzzLite = `#!/bin/bash -eu
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CC $CFLAGS $LIB_FUZZING_ENGINE \\
+  $SRC/${baseName}/.clusterfuzzlite/fuzzer_example.c \\
+  -o $OUT/fuzzer_example
+`;
+
+    const buildContent = isOssFuzz
+      ? buildTemplate
+      : buildTemplateClusterfuzzLite;
+    wsedit.insert(
+      ossfuzzBuildFilepath,
+      new vscode.Position(0, 0),
+      buildContent
+    );
+  }
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'c'
+  );
+
+  /* Sample template fuzzer */
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/fuzzer_example.c'
+  );
+  if (fs.existsSync(sampleFuzzFile.path) === false) {
+    wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+    const sampleFuzzFileContents = fuzzTemplate.cLangSimpleStringFuzzer;
+
+    wsedit.insert(
+      sampleFuzzFile,
+      new vscode.Position(0, 0),
+      sampleFuzzFileContents
+    );
+  }
+
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}
+
+async function setupCPPProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  baseName: string,
+  isOssFuzz: boolean
+) {
+  // Dockerfile
+  // Only create a new Dockerfile if it doesn't already exist
+  if (fs.existsSync(ossfuzzDockerFilepath.path) === false) {
+    const dockerfileTemplate =
+      getBaseDockerFile('cpp') +
+      ` 
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+WORKDIR ${projectNameFromRepo}
+COPY build.sh *.cpp $SRC/`;
+
+    const dockerfileTemplateClusterfuzzLite = `FROM ghcr.io/aixcc-finals/base-builder
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+
+COPY . $SRC/${baseName}
+COPY .clusterfuzzlite/build.sh $SRC/build.sh
+WORKDIR $SRC/${baseName}`;
+
+    const contentToWrite = isOssFuzz
+      ? dockerfileTemplate
+      : dockerfileTemplateClusterfuzzLite;
+
+    // Create the file and add the contents
+    wsedit.createFile(ossfuzzDockerFilepath, {ignoreIfExists: true});
+    wsedit.insert(
+      ossfuzzDockerFilepath,
+      new vscode.Position(0, 0),
+      contentToWrite
+    );
+  }
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  // Only create the build file if it doesn't exist
+  if (fs.existsSync(ossfuzzBuildFilepath.path) === false) {
+    vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+    wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+    const buildTemplate =
+      `#!/bin/bash -eu
+  ` +
+      getLicenseHeader() +
+      `
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CXX $CXXFLAGS $LIB_FUZZING_ENGINE $SRC/fuzzer_example.cpp -o $OUT/fuzzer_example
+`;
+    const buildTemplateClusterfuzzLite = `#!/bin/bash -eu
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CXX $CXXFLAGS $LIB_FUZZING_ENGINE \\
+  $SRC/${baseName}/.clusterfuzzlite/fuzzer_example.cpp \\
+  -o $OUT/fuzzer_example
+`;
+
+    const buildContent = isOssFuzz
+      ? buildTemplate
+      : buildTemplateClusterfuzzLite;
+    wsedit.insert(
+      ossfuzzBuildFilepath,
+      new vscode.Position(0, 0),
+      buildContent
+    );
+  }
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'c++'
+  );
+
+  /* Sample template fuzzer */
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath +
+      '/' +
+      baseFolder +
+      '/' +
+      projectNameFromRepo +
+      '/fuzzer_example.cpp'
+  );
+  if (fs.existsSync(sampleFuzzFile.path) === false) {
+    wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+    const sampleFuzzFileContents = fuzzTemplate.cppLangFDPTemplateFuzzer;
+
+    wsedit.insert(
+      sampleFuzzFile,
+      new vscode.Position(0, 0),
+      sampleFuzzFileContents
+    );
+  }
+
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}
+
+async function setupPythonProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  baseName: string,
+  isOssFuzz: boolean
+) {
+  // Only write to Dockerfile if it doesn't already exist
+  // Dockerfile
+  if (fs.existsSync(ossfuzzDockerFilepath.path) === false) {
+    const dockerfileTemplate =
+      getBaseDockerFile('python') +
+      ` 
+  RUN python3 -m pip install --upgrade pip
+  RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+  WORKDIR ${projectNameFromRepo}
+  COPY build.sh *.py $SRC/`;
+
+    const dockerfileTemplateClusterfuzzLite =
+      getBaseDockerFile('python') +
+      ` 
+  RUN apt-get update && apt-get install -y make autoconf automake libtool
+
+  COPY . $SRC/${baseName}
+  COPY .clusterfuzzlite/build.sh $SRC/build.sh
+  WORKDIR $SRC/${baseName}`;
+
+    const contentToWrite = isOssFuzz
+      ? dockerfileTemplate
+      : dockerfileTemplateClusterfuzzLite;
+
+    wsedit.insert(
+      ossfuzzDockerFilepath,
+      new vscode.Position(0, 0),
+      contentToWrite
+    );
+  }
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  // Only create the build file if it doesn't exist
+  if (fs.existsSync(ossfuzzBuildFilepath.path) === false) {
+    vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+    wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+    const buildTemplate =
+      `#!/bin/bash -eu
+  ` +
+      getLicenseHeader() +
+      `
+python3 -m pip install .
+
+# Build fuzzers (files prefixed with fuzz_) to $OUT
+for fuzzer in $(find $SRC -name 'fuzz_*.py'); do
+  compile_python_fuzzer $fuzzer
+done`;
+
+    const buildTemplateClusterfuzzLite = `#!/bin/bash -eu
+python3 -m pip install .
+
+# Build fuzzers (files prefixed with fuzz_) to $OUT
+for fuzzer in $(find $SRC -name 'fuzz_*.py'); do
+  compile_python_fuzzer $fuzzer
+done`;
+
+    const buildContent = isOssFuzz
+      ? buildTemplate
+      : buildTemplateClusterfuzzLite;
+    wsedit.insert(
+      ossfuzzBuildFilepath,
+      new vscode.Position(0, 0),
+      buildContent
+    );
+  }
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'python'
+  );
+
+  // Sample template fuzzer
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/fuzz_ex1.py'
+  );
+  if (fs.existsSync(sampleFuzzFile.path) === false) {
+    wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+    const sampleFuzzFileContents = fuzzTemplate.pythonLangFileInputFuzzer;
+
+    wsedit.insert(
+      sampleFuzzFile,
+      new vscode.Position(0, 0),
+      sampleFuzzFileContents
+    );
+  }
+
+  // README.md
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}

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

@@ -0,0 +1,306 @@
+// 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 {extensionConfig} from './config';
+import {getApi, FileDownloader} from '@microsoft/vscode-file-downloader-api';
+
+const fs = require('fs');
+const {spawn} = require('node:child_process');
+const statusBarComp = vscode.window.createStatusBarItem(
+  vscode.StatusBarAlignment.Right,
+  100
+);
+
+import {println, printRaw, debugPrintln} from './logger';
+
+export async function setStatusText(statusText: string) {
+  //let myStatusBarItem: vscode.StatusBarItem;
+  statusBarComp.text = '$(megaphone) OSS-Fuzz: ' + statusText;
+  statusBarComp.show();
+}
+
+export async function downloadRemoteURL(
+  urlString: string,
+  targetFile: string,
+  context: vscode.ExtensionContext
+) {
+  const fileDownloader: FileDownloader = await getApi();
+  println('URL: ' + urlString);
+  let codeCoverageFile: vscode.Uri;
+  try {
+    codeCoverageFile = await fileDownloader.downloadFile(
+      vscode.Uri.parse(urlString),
+      targetFile,
+      context
+    );
+  } catch (err) {
+    println('Could not get the coverage summary file');
+    return false;
+  }
+  return codeCoverageFile;
+}
+
+export async function getLocalOutBuildDir(projectName: string) {
+  const summaryCovPath =
+    extensionConfig.ossFuzzPepositoryWorkPath + '/build/out/' + projectName;
+  return summaryCovPath;
+}
+
+export async function getOSSFuzzCloudURL(projectName: string) {
+  const currentDate = new Date();
+  const yesterday = new Date(currentDate);
+  yesterday.setDate(yesterday.getDate() - 1);
+
+  const day = yesterday.getDate();
+  const month = yesterday.getMonth();
+  const year = yesterday.getFullYear();
+
+  let urlString =
+    'https://storage.googleapis.com/oss-fuzz-coverage/' +
+    projectName +
+    '/reports/' +
+    year.toString();
+
+  if (month < 10) {
+    urlString += '0';
+  }
+  urlString += month.toString();
+  if (day < 10) {
+    urlString += '0';
+  }
+  urlString += day.toString();
+
+  return urlString;
+}
+
+/**
+ * Checks if the current workspace has a generated OSS-Fuzz folder. This is the
+ * generated folder from our auto-generation capabilities.
+ *
+ * @returns boolean
+ */
+export async function hasOssFuzzInWorkspace() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+
+  if (!workspaceFolder) {
+    return false;
+  }
+
+  // Identify if the workspace folder has a OSS-Fuzz set up.
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+  const ossfuzzDockerFilepath = vscode.Uri.file(wsPath + '/OSS-Fuzz/');
+  try {
+    if (await vscode.workspace.fs.readDirectory(ossfuzzDockerFilepath)) {
+      for (const [name, type] of await vscode.workspace.fs.readDirectory(
+        ossfuzzDockerFilepath
+      )) {
+        // If it's a directory then we know we have the project set up in there.
+        if (type === 2) {
+          // We assume this is the project folder for now.
+          println('Found the relevant directory: ' + name);
+          return true;
+        }
+      }
+    }
+  } catch {
+    /* empty */
+  }
+  return false;
+}
+
+/**
+ * Gets the project name of the integrated OSS-Fuzz project.
+ * @returns string
+ */
+export async function getOssFuzzWorkspaceProjectName() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return 'N/A';
+  }
+
+  // Identify if the workspace folder has a OSS-Fuzz set up.
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+  const ossfuzzDockerFilepath = vscode.Uri.file(wsPath + '/OSS-Fuzz/');
+  try {
+    if (await vscode.workspace.fs.readDirectory(ossfuzzDockerFilepath)) {
+      for (const [name, type] of await vscode.workspace.fs.readDirectory(
+        ossfuzzDockerFilepath
+      )) {
+        if (type === 2) {
+          // println('Is a directory');
+          // We assume this is the project folder for now.
+          return name;
+        }
+      }
+    }
+  } catch {
+    /* empty */
+  }
+
+  return 'N/A';
+}
+
+/**
+ * Lists the fuzzers available in the OSS-Fuzz build project.
+ *
+ * @param projectName
+ * @param ossFuzzRepositoryPath
+ * @returns
+ */
+export async function listFuzzersForProject(
+  projectName: string,
+  ossFuzzRepositoryPath: string
+) {
+  const projectOssFuzzBuildPath = vscode.Uri.file(
+    ossFuzzRepositoryPath + '/build/out/' + projectName
+  );
+  const fuzzersInProject: Array<string> = [];
+  for (const [name, type] of await vscode.workspace.fs.readDirectory(
+    projectOssFuzzBuildPath
+  )) {
+    // Is it a file?
+    if (type === 1) {
+      const filepath =
+        ossFuzzRepositoryPath + '/build/out/' + projectName + '/' + name;
+      const binary = fs.readFileSync(filepath);
+
+      // Check if fuzzer entrypoint exists in file. This is similar to how OSS-Fuzz
+      // checks whether a file is fuzzer or not.
+      if (binary.lastIndexOf('LLVMFuzzerTestOneInput') !== -1) {
+        fuzzersInProject.push(name);
+      }
+    }
+  }
+  println('Successfully build the project.');
+  println('The fuzzers in project');
+  for (const fuzzName of fuzzersInProject) {
+    println(fuzzName);
+  }
+  return fuzzersInProject;
+}
+
+/**
+ * Helper functions for identifying the primary programming language of the workspace.
+ *
+ * This is achieved by identifying the suffix of files and then sorting
+ * based on those with most of a given language supported by OSS-Fuzz.
+ *
+ * @returns
+ */
+export async function determineWorkspaceLanguage() {
+  const pythonFiles = await vscode.workspace.findFiles('**/*.py');
+  const cppFiles = await vscode.workspace.findFiles('**/*.c++');
+  const cfiles = await vscode.workspace.findFiles('**/*.c');
+  const rustFiles = await vscode.workspace.findFiles('**/*.rust');
+  const golangFiles = await vscode.workspace.findFiles('**/*.go');
+
+  println('Number of python files: ' + pythonFiles.length);
+  println('Number of C++ files: ' + cppFiles.length);
+  println('Number of C files: ' + cfiles.length);
+  println('Number of rustFiles files: ' + rustFiles.length);
+  println('Number of golangFiles files: ' + golangFiles.length);
+
+  const maxCount = Math.max(
+    pythonFiles.length,
+    cppFiles.length,
+    cfiles.length,
+    rustFiles.length,
+    golangFiles.length
+  );
+  let target = '';
+  if (maxCount === pythonFiles.length) {
+    target = 'python';
+  } else if (maxCount === cppFiles.length) {
+    target = 'c++';
+  } else if (maxCount === cfiles.length) {
+    target = 'c';
+  } else if (maxCount === rustFiles.length) {
+    target = 'rust';
+  } else if (maxCount === golangFiles.length) {
+    target = 'golang';
+  } else {
+    target = 'not implemented';
+  }
+
+  println('Target language: ' + target);
+  return target;
+}
+
+/**
+ * Helper method to execute commands on the system.
+ */
+export async function systemSync(cmd: string, args: Array<string | undefined>) {
+  debugPrintln('Running command');
+  debugPrintln(cmd);
+  debugPrintln(args.toString());
+  debugPrintln('<<<<<<<<<<<<');
+
+  // Launch the command
+  const command = spawn(cmd, args);
+
+  // Callbacks for output events, to capture stdout and stderr live.
+  command.stdout.on('data', (x: {toString: () => string}) => {
+    printRaw(x.toString());
+  });
+  command.stderr.on('data', (x: {toString: () => string}) => {
+    printRaw(x.toString());
+  });
+
+  // Monitor for child exit.
+  let hasChildExited = 0;
+  let childExitCode = 0;
+  command.on('exit', (code: any, signal: any) => {
+    // println('child process exited with ' + `code ${code} and signal ${signal}`);
+    childExitCode = code;
+    hasChildExited = 1;
+  });
+
+  // Block until the child process has exited.
+  const snooze = (ms: number) =>
+    new Promise(resolve => setTimeout(resolve, ms));
+
+  let idx = 0;
+  const maxSeconds = 1800;
+  debugPrintln('Child exited: ' + hasChildExited);
+
+  // I think we can convert the following loop to a Promise wrapping the command
+  // exeuction. TODO(David).
+  while (hasChildExited === 0 && idx < maxSeconds) {
+    idx += 1;
+    await snooze(1000);
+  }
+
+  // Command execution is done, return appropriately if success/error.
+  if (childExitCode !== 0) {
+    println('Command execution errored');
+    return [false, command.toString()];
+  }
+  // println('Succes');
+  return [true, command.toString()];
+}
+
+export async function systemSyncLogIfFailure(
+  cmd: string,
+  args: Array<string | undefined>
+): Promise<boolean> {
+  const [res, cmdMsg] = await systemSync(cmd, args);
+  if (res === false) {
+    println(cmdMsg);
+    return false;
+  }
+  return true;
+}