Add files using upload-large-folder tool

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

@@ -0,0 +1,185 @@
+---
+layout: default
+title: Integrating a Java/JVM project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 4
+permalink: /getting-started/new-project-guide/jvm-lang/
+---
+
+# Integrating a Java/JVM project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Java or any other language
+running on the Java Virtual Machine (JVM) 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 JVM project are outlined below.
+
+## Jazzer
+
+Java fuzzing in OSS-Fuzz depends on
+[Jazzer](https://github.com/CodeIntelligenceTesting/jazzer), which is
+pre-installed on the OSS-Fuzz base docker images. As Jazzer operates directly
+on the bytecode level, it can be applied to any project written in a JVM-based
+language. More information on how Jazzer fuzz targets look like can be found in
+its
+[README's Usage section](https://github.com/CodeIntelligenceTesting/jazzer#usage).
+
+## Project files
+
+### Example project
+
+We recommend viewing
+[json-sanitizer](https://github.com/google/oss-fuzz/tree/master/projects/json-sanitizer)
+as an example of a simple Java-only fuzzing project. Additional examples,
+including one for a Java project with native dependencies, are part of the
+[java-example](https://github.com/google/oss-fuzz/tree/master/projects/java-example)
+project.
+
+### project.yaml
+
+The `language` attribute must be specified as follows:
+
+```yaml
+language: jvm
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). So far the only
+supported sanitizers are AddressSanitizer (`address`) and
+UndefinedBehaviorSanitizer (`undefined`). For pure Java projects, specify
+just `address`:
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-jvm`
+
+The OSS-Fuzz base Docker images already come with OpenJDK 15 pre-installed. If
+you need Maven to build your project, you can install it by adding the following
+line to your Dockerfile:
+
+```docker
+RUN apt-get update && apt-get install -y maven
+```
+
+Apart from this, you should usually not need to do more than to clone the
+project, set a `WORKDIR`, and copy any necessary files, or install any
+project-specific dependencies here as you normally would.
+
+### Fuzzers
+
+In the simplest case, every fuzzer consists of a single Java file with a
+filename matching `*Fuzzer.java` and no `package` directive. An example fuzz
+target could thus be a file `ExampleFuzzer.java` with contents:
+
+```java
+public class ExampleFuzzer {
+    public static void fuzzerTestOneInput(byte[] input) {
+        ...
+        // Call a function of the project under test with arguments derived from
+        // input and throw an exception if something unwanted happens.
+        ...
+    }
+}
+```
+
+### build.sh
+
+For JVM projects, `build.sh` does need some more significant modifications
+over C/C++ projects. Below is an annotated example build script for a
+Java-only project with single-file fuzz targets as described above:
+
+```sh
+# Step 1: Build the project
+
+# Build the project .jar as usual, e.g. using Maven.
+mvn package
+# In this example, the project is built with Maven, which typically includes the
+# project version into the name of the packaged .jar file. The version can be
+# obtained as follows:
+CURRENT_VERSION=$(mvn org.apache.maven.plugins:maven-help-plugin:3.2.0:evaluate \
+-Dexpression=project.version -q -DforceStdout)
+# Copy the project .jar into $OUT under a fixed name.
+cp "target/sample-project-$CURRENT_VERSION.jar" $OUT/sample-project.jar
+
+# Specify the projects .jar file(s), separated by spaces if there are multiple.
+PROJECT_JARS="sample-project.jar"
+
+# Step 2: Build the fuzzers (should not require any changes)
+
+# The classpath at build-time includes the project jars in $OUT as well as the
+# Jazzer API.
+BUILD_CLASSPATH=$(echo $PROJECT_JARS | xargs printf -- "$OUT/%s:"):$JAZZER_API_PATH
+
+# All .jar and .class files lie in the same directory as the fuzzer at runtime.
+RUNTIME_CLASSPATH=$(echo $PROJECT_JARS | xargs printf -- "\$this_dir/%s:"):\$this_dir
+
+for fuzzer in $(find $SRC -name '*Fuzzer.java'); do
+  fuzzer_basename=$(basename -s .java $fuzzer)
+  javac -cp $BUILD_CLASSPATH $fuzzer
+  cp $SRC/$fuzzer_basename.class $OUT/
+
+  # Create an execution wrapper that executes Jazzer with the correct arguments.
+  echo "#!/bin/bash
+# LLVMFuzzerTestOneInput for fuzzer detection.
+this_dir=\$(dirname \"\$0\")
+if [[ \"\$@\" =~ (^| )-runs=[0-9]+($| ) ]]; then
+  mem_settings='-Xmx1900m:-Xss900k'
+else
+  mem_settings='-Xmx2048m:-Xss1024k'
+fi
+LD_LIBRARY_PATH=\"$JVM_LD_LIBRARY_PATH\":\$this_dir \
+\$this_dir/jazzer_driver --agent_path=\$this_dir/jazzer_agent_deploy.jar \
+--cp=$RUNTIME_CLASSPATH \
+--target_class=$fuzzer_basename \
+--jvm_args=\"\$mem_settings:-Djava.awt.headless=true\" \
+\$@" > $OUT/$fuzzer_basename
+  chmod +x $OUT/$fuzzer_basename
+done
+```
+
+The [java-example](https://github.com/google/oss-fuzz/blob/master/projects/java-example/build.sh)
+project contains an example of a `build.sh` for Java projects with native
+libraries.
+
+## FuzzedDataProvider
+
+Jazzer provides a `FuzzedDataProvider` that can simplify the task of creating a
+fuzz target by translating the raw input bytes received from the fuzzer into
+useful primitive Java types. Its functionality is similar to
+`FuzzedDataProviders` available in other languages, such as
+[Python](https://github.com/google/atheris#fuzzeddataprovider) and
+[C++](https://github.com/google/fuzzing/blob/master/docs/split-inputs.md).
+
+On OSS-Fuzz, the required library is available in the base docker images under
+the path `$JAZZER_API_PATH`, which is added to the classpath by the example
+build script shown above. Locally, the library can be obtained from
+[Maven Central](https://search.maven.org/search?q=g:com.code-intelligence%20a:jazzer-api).
+
+A fuzz target using the `FuzzedDataProvider` would look as follows:
+
+```java
+import com.code_intelligence.jazzer.api.FuzzedDataProvider;
+
+public class ExampleFuzzer {
+    public static void fuzzerTestOneInput(FuzzedDataProvider data) {
+        int number = data.consumeInt();
+        String string = data.consumeRemainingAsString();
+        // ...
+    }
+}
+```
+
+For a list of convenience methods offered by `FuzzedDataProvider`, consult its
+[javadocs](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html).

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

@@ -0,0 +1,148 @@
+---
+layout: default
+title: Integrating a Rust project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 2
+permalink: /getting-started/new-project-guide/rust-lang/
+---
+
+# Integrating a Rust project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Rust 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 Rust project are outlined below.
+
+## cargo-fuzz support
+
+Rust integration with OSS-Fuzz is expected to use [`cargo
+fuzz`](https://github.com/rust-fuzz/cargo-fuzz) to build fuzzers. The `cargo
+fuzz` tool will build code with required compiler flags as well as link to the
+correct libFuzzer on OSS-Fuzz itself. Note that using `cargo fuzz` also makes it
+quite easy to run the fuzzers locally yourself if you get a failing test case!
+
+## Project files
+
+First you'll want to follow the [setup instructions for `cargo fuzz`
+itself](https://rust-fuzz.github.io/book/). Afterwards your project should have:
+
+* A top-level `fuzz` directory.
+* A `fuzz/Cargo.toml` manifest which pulls in necessary dependencies to fuzz.
+* Some `fuzz/fuzz_targets/*.rs` files which are the fuzz targets that will be
+  compiled and run on OSS-Fuzz.
+
+Note that you can customize this layout as well, but you'll need to edit some
+the scripts below to integrate into OSS-Fuzz.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: rust
+```
+
+The only supported fuzzing engine and sanitizer are `libfuzzer` and `address`,
+respectively.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/project.yaml#L3-L6)
+
+```yaml
+sanitizers:
+  - address
+fuzzing_engines:
+  - libfuzzer
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-rust`
+
+The OSS-Fuzz builder image has the latest nightly release of Rust as well as
+`cargo fuzz` pre-installed and in `PATH`. In the `Dockerfile` for your project
+all you'll need to do is fetch the latest copy of your code and install any
+system dependencies necessary to build your project.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/Dockerfile#L18-L20)
+
+```dockerfile
+RUN git clone --depth 1 https://github.com/serde-rs/json json
+```
+
+### build.sh
+
+Here it's expected that you'll build the fuzz targets for your project and then
+copy the final binaries into the output directory.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/build.sh#L20):
+
+```sh
+cd $SRC/json
+cargo fuzz build -O
+cp fuzz/target/x86_64-unknown-linux-gnu/release/from_slice $OUT/
+```
+
+Note that you likely want to pass the `-O` flag to `cargo fuzz build` which
+builds fuzzers in release mode. You may also want to pass the
+`--debug-assertions` flag to enable more checks while fuzzing. In this example
+the `from_slice` binary is the fuzz target.
+
+With some bash-fu you can also automatically copy over all fuzz targets into
+the output directory so when you add a fuzz target to your project it's
+automatically integrated into OSS-Fuzz:
+
+```sh
+FUZZ_TARGET_OUTPUT_DIR=target/x86_64-unknown-linux-gnu/release
+for f in fuzz/fuzz_targets/*.rs
+do
+    FUZZ_TARGET_NAME=$(basename ${f%.*})
+    cp $FUZZ_TARGET_OUTPUT_DIR/$FUZZ_TARGET_NAME $OUT/
+done
+```
+
+## Writing fuzzers using a test-style strategy
+
+In Rust you will often have tests written in a way so they are only 
+compiled into the final binary when build in test-mode. This is, achieved by
+wrapping your test code in `cfg(test)`, e.g.
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    ...
+```
+
+Cargo-fuzz automatically enables the `fuzzing` feature, which means you can
+follow a similar strategy to writing fuzzers as you do when writing tests.
+Specifically, you can create modules wrapped in the `fuzzing` feature:
+```rust
+#[cfg(fuzzing)]
+pub mod fuzz_logic {
+    use super::*;
+
+    ...
+```
+and then call the logic within `fuzz_logic` from your fuzzer. 
+
+Furthermore, within your `.toml` files, you can then specify fuzzing-specific
+dependencies by wrapping them as follows:
+```
+[target.'cfg(fuzzing)'.dependencies]
+```
+similar to how you wrap test-dependencies as follows:
+```
+[dev-dependencies]
+```
+
+Finally, you can also combine the testing logic you have and the fuzz logic. This
+can be achieved simply by using 
+```rust
+#[cfg(any(test, fuzzing))]
+```
+
+A project that follows this structure is Linkerd2-proxy and the project files can be
+seen [here](https://github.com/google/oss-fuzz/tree/master/projects/linkerd2-proxy).

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

@@ -0,0 +1,78 @@
+---
+layout: default
+title: Integrating a Swift project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 1
+permalink: /getting-started/new-project-guide/swift-lang/
+---
+
+# Integrating a Swift project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Swift 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 Swift project are outlined below.
+
+## Project files
+
+First, you need to write a Swift fuzz target that accepts a stream of bytes and
+calls the program API with that. This fuzz target should reside in your project
+repository.
+
+The structure of the project directory in OSS-Fuzz repository doesn't differ for
+projects written in Swift. The project files have the following Swift specific
+aspects.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: swift
+```
+
+The only supported fuzzing engine is `libfuzzer`
+
+The supported sanitizers are and `address`, `thread`
+
+[Example](https://github.com/google/oss-fuzz/blob/2a15c3c88b21f4f1be2a7ff115f72bd7a08e34ac/projects/swift-nio/project.yaml#L9):
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+  - thread
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-swift`
+instead of using the simple base-builder
+
+### build.sh
+
+A `precompile_swift` generates an environment variable `SWIFTFLAGS`
+This can then be used in the building command such as `swift build -c release $SWIFTFLAGS`
+
+
+A usage example from swift-protobuf project is
+
+```sh
+. precompile_swift
+# build project
+cd FuzzTesting
+swift build -c debug $SWIFTFLAGS
+
+(
+cd .build/debug/
+find . -maxdepth 1 -type f -name "*Fuzzer" -executable | while read i; do cp $i $OUT/"$i"-debug; done
+)
+
+```

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

@@ -0,0 +1 @@
+build/

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

@@ -0,0 +1,10 @@
+.vscode/**
+.vscode-test/**
+src/**
+.gitignore
+.yarnrc
+vsc-extension-quickstart.md
+**/tsconfig.json
+**/.eslintrc.json
+**/*.map
+**/*.ts

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/tools/vscode-extension/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   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.

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/tools/vscode-extension/README.md

@@ -0,0 +1,17 @@
+# OSS-Fuzz VSCode extension
+
+[OSS-Fuzz](https://github.com/google/oss-fuzz) is a fuzzing toolkit and service for fuzzing open source projects. This VSCode extension provides features and capabilities for interacting with the OSS-Fuzz toolkit and also to compare local changes to the OSS-Fuzz cloud database by way of [Open source fuzz introspection](https://introspector.oss-fuzz.com).
+
+## Features
+
+The VSCode extension is largely driven by commands at this point. The featues of these commands includes:
+
+- Easily setting up OSS-Fuzz
+- Templates for easily setting up a new OSS-Fuzz project
+- Building arbitrary projects from OSS-Fuzz
+- Modify a project from VSCode and test changes in OSS-Fuzz
+- Easily extract code coverage of fuzzers, including local-only fuzzers
+- Compare local code coverage to what is currently achieved by OSS-Fuzz
+- Auto-generation of fuzzer templates
+
+For a full list of commands and their features, please check the commands page.

local-test-commons-compress-full-01-vuln_5/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_5/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_5/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_5/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_5/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_5/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_5/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_5/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_5/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_5/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;
+}