Add files using upload-large-folder tool

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-320/recreate.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+rm *.7z
+for COMPRESSION in "LZMA" "LZMA2" "PPMd" "BZip2" "Deflate" "Copy"; do
+  # New solid block every 10 files.
+  7za a -m0=$COMPRESSION -ms10f  $COMPRESSION-solid.7z ../../../../src/main/java/org/apache/commons/compress/compressors
+  # Each file in isolation
+  7za a -m0=$COMPRESSION -ms=off $COMPRESSION.7z       ../../../../src/main/java/org/apache/commons/compress/compressors
+done

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/META-INF/services/org.apache.commons.compress.archivers.ArchiveStreamProvider

@@ -0,0 +1 @@
+org.apache.commons.compress.archivers.TestArchiveStreamProvider

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/archives/FreeBSD.ar

@@ -0,0 +1,29 @@
+!<arch>
+1/              1238278221  1721  1721  100664  27        `
+abcdefghijklmnopqrstuvwxyz
+
+12/             1238278221  1721  1721  100664  27        `
+abcdefghijklmnopqrstuvwxyz
+
+123/            1238278221  1721  1721  100664  27        `
+abcdefghijklmnopqrstuvwxyz
+
+1234/           1238278222  1721  1721  100664  27        `
+abcdefghijklmnopqrstuvwxyz
+
+12345/          1238278222  1721  1721  100664  27        `
+abcdefghijklmnopqrstuvwxyz
+
+123450/         1238278222  1721  1721  100644  27        `
+abcdefghijklmnopqrstuvwxyz
+
+123456/         1238278222  1721  1721  100664  26        `
+bcdefghijklmnopqrstuvwxyz
+123457/         1238278222  1721  1721  100644  25        `
+cdefghijklmnopqrstuvwxyz
+
+123458/         1238278222  1721  1721  100644  24        `
+defghijklmnopqrstuvwxyz
+123459/         1238278222  1721  1721  100644  23        `
+efghijklmnopqrstuvwxyz
+

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/archives/SunOS.ar

@@ -0,0 +1,29 @@
+!<arch>
+1/              1238264462  2606  1     100644  27        `
+abcdefghijklmnopqrstuvwxyz
+
+12/             1238277260  2606  1     100644  27        `
+abcdefghijklmnopqrstuvwxyz
+
+123/            1238277265  2606  1     100644  27        `
+abcdefghijklmnopqrstuvwxyz
+
+1234/           1238277275  2606  1     100644  27        `
+abcdefghijklmnopqrstuvwxyz
+
+12345/          1238277277  2606  1     100644  27        `
+abcdefghijklmnopqrstuvwxyz
+
+123450/         1238277385  2606  1     100644  27        `
+abcdefghijklmnopqrstuvwxyz
+
+123456/         1238277620  2606  1     100644  26        `
+bcdefghijklmnopqrstuvwxyz
+123457/         1238277660  2606  1     100644  25        `
+cdefghijklmnopqrstuvwxyz
+
+123458/         1238277670  2606  1     100644  24        `
+defghijklmnopqrstuvwxyz
+123459/         1238277679  2606  1     100644  23        `
+efghijklmnopqrstuvwxyz
+

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/longsymlink/files.txt

@@ -0,0 +1 @@
+0xxxxxxxxx10xxxxxxxx20xxxxxxxx30xxxxxxxx40xxxxxxxx50xxxxxxxx60xxxxxxxx70xxxxxxxx80xxxxxxxx90xxxxxxxx100xxxxxxx110xxxxxxx120xxxxxxx130xxxxxxx -> 0yyyyyyyyy10yyyyyyyy20yyyyyyyy30yyyyyyyy40yyyyyyyy50yyyyyyyy60yyyyyyyy70yyyyyyyy80yyyyyyyy90yyyyyyyy100yyyyyyy110yyyyyyy120yyyyyyy130yyyyyyy

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/org/apache/commons/compress/ico/readme.md

@@ -0,0 +1,18 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You 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.
+-->
+
+The ICO file in this directory are from Apache projects.

local-test-commons-compress-delta-03/fuzz-tooling/docs/_sass/color_schemes/wider.scss

@@ -0,0 +1,2 @@
+@import "./color_schemes/light";
+$content-width: 70rem;

local-test-commons-compress-delta-03/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-delta-03/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-delta-03/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-delta-03/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-delta-03/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-delta-03/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-delta-03/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-delta-03/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-delta-03/fuzz-tooling/docs/reference/useful_links.md

@@ -0,0 +1,51 @@
+---
+layout: default
+title: Useful links
+nav_order: 2
+permalink: /reference/useful-links/
+parent: Reference
+---
+
+# Useful links
+
+- TOC
+{:toc}
+---
+
+## Web Interface
+
+* The main page: [oss-fuzz.com](https://oss-fuzz.com)
+
+## Build Status
+
+* [This page](https://oss-fuzz-build-logs.storage.googleapis.com/index.html)
+  gives the latest build logs for each project.
+
+## Blog posts
+
+* 2016-12-01 - Announcing OSS-Fuzz: Continuous fuzzing for open source software
+([Open Source](https://opensource.googleblog.com/2016/12/announcing-oss-fuzz-continuous-fuzzing.html),
+[Testing](https://testing.googleblog.com/2016/12/announcing-oss-fuzz-continuous-fuzzing.html),
+[Security](https://security.googleblog.com/2016/12/announcing-oss-fuzz-continuous-fuzzing.html))
+* 2017-05-08 - OSS-Fuzz: Five months later, and rewarding projects
+([Open Source](https://opensource.googleblog.com/2017/05/oss-fuzz-five-months-later-and.html),
+[Testing](https://testing.googleblog.com/2017/05/oss-fuzz-five-months-later-and.html),
+[Security](https://security.googleblog.com/2017/05/oss-fuzz-five-months-later-and.html))
+* 2018-11-06 - A New Chapter for OSS-Fuzz
+([Security](https://security.googleblog.com/2018/11/a-new-chapter-for-oss-fuzz.html))
+* 2020-10-09 - [Fuzzing internships for Open Source Software](https://security.googleblog.com/2020/10/fuzzing-internships-for-open-source.html)
+* 2020-12-07 - [Improving open source security during the Google summer internship program](https://security.googleblog.com/2020/12/improving-open-source-security-during.html)
+* 2021-03-10 - [Fuzzing Java in OSS-Fuzz](https://security.googleblog.com/2021/03/fuzzing-java-in-oss-fuzz.html)
+* 2021-12-16 - [Improving OSS-Fuzz and Jazzer to catch Log4Shell](https://security.googleblog.com/2021/12/improving-oss-fuzz-and-jazzer-to-catch.html)
+* 2022-09-08 - [Fuzzing beyond memory corruption: Finding broader classes of vulnerabilities automatically](https://security.googleblog.com/2022/09/fuzzing-beyond-memory-corruption.html)
+* 2023-02-01 - [Taking the next step: OSS-Fuzz in 2023](https://security.googleblog.com/2023/02/taking-next-step-oss-fuzz-in-2023.html)
+
+## Tutorials
+
+* [libFuzzer documentation](https://llvm.org/docs/LibFuzzer.html)
+* [libFuzzer tutorial](https://github.com/google/fuzzing/blob/master/tutorial/libFuzzerTutorial.md)
+* [libFuzzer workshop](https://github.com/Dor1s/libfuzzer-workshop)
+* [Structure-Aware Fuzzing with libFuzzer](https://github.com/google/fuzzer-test-suite/blob/master/tutorial/structure-aware-fuzzing.md)
+* [Chromium Fuzzing Page](https://chromium.googlesource.com/chromium/src/testing/libfuzzer/)
+* [Chromium Efficient Fuzzing Guide](https://chromium.googlesource.com/chromium/src/testing/libfuzzer/+/HEAD/efficient_fuzzing.md)
+* [ClusterFuzz documentation](https://google.github.io/clusterfuzz/)