Add files using upload-large-folder tool

local-test-tika-full-01-vuln_7/fuzz-tooling/docs/_sass/color_schemes/wider.scss

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

local-test-tika-full-01-vuln_7/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-tika-full-01-vuln_7/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-tika-full-01-vuln_7/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-tika-full-01-vuln_7/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-tika-full-01-vuln_7/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-tika-full-01-vuln_7/fuzz-tooling/docs/getting-started/accepting_new_projects.md

@@ -0,0 +1,36 @@
+---
+layout: default
+title: Accepting new projects
+parent: Getting started
+nav_order: 1
+permalink: /getting-started/accepting-new-projects/
+---
+
+# Accepting New Projects
+
+To be accepted to OSS-Fuzz, an open-source project must
+have a significant user base and/or be critical to the global IT infrastructure.
+
+To submit a new project, do the following:
+
+1. [Create a pull request](https://help.github.com/articles/creating-a-pull-request/)
+with a new `projects/<project_name>/project.yaml` file
+([example](https://github.com/google/oss-fuzz/tree/master/projects/libarchive/project.yaml)).
+    **Note:** `project_name` can only contain alphanumeric characters,
+    underscores(_) or dashes(-).
+2. In the file, provide the following information:
+  * Your project's homepage. ([`homepage`]({{ site.baseurl }}/getting-started/new-project-guide/#homepage))
+  * Your project's main repository URL. ([`main_repo`]({{ site.baseurl }}/getting-started/new-project-guide/#main_repo))
+  * Your project's primary language. ([`language`]({{ site.baseurl }}/getting-started/new-project-guide/#language))
+  * An email address for the engineering contact to be CCed on new issues ([`primary_contact`]({{ site.baseurl }}/getting-started/new-project-guide/#primary)), satisfying the following:
+       * The address belongs to an established project committer (according to VCS logs).
+        If the address isn't you, or if the address differs from VCS, we'll require an informal
+        email verification.
+       * The address is associated with a Google account
+        ([why?]({{ site.baseurl }}/faq/#why-do-you-require-a-google-account-for-authentication)).
+        If you use an alternate email address
+        [linked to a Google Account](https://support.google.com/accounts/answer/176347?hl=en),
+        you'll only get access to [filed bugs in the issue tracker](https://bugs.chromium.org/p/oss-fuzz/issues/list), not to the [ClusterFuzz]({{ site.baseurl }}/further-reading/clusterfuzz)
+        dashboard. This is due to appengine API limitations.
+3. Once your project is accepted, configure it by following the
+  [New Project Guide]({{ site.baseurl }}/getting-started/new-project-guide/).

local-test-tika-full-01-vuln_7/fuzz-tooling/docs/getting-started/new-project-guide/bazel.md

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

local-test-tika-full-01-vuln_7/fuzz-tooling/docs/getting-started/new-project-guide/go_lang.md

@@ -0,0 +1,125 @@
+---
+layout: default
+title: Integrating a Go project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 1
+permalink: /getting-started/new-project-guide/go-lang/
+---
+
+# Integrating a Go project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Go 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 Go project are outlined below.
+
+## Go-fuzz support
+
+OSS-Fuzz supports **go-fuzz** in the
+[libFuzzer compatible mode](https://github.com/mdempsky/go114-fuzz-build)
+only. In that mode, fuzz targets for Go use the libFuzzer engine with native Go
+coverage instrumentation. Binaries compiled in this mode provide the same
+libFuzzer command line interface as non-Go fuzz targets.
+
+## Native Go Fuzzing support
+
+OSS-fuzz supports [fuzzers written for the native Go 1.18 engine](https://go.dev/doc/fuzz/). These fuzzers are built as libFuzzer binaries in a similar fashion as fuzzers written for the go-fuzz engine. Because of that, dictionaries and seed corpora should be handled in accordance with [the OSS-fuzz documentation](https://google.github.io/oss-fuzz/getting-started/new-project-guide/#seed-corpus).
+Unlike libFuzzer/go-fuzz targets which must accept one data buffer, fuzz targets written for the Native Go engine can accept any number of arguments of any type. Here is an example of a valid fuzzer with multiple arguments:
+
+```go
+package demofuzzing
+
+import (
+    "fmt"
+    "testing"
+)
+
+func FuzzDemo(f *testing.F) {
+    f.Fuzz(func(t *testing.T, data1 string, data2 uint32, data3 float64) {
+        fmt.Println(data1)
+        fmt.Println(data2)
+        fmt.Println(data3)
+    })
+}
+```
+
+Some requirements for native Go 1.18 fuzzers are:
+* The only `testing.F` method supported is currently `F.Fuzz()`.
+* `F.Add()` will not add seeds when fuzzing. To provide OSS-fuzz with a seed corpus, follow the documentation [here](https://google.github.io/oss-fuzz/getting-started/new-project-guide/#seed-corpus).
+
+## Project files
+
+First, you need to write a Go fuzz target. This fuzz target should reside in your project
+repository
+([example](https://github.com/golang/go/blob/4ad13555184eb0697c2e92c64c1b0bdb287ccc10/src/html/fuzz.go#L13)).
+
+The structure of the project directory in OSS-Fuzz repository doesn't differ for
+projects written in Go. The project files have the following Go specific
+aspects.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: go
+```
+
+The only supported fuzzing engine and sanitizer are `libfuzzer` and `address`,
+respectively.
+[Example](https://github.com/google/oss-fuzz/blob/356f2b947670b7eb33a1f535c71bc5c87a60b0d1/projects/syzkaller/project.yaml#L7):
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-go`
+
+The OSS-Fuzz builder image has the latest stable release of Golang installed. In
+order to install dependencies of your project, add `RUN git clone ...` command to
+your Dockerfile.
+[Example](https://github.com/google/oss-fuzz/blob/356f2b947670b7eb33a1f535c71bc5c87a60b0d1/projects/syzkaller/Dockerfile#L23):
+
+```dockerfile
+# Dependency for one of the fuzz targets.
+RUN git clone --depth 1 https://github.com/ianlancetaylor/demangle
+```
+
+go-fuzz will then automatically download the dependencies based on the go.mod file
+
+### build.sh
+
+In order to build a Go fuzz target, you need to call `go-fuzz`
+command first, and then link the resulting `.a` file against
+`$LIB_FUZZING_ENGINE` using the `$CXX $CXXFLAGS ...` command.
+
+For go-fuzz fuzzers, the best way to do this is by using the [`compile_go_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_go_fuzzer), and for native Go 1.18 fuzzers it is recommended to use the [`compile_native_go_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_native_go_fuzzer). Both of these also support coverage builds.
+
+`compile_native_go_fuzzer` requires two dependencies which can be installed with:
+```bash
+go install github.com/AdamKorcz/go-118-fuzz-build@latest
+go get github.com/AdamKorcz/go-118-fuzz-build/testing
+```
+
+A usage example from go-dns project is
+
+```sh
+compile_go_fuzzer github.com/miekg/dns FuzzNewRR fuzz_newrr fuzz
+```
+
+Arguments are :
+* path of the package with the fuzz target
+* name of the fuzz function
+* name of the fuzzer to be built
+* optional tag to be used by `go build` and such

local-test-tika-full-01-vuln_7/fuzz-tooling/docs/getting-started/new-project-guide/javascript_lang.md

@@ -0,0 +1,140 @@
+---
+layout: default
+title: Integrating a JavaScript project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 4
+permalink: /getting-started/new-project-guide/javascript-lang/
+---
+
+# Integrating a JavaScript project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in JavaScript for Node.js 
+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 JavaScript project are outlined below.
+
+## Jazzer.js
+
+JavaScript fuzzing in OSS-Fuzz is powered by
+[Jazzer.js](https://github.com/CodeIntelligenceTesting/jazzer.js), which is
+installed during the build step. As Jazzer.js operates directly on the JavaScript
+source code level, it can be applied to any project written in a language that 
+can be transpiled into JavaScript such as TypeScript. More information on how Jazzer.js
+fuzz targets look like can be found in its
+[README's Usage section](https://github.com/CodeIntelligenceTesting/jazzer.js#usage).
+
+## Project files
+
+### Example project
+
+We recommend viewing
+[javascript-example](https://github.com/google/oss-fuzz/tree/master/projects/javascript-example)
+as an example of a simple JavaScript fuzzing project. We also recommend having a look at
+[typescript-example](https://github.com/google/oss-fuzz/tree/master/projects/typescript-example)
+as an example of how to fuzz TypeScript projects. This example also demonstrates how to use 
+Jazzer.js fuzzed data provider.
+
+### project.yaml
+
+The `language` attribute must be specified as follows:
+
+```yaml
+language: javascript
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). So far, native sanitizers such as 
+AddressSanitizer (`address`) and UndefinedBehaviorSanitizer (`undefined`) are not supported. 
+They would only be needed for projects that have native addons, which is a rather infrequent
+use case for JavaScript projects. If you have a project where you need ASan or UBSan, please 
+create open an issue on [Jazzer.js GitHub repo](https://github.com/CodeIntelligenceTesting/jazzer.js). None (`none`) is the default sanitizer for 
+JavaScript projects, so setting it up in `project.yaml` is optional.
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - none
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-javascript`
+
+The OSS-Fuzz base Docker images already come with Node.js 19 and `npm` pre-installed.
+Apart from that, you should usually not need to do more than to clone the
+project, set a `WORKDIR`, and copy any necessary files, or install any
+project-specific dependencies here as you normally would.
+
+### Fuzzers
+
+In the simplest case, every fuzzer consists of a single JavaScript file that exports
+a function named `fuzz` taking a single argument of type [Buffer](https://nodejs.org/api/buffer.html). 
+An example fuzz target could thus be a file `fuzz_string_compare.js` with contents:
+
+```javascript
+/**
+ * @param { Buffer } data
+ */
+module.exports.fuzz = function (data) {
+    const s = data.toString();
+    if (s.length !== 16) {
+        return;
+    }
+    if (
+        s.slice(0, 8) === "Awesome " &&
+        s.slice(8, 15) === "Fuzzing" &&
+        s[15] === "!"
+    ) {
+        throw Error("Welcome to Awesome Fuzzing!");
+    }
+};
+```
+
+### build.sh
+
+The OSS-Fuzz base docker image for JavaScript comes with the [`compile_javascript_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_javascript_fuzzer) preinstalled. In `build.sh`, you should install dependencies for your project, and if necessary compile the code into JavaScript. Then, you can use the script to build the fuzzers. The script ensures that [@Jazzer.js/core](https://www.npmjs.com/package/@jazzer.js/core) is installed so that its CLI can be used to execute your fuzz tests. It also generates a wrapper script that can be used as a drop-in replacement for libFuzzer. This means that the generated script accepts the same command line flags for libFuzzer. Under the hood these flags are simply forwarded to the libFuzzer native addon used by Jazzer.js.
+
+A usage example from the javascript-example project is
+
+```shell
+compile_javascript_fuzzer example fuzz_string_compare.js --sync
+```
+
+Arguments are:
+* relative path of the project in the $SRC directory
+* relative path to the fuzz test inside the project
+* remaining arguments are forwarded to the [Jazzer.js CLI](https://github.com/CodeIntelligenceTesting/jazzer.js/blob/main/docs/fuzz-targets.md#running-the-fuzz-target)
+
+The [javascript-example](https://github.com/google/oss-fuzz/blob/master/projects/javascript-example/build.sh)
+project contains an example of a `build.sh` for JavaScript projects.
+
+## FuzzedDataProvider
+
+Jazzer.js provides a `FuzzedDataProvider` that can simplify the task of creating a
+fuzz target by translating the raw input bytes received from the fuzzer into
+useful primitive JavaScript types. Its functionality is similar to
+`FuzzedDataProviders` available in other languages, such as
+[Java](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html) and
+[C++](https://github.com/google/fuzzing/blob/master/docs/split-inputs.md).
+
+A fuzz target using the `FuzzedDataProvider` would look as follows:
+
+```javascript
+const { FuzzedDataProvider } = require("@jazzer.js/core");
+
+/**
+ * @param { Buffer } fuzzerInputData
+ */
+module.exports.fuzz = function (fuzzerInputData) {
+    const data = new FuzzedDataProvider(fuzzerInputData);
+    const i = data.consumeIntegral(4);
+    const s = data.consumeRemainingAsString();
+    exploreMe(i, s);
+};
+```

local-test-tika-full-01-vuln_7/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-tika-full-01-vuln_7/fuzz-tooling/docs/getting-started/new-project-guide/swift_lang.md

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

local-test-tika-full-01-vuln_7/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-tika-full-01-vuln_7/fuzz-tooling/docs/reference/reference.md

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

local-test-tika-full-01-vuln_7/fuzz-tooling/tools/vscode-extension/.gitignore

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

local-test-tika-full-01-vuln_7/fuzz-tooling/tools/vscode-extension/.prettierrc.js

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

local-test-tika-full-01-vuln_7/fuzz-tooling/tools/vscode-extension/.vscodeignore

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

local-test-tika-full-01-vuln_7/fuzz-tooling/tools/vscode-extension/README.md

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

local-test-tika-full-01-vuln_7/fuzz-tooling/tools/vscode-extension/src/coverageHelper.ts

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

local-test-tika-full-01-vuln_7/fuzz-tooling/tools/vscode-extension/src/logger.ts

@@ -0,0 +1,31 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+export const vscodeOutputChannel =
+  vscode.window.createOutputChannel('oss-fuzz');
+
+export function println(line: string) {
+  vscodeOutputChannel.appendLine(line);
+}
+
+export function printRaw(line: string) {
+  vscodeOutputChannel.append(line);
+}
+
+export function debugPrintln(line: string) {
+  console.log(line);
+}