Add files using upload-large-folder tool

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/advanced-topics/advanced_topics.md

@@ -0,0 +1,9 @@
+---
+layout: default
+title: Advanced topics
+has_children: true
+nav_order: 3
+permalink: /advanced-topics/
+---
+
+# Advanced topics

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/advanced-topics/bug_fixing_guidance.md

@@ -0,0 +1,94 @@
+---
+layout: default
+title: Bug fixing guidance
+nav_order: 6
+permalink: /advanced-topics/bug-fixing-guidance
+---
+
+# Bug fixing guidance
+{: .no_toc}
+
+This page provides brief guidance on how to prioritise and fix bugs reported by
+OSS-Fuzz.
+
+- TOC
+{:toc}
+
+## Threat modelling
+In general the severity of an issue reported by OSS-Fuzz must be determined
+relative to the threat model of the project under analysis. Therefore, although
+the fuzzers OSS-Fuzz makes an effort into determining the severity of the bug
+the true severity of the bug depends on the threat model of the project.
+
+## Bug prioritisation
+
+### Security issues
+These are the top priority of solving. A label is attached to these on
+the OSS-Fuzz testcase page and you can also search up all of these on monorail
+using the search pattern `-Bug=security`.
+
+Issues of this kind include issues reported by Address Sanitizer, e.g.
+heap-based buffer overflows, stack-based buffer overflows and use-after-frees.
+
+### Functional issues and memory leaks
+These are issues that in general can tamper with the functionality of the
+application. The bugs that have highest priority in this case are those that
+can be easily triggered by an untrusted user of the project.
+
+### Timeouts and out-of-memory
+These are in general the least prioritised issues to solve.
+
+### Bug prioritisation of non C/C++ projects
+Currently there is no prioritisation of bugs in non C/C++ projects. As such, in
+this scenario it is crucial you do the analysis yourself relative to the threat
+model of your project.
+
+## Non-reproducible bugs
+OSS-Fuzz will report some bugs that are labeled `Reliably reproduces: NO` and
+these can be tricky to deal with. A non-reproducible bug is an issue that
+OSS-Fuzz did indeed discover, however, OSS-Fuzz is unable to reproduce the bug
+with `python infra/helper.py reproduce`. In general, our suggestion is to do
+analysis of the bug and determine whether there in fact is an issue.
+
+The non-reproducible bugs can be of varying nature. Some of these bugs will be
+due to some internal state of the target application being manipulated over the
+cause of several executions of the fuzzer function. This could be several
+hundreds or even thousands of executions and the bug may not be reproducible by
+a single fuzzer test-case, however, there is indeed a bug in the application.
+There are other reasons why bugs may be non-reproducible and in general any
+non-determinism introduced into the application can have an effect on this.
+
+In the case of non-reproducible bugs our advice is to put effort into analysing
+the potential bug and also assess whether this is due to some internal state
+that persists between each fuzz run. If that is indeed the case then we also
+suggest investigating whether the fuzzer can be written such that the internal
+state in the code will be reset between each fuzz run.
+
+## Should all reported issues be solved?
+It is reported by some project maintainers that fixing timeout issues reported
+by OSS-Fuzz can increase the complexity of the project’s source code. The
+result of this is that maintainers put effort into solving a timeout issue and
+the fix results in additional complexity of the project. The question is
+whether in a scenario like this if the overall result actually improves the
+state of the application.
+
+In order to answer this question we must assess the issue relative to the
+threat model. Following the timeout anecdote then some timing issues can have
+severe security implications. For example, if the timeout issue can cause
+manipulation of control-flow then the timing issue may be of high security
+severity. As such, it is difficult to say in the general case whether or not
+some bugs should not be solved, as it should be analysed and determined on a
+project-by-project basis.
+
+In the event that a bug is reported by OSS-Fuzz that is not relevant to
+security or reliability of the application then there may still be a point to
+fixing the bug. For example, if the issue is often run into by the fuzzer then
+the fuzzer may have difficulty exploring further code in the target, and thus
+fixing the bug will allow the fuzzer to explore further code. In this case some
+suggested examples of resolving the issue could be:
+* Perform a hot-patch that is only applied during fuzzer executions and does
+not overcomplicate the project’s code.
+* Patch the code of the fuzzer to avoid the timeout. For example, some fuzzers
+restrict the size of the input to avoid certain deep recursions or
+time-intensive loops.
+* Patch the code in the target despite complicating things.

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/advanced-topics/code_coverage.md

@@ -0,0 +1,130 @@
+---
+layout: default
+title: Code coverage
+parent: Advanced topics
+nav_order: 2
+permalink: /advanced-topics/code-coverage/
+---
+
+# Code Coverage
+{: .no_toc}
+
+For projects written in C/C++, Rust, Go, Swift or Java and other JVM-based languages,
+you can generate code coverage reports using Clang source-based code coverage.
+This page walks you through the basic steps.
+For more details on C/C++ coverage, see [Clang's documentation].
+
+Code coverage reports generation for other languages is not supported yet.
+
+- TOC
+{:toc}
+---
+
+## Pull the latest Docker images
+
+Docker images get regularly updated with a newer version of build tools, build
+configurations, scripts, and other changes. We recommend you pull the most
+recent images by running the following command:
+
+```bash
+$ python infra/helper.py pull_images
+```
+
+## Build fuzz targets
+
+Code coverage report generation requires a special build configuration to be
+used. To create a code coverage build for your project, run these commands:
+
+```bash
+$ python infra/helper.py build_image $PROJECT_NAME
+$ python infra/helper.py build_fuzzers --sanitizer=coverage $PROJECT_NAME
+```
+
+## Establish access to GCS
+
+To get a good understanding of fuzz testing quality, you should generate code
+coverage reports by running fuzz targets against the corpus
+aggregated by OSS-Fuzz. Set up `gsutil` and ensure that you have access to the
+corpora by doing the following:
+
+* Install the [gsutil tool].
+* Check whether you have access to the corpus for your project:
+
+```bash
+$ gsutil ls gs://${PROJECT_NAME}-corpus.clusterfuzz-external.appspot.com/
+```
+
+If you see an authorization error from the command above, run this:
+
+```bash
+$ gcloud auth login
+```
+
+and try again. Once `gsutil` works, you can run the report generation.
+
+## Generate code coverage reports
+
+### Full project report
+
+If you want to generate a code coverage report using the corpus aggregated on
+OSS-Fuzz, run this command:
+
+```bash
+$ python infra/helper.py coverage $PROJECT_NAME
+```
+
+If you want to generate a code coverage report using the corpus you have
+locally, copy the corpus into the
+`build/corpus/$PROJECT_NAME/<fuzz_target_name>/` directories for each fuzz
+target, then run this command:
+
+```bash
+$ python infra/helper.py coverage --no-corpus-download $PROJECT_NAME
+```
+
+### Single fuzz target
+
+You can generate a code coverage report for a particular fuzz target by using
+the `--fuzz-target` argument:
+
+```bash
+$ python infra/helper.py coverage --fuzz-target=<fuzz_target_name> $PROJECT_NAME
+```
+
+In this mode, you can specify an arbitrary corpus location for the fuzz target
+(instead of the corpus downloaded from OSS-Fuzz) by using `--corpus-dir`:
+
+```bash
+$ python infra/helper.py coverage --fuzz-target=<fuzz_target_name> \
+    --corpus-dir=<my_local_corpus_dir> $PROJECT_NAME
+```
+
+### Additional arguments for `llvm-cov` (C/C++/Rust only)
+
+You may want to use some of the options provided by the [llvm-cov tool], like
+`-ignore-filename-regex=`. You can pass these to the helper script after `--`:
+
+```bash
+$ python infra/helper.py coverage $PROJECT_NAME -- \
+    -ignore-filename-regex=.*code/to/be/ignored/.* <other_extra_args>
+```
+
+If you want to specify particular source files or directories to show in the
+report, list their paths at the end of the extra arguments sequence:
+
+```bash
+$ python infra/helper.py coverage zlib -- \
+    <other_extra_args> /src/zlib/inftrees.c /src/zlib_uncompress_fuzzer.cc /src/zlib/zutil.c
+```
+
+If you want OSS-Fuzz to use extra arguments when generating code coverage
+reports for your project, add the arguments into your `project.yaml` file as
+follows:
+
+```yaml
+coverage_extra_args: -ignore-filename-regex=.*crc.* -ignore-filename-regex=.*adler.* <other_extra_args>
+```
+
+[Clang's documentation]: https://clang.llvm.org/docs/SourceBasedCodeCoverage.html
+[gsutil tool]: https://cloud.google.com/storage/docs/gsutil_install
+[llvm-cov tool]: https://llvm.org/docs/CommandGuide/llvm-cov.html

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/advanced-topics/corpora.md

@@ -0,0 +1,70 @@
+---
+layout: default
+title: Corpora
+parent: Advanced topics
+nav_order: 3
+permalink: /advanced-topics/corpora/
+---
+
+# Accessing Corpora
+{: .no_toc}
+
+If you want to access the corpora that we are using for your fuzz targets
+(synthesized by the fuzzing engines), follow these steps.
+
+- TOC
+{:toc}
+---
+
+## Obtain access
+
+To get access to a project's corpora, you must be listed as the
+primary contact or as an auto cc in the project's `project.yaml` file, as described
+in the [New Project Guide]({{ site.baseurl }}/getting-started/new-project-guide/#projectyaml).
+If you don't do this, most of the links below won't work.
+
+## Install Google Cloud SDK
+
+The corpora for fuzz targets are stored on [Google Cloud
+Storage](https://cloud.google.com/storage/). To access them, you need to
+[install the gsutil
+tool](https://cloud.google.com/storage/docs/gsutil_install), which is part of
+the Google Cloud SDK. Follow the instructions on the installation page to
+login with the Google account listed in your project's `project.yaml` file.
+
+## Viewing the corpus for a fuzz target
+
+The fuzzer statistics page for your project on
+[ClusterFuzz]({{ site.baseurl }}/further-reading/clusterfuzz)
+contains a link to the Google Cloud console for your corpus under the
+**corpus_size** column. Click the link to browse and download individual test inputs in the
+corpus.
+
+![viewing_corpus](https://raw.githubusercontent.com/google/oss-fuzz/master/docs/images/viewing_corpus.png)
+
+## Downloading the corpus 
+
+If you want to download the entire corpus, click the link in the **corpus_size** column, then
+copy the **Buckets** path at the top of the page:
+
+![corpus_path](https://raw.githubusercontent.com/google/oss-fuzz/master/docs/images/corpus_path.png)
+
+Copy the corpus to a directory on your
+machine by running the following command:
+
+```bash
+$ gsutil -m cp -r gs://<bucket_path> <local_directory>
+```
+Using the expat example above, this would be:
+
+```bash
+$ gsutil -m cp -r \
+    gs://expat-corpus.clusterfuzz-external.appspot.com/libFuzzer/expat_parse_fuzzer \
+    <local_directory>
+```
+
+## Corpus backups
+
+We keep daily zipped backups of your corpora. These can be accessed from the
+**corpus_backup** column of the fuzzer statistics page. Downloading these can
+be significantly faster than running `gsutil -m cp -r` on the corpus bucket.

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/advanced-topics/debugging.md

@@ -0,0 +1,45 @@
+---
+layout: default
+title: Debugging
+parent: Advanced topics
+nav_order: 4
+permalink: /advanced-topics/debugging/
+---
+
+# Debugging issues
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+## Debugging build scripts
+
+While developing your build script, it may be useful to run bash within the
+container:
+
+```bash
+$ python infra/helper.py shell $PROJECT_NAME  # runs /bin/bash within container
+$ compile                                     # runs compilation manually
+```
+
+## Debugging fuzzers with GDB
+
+If you wish to debug a fuzz target with gdb, you can use the base-runner-debug
+image:
+
+```bash
+# Copy input testcase into host output directory so it can be accessed
+# within the Docker image.
+$ cp /path/to/testcase build/out/$PROJECT_NAME
+
+# Run the Docker image containing GDB.
+$ python infra/helper.py shell base-runner-debug
+$ gdb --args /out/$PROJECT_NAME/$FUZZ_TARGET_NAME /out/$PROJECT_NAME/testcase
+```
+
+**Note:** The `base-runner-debug` image does not have access to your sources, so
+you will not be able to do source code level debugging. We recommend integrating
+your fuzz target upstream as part of
+[ideal integration]({{ site.baseurl }}/advanced-topics/ideal-integration/)
+for debugging purposes.

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/advanced-topics/fuzz_introspector.md

@@ -0,0 +1,118 @@
+---
+layout: default
+title: Fuzz Introspector
+parent: Advanced topics
+nav_order: 2
+permalink: /advanced-topics/fuzz-introspector/
+---
+
+# Fuzz Introspector
+{: .no_toc}
+
+For projects written in C/C++, Python and Java you can generate Fuzz
+Introspector reports to help guide the development of your fuzzing suite.
+These reports help to extract details about the fuzzing setup of your
+project with the goal of making it easier to improve the fuzzing set up.
+The Fuzz Introspector reports are generated automatically and uploaded
+to the cloud like code coverage reports, and you can also generate them
+locally using the OSS-Fuzz helper script.
+
+
+- TOC
+{:toc}
+---
+
+## Fuzz Introspector overview
+
+As soon as your project is run with ClusterFuzz (<1 day), you can view the Fuzz
+Introspector report for your project.
+[Fuzz Introspector](https://github.com/ossf/fuzz-introspector) helps you
+understand your fuzzers' performance and identify any potential blockers.
+It provides individual and aggregated fuzzer reachability and coverage reports.
+You can monitor each fuzzer's static reachability potential and compare it
+against dynamic coverage and identify any potential bottlenecks.
+Fuzz Introspector can offer suggestions on increasing coverage by adding new
+fuzz targets or modify existing ones.
+Fuzz Introspector reports can be viewed from the [OSS-Fuzz
+homepage](https://oss-fuzz.com/) or through this
+[index](http://oss-fuzz-introspector.storage.googleapis.com/index.html).
+
+- [Fuzz Introspector documentation](https://fuzz-introspector.readthedocs.io/en/latest/)
+- [Fuzz Introspector source code](https://github.com/ossf/fuzz-introspector)
+- [OSS-Fuzz Fuzz Introspector reports](http://oss-fuzz-introspector.storage.googleapis.com/index.html)
+
+
+## Tutorials and guides
+
+The reports generated can be a lot to digest when first viewing them. The 
+[Fuzz Introspector documentation](https://fuzz-introspector.readthedocs.io/en/latest/)
+provides various user guides and tutorials rooted in OSS-Fuzz projects, which is
+a useful reference on how to make use of the reports.
+
+For ideas on how to use Fuzz Introspector, see [user guides](https://fuzz-introspector.readthedocs.io/en/latest/user-guides/index.html) which includes sections e.g.
+- [Quickly extract overview of a given project](https://fuzz-introspector.readthedocs.io/en/latest/user-guides/quick-overview.html)
+- [Get ideas for new fuzz targets](https://fuzz-introspector.readthedocs.io/en/latest/user-guides/get-ideas-for-new-targets.html)
+- [Comparing introspector reports](https://fuzz-introspector.readthedocs.io/en/latest/user-guides/comparing-introspector-reports.html)
+
+## Run Fuzz Introspector locally
+
+To generate a Fuzz Introspector report locally use `infra/helper.py` and the
+`introspector` command. Fuzz Introspector relies on code coverage to
+analyze a given project, and this means we need to extract code coverage in the
+Fuzz Introspector process. We can do this in two ways. First, by running the fuzzers
+for a given amount of time, and, second, by generating code coverage using the public
+corpus available from OSS-Fuzz.
+
+
+### Generate reports by running fuzzers for X seconds
+
+The following command will generate a Fuzz Introspector report for the `libdwarf` project
+and will extract code coverage based on a corpus created from running the fuzzers for 30
+seconds.
+
+```bash
+$ python3 infra/helper.py introspector libdwarf --seconds=30
+```
+
+If the above command was succesful, you should see output along the lines of:
+
+```bash
+INFO:root:To browse the report, run: python3 -m http.server 8008 --directory /home/my_user/oss-fuzz/build/out/libdwarf/introspector-report/inspector and navigate to localhost:8008/fuzz_report.html in your browser
+```
+The above output gives you directions on how to start a simple webserver using
+`python3 -m http.server`, which you can use to view the Fuzz Introspector report.
+
+### Generate reports by using public corpora
+
+The following command will generate a Fuzz Introspector report for the `libdwarf` project
+and will extract code coverage based on the publicly available corpora. 
+
+```bash
+$ python3 infra/helper.py introspector libdwarf --public-corpora
+```
+
+Assuming the above command is succesful you can view the report using `python3 -m http.server`
+following the example described above.
+
+
+## Differences in build tooling
+
+There are some differences in build environment for Fuzz Introspector builds
+in comparison to e.g. ASAN or code coverage builds. The reason is that
+Fuzz Introspector relies on certain compile-time tools to do its analysis.
+This compile time tooling differs between languages, namely:
+- For C/C++, Fuzz Introspector relies on [LLVM LTO](https://llvm.org/docs/LinkTimeOptimization.html) and [LLVM Gold](https://llvm.org/docs/GoldPlugin.html)
+- For Python, Fuzz Introspector relies on a modified [PyCG](https://github.com/vitsalis/PyCG)
+- For Java, Fuzz Introspector relies on [Soot](https://soot-oss.github.io/soot/)
+
+The consequence of this is your project must be compatible with these projects.
+PyCG and Soot have not shown to be a blocker for many projects, however, experience
+has shown that sometimes a project's build needs modification in order to compile
+with LLVM LTO. The easiest way to test if your project works with LLVM is checking
+whether your project can compile with the flags `-flto -fuse-ld=gold` and using
+the gold linker. OSS-Fuzz automatically sets these flags and linker options when
+using `infra/helper.py` to build your project with `--sanitizer=introspector`, e.g.
+
+```bash
+python3 infra/helper.py build_fuzzers --sanitizer=introspector PROJ_NAME
+```

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/advanced-topics/ideal_integration.md

@@ -0,0 +1,174 @@
+---
+layout: default
+title: Ideal integration
+parent: Advanced topics
+nav_order: 1
+permalink: /advanced-topics/ideal-integration/
+---
+
+# Ideal integration with OSS-Fuzz
+{: .no_toc}
+
+OSS projects have different build and test systems. We can't expect them all to
+implement and maintain fuzz targets or integrate them with OSS-Fuzz in the same
+way. However, we do have recommendations.
+
+This page documents several features (starting from the easiest) that will make
+automated fuzzing simple and efficient, and will help you catch regressions
+early in the development cycle. This simple
+[example](https://github.com/google/oss-fuzz/tree/master/projects/example/my-api-repo)
+covers most of the items. 
+
+- TOC
+{:toc}
+---
+
+## Summary
+
+Every [fuzz target](https://llvm.org/docs/LibFuzzer.html#fuzz-target):
+* Is [maintained by code owners](#fuzz-target) in their RCS (Git, SVN, etc).
+* Is [built with the rest of the tests](#build-support) - no bit rot! 
+* Has a [seed corpus](#seed-corpus) with good [code coverage](#coverage).
+* Has a [dictionary](#dictionary), if applicable.
+* Is [continuously tested on the seed corpus](#regression-testing) with
+  [ASan/UBSan/MSan](https://github.com/google/sanitizers).
+* Is [fast and has no OOMs](#performance).
+
+## Fuzz Target
+
+The code of the [fuzz target(s)](https://llvm.org/docs/LibFuzzer.html#fuzz-target) should be
+part of the project's source code repository.  All fuzz targets should be easily
+discoverable (reside in the same directory, follow the same naming pattern,
+etc.). 
+
+This makes it easy to maintain the fuzzers and minimizes breakages that can
+arise as source code changes over time.
+
+Make sure to fuzz the target locally for a small period of time to ensure that 
+it does not crash, hang, or run out of memory instantly. Also make sure that the fuzzer can
+make at least some progress. If you're having trouble, read about [what makes a good fuzz
+target](https://github.com/google/fuzzing/blob/master/docs/good-fuzz-target.md).
+
+The interface between the [fuzz target](https://llvm.org/docs/LibFuzzer.html#fuzz-target)
+and the fuzzing engines is C, so you can use either C or C++ to implement the
+fuzz target. Make sure to not return values other than **zero** [^1].
+
+Examples: 
+[boringssl](https://github.com/google/boringssl/tree/master/fuzz),
+[SQLite](https://www.sqlite.org/src/artifact/ad79e867fb504338),
+[s2n](https://github.com/awslabs/s2n/tree/master/tests/fuzz),
+[openssl](https://github.com/openssl/openssl/tree/master/fuzz),
+[FreeType](http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/src/tools/ftfuzzer),
+[re2](https://github.com/google/re2/tree/master/re2/fuzzing),
+[harfbuzz](https://github.com/behdad/harfbuzz/tree/master/test/fuzzing),
+[pcre2](https://vcs.pcre.org/pcre2/code/trunk/src/pcre2_fuzzsupport.c?view=markup),
+[ffmpeg](https://github.com/FFmpeg/FFmpeg/blob/master/tools/target_dec_fuzzer.c).
+
+[^1]: While LibFuzzer uses a non-zero value as a signal to discard inputs other fuzzers in
+use by OSS-Fuzz do not necessarily support this behavior. (Discarding inputs can be used
+to stop a fuzzer from exploring further, which should only be used with good reason.)
+
+## Build support
+
+Many different build systems exist in the open-source world. The less OSS-Fuzz
+knows about them, the better it can scale.
+
+An ideal build integration for OSS-Fuzz looks like this:
+* For every fuzz target `foo` in the project, there is a build rule that
+builds `foo_fuzzer`, a binary that: 
+	* Contains the fuzzing entry point.
+	* Contains (`LLVMFuzzerTestOneInput`) and all the code it depends on.
+	* Uses the `main()` function from `$LIB_FUZZING_ENGINE` (env var [provided]({{ site.baseurl }}/getting-started/new-project-guide/) by OSS-Fuzz environment).
+* Since the build system supports changing the compiler and passing extra compiler
+flags, the build command for `foo_fuzzer` looks similar to this:
+
+```bash
+# Assume the following env vars are set:
+# CC, CXX, CFLAGS, CXXFLAGS, LIB_FUZZING_ENGINE
+$ make_or_whatever_other_command foo_fuzzer
+```
+
+This minimizes OSS-Fuzz-specific configuration, making your fuzzing more robust.
+
+There is no point in hardcoding the exact compiler flags in the build system
+because they a) may change and b) depend on the fuzzing engine and sanitizer
+being used.
+
+## Seed Corpus
+
+The *seed corpus* is a set of test inputs, stored as individual files, provided
+to the fuzz target as a starting point (to "seed" the mutations). The quality of
+the seed corpus has a huge impact on fuzzing efficiency; the higher the quality,
+the easier it is for the fuzzer to discover new code paths. The ideal corpus is
+a minimal set of inputs that provides maximal code coverage. 
+
+For better OSS-Fuzz integration,  the seed corpus should be available in
+revision control (it can be the same as or different from the source code). It
+should be regularly extended with the inputs that (used to) trigger bugs and/or
+touch new parts of the code. 
+
+Examples: 
+[boringssl](https://github.com/google/boringssl/tree/master/fuzz),
+[openssl](https://github.com/openssl/openssl/tree/master/fuzz),
+[nss](https://github.com/mozilla/nss-fuzzing-corpus) (corpus in a separate repo).
+
+## Dictionary
+
+For some input types, a simple dictionary of tokens used by the input language
+can have a dramatic impact on fuzzing efficiency.  For example, when fuzzing an
+XML parser, a dictionary of XML tokens is helpful. AFL++ has a
+[collection](https://github.com/AFLplusplus/AFLplusplus/tree/master/dictionaries)
+of dictionaries for popular data formats. Ideally, a dictionary should be
+maintained alongside the fuzz target, and it must use [correct
+syntax](https://llvm.org/docs/LibFuzzer.html#dictionaries).
+
+## Coverage
+
+For a fuzz target to be useful, it must have good coverage in the code that it
+is testing. You can view the coverage for your fuzz targets by looking at the
+[fuzzer stats]({{ site.baseurl }}/further-reading/clusterfuzz#fuzzer-stats)
+dashboard on ClusterFuzz, as well as [coverage reports]({{ site.baseurl
+}}/further-reading/clusterfuzz#coverage-reports).
+
+To generate an aggregated code coverage report for your project, please see the
+[code coverage]({{ site.baseurl }}/advanced-topics/code-coverage) page.
+
+Coverage can often be improved by adding dictionaries, more inputs for seed
+corpora, and fixing timeouts/out-of-memory bugs in your targets.
+
+## Regression Testing
+
+Fuzz targets should be regularly tested (not necessarily fuzzed!) as a part of
+the project's regression testing process. One way to do so is to link the fuzz
+target with a simple standalone driver
+([example](https://github.com/llvm-mirror/compiler-rt/tree/master/lib/fuzzer/standalone))
+that runs the provided inputs, then use this driver with the seed corpus created
+in previous step. We recommend you use
+[sanitizers](https://github.com/google/sanitizers) during regression testing.
+
+Examples: [SQLite](https://www.sqlite.org/src/artifact/d9f1a6f43e7bab45),
+[openssl](https://github.com/openssl/openssl/blob/master/fuzz/test-corpus.c).
+
+## Performance
+
+Fuzz targets should perform well, because high memory usage and/or slow
+execution speed can slow the down the growth of coverage and finding of new
+bugs. ClusterFuzz provides a [performance analyzer]({{ site.baseurl
+}}/further-reading/clusterfuzz/#performance-analyzer) for each fuzz target that
+shows problems that are impacting performance.
+
+## Not a project member?
+
+If you are a member of the project you want to fuzz, most of the steps above are
+simple. However in some cases, someone outside the project team may want to fuzz
+the code, and the project maintainers are not interested in helping.
+
+In such cases, we can host the fuzz targets, dictionaries, etc. in OSS-Fuzz's 
+repository and mention them in the Dockerfile. It's not ideal, because the fuzz
+targets will not be continuously tested, so may quickly bitrot.
+
+Examples: [libxml2](https://github.com/google/oss-fuzz/tree/master/projects/libxml2),
+[c-ares](https://github.com/google/oss-fuzz/tree/master/projects/c-ares), [expat](https://github.com/google/oss-fuzz/tree/master/projects/expat).
+
+If you are not a project maintainer, we may not be able to CC you to security
+bugs found by OSS-Fuzz.

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/advanced-topics/reproducing.md

@@ -0,0 +1,160 @@
+---
+layout: default
+title: Reproducing
+parent: Advanced topics
+nav_order: 5
+permalink: /advanced-topics/reproducing/
+---
+
+# Reproducing OSS-Fuzz issues
+{: .no_toc}
+
+You've been CCed on an OSS-Fuzz issue
+([examples](https://bugs.chromium.org/p/oss-fuzz/issues/list?can=1&q=Type%3ABug%2CBug-Security)).
+Now what? Before attempting to fix the bug, you should be able to reliably
+reproduce it. 
+
+- TOC
+{:toc}
+---
+
+## Fuzz target bugs
+
+Every issue has a [reproducer file]({{ site.baseurl
+}}/reference/glossary/#reproducer) (also know as a "testcase" file) attached.
+Download it. This file contains the bytes that were fed to the [fuzz
+target](https://llvm.org/docs/LibFuzzer.html#fuzz-target).
+
+**Note:** If the issue is not public, you will need to login using a
+[Google account](https://support.google.com/accounts/answer/176347?hl=en)
+([why?]({{ site.baseurl
+}}/faq/#why-do-you-require-a-google-account-for-authentication)) that the bug
+report CCs.
+
+If you have already
+[integrated]({{ site.baseurl }}/advanced-topics/ideal-integration/)
+the fuzz target with your build and test system, all you have to do is run this command:
+```bash
+$ ./fuzz_target_binary <testcase_path>
+```
+
+For timeout bugs, add the `-timeout=65` argument. For OOM bugs, add the
+`-rss_limit_mb=2560` argument. Read more on [how timeouts and OOMs are
+handled]({{ site.baseurl }}/faq/#how-do-you-handle-timeouts-and-ooms).
+
+Depending on the nature of the bug, the fuzz target binary needs to be built
+with the appropriate [sanitizer](https://github.com/google/sanitizers)
+(for example, if it's a buffer overflow, build with
+[AddressSanitizer](http://clang.llvm.org/docs/AddressSanitizer.html)).
+
+If you're not sure how to build the fuzzer using the project's build system,
+you can also use Docker commands to replicate the exact build steps used by
+OSS-Fuzz, then feed the reproducer input to the fuzz target ([how?]({{
+site.baseurl }}/getting-started/new-project-guide/#prerequisites), [why?]({{
+site.baseurl }}/faq/#why-do-you-use-docker)).
+
+## Building using Docker
+
+### Cloning OSS-Fuzz
+
+To use the following `infra/helper.py` commands, you need a checkout of OSS-Fuzz:
+
+```bash
+$ git clone --depth=1 https://github.com/google/oss-fuzz.git
+$ cd oss-fuzz
+```
+
+### Pull the latest Docker images
+
+Docker images get regularly updated with a newer version of build tools, build
+configurations, scripts, and other changes. In some cases, a particular issue
+can be reproduced only with a fresh image being used. Pull the latest images
+by running the following command:
+
+```bash
+$ python infra/helper.py pull_images
+```
+
+### Build the image and the fuzzers
+
+Run the following commands:
+
+```bash
+$ python infra/helper.py build_image $PROJECT_NAME
+$ python infra/helper.py build_fuzzers --sanitizer <address/memory/undefined> \
+    --architecture <x86_64/i386> $PROJECT_NAME
+```
+
+The `sanitizer` used in the report is the value in the
+**Sanitizer** column. It's one of the following:
+  * **address** for AddressSanitizer.
+  * **memory** for MemorySanitizer.
+  * **undefined** for UndefinedBehaviorSanitizer.
+
+**Notes**:
+   * The `architecture` argument is only necessary if you want to specify
+`i386` configuration.
+   * Some bugs (specially ones related to pointer and integer overflows) are reproducible only in 32 bit mode or only in 64 bit mode.
+If you can't reproduce a particular bug building for x86_64, try building for i386.
+
+## Reproducing bugs
+
+After you build an image and a fuzzer, you can reproduce a bug by running the following command:
+
+```bash
+$ python infra/helper.py reproduce $PROJECT_NAME <fuzz_target_name> <testcase_path>
+```
+
+For example, to build the [libxml2](https://github.com/google/oss-fuzz/tree/master/projects/libxml2)
+project with UndefinedBehaviorSanitizer (`undefined`) instrumentation and
+reproduce a crash testcase for a fuzzer named `libxml2_xml_read_memory_fuzzer`,
+you would run: 
+
+```bash
+$ python infra/helper.py build_image libxml2
+$ python infra/helper.py build_fuzzers --sanitizer undefined libxml2
+$ python infra/helper.py reproduce libxml2 libxml2_xml_read_memory_fuzzer ~/Downloads/testcase
+```
+
+## Reproduce using local source checkout
+
+You can also mount local sources into the running container by using these commands:
+
+```bash
+$ python infra/helper.py build_fuzzers \
+    --sanitizer <address/memory/undefined> $PROJECT_NAME <source_path>
+$ python infra/helper.py reproduce $PROJECT_NAME <fuzz_target_name> <testcase_path>
+```
+
+Once you reproduce the bug, you can do the following:
+
+- **Fix issue:** Write a patch to fix the issue in your local checkout, then
+   use the previous command to verify the fix (i.e. no crash occurred). 
+   [Use gdb]({{ site.baseurl }}/advanced-topics/debugging/#debugging-fuzzers-with-gdb)
+   if needed.
+- **Submit fix:** Submit the fix in the project's repository. ClusterFuzz will
+  automatically pick up the changes, recheck the testcase, and close the
+  issue (in &lt; 1 day).
+- **Improve fuzzing support:** Consider
+   [improving your integration with OSS-Fuzz]({{ site.baseurl }}/advanced-topics/ideal-integration/).
+
+## Reproducing build failures
+
+Our infrastructure runs some sanity tests to make sure that your build was
+correctly configured, even if it succeeded. To reproduce these locally, run these commands:
+
+```bash
+$ python infra/helper.py build_image $PROJECT_NAME
+$ python infra/helper.py build_fuzzers --sanitizer <address/memory/undefined> \
+    --engine <libfuzzer/afl/honggfuzz/centipede> --architecture <x86_64/i386> $PROJECT_NAME
+$ python infra/helper.py check_build  --sanitizer <address/memory/undefined> \
+    --engine <libfuzzer/afl/honggfuzz/centipede> --architecture <x86_64/i386> $PROJECT_NAME \
+    <fuzz_target_name>
+```
+
+**Note:** Unless you have a reason to think the build is an `i386` build, the build
+is probably an `x86_64` build and the `architecture` argument can be omitted.
+
+If you need to reproduce a `coverage` build failure, follow the
+[Code Coverage page]({{ site.baseurl }}/advanced-topics/code-coverage) to build
+your project and generate a code coverage report.

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/assets/css/just-the-docs-wider.scss

@@ -0,0 +1,3 @@
+---
+---
+{% include css/just-the-docs.scss.liquid color_scheme="wider" %}

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/further-reading/clusterfuzz.md

@@ -0,0 +1,67 @@
+---
+layout: default
+title: ClusterFuzz
+parent: Further reading
+nav_order: 1
+permalink: /further-reading/clusterfuzz/
+---
+
+# ClusterFuzz
+
+[ClusterFuzz](https://github.com/google/clusterfuzz) is the distributed fuzzing
+infrastructure behind OSS-Fuzz. It was initially built for fuzzing Chrome at
+scale.
+
+- TOC
+{:toc}
+---
+
+## Web interface
+
+ClusterFuzz provides a [web interface](https://oss-fuzz.com)
+to view statistics about your fuzz targets, as well as current crashes.
+
+*Note*: Access is restricted to project developers who we auto CC on new bug
+reports.
+
+## Testcase reports
+
+ClusterFuzz will automatically de-duplicate and file reproducible crashes into
+our [bug tracker](https://bugs.chromium.org/p/oss-fuzz/issues/list). We provide
+a crash report page that gives you the stack trace, a link to the crashing
+testcase, and regression ranges where the bug was most likely introduced.
+
+![report]({{ site.baseurl }}/images/pcre2_testcase.png?raw=true)
+
+## Fuzzer stats
+
+You can view statistics about your fuzz targets (e.g. speed, coverage
+information, memory usage) on our fuzzer statistics dashboard.
+
+![stats]({{ site.baseurl }}/images/freetype_stats_graphs.png?raw=true)
+
+![stats]({{ site.baseurl }}/images/freetype_stats_table.png?raw=true)
+
+## Coverage reports
+
+We provide coverage reports, where we highlight the parts of source code that
+are being reached by your fuzz target. Make sure to look at the uncovered code
+marked in red and add appropriate fuzz targets to cover those use cases.
+
+![coverage_1]({{ site.baseurl }}/images/freetype_coverage_1.png?raw=true)
+![coverage_2]({{ site.baseurl }}/images/freetype_coverage_2.png?raw=true)
+
+## Performance analyzer
+
+You can view performance issues that your fuzz target is running into (e.g.
+leaks, timeouts, etc) by clicking on `Performance` link on our fuzzer statistics
+dashboard. Make sure to fix all cited issues, so as to keep your fuzz target
+running efficiently and finding new bugs.
+
+![performance_analyzer]({{ site.baseurl }}/images/expat_performance_analyzer.png?raw=true)
+
+## Crash stats
+
+You can view statistics of crashes over time on our crash statistics dashboard.
+
+![crash_stats]({{ site.baseurl }}/images/crash_stats.png?raw=true)

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/further-reading/further_reading.md

@@ -0,0 +1,9 @@
+---
+layout: default
+title: Further reading
+has_children: true
+nav_order: 4
+permalink: /further-reading/
+---
+
+# Further reading

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/further-reading/fuzzer_environment.md

@@ -0,0 +1,77 @@
+---
+layout: default
+title: Fuzzer environment
+parent: Further reading
+nav_order: 2
+permalink: /further-reading/fuzzer-environment/
+---
+
+# Fuzzer environment on ClusterFuzz
+
+Your fuzz targets will be run on a
+[Google Compute Engine](https://cloud.google.com/compute/) VM (Linux).
+
+- TOC
+{:toc}
+---
+
+## Runtime Dependencies
+
+You should not make any assumptions on the availability of dependent packages 
+in the execution environment. Packages that are installed via
+[Dockerfile]({{ site.baseurl }}/getting-started/new-project-guide/#dockerfile)
+or built as part of 
+[build.sh]({{ site.baseurl }}/getting-started/new-project-guide/#buildsh)
+are not available on the bot runtime environment (where the fuzz targets run).
+
+If you need these dependencies in the runtime environment, you can either:
+- Install the packages via Dockerfile
+([example](https://github.com/google/oss-fuzz/blob/2d5e2ef84f281e6ab789055aa735606d3122fda9/projects/tor/Dockerfile#L19))
+and then link statically against them
+([example](https://github.com/google/oss-fuzz/blob/2d5e2ef84f281e6ab789055aa735606d3122fda9/projects/tor/build.sh#L40)).
+- Or build the dependencies statically in
+[build.sh]({{ site.baseurl }}/getting-started/new-project-guide/#buildsh)
+([example](https://github.com/google/oss-fuzz/blob/64f8b6593da141b97c98c7bc6f07df92c42ee010/projects/ffmpeg/build.sh#L26)).
+
+All build artifacts needed during fuzz target execution should be inside the
+`$OUT` directory. Only those artifacts are archived and used on the bots.
+Everything else is ignored (e.g. artifacts in `$WORK`, `$SRC`, etc) and hence
+is not available in the execution environment.
+
+We strongly recommend static linking because it just works. 
+However dynamic linking can work if shared objects are included in the `$OUT` directory and are loaded relative
+to `'$ORIGIN'`, the path of the binary (see the discussion of `'$ORIGIN'` [here](http://man7.org/linux/man-pages/man8/ld.so.8.html)).
+A fuzzer can be instructed to load libraries relative to `'$ORIGIN'` during compilation (i.e. `-Wl,-rpath,'$ORIGIN/lib'` )
+or afterwards using `chrpath -r '$ORIGIN/lib' $OUT/$fuzzerName` ([example](https://github.com/google/oss-fuzz/blob/09aa9ac556f97bd4e31928747eca0c8fed42509f/projects/php/build.sh#L40)). Note that `'$ORIGIN'` should be surrounded
+by single quotes because it is not an environment variable like `$OUT` that can be retrieved during execution of `build.sh`.
+Its value is retrieved during execution of the binary. You can verify that you did this correctly using `ldd <fuzz_target_name>` and the `check_build` command in `infra/helper.py`.
+
+You should ensure that the fuzz target works correctly by using `run_fuzzer`
+command (see instructions
+[here]({{ site.baseurl }}/getting-started/new-project-guide/#testing-locally)).
+This command uses a clean base-runner docker container and not the base-builder
+docker container created during build-time.
+
+## argv[0]
+
+You must not modify `argv[0]`. It is required for certain things to work
+correctly.
+
+## Current working directory
+
+You should not make any assumptions about the current working directory of your
+fuzz target. If you need to load data files, please use `argv[0]` to get the
+directory where your fuzz target executable is located.
+
+## File system
+
+Everything except `/tmp` is read-only, including the directory that your fuzz
+target executable lives in.
+
+`/dev` is also unavailable.
+
+## Hardware
+
+Your project should not be compiled with `-march=native` or `-mtune=native`
+flags, as the build infrastructure and fuzzing machines may have different CPUs
+as well as other hardware differences. You may however use `-mtune=generic`.

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/getting-started/bug_disclosure_guidelines.md

@@ -0,0 +1,23 @@
+---
+layout: default
+title: Bug disclosure guidelines
+parent: Getting started
+nav_order: 4
+permalink: /getting-started/bug-disclosure-guidelines/
+---
+
+## Bug Disclosure Guidelines
+
+Following [Google's standard disclosure policy](https://googleprojectzero.blogspot.com/2015/02/feedback-and-data-driven-updates-to.html),
+OSS-Fuzz will adhere to following disclosure principles:
+
+  - **Deadline**. After notifying project authors, we will open reported
+    issues to the public in 90 days, or after the fix is released (whichever
+    comes earlier).
+  - **Weekends and holidays**. If a deadline is due to expire on a weekend,
+    the deadline will be moved to the next normal work day.
+  - **Grace period**. We have a 14-day grace period. If a 90-day deadline
+    expires but the upstream engineers let us know before the deadline that a
+    patch is scheduled for release on a specific day within 14 days following
+    the deadline, the public disclosure will be delayed until the availability
+    of the patch.

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/getting-started/continuous_integration.md

@@ -0,0 +1,271 @@
+---
+layout: default
+title: Continuous Integration
+parent: Getting started
+nav_order: 5
+permalink: /getting-started/continuous-integration/
+---
+
+# Continuous Integration
+
+OSS-Fuzz offers **CIFuzz**, a GitHub action/CI job that runs your fuzz targets
+on pull requests. This works similarly to running unit tests in CI. CIFuzz helps
+you find and fix bugs before they make it into your codebase.
+Currently, CIFuzz primarily supports projects hosted on GitHub.
+Non-OSS-Fuzz users can use CIFuzz with additional features through
+[ClusterFuzzLite](https://google.github.io/clusterfuzzlite/).
+
+## How it works
+
+CIFuzz builds your project's fuzzers from the source at a particular
+pull request or commit. Then CIFuzz runs the fuzzers for a short amount of time.
+If CIFuzz finds a crash, CIFuzz reports the stacktrace, makes the crashing
+input available for download and the CI test fails (red X).
+
+If CIFuzz doesn't find a crash during the allotted time, the CI test passes
+(green check). If CIFuzz finds a crash, it reports the crash only if both of
+following are true:
+* The crash is reproducible (on the PR/commit build).
+* The crash does not occur on older OSS-Fuzz builds. (If the crash does occur
+  on older builds, then it was not introduced by the PR/commit
+  being tested.)
+
+If your project supports [OSS-Fuzz's code coverage]({{ site.baseurl }}/advanced-topics/code-coverage),
+CIFuzz only runs the fuzzers affected by a pull request/commit.
+Otherwise it will divide up the allotted fuzzing time (10 minutes by default)
+among all fuzzers in the project.
+
+CIFuzz uses 30 day old/public regressions and corpora from OSS-Fuzz. This makes
+fuzzing more effective and gives you regression testing for free.
+
+## Requirements
+
+1. Your project must be integrated with OSS-Fuzz.
+1. Your project is hosted on GitHub.
+1. Your repository needs to be cloned with `git` in oss-fuzz Dockerfile (do not use `go get` or other methods)
+
+## Integrating into your repository
+
+You can integrate CIFuzz into your project using the following steps:
+1. Create a `.github` directory in the root of your project.
+1. Create a `workflows` directory inside of your `.github` directory.
+1. Copy the example [`cifuzz.yml`](https://github.com/google/oss-fuzz/blob/master/infra/cifuzz/example_cifuzz.yml)
+file over from the OSS-Fuzz repository to the `workflows` directory.
+1. Change the `oss-fuzz-project-name` value in `cifuzz.yml` from `example` to the name of your OSS-Fuzz project. It is **very important** that you use your OSS-Fuzz project name which is case sensitive. This name
+is the name of your project's subdirectory in the [`projects`](https://github.com/google/oss-fuzz/tree/master/projects) directory of OSS-Fuzz.
+1. Set the value of `fuzz-seconds`. The longest time that the project maintainers are acceptable with should be used. This value should be at minimum 600 seconds and scale with project size.
+
+Your directory structure should look like the following:
+```
+project
+|___ .github
+|    |____ workflows
+|          |____ cifuzz.yml
+|___ other-files
+```
+
+cifuzz.yml for an example project:
+
+```yaml
+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: 'example'
+       language: c++
+   - name: Run Fuzzers
+     uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+     with:
+       oss-fuzz-project-name: 'example'
+       language: c++
+       fuzz-seconds: 600
+       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
+```
+
+
+### Optional configuration
+
+#### Configurable Variables
+
+`language`: (optional) The language your target program is written in. Defaults
+to `c++`. This should be the same as the value you set in `project.yaml`. See
+[this explanation]({{ site.baseurl }}//getting-started/new-project-guide/#language)
+for more details.
+
+`fuzz-seconds`: Determines how long CIFuzz spends fuzzing your project in seconds.
+The default is 600 seconds. The GitHub Actions max run time is 21600 seconds (6
+hours). This variable is only meaningful when supplied to the `run_fuzzers`
+action, not the `build_fuzzers` action.
+
+`dry-run`: Determines if CIFuzz surfaces errors. The default value is `false`. When set to `true`,
+CIFuzz will never report a failure even if it finds a crash in your project.
+This requires the user to manually check the logs for detected bugs. If dry run mode is desired,
+make sure to set the dry-run parameters in both the `Build Fuzzers` and `Run Fuzzers` action step.
+
+`allowed-broken-targets-percentage`: Can be set if you want to set a stricter
+limit for broken fuzz targets than OSS-Fuzz's check_build. Most users should
+not set this. This value is only meaningful when supplied to the `run_fuzzers`
+action, not the `build_fuzzers` action.
+
+`sanitizer`: Determines a sanitizer to build and run fuzz targets with. The choices are `'address'`,
+`'memory'` and `'undefined'`. The default is `'address'`. It is important to note that the `Build Fuzzers`
+and the `Run Fuzzers` sanitizer field needs to be the same. To specify a list of sanitizers
+a [matrix](https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions#jobsjob_idstrategymatrix)
+can be used. To use a sanitizer add it to the list of sanitizers in the matrix field below:
+
+`report-timeouts`: Determines whether to report fails due to timeouts.
+
+`report-ooms`: Determines whether to report fails due to OOM.
+
+```yaml
+{% raw %}
+name: CIFuzz
+on: [pull_request]
+permissions: {}
+jobs:
+ Fuzzing:
+   runs-on: ubuntu-latest
+   permissions:
+     security-events: write
+   strategy:
+     fail-fast: false
+     matrix:
+       sanitizer: [address, undefined, memory]
+   steps:
+   - name: Build Fuzzers (${{ matrix.sanitizer }})
+     id: build
+     uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+     with:
+       oss-fuzz-project-name: 'example'
+       language: c++
+       sanitizer: ${{ matrix.sanitizer }}
+   - name: Run Fuzzers (${{ matrix.sanitizer }})
+     uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+     with:
+       oss-fuzz-project-name: 'example'
+       language: c++
+       fuzz-seconds: 600
+       sanitizer: ${{ matrix.sanitizer }}
+       output-sarif: true
+   - name: Upload Crash
+     uses: actions/upload-artifact@v3
+     if: steps.build.outcome == 'success'
+     with:
+       name: ${{ matrix.sanitizer }}-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
+{% endraw %}
+```
+
+#### Branches and paths
+
+You can make CIFuzz trigger only on certain branches or paths by following the
+instructions [here](https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions).
+For example, the following code can used to trigger CIFuzz only on changes to
+C/C++ code residing on master and release branches:
+
+```yaml
+name: CIFuzz
+on:
+  pull_request:
+    branches:
+      - master
+      - 'releases/**'
+    paths:
+      - '**.c'
+      - '**.cc'
+      - '**.cpp'
+      - '**.cxx'
+      - '**.h'
+permissions: {}
+jobs:
+ Fuzzing:
+   runs-on: ubuntu-latest
+   steps:
+   - name: Build Fuzzers
+     id: build
+     uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+     with:
+       oss-fuzz-project-name: 'example'
+       language: c++
+   - name: Run Fuzzers
+     uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+     with:
+       oss-fuzz-project-name: 'example'
+       language: c++
+       fuzz-seconds: 600
+   - name: Upload Crash
+     uses: actions/upload-artifact@v3
+     if: failure() && steps.build.outcome == 'success'
+     with:
+       name: artifacts
+       path: ./out/artifacts
+```
+
+You can checkout CIFuzz configs for OSS-Fuzz projects. Example -
+[systemd](https://github.com/systemd/systemd/blob/main/.github/workflows/cifuzz.yml),
+[curl](https://github.com/curl/curl/blob/master/.github/workflows/fuzz.yml).
+
+## Understanding results
+
+The results of CIFuzz can be found in two different places.
+
+* Run fuzzers log:
+    1. This log can be accessed in the `actions` tab of a CIFuzz integrated repo.
+    1. Click on the `CIFuzz` button in the workflow selector on the left hand side.
+    1. Click on the event triggered by your desired pull request.
+    1. Click the `Fuzzing` workflow.
+    1. Select the `Run Fuzzer` drop down. It should show the timestamps and results
+    from each of the fuzz targets.
+
+![Finding fuzzer output](../images/run_fuzzers.png)
+
+
+
+*  Artifacts:
+When the fuzzer crashes the input file that causes the crash is uploaded as an
+artifact.
+To download the artifact, do the following steps:
+1. Click on the summary from the run, as illustrated in the screenshot below:
+
+![github-actions-summary]
+
+2. Click on the artifact you wish to download from the summary page, as
+   illustrated in the screenshot below:
+
+![github-actions-download-crash]
+
+[github-actions-summary]: (https://raw.githubusercontent.com/google/clusterfuzzlite/refs/heads/bucket/images/github-actions-summary.png)
+[github-actions-download-crash]: (https://raw.githubusercontent.com/google/clusterfuzzlite/refs/heads/bucket/images/github-actions-download-crash.png)
+
+## Feedback/Questions/Issues
+
+Create an issue in [OSS-Fuzz](https://github.com/google/oss-fuzz/issues/new) if you have questions or any other feedback on CIFuzz.

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/getting-started/getting_started.md

@@ -0,0 +1,11 @@
+---
+layout: default
+title: Getting started
+has_children: true
+nav_order: 2
+permalink: /getting-started/
+---
+
+# Getting started
+These pages walk you through the process of integrating your open source project
+with OSS-Fuzz.

local-test-commons-compress-full-01-vuln_0/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_0/fuzz-tooling/docs/getting-started/new_project_guide.md

@@ -0,0 +1,553 @@
+---
+layout: default
+title: Setting up a new project
+parent: Getting started
+has_children: true
+nav_order: 2
+permalink: /getting-started/new-project-guide/
+---
+
+# Setting up a new project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+## Prerequisites
+
+Before you can start setting up your new project for fuzzing, you must do the following:
+
+- [Integrate]({{ site.baseurl }}/advanced-topics/ideal-integration/) one or more [fuzz targets]({{ site.baseurl }}/reference/glossary/#fuzz-target)
+  with the project you want to fuzz.
+
+  For examples, see
+[boringssl](https://github.com/google/boringssl/tree/master/fuzz) or
+[SQLite](https://www.sqlite.org/src/artifact/ad79e867fb504338) (C/C++),
+[go-fuzz](https://github.com/dvyukov/go-fuzz-corpus/tree/86a5af9d6842f80b205a082538ea28f61bbb8ccb) or
+[syzkaller](https://github.com/google/syzkaller/tree/7c7ded697e6322b0975f061b7e268fe44f585dab/prog/test)
+(Go).
+
+- [Install Docker](https://docs.docker.com/engine/installation)
+  (Googlers can visit [go/installdocker](https://goto.google.com/installdocker)).
+  [Why Docker?]({{ site.baseurl }}/faq/#why-do-you-use-docker)
+
+  If you want to run `docker` without `sudo`, you can
+  [create a docker group](https://docs.docker.com/engine/installation/linux/ubuntulinux/#/create-a-docker-group).
+
+  **Note:** Docker images can consume significant disk space. Run
+  [docker-cleanup](https://gist.github.com/mikea/d23a839cba68778d94e0302e8a2c200f)
+  periodically to garbage-collect unused images.
+
+- (optional) [Install gsutil](https://cloud.google.com/storage/docs/gsutil_install) for local code coverage testing.
+  For Google internal (gLinux) machines, please refer [here](https://cloud.google.com/storage/docs/gsutil_install#deb) instead.
+
+## Creating the file structure
+
+Each OSS-Fuzz project has a subdirectory
+inside the [`projects/`](https://github.com/google/oss-fuzz/tree/master/projects) directory in the [OSS-Fuzz repository](https://github.com/google/oss-fuzz). For example, the [boringssl](https://github.com/google/boringssl)
+project is located in [`projects/boringssl`](https://github.com/google/oss-fuzz/tree/master/projects/boringssl).
+
+Each project directory also contains the following three configuration files:
+
+* [project.yaml](#projectyaml) - provides metadata about the project.
+* [Dockerfile](#dockerfile) - defines the container environment with information
+on dependencies needed to build the project and its [fuzz targets]({{ site.baseurl }}/reference/glossary/#fuzz-target).
+* [build.sh](#buildsh) - defines the build script that executes inside the Docker container and
+generates the project build.
+
+You can automatically create a new directory for your project in OSS-Fuzz and
+generate templated versions of the configuration files
+by running the following commands:
+
+```bash
+$ cd /path/to/oss-fuzz
+$ export PROJECT_NAME=<project_name>
+$ export LANGUAGE=<project_language>
+$ python infra/helper.py generate $PROJECT_NAME --language=$LANGUAGE
+```
+
+Once the template configuration files are created, you can modify them to fit your project.
+
+**Note:** We prefer that you keep and maintain [fuzz targets]({{ site.baseurl }}/reference/glossary/#fuzz-target) in your own source code repository. If this isn't possible, you can store them inside the OSS-Fuzz project directory you created.
+
+## project.yaml {#projectyaml}
+
+This configuration file stores project metadata. The following attributes are supported:
+
+- [homepage](#homepage)
+- [language](#language)
+- [primary_contact](#primary)
+- [auto_ccs](#auto_ccs)
+- [main_repo](#main_repo)
+- [vendor_ccs](#vendor) (optional)
+- [sanitizers](#sanitizers) (optional)
+- [architectures](#architectures) (optional)
+- [help_url](#help_url) (optional)
+- [builds_per_day](#build_frequency) (optional)
+- [file_github_issue](#file_github_issue) (optional)
+
+### homepage
+You project's homepage.
+
+### language
+
+Programming language the project is written in. Values you can specify include:
+
+* `c`
+* `c++`
+* [`go`]({{ site.baseurl }}//getting-started/new-project-guide/go-lang/)
+* [`rust`]({{ site.baseurl }}//getting-started/new-project-guide/rust-lang/)
+* [`python`]({{ site.baseurl }}//getting-started/new-project-guide/python-lang/)
+* [`jvm` (Java, Kotlin, Scala and other JVM-based languages)]({{ site.baseurl }}//getting-started/new-project-guide/jvm-lang/)
+* [`swift`]({{ site.baseurl }}//getting-started/new-project-guide/swift-lang/)
+* [`javascript`]({{ site.baseurl }}//getting-started/new-project-guide/javascript-lang/)
+
+### primary_contact, auto_ccs {#primary}
+The primary contact and list of other contacts to be CCed. Each person listed gets access to ClusterFuzz, including crash reports and fuzzer statistics, and are auto-cced on new bugs filed in the OSS-Fuzz
+tracker. If you're a primary or a CC, you'll need to use a [Google account](https://support.google.com/accounts/answer/176347?hl=en) to get full access. ([why?]({{ site.baseurl }}/faq/#why-do-you-require-a-google-account-for-authentication)).
+
+### main_repo {#main_repo}
+Path to source code repository hosting the code, e.g. `https://path/to/main/repo.git`. 
+
+### vendor_ccs (optional) {#vendor}
+The list of vendor email addresses that are downstream consumers of the project and want access to
+the bug reports as they are filed.
+
+Any changes to this list must follow these rules:
+- Approved by the project maintainer (e.g. comment on pull request, reply on project mailing list).
+- An organization email address is used.
+
+### sanitizers (optional) {#sanitizers}
+The list of sanitizers to use. Possible values are: `address`, `memory` and `undefined`.
+If you don't specify a list, `sanitizers` uses a default list of supported
+sanitizers (currently ["address"](https://clang.llvm.org/docs/AddressSanitizer.html) and
+["undefined"](https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html)).
+
+[MemorySanitizer](https://clang.llvm.org/docs/MemorySanitizer.html) ("memory") is also supported
+and recommended, but is not enabled by default due to the likelihood of false positives from
+un-instrumented system dependencies.
+If you want to use "memory," please build all libraries your project needs using
+MemorySanitizer.
+This can be done by building them with the compiler flags provided during
+MemorySanitizer builds.
+Then, you can opt in by adding "memory" to your list of sanitizers.
+
+If your project does not build with a particular sanitizer configuration and you need some time to fix
+it, you can use `sanitizers` to override the defaults temporarily. For example, to disable the
+UndefinedBehaviourSanitizer build, just specify all supported sanitizers except "undefined".
+
+If you want to test a particular sanitizer to see what crashes it generates without filing
+them in the issue tracker, you can set an `experimental` flag. For example, if you want to test "memory", set `experimental: True` like this:
+
+```
+sanitizers:
+ - address
+ - memory:
+    experimental: True
+ - undefined
+ ```
+
+Crashes can be accessed on the [ClusterFuzz
+homepage]({{ site.baseurl }}/further-reading/clusterfuzz#web-interface).
+
+`sanitizers` example: [boringssl](https://github.com/google/oss-fuzz/blob/master/projects/boringssl/project.yaml).
+
+### architectures (optional) {#architectures}
+The list of architectures to fuzz on.
+ClusterFuzz supports fuzzing on x86_64 (aka x64) by default.
+Some projects can benefit from i386 fuzzing. OSS-Fuzz will build and run
+AddressSanitizer with libFuzzer on i386 by doing the following:
+
+```yaml
+architectures:
+ - x86_64
+ - i386
+ ```
+
+By fuzzing on i386 you might find bugs that:
+* Only occur in architecture-specific source code (e.g. code that contains i386 assembly).
+* Exist in architecture-independent source code and which only affects i386 users.
+* Exist in architecture-independent source code and which affects users on other 32-bit platforms such as AArch32 (aka 32-bit ARM).
+
+Note that some bugs which affect x86_64 may be discovered on i386 and filed as such.
+On the testcase page of each oss-fuzz issue is a list of other jobs where the crash reproduces, this can let you know if the crash exists on x86_64 as well.
+
+Fuzzing on i386 is not enabled by default because many projects won't build for i386 without some modification to their OSS-Fuzz build process.
+For example, you will need to link against `$LIB_FUZZING_ENGINE` and possibly install i386 dependencies within the x86_64 docker image ([for example](https://github.com/google/oss-fuzz/blob/5b8dcb5d942b3b8bc173b823fb9ddbdca7ec6c99/projects/gdal/build.sh#L18)) to get things working.
+
+There are [known bugs](https://github.com/google/oss-fuzz/issues/2746) in ASAN
+on i386 that cause ClusterFuzz to report unreproducible crashes for 0 length
+testcases. There are no plans to fix these bugs so be ready for slightly more
+false positives if you use i386. These false positives should be somewhat easy
+to identify since they will manifest as crashes in ASAN rather than your code.
+
+### fuzzing_engines (optional) {#fuzzing_engines}
+The list of fuzzing engines to use.
+By default, `libfuzzer`, `afl`, `honggfuzz`, and `centipede` are used. It is recommended to
+use all of them if possible. `libfuzzer` is required by OSS-Fuzz.
+
+### help_url (optional) {#help_url}
+A link to a custom help URL that appears in bug reports instead of the default
+[OSS-Fuzz guide to reproducing crashes]({{ site.baseurl }}/advanced-topics/reproducing/). This can be useful if you assign
+bugs to members of your project unfamiliar with OSS-Fuzz, or if they should follow a different workflow for
+reproducing and fixing bugs than the standard one outlined in the reproducing guide.
+
+`help_url` example: [skia](https://github.com/google/oss-fuzz/blob/master/projects/skia/project.yaml).
+
+### builds_per_day (optional) {#build_frequency}
+The number of times the project should be built per day.
+OSS-Fuzz allows upto 4 builds per day, and builds once per day by default.
+Example:
+```yaml
+builds_per_day: 2
+```
+
+Will build the project twice per day.
+
+### file_github_issue (optional) {#file_github_issue}
+Whether to mirror issues on github instead of having them only in the OSS-Fuzz
+tracker.
+
+## Dockerfile {#dockerfile}
+
+This configuration file defines the Docker image for your project. Your [build.sh](#buildsh) script will be executed in inside the container you define.
+For most projects, the image is simple:
+```docker
+FROM gcr.io/oss-fuzz-base/base-builder       # base image with clang toolchain
+RUN apt-get update && apt-get install -y ... # install required packages to build your project
+RUN git clone <git_url> <checkout_dir>       # checkout all sources needed to build your project
+WORKDIR <checkout_dir>                       # current directory for the build script
+COPY build.sh fuzzer.cc $SRC/                # copy build script and other fuzzer files in src dir
+```
+In the above example, the git clone will check out the source to `$SRC/<checkout_dir>`.
+
+Depending on your project's language, you will use a different base image,
+for instance `FROM gcr.io/oss-fuzz-base/base-builder-go` for golang.
+
+For an example, see
+[expat/Dockerfile](https://github.com/google/oss-fuzz/tree/master/projects/expat/Dockerfile)
+or
+[syzkaller/Dockerfile](https://github.com/google/oss-fuzz/blob/master/projects/syzkaller/Dockerfile).
+
+In the case of a project with multiple languages/toolchains needed,
+you can run installation scripts `install_lang.sh` where lang is the language needed.
+You also need to setup environment variables needed by this toolchain, for example `GOPATH` is needed by golang.
+For an example, see
+[ecc-diff-fuzzer/Dockerfile](https://github.com/google/oss-fuzz/blob/master/projects/ecc-diff-fuzzer/Dockerfile).
+where we use `base-builder-rust`and install golang
+
+## build.sh {#buildsh}
+
+This file defines how to build binaries for [fuzz targets]({{ site.baseurl }}/reference/glossary/#fuzz-target) in your project.
+The script is executed within the image built from your [Dockerfile](#Dockerfile).
+
+In general, this script should do the following:
+
+- Build the project using your build system with the correct compiler.
+- Provide compiler flags as [environment variables](#Requirements).
+- Build your [fuzz targets]({{ site.baseurl }}/reference/glossary/#fuzz-target) and link your project's build with libFuzzer.
+
+Resulting binaries should be placed in `$OUT`.
+
+Here's an example from Expat ([source](https://github.com/google/oss-fuzz/blob/master/projects/expat/build.sh)):
+
+```bash
+#!/bin/bash -eu
+
+./buildconf.sh
+# configure scripts usually use correct environment variables.
+./configure
+
+make clean
+make -j$(nproc) all
+
+$CXX $CXXFLAGS -std=c++11 -Ilib/ \
+    $SRC/parse_fuzzer.cc -o $OUT/parse_fuzzer \
+    $LIB_FUZZING_ENGINE .libs/libexpat.a
+
+cp $SRC/*.dict $SRC/*.options $OUT/
+```
+
+If your project is written in Go, check out the [Integrating a Go project]({{ site.baseurl }}//getting-started/new-project-guide/go-lang/) page.
+
+**Note:**
+
+1. Don't assume the fuzzing engine is libFuzzer by default, because we generate builds for libFuzzer, AFL++, Honggfuzz, and Centipede fuzzing engine configurations. Instead, link the fuzzing engine using $LIB_FUZZING_ENGINE.
+2. Make sure that the binary names for your [fuzz targets]({{ site.baseurl }}/reference/glossary/#fuzz-target) contain only
+alphanumeric characters, underscore(_) or dash(-). Otherwise, they won't run on our infrastructure.
+3. Don't remove source code files. They are needed for code coverage.
+
+### Temporarily disabling code instrumentation during builds
+
+In some cases, it's not necessary to instrument every 3rd party library or tool that supports the build target. Use the following snippet to build tools or libraries without instrumentation:
+
+
+```
+CFLAGS_SAVE="$CFLAGS"
+CXXFLAGS_SAVE="$CXXFLAGS"
+unset CFLAGS
+unset CXXFLAGS
+export AFL_NOOPT=1
+
+#
+# build commands here that should not result in instrumented code.
+#
+
+export CFLAGS="${CFLAGS_SAVE}"
+export CXXFLAGS="${CXXFLAGS_SAVE}"
+unset AFL_NOOPT
+```
+
+### build.sh script environment
+
+When your build.sh script is executed, the following locations are available within the image:
+
+| Location| Env Variable | Description |
+|---------| ------------ | ----------  |
+| `/out/` | `$OUT`         | Directory to store build artifacts (fuzz targets, dictionaries, options files, seed corpus archives). |
+| `/src/` | `$SRC`         | Directory to checkout source files. |
+| `/work/`| `$WORK`        | Directory to store intermediate files. |
+
+Although the files layout is fixed within a container, environment variables are
+provided so you can write retargetable scripts.
+
+In case your fuzz target uses the [FuzzedDataProvider] class, make sure it is
+included via `#include <fuzzer/FuzzedDataProvider.h>` directive.
+
+[FuzzedDataProvider]: https://github.com/google/fuzzing/blob/master/docs/split-inputs.md#fuzzed-data-provider
+
+### build.sh requirements {#Requirements}
+
+Only binaries without an extension are accepted as targets. Extensions are reserved for other artifacts, like .dict.
+
+You *must* use the special compiler flags needed to build your project and fuzz targets.
+These flags are provided in the following environment variables:
+
+| Env Variable           | Description
+| -------------          | --------
+| `$CC`, `$CXX`, `$CCC`  | The C and C++ compiler binaries.
+| `$CFLAGS`, `$CXXFLAGS` | C and C++ compiler flags.
+| `$LIB_FUZZING_ENGINE`  | C++ compiler argument to link fuzz target against the prebuilt engine library (e.g. libFuzzer).
+
+You *must* use `$CXX` as a linker, even if your project is written in pure C.
+
+Most well-crafted build scripts will automatically use these variables. If not,
+pass them manually to the build tool.
+
+See the [Provided Environment Variables](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/README.md#provided-environment-variables) section in
+`base-builder` image documentation for more details.
+
+### Static and dynamic linking of libraries
+The `build.sh` should produce fuzzers that are statically linked. This is because the
+fuzzer build environment is different to the fuzzer runtime environment and if your
+project depends on third party libraries then it is likely they will not be present
+in the execution environment. Thus, any shared libraries you may install or compile in
+`build.sh` or `Dockerfile` will not be present in the fuzzer runtime environment. There
+are exceptions to this rule, and for further information on this please see the [fuzzer environment]({{ site.baseurl }}/further-reading/fuzzer-environment/) page.
+
+## Disk space restrictions
+
+Our builders have a disk size of 250GB (this includes space taken up by the OS). Builds must keep peak disk usage below this.
+
+In addition, please keep the size of the build (everything copied to `$OUT`) small (<10GB uncompressed). The build is repeatedly transferred and unzipped during fuzzing and runs on VMs with limited disk space.
+
+## Fuzzer execution environment
+
+For more on the environment that
+your [fuzz targets]({{ site.baseurl }}/reference/glossary/#fuzz-target) run in, and the assumptions you can make, see the [fuzzer environment]({{ site.baseurl }}/further-reading/fuzzer-environment/) page.
+
+## Testing locally
+
+You can build your docker image and fuzz targets locally, so you can test them before you push them to the OSS-Fuzz repository.
+
+1. Run the same helper script you used to create your directory structure, this time using it to build your docker image and [fuzz targets]({{ site.baseurl }}/reference/glossary/#fuzz-target):
+
+    ```bash
+    $ cd /path/to/oss-fuzz
+    $ python infra/helper.py build_image $PROJECT_NAME
+    $ python infra/helper.py build_fuzzers --sanitizer <address/memory/undefined> $PROJECT_NAME
+    ```
+
+    The built binaries appear in the `/path/to/oss-fuzz/build/out/$PROJECT_NAME`
+    directory on your machine (and `$OUT` in the container).
+
+    **Note:** You *must* run your fuzz target binaries inside the base-runner docker
+    container to make sure that they work properly.
+
+2. Find failures to fix by running the `check_build` command:
+
+    ```bash
+    $ python infra/helper.py check_build $PROJECT_NAME
+    ```
+
+3. If you want to test changes against a particular fuzz target, run the following command:
+
+    ```bash
+    $ python infra/helper.py run_fuzzer --corpus-dir=<path-to-temp-corpus-dir> $PROJECT_NAME <fuzz_target>
+    ```
+
+4. We recommend taking a look at your code coverage as a test to ensure that
+your fuzz targets get to the code you expect. This would use the corpus
+generated from the previous `run_fuzzer` step in your local corpus directory.
+
+    ```bash
+    $ python infra/helper.py build_fuzzers --sanitizer coverage $PROJECT_NAME
+    $ python infra/helper.py coverage $PROJECT_NAME --fuzz-target=<fuzz_target> --corpus-dir=<path-to-temp-corpus-dir>
+    ```
+
+You may need to run `python infra/helper.py pull_images` to use the latest
+coverage tools. Please refer to
+[code coverage]({{ site.baseurl }}/advanced-topics/code-coverage/) for detailed
+information on code coverage generation.
+
+
+**Note:** Currently, we only support AddressSanitizer (address) and UndefinedBehaviorSanitizer (undefined)
+configurations by default.
+MemorySanitizer is recommended, but needs to be enabled manually since you must build all runtime dependencies with MemorySanitizer.
+<b>Make sure to test each
+of the supported build configurations with the above commands (build_fuzzers -> run_fuzzer -> coverage).</b>
+
+If everything works locally, it should also work on our automated builders and ClusterFuzz. If you check in
+your files and experience failures, review your [dependencies]({{ site.baseurl }}/further-reading/fuzzer-environment/#dependencies).
+
+## Debugging Problems
+
+If you run into problems, our [Debugging page]({{ site.baseurl }}/advanced-topics/debugging/) lists ways to debug your build scripts and
+[fuzz targets]({{ site.baseurl }}/reference/glossary/#fuzz-target).
+
+## Efficient fuzzing
+
+To improve your fuzz target ability to find bugs faster, you should consider the
+following ways:
+
+### Seed Corpus
+
+Most fuzzing engines use evolutionary fuzzing algorithms. Supplying a seed
+corpus consisting of good sample inputs is one of the best ways to improve [fuzz
+target]({{ site.baseurl }}/reference/glossary/#fuzz-target)'s coverage.
+
+To provide a corpus for `my_fuzzer`, put `my_fuzzer_seed_corpus.zip` file next
+to the [fuzz target]({{ site.baseurl }}/reference/glossary/#fuzz-target)'s binary in `$OUT` during the build. Individual files in this
+archive will be used as starting inputs for mutations. You can store the corpus
+next to source files, generate during build or fetch it using curl or any other
+tool of your choice.
+(example: [boringssl](https://github.com/google/oss-fuzz/blob/master/projects/boringssl/build.sh#L41)).
+
+Seed corpus files will be used for cross-mutations and portions of them might appear
+in bug reports or be used for further security research. It is important that corpus
+has an appropriate and consistent license.
+
+OSS-Fuzz only: See also [Accessing Corpora]({{ site.baseurl }}/advanced-topics/corpora/) for information about getting access to the corpus we are currently using for your fuzz targets.
+
+### Dictionaries
+
+Dictionaries hugely improve fuzzing efficiency for inputs with lots of similar
+sequences of bytes. [libFuzzer documentation](https://llvm.org/docs/LibFuzzer.html#dictionaries)
+
+Put your dict file in `$OUT`. If the dict filename is the same as your target
+binary name (i.e. `%fuzz_target%.dict`), it will be automatically used. If the
+name is different (e.g. because it is shared by several targets), specify this
+in .options file:
+
+```
+[libfuzzer]
+dict = dictionary_name.dict
+```
+
+It is common for several [fuzz targets]({{ site.baseurl }}/reference/glossary/#fuzz-target)
+to reuse the same dictionary if they are fuzzing very similar inputs.
+(example: [expat](https://github.com/google/oss-fuzz/blob/ad88a2e5295d91251d15f8a612758cd9e5ad92db/projects/expat/parse_fuzzer.options)).
+
+### Input Size
+
+By default, the fuzzing engine will generate input of any arbitrary length.
+This might be useful to try corner cases that could lead to a
+security vulnerability. However, if large inputs are not necessary to
+increase the coverage of your target API, it is important to add a limit
+here to significantly improve performance.
+
+```cpp
+if (size < kMinInputLength || size > kMaxInputLength)
+  return 0;
+```
+
+## Checking in to the OSS-Fuzz repository
+
+Once you've tested your fuzzing files locally, fork OSS-Fuzz, commit, and push to the fork. Then
+create a pull request with your change. Follow the
+[Forking Project](https://guides.github.com/activities/forking/) guide if you're new to contributing
+via GitHub.
+
+### Copyright headers
+
+Please include copyright headers for all files checked in to oss-fuzz:
+
+```
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+```
+
+**Exception:** If you're porting a fuzz target from Chromium, keep the original Chromium license header.
+
+## Reviewing results
+
+Once your change is merged, your project and fuzz targets should be automatically built and run on
+ClusterFuzz after a short while (&lt; 1 day). If you think there's a problem, you can check your project's [build status](https://oss-fuzz-build-logs.storage.googleapis.com/index.html).
+
+Use the [ClusterFuzz web interface](https://oss-fuzz.com/) to review the following:
+* Crashes generated
+* Code coverage statistics
+* Fuzzer statistics
+* Fuzzer performance analyzer (linked from fuzzer statistics)
+
+**Note:** Your Google Account must be listed in [project.yaml](#projectyaml) for you to have access to the ClusterFuzz web interface.
+
+### Status Badge
+
+![Example
+Badge](https://oss-fuzz-build-logs.storage.googleapis.com/badges/curl.svg)
+
+Once your project has started [building](https://oss-fuzz-build-logs.storage.googleapis.com/index.html), we'd love it if you added our badge in
+your project's README. This allows you to see bugs found by your OSS-Fuzz
+integration at a glance. See
+[brotli](https://github.com/google/brotli#introduction)'s
+README for an example.
+
+Adding it is super easy, just follow this template:
+```markdown
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/<project>.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:<project>)
+```
+
+## Monitoring performance via Fuzz Introspector
+
+As soon as your project is run with ClusterFuzz (< 1 day), you can view the Fuzz
+Introspector report for your project.
+[Fuzz Introspector](https://github.com/ossf/fuzz-introspector) helps you
+understand your fuzzers' performance and identify any potential blockers.
+It provides individual and aggregated fuzzer reachability and coverage reports.
+You can monitor each fuzzer's static reachability potential and compare it
+against dynamic coverage and identify any potential bottlenecks.
+Fuzz Introspector can offer suggestions on increasing coverage by adding new
+fuzz targets or modify existing ones.
+Fuzz Introspector reports can be viewed from the [OSS-Fuzz
+homepage](https://oss-fuzz.com/) or through this
+[index](http://oss-fuzz-introspector.storage.googleapis.com/index.html).
+Fuzz Introspector support C and C++ projects.
+Support for Java and Python projects is in the progress.
+
+You can view the [Fuzz Introspector report for bzip2](https://storage.googleapis.com/oss-fuzz-introspector/bzip2/inspector-report/20221017/fuzz_report.html)
+as an example.

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/oss-fuzz/architecture.md

@@ -0,0 +1,33 @@
+---
+layout: default
+title: Architecture
+permalink: /architecture/
+nav_order: 1
+parent: OSS-Fuzz
+---
+
+# Architecture
+![OSS-Fuzz architecture diagram]({{ site.baseurl }}/images/process.png?raw=true)
+
+The process works like this:
+
+1. A maintainer of an open source project (or an outside volunteer) creates
+one or more [fuzz targets](https://llvm.org/docs/LibFuzzer.html#fuzz-target)
+and [integrates]({{ site.baseurl }}/advanced-topics/ideal-integration/) them
+with the project's build and test system.
+1. The project is [accepted to OSS-Fuzz]({{ site.baseurl }}/getting-started/accepting-new-projects/) and the developer commits their build configurations.
+1. The OSS-Fuzz [builder](https://github.com/google/oss-fuzz/tree/master/infra/build) builds the project from the committed configs.
+1. The builder uploads the fuzz targets to the OSS-Fuzz GCS bucket.
+1. [ClusterFuzz]({{ site.baseurl }}/further-reading/clusterfuzz) downloads the fuzz targets and begins to fuzz the projects.
+1. When Clusterfuzz finds a
+  bug, it reports the issue automatically to the OSS-Fuzz
+  [issue tracker](https://bugs.chromium.org/p/oss-fuzz/issues/list) 
+  ([example](https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=9)).
+  ([Why use a different tracker?]({{ site.baseurl }}/faq/#why-do-you-use-a-different-issue-tracker-for-reporting-bugs-in-oss-projects))
+1. Project owners are CCed on the bug report.
+1. The project developer fixes the bug upstream and credits OSS-Fuzz for the
+  discovery (the commit message should contain the string **'Credit to OSS-Fuzz'**).
+
+Once the developer fixes the bug, [ClusterFuzz]({{ site.baseurl }}/further-reading/clusterfuzz) automatically
+verifies the fix, adds a comment, and closes the issue ([example](https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=53#c3)). After the fix is verified or 90 days after reporting (whichever is earlier), the issue becomes [public]({{ site.baseurl }}/getting-started/bug-disclosure-guidelines/).
+

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/reference/glossary.md

@@ -0,0 +1,99 @@
+---
+layout: default
+title: Glossary
+nav_order: 1
+permalink: /reference/glossary/
+parent: Reference
+---
+
+# Glossary
+
+For general fuzzing terms, see the [glossary] from [google/fuzzing] project.
+
+[glossary]: https://github.com/google/fuzzing/blob/master/docs/glossary.md
+[google/fuzzing]: https://github.com/google/fuzzing
+
+- TOC
+{:toc}
+---
+
+## OSS-Fuzz specific terms
+
+### ClusterFuzz
+
+A scalable fuzzing infrastructure that is used for OSS-Fuzz backend.
+[ClusterFuzz] is also used to fuzz Chrome and many other projects. A quick
+overview of ClusterFuzz user interface is available on this [page].
+
+[page]: {{ site.baseurl }}/further-reading/clusterfuzz
+[ClusterFuzz]: https://github.com/google/clusterfuzz
+
+### Fuzz Target
+
+In addition to its
+[general definition](https://github.com/google/fuzzing/blob/master/docs/glossary.md#fuzz-target),
+in OSS-Fuzz a fuzz target can be used to
+[reproduce bug reports]({{ site.baseurl }}/advanced-topics/reproducing/).
+It is recommended to use it for regression testing as well (see
+[ideal integration]({{ site.baseurl }}/advanced-topics/ideal-integration/)).
+
+### Job type
+
+Or **Fuzzer Build**.
+
+This refers to a build that contains all the [fuzz targets] for a given
+[project](#project), is run with a specific [fuzzing engine], in a specific
+build mode (e.g. with enabled/disabled assertions), and optionally combined
+with a [sanitizer].
+
+For example, we have a "libfuzzer_asan_sqlite" job type, indicating a build of
+all sqlite3 [fuzz targets] using [libFuzzer](http://libfuzzer.info) and
+[ASan](http://clang.llvm.org/docs/AddressSanitizer.html).
+
+### Project
+
+A project is an open source software project that is integrated with OSS-Fuzz.
+Each project has a single set of configuration files 
+(example: [expat](https://github.com/google/oss-fuzz/tree/master/projects/expat))
+and may have one or more [fuzz targets]
+(example: [openssl](https://github.com/openssl/openssl/blob/master/fuzz/)).
+
+### Reproducer
+
+Or a **testcase**.
+
+A [test input] that causes a specific bug to reproduce.
+
+[fuzz targets]: https://github.com/google/fuzzing/blob/master/docs/glossary.md#fuzz-target
+[fuzzing engine]: https://github.com/google/fuzzing/blob/master/docs/glossary.md#fuzzing-engine
+[sanitizer]: https://github.com/google/fuzzing/blob/master/docs/glossary.md#sanitizer
+[test input]: https://github.com/google/fuzzing/blob/master/docs/glossary.md#test-input
+
+### Sanitizers
+
+Fuzzers are usually built with one or more [sanitizer](https://github.com/google/sanitizers) enabled. 
+
+```bash
+$ python infra/helper.py build_fuzzers --sanitizer undefined json
+```
+
+Supported sanitizers:
+
+| Sanitizer | Description
+| ------------ | ----------
+| `address` *(default)* | [Address Sanitizer](https://github.com/google/sanitizers/wiki/AddressSanitizer) with [Leak Sanitizer](https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer).
+| `undefined` | [Undefined Behavior Sanitizer](http://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html).
+| `memory` | [Memory Sanitizer](https://github.com/google/sanitizers/wiki/MemorySanitizer).<br/>*NOTE: It is critical that you build __all__ the code in your program (including libraries it uses) with Memory Sanitizer. Otherwise, you will see false positive crashes due to an inability to see initializations in uninstrumented code.*
+| `coverage` | Used for generating code coverage reports. See [Code Coverage doc]({{ site.baseurl }}/advanced-topics/code-coverage/).
+
+Compiler flag values for predefined configurations are specified in the [Dockerfile](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/Dockerfile). 
+These flags can be overridden by specifying `$SANITIZER_FLAGS` directly.
+
+You can choose which configurations to automatically run your fuzzers with in `project.yaml` file (e.g. [sqlite3](https://github.com/google/oss-fuzz/tree/master/projects/sqlite3/project.yaml)).
+
+### Architectures
+ClusterFuzz supports fuzzing on x86_64 (aka x64) by default. However you can also fuzz using AddressSanitizer and libFuzzer on i386 (aka x86, or 32 bit) by specifying the `$ARCHITECTURE` build environment variable using the `--architecture` option:
+
+```bash
+python infra/helper.py build_fuzzers --architecture i386 json
+```

local-test-commons-compress-full-01-vuln_0/fuzz-tooling/docs/reference/reference.md

@@ -0,0 +1,9 @@
+---
+layout: default
+title: Reference
+has_children: true
+nav_order: 6
+permalink: /reference/
+---
+
+# Reference