Add files using upload-large-folder tool

local-test-tika-delta-04/fuzz-tooling/infra/base-images/all.sh

@@ -0,0 +1,28 @@
+#!/bin/bash -eux
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+docker build --pull -t ghcr.io/aixcc-finals/base-image "$@" infra/base-images/base-image
+docker build -t ghcr.io/aixcc-finals/base-clang "$@" infra/base-images/base-clang
+docker build -t ghcr.io/aixcc-finals/base-builder "$@" infra/base-images/base-builder
+docker build -t ghcr.io/aixcc-finals/base-builder-go "$@" infra/base-images/base-builder-go
+docker build -t ghcr.io/aixcc-finals/base-builder-jvm "$@" infra/base-images/base-builder-jvm
+docker build -t ghcr.io/aixcc-finals/base-builder-python "$@" infra/base-images/base-builder-python
+docker build -t ghcr.io/aixcc-finals/base-builder-rust "$@" infra/base-images/base-builder-rust
+docker build -t ghcr.io/aixcc-finals/base-builder-ruby "$@" infra/base-images/base-builder-ruby
+docker build -t ghcr.io/aixcc-finals/base-builder-swift "$@" infra/base-images/base-builder-swift
+docker build -t ghcr.io/aixcc-finals/base-runner "$@" infra/base-images/base-runner
+docker build -t ghcr.io/aixcc-finals/base-runner-debug "$@" infra/base-images/base-runner-debug

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

@@ -0,0 +1,410 @@
+# Copyright 2019 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 to build a image from a specific commit, branch or pull request.
+
+This module is allows each of the OSS Fuzz projects fuzzers to be built
+from a specific point in time. This feature can be used for implementations
+like continuious integration fuzzing and bisection to find errors
+"""
+import argparse
+import bisect
+import datetime
+import os
+import collections
+import json
+import logging
+import re
+import shutil
+import tempfile
+
+import helper
+import repo_manager
+import retry
+import utils
+
+BuildData = collections.namedtuple(
+    'BuildData', ['project_name', 'engine', 'sanitizer', 'architecture'])
+
+_GIT_DIR_MARKER = 'gitdir: '
+_IMAGE_BUILD_TRIES = 3
+
+
+class BaseBuilderRepo:
+  """Repo of base-builder images."""
+
+  def __init__(self):
+    self.timestamps = []
+    self.digests = []
+
+  def add_digest(self, timestamp, digest):
+    """Add a digest."""
+    self.timestamps.append(timestamp)
+    self.digests.append(digest)
+
+  def find_digest(self, timestamp):
+    """Find the latest image before the given timestamp."""
+    index = bisect.bisect_right(self.timestamps, timestamp)
+    if index > 0:
+      return self.digests[index - 1]
+
+    logging.error('Failed to find suitable base-builder.')
+    return None
+
+
+def _replace_gitdir(src_dir, file_path):
+  """Replace gitdir with a relative path."""
+  with open(file_path) as handle:
+    lines = handle.readlines()
+
+  new_lines = []
+  for line in lines:
+    if line.startswith(_GIT_DIR_MARKER):
+      absolute_path = line[len(_GIT_DIR_MARKER):].strip()
+      if not os.path.isabs(absolute_path):
+        # Already relative.
+        return
+
+      current_dir = os.path.dirname(file_path)
+      # Rebase to /src rather than the host src dir.
+      base_dir = current_dir.replace(src_dir, '/src')
+      relative_path = os.path.relpath(absolute_path, base_dir)
+      logging.info('Replacing absolute submodule gitdir from %s to %s',
+                   absolute_path, relative_path)
+
+      line = _GIT_DIR_MARKER + relative_path
+
+    new_lines.append(line)
+
+  with open(file_path, 'w') as handle:
+    handle.write(''.join(new_lines))
+
+
+def _make_gitdirs_relative(src_dir):
+  """Make gitdirs relative."""
+  for root_dir, _, files in os.walk(src_dir):
+    for filename in files:
+      if filename != '.git':
+        continue
+
+      file_path = os.path.join(root_dir, filename)
+      _replace_gitdir(src_dir, file_path)
+
+
+def _replace_base_builder_digest(dockerfile_path, digest):
+  """Replace the base-builder digest in a Dockerfile."""
+  with open(dockerfile_path) as handle:
+    lines = handle.readlines()
+
+  new_lines = []
+  for line in lines:
+    if line.strip().startswith('FROM'):
+      line = 'FROM ghcr.io/aixcc-finals/base-builder@' + digest + '\n'
+
+    new_lines.append(line)
+
+  with open(dockerfile_path, 'w') as handle:
+    handle.write(''.join(new_lines))
+
+
+def copy_src_from_docker(project_name, host_dir):
+  """Copy /src from docker to the host."""
+  # Copy /src to host.
+  image_name = 'gcr.io/oss-fuzz/' + project_name
+  src_dir = os.path.join(host_dir, 'src')
+  if os.path.exists(src_dir):
+    shutil.rmtree(src_dir, ignore_errors=True)
+
+  docker_args = [
+      '-v',
+      host_dir + ':/out',
+      image_name,
+      'cp',
+      '-r',
+      '-p',
+      '/src',
+      '/out',
+  ]
+  helper.docker_run(docker_args)
+
+  # Submodules can have gitdir entries which point to absolute paths. Make them
+  # relative, as otherwise we can't do operations on the checkout on the host.
+  _make_gitdirs_relative(src_dir)
+  return src_dir
+
+
+@retry.wrap(_IMAGE_BUILD_TRIES, 2)
+def _build_image_with_retries(project_name):
+  """Build image with retries."""
+  return helper.build_image_impl(helper.Project(project_name))
+
+
+def get_required_post_checkout_steps(dockerfile_path):
+  """Get required post checkout steps (best effort)."""
+
+  checkout_pattern = re.compile(r'\s*RUN\s*(git|svn|hg)')
+
+  # If the build.sh is copied from upstream, we need to copy it again after
+  # changing the revision to ensure correct building.
+  post_run_pattern = re.compile(r'\s*RUN\s*(.*build\.sh.*(\$SRC|/src).*)')
+
+  with open(dockerfile_path) as handle:
+    lines = handle.readlines()
+
+  subsequent_run_cmds = []
+  for i, line in enumerate(lines):
+    if checkout_pattern.match(line):
+      subsequent_run_cmds = []
+      continue
+
+    match = post_run_pattern.match(line)
+    if match:
+      workdir = helper.workdir_from_lines(lines[:i])
+      command = match.group(1)
+      subsequent_run_cmds.append((workdir, command))
+
+  return subsequent_run_cmds
+
+
+# pylint: disable=too-many-locals
+def build_fuzzers_from_commit(commit,
+                              build_repo_manager,
+                              host_src_path,
+                              build_data,
+                              base_builder_repo=None):
+  """Builds a OSS-Fuzz fuzzer at a specific commit SHA.
+
+  Args:
+    commit: The commit SHA to build the fuzzers at.
+    build_repo_manager: The OSS-Fuzz project's repo manager to be built at.
+    build_data: A struct containing project build information.
+    base_builder_repo: A BaseBuilderRepo.
+  Returns:
+    0 on successful build or error code on failure.
+  """
+  oss_fuzz_repo_manager = repo_manager.RepoManager(helper.OSS_FUZZ_DIR)
+  num_retry = 1
+
+  def cleanup():
+    # Re-copy /src for a clean checkout every time.
+    copy_src_from_docker(build_data.project_name,
+                         os.path.dirname(host_src_path))
+    build_repo_manager.fetch_all_remotes()
+
+  projects_dir = os.path.join('projects', build_data.project_name)
+  dockerfile_path = os.path.join(projects_dir, 'Dockerfile')
+
+  for i in range(num_retry + 1):
+    build_repo_manager.checkout_commit(commit, clean=False)
+
+    post_checkout_steps = get_required_post_checkout_steps(dockerfile_path)
+    for workdir, post_checkout_step in post_checkout_steps:
+      logging.info('Running post-checkout step `%s` in %s.', post_checkout_step,
+                   workdir)
+      helper.docker_run([
+          '-w',
+          workdir,
+          '-v',
+          host_src_path + ':' + '/src',
+          'gcr.io/oss-fuzz/' + build_data.project_name,
+          '/bin/bash',
+          '-c',
+          post_checkout_step,
+      ])
+
+    project = helper.Project(build_data.project_name)
+    result = helper.build_fuzzers_impl(project=project,
+                                       clean=True,
+                                       engine=build_data.engine,
+                                       sanitizer=build_data.sanitizer,
+                                       architecture=build_data.architecture,
+                                       env_to_add=None,
+                                       source_path=host_src_path,
+                                       mount_path='/src')
+    if result or i == num_retry:
+      break
+
+    # Retry with an OSS-Fuzz builder container that's closer to the project
+    # commit date.
+    commit_date = build_repo_manager.commit_date(commit)
+
+    # Find first change in the projects/<PROJECT> directory before the project
+    # commit date.
+    oss_fuzz_commit, _, _ = oss_fuzz_repo_manager.git([
+        'log', '--before=' + commit_date.isoformat(), '-n1', '--format=%H',
+        projects_dir
+    ],
+                                                      check_result=True)
+    oss_fuzz_commit = oss_fuzz_commit.strip()
+    if not oss_fuzz_commit:
+      logging.info(
+          'Could not find first OSS-Fuzz commit prior to upstream commit. '
+          'Falling back to oldest integration commit.')
+
+      # Find the oldest commit.
+      oss_fuzz_commit, _, _ = oss_fuzz_repo_manager.git(
+          ['log', '--reverse', '--format=%H', projects_dir], check_result=True)
+
+      oss_fuzz_commit = oss_fuzz_commit.splitlines()[0].strip()
+
+    if not oss_fuzz_commit:
+      logging.error('Failed to get oldest integration commit.')
+      break
+
+    logging.info('Build failed. Retrying on earlier OSS-Fuzz commit %s.',
+                 oss_fuzz_commit)
+
+    # Check out projects/<PROJECT> dir to the commit that was found.
+    oss_fuzz_repo_manager.git(['checkout', oss_fuzz_commit, projects_dir],
+                              check_result=True)
+
+    # Also use the closest base-builder we can find.
+    if base_builder_repo:
+      base_builder_digest = base_builder_repo.find_digest(commit_date)
+      if not base_builder_digest:
+        return False
+
+      logging.info('Using base-builder with digest %s.', base_builder_digest)
+      _replace_base_builder_digest(dockerfile_path, base_builder_digest)
+
+    # Rebuild image and re-copy src dir since things in /src could have changed.
+    if not _build_image_with_retries(build_data.project_name):
+      logging.error('Failed to rebuild image.')
+      return False
+
+    cleanup()
+
+  cleanup()
+  return result
+
+
+def detect_main_repo(project_name, repo_name=None, commit=None):
+  """Checks a docker image for the main repo of an OSS-Fuzz project.
+
+  Note: The default is to use the repo name to detect the main repo.
+
+  Args:
+    project_name: The name of the oss-fuzz project.
+    repo_name: The name of the main repo in an OSS-Fuzz project.
+    commit: A commit SHA that is associated with the main repo.
+
+  Returns:
+    A tuple containing (the repo's origin, the repo's path).
+  """
+
+  if not repo_name and not commit:
+    logging.error(
+        'Error: can not detect main repo without a repo_name or a commit.')
+    return None, None
+  if repo_name and commit:
+    logging.info(
+        'Both repo name and commit specific. Using repo name for detection.')
+
+  # Change to oss-fuzz main directory so helper.py runs correctly.
+  utils.chdir_to_root()
+  if not _build_image_with_retries(project_name):
+    logging.error('Error: building %s image failed.', project_name)
+    return None, None
+  docker_image_name = 'gcr.io/oss-fuzz/' + project_name
+  command_to_run = [
+      'docker', 'run', '--rm', '-t', docker_image_name, 'python3',
+      os.path.join('/opt', 'cifuzz', 'detect_repo.py')
+  ]
+  if repo_name:
+    command_to_run.extend(['--repo_name', repo_name])
+  else:
+    command_to_run.extend(['--example_commit', commit])
+  out, _, _ = utils.execute(command_to_run)
+  match = re.search(r'\bDetected repo: ([^ ]+) ([^ ]+)', out.rstrip())
+  if match and match.group(1) and match.group(2):
+    return match.group(1), match.group(2)
+
+  logging.error('Failed to detect repo:\n%s', out)
+  return None, None
+
+
+def load_base_builder_repo():
+  """Get base-image digests."""
+  gcloud_path = shutil.which('gcloud')
+  if not gcloud_path:
+    logging.warning('gcloud not found in PATH.')
+    return None
+
+  result, _, _ = utils.execute([
+      gcloud_path,
+      'container',
+      'images',
+      'list-tags',
+      'ghcr.io/aixcc-finals/base-builder',
+      '--format=json',
+      '--sort-by=timestamp',
+  ],
+                               check_result=True)
+  result = json.loads(result)
+
+  repo = BaseBuilderRepo()
+  for image in result:
+    timestamp = datetime.datetime.fromisoformat(
+        image['timestamp']['datetime']).astimezone(datetime.timezone.utc)
+    repo.add_digest(timestamp, image['digest'])
+
+  return repo
+
+
+def main():
+  """Main function."""
+  logging.getLogger().setLevel(logging.INFO)
+
+  parser = argparse.ArgumentParser(
+      description='Build fuzzers at a specific commit')
+  parser.add_argument('--project_name',
+                      help='The name of the project where the bug occurred.',
+                      required=True)
+  parser.add_argument('--commit',
+                      help='The newest commit SHA to be bisected.',
+                      required=True)
+  parser.add_argument('--engine',
+                      help='The default is "libfuzzer".',
+                      default='libfuzzer')
+  parser.add_argument('--sanitizer',
+                      default='address',
+                      help='The default is "address".')
+  parser.add_argument('--architecture', default='x86_64')
+
+  args = parser.parse_args()
+
+  repo_url, repo_path = detect_main_repo(args.project_name, commit=args.commit)
+
+  if not repo_url or not repo_path:
+    raise ValueError('Main git repo can not be determined.')
+
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    host_src_dir = copy_src_from_docker(args.project_name, tmp_dir)
+    build_repo_manager = repo_manager.RepoManager(
+        os.path.join(host_src_dir, os.path.basename(repo_path)))
+    base_builder_repo = load_base_builder_repo()
+
+    build_data = BuildData(project_name=args.project_name,
+                           engine=args.engine,
+                           sanitizer=args.sanitizer,
+                           architecture=args.architecture)
+    if not build_fuzzers_from_commit(args.commit,
+                                     build_repo_manager,
+                                     host_src_dir,
+                                     build_data,
+                                     base_builder_repo=base_builder_repo):
+      raise RuntimeError('Failed to build.')
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-04/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-tika-delta-04/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/build.sh

@@ -0,0 +1,22 @@
+#!/bin/bash -eu
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# Build and install project (using current CFLAGS, CXXFLAGS).
+npm install ./node-shell-quote/
+
+# Build fuzzers.
+npm i -g @gitlab-org/jsfuzz

local-test-tika-delta-04/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/target.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2022 Google LLC
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *      http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* Exploit shell quote with fuzzer's input as a parameter of echo.
+ * This PoC is extended from a report in GitHub Advisory Database:
+ * https://github.com/advisories/GHSA-g4rg-993r-mgx7
+ * The original report records a shell injection exploit in shell-quote v1.7.2,
+ * we show that a similar shell corruption exploit still persists in v1.7.3,
+ * after a commit that intends to fix the original exploit.
+ * */
+
+/* Fuzz the target program with buf generated by Jsfuzz. */
+function fuzz(buf) {
+    buf = String(buf)
+    const childProcess = require('child_process');
+    const shellQuote = require('shell-quote');
+    childProcess.execSync(shellQuote.quote(['echo', buf]));
+}
+
+/* Run Jsfuzz. */
+module.exports = {
+    fuzz
+};

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

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+PROJECT=$1
+FUZZING_LANGUAGE=$2
+
+gcloud builds submit "https://github.com/google/oss-fuzz" \
+  --async \
+  --git-source-revision=master \
+  --config=cloudbuild.yaml \
+  --substitutions=_PROJECT=$PROJECT,_FUZZING_LANGUAGE=$FUZZING_LANGUAGE \
+  --project=oss-fuzz \
+  --region=us-central1

local-test-tika-delta-04/fuzz-tooling/infra/experimental/chronos/prepare-replay-rebuild

@@ -0,0 +1,21 @@
+#!/usr/bin/bash
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+PROJECT=$1
+{
+    echo "ENV REPLAY_ENABLED=1";
+} >> "projects/$PROJECT/Dockerfile"

local-test-tika-delta-04/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-tika-delta-04/fuzz-tooling/tools/vscode-extension/src/commands/cmdBuildFuzzerFromWorkspaceCFLite.ts

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// 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';
+import {setStatusText} from '../utils';
+import {buildFuzzersFromWorkspaceClusterfuzzLite} from '../ossfuzzWrappers';
+
+export async function cmdInputCollectorBuildFuzzersFromWorkspaceCFLite() {
+  // Create an history object
+  const args = new Object({
+    toClean: false,
+  });
+
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.WSBuildFuzzers',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchbuildFuzzersFromWorkspaceClusterfuzzLite,
+  });
+  console.log('L1: ' + commandHistory.length);
+  commandHistory.push(commandObject);
+
+  await cmdDispatchbuildFuzzersFromWorkspaceClusterfuzzLite(args);
+  return true;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function cmdDispatchbuildFuzzersFromWorkspaceClusterfuzzLite(_args: any) {
+  await setStatusText('[CFLite] Building fuzzers: starting');
+  const res = await buildFuzzersFromWorkspaceClusterfuzzLite();
+  if (res) {
+    await setStatusText('[CFLite] Building fuzzers: finished');
+  } else {
+    await setStatusText('[CFLite] Building fuzzers: failed');
+  }
+}

local-test-tika-delta-04/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-tika-delta-04/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-tika-delta-04/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-tika-delta-04/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-tika-delta-04/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-tika-delta-04/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-tika-delta-04/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-tika-delta-04/fuzz-tooling/tools/vscode-extension/src/commands/cmdTestFuzzer.ts

@@ -0,0 +1,90 @@
+// 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 {runFuzzerHandler, buildFuzzersFromWorkspace} 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 cmdInputCollectorTestFuzzer() {
+  setStatusText('Testing specific fuzzer: getting input');
+  // Get the project name and fuzzer name to test.
+  const ossFuzzProjectNameInput = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'The OSS-Fuzz project name',
+  });
+  if (!ossFuzzProjectNameInput) {
+    println('Did not get a ossFuzzTargetProject');
+    return;
+  }
+  println('Project name: ' + ossFuzzProjectNameInput);
+
+  // 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({
+    projectName: ossFuzzProjectNameInput.toString(),
+    fuzzerName: fuzzerNameInput.toString(),
+  });
+
+  // Create a dispatcher object.
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.TestFuzzer',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchTestFuzzerHandler,
+  });
+  commandHistory.push(commandObject);
+
+  await cmdDispatchTestFuzzerHandler(args);
+}
+
+async function cmdDispatchTestFuzzerHandler(args: any) {
+  // Build the project
+  setStatusText('Test specific fuzzer: building fuzzers in workspace');
+  if (!(await buildFuzzersFromWorkspace(args.projectName, '', false))) {
+    println('Build projects');
+    return;
+  }
+
+  // Run the fuzzer for 10 seconds
+  println('Running fuzzer');
+  setStatusText('Test specific fuzzer: running fuzzer ' + args.fuzzerName);
+  await runFuzzerHandler(
+    args.projectName,
+    args.fuzzerName,
+    extensionConfig.numberOfSecondsForTestRuns.toString(),
+    ''
+  );
+  setStatusText('Test specific fuzzer: test completed of ' + args.fuzzerName);
+  return;
+}

local-test-tika-delta-04/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-tika-delta-04/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;
+}