Add files using upload-large-folder tool

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder-ruby/Dockerfile

@@ -0,0 +1,56 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-builder:${IMG_TAG}
+
+RUN git clone https://github.com/trailofbits/ruzzy.git $SRC/ruzzy
+
+RUN install_ruby.sh
+ENV PATH="$PATH:/usr/local/rvm/rubies/ruby-3.3.1/bin"
+
+RUN gem update --system 3.5.11
+
+# Install ruzzy
+WORKDIR $SRC/ruzzy
+
+# The MAKE variable allows overwriting the make command at runtime. This forces the
+# Ruby C extension to respect ENV variables when compiling, like CC, CFLAGS, etc.
+ENV MAKE="make --environment-overrides V=1"
+
+RUN CC="clang" \
+CXX="clang++" \
+LDSHARED="clang -shared" \
+LDSHAREDXX="clang++ -shared" \
+gem build
+
+RUN MAKE="make --environment-overrides V=1" \
+CC="clang" \
+CXX="clang++" \
+LDSHARED="clang -shared" \
+LDSHAREDXX="clang++ -shared" \
+CXXFLAGS="-fPIC" \
+CFLAGS="-fPIC" \
+RUZZY_DEBUG=1 gem install --install-dir /install/ruzzy --development --verbose ruzzy-*.gem
+
+
+ENV LDSHARED="$CC -shared"
+ENV LDSHAREDXX="$CXX -shared"
+
+ENV GEM_HOME="$OUT/fuzz-gem"
+ENV GEM_PATH="/install/ruzzy"
+
+COPY ruzzy-build /usr/bin/ruzzy-build

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder-rust/Dockerfile

@@ -0,0 +1,37 @@
+# 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.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-builder:${IMG_TAG}
+
+ENV CARGO_HOME=/rust
+ENV RUSTUP_HOME=/rust/rustup
+ENV PATH=$PATH:/rust/bin
+# Set up custom environment variable for source code copy for coverage reports
+ENV OSSFUZZ_RUSTPATH /rust
+
+# Force rustup to ignore `rust-toolchain` and `rust-toolchain.toml` files by
+# manually specifying what toolchain to use. Note that this environment variable
+# is additionally used by `install_rust.sh` as the toolchain to install.
+# cf https://rust-lang.github.io/rustup/overrides.html
+ENV RUSTUP_TOOLCHAIN nightly-2024-07-12
+
+# Configure the linker used by default for x86_64 linux to be `clang` instead of
+# rustc's default of `cc` which is able to find custom-built libraries like
+# `libc++` by default more easily.
+ENV CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER clang
+
+RUN install_rust.sh

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/compile_centipede

@@ -0,0 +1,32 @@
+#!/bin/bash -eu
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+echo "Skipping compilation; using precompiled centipede"
+
+if [[ "$SANITIZER" == 'none' ]]; then
+  cp "$CENTIPEDE_BIN_DIR/centipede" "$OUT"
+fi
+
+cp "$CENTIPEDE_BIN_DIR/libcentipede_runner.pic.a" "$LIB_FUZZING_ENGINE"
+
+export CENTIPEDE_FLAGS=`cat "$SRC/fuzztest/centipede/clang-flags.txt" | tr '\n' ' '`
+export LIBRARIES_FLAGS="-Wno-unused-command-line-argument -Wl,-ldl -Wl,-lrt -Wl,-lpthread -Wl,$SRC/fuzztest/centipede/weak.o"
+
+export CFLAGS="$CFLAGS $CENTIPEDE_FLAGS $LIBRARIES_FLAGS"
+export CXXFLAGS="$CXXFLAGS $CENTIPEDE_FLAGS $LIBRARIES_FLAGS"
+
+echo 'done.'

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/jcc/build_jcc.bash

@@ -0,0 +1,25 @@
+#!/bin/bash -eu
+#
+# 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.
+#
+################################################################################
+
+go build jcc.go
+go build jcc2.go
+gsutil cp jcc gs://clusterfuzz-builds/jcc/clang++-jcc
+gsutil cp jcc gs://clusterfuzz-builds/jcc/clang-jcc
+
+gsutil cp jcc2 gs://clusterfuzz-builds/jcc/clang++-jcc2
+gsutil cp jcc2 gs://clusterfuzz-builds/jcc/clang-jcc2

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/jcc/go.mod

@@ -0,0 +1,3 @@
+module github.com/google/jcc
+
+go 1.21

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/jcc/jcc.go

@@ -0,0 +1,88 @@
+// 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.
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+func ExecBuildCommand(bin string, args []string) (int, string, string) {
+	// Executes the original command.
+	cmd := exec.Command(bin, args...)
+	var outb, errb bytes.Buffer
+	cmd.Stdout = &outb
+	cmd.Stderr = &errb
+	cmd.Stdin = os.Stdin
+	cmd.Run()
+	return cmd.ProcessState.ExitCode(), outb.String(), errb.String()
+}
+
+func Compile(bin string, args []string) (int, string, string) {
+	// Run the actual command.
+	return ExecBuildCommand(bin, args)
+}
+
+func AppendStringToFile(filepath, new_content string) error {
+	// Appends |new_content| to the content of |filepath|.
+	file, err := os.OpenFile(filepath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	_, err = file.WriteString(new_content)
+	return err
+}
+
+func WriteStdErrOut(args []string, outstr string, errstr string) {
+	// Prints |outstr| to stdout, prints |errstr| to stderr, and saves |errstr| to err.log.
+	fmt.Print(outstr)
+	fmt.Fprint(os.Stderr, errstr)
+	// Record what compile args produced the error and the error itself in log file.
+	AppendStringToFile("/tmp/err.log", fmt.Sprintf("%s\n", args)+errstr)
+}
+
+func main() {
+	f, err := os.OpenFile("/tmp/jcc.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+
+	if err != nil {
+		log.Println(err)
+	}
+	defer f.Close()
+	if _, err := f.WriteString(fmt.Sprintf("%s\n", os.Args)); err != nil {
+		log.Println(err)
+	}
+
+	args := os.Args[1:]
+	basename := filepath.Base(os.Args[0])
+	isCPP := basename == "clang++-jcc"
+	newArgs := args
+
+	var bin string
+	if isCPP {
+		bin = "clang++"
+	} else {
+		bin = "clang"
+	}
+	fullCmdArgs := append([]string{bin}, newArgs...)
+	retcode, out, errstr := Compile(bin, newArgs)
+	WriteStdErrOut(fullCmdArgs, out, errstr)
+	os.Exit(retcode)
+}

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/jcc/jcc2.go

@@ -0,0 +1,401 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/fs"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+var MaxMissingHeaderFiles = 10
+var CppifyHeadersMagicString = "\n/* JCCCppifyHeadersMagicString */\n"
+
+func CopyFile(src string, dst string) {
+	contents, err := ioutil.ReadFile(src)
+	if err != nil {
+		panic(err)
+	}
+	err = ioutil.WriteFile(dst, contents, 0644)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func TryFixCCompilation(cmdline []string) ([]string, int, string, string) {
+	var newFile string = ""
+	for i, arg := range cmdline {
+		if !strings.HasSuffix(arg, ".c") {
+			continue
+		}
+		if _, err := os.Stat(arg); errors.Is(err, os.ErrNotExist) {
+			continue
+		}
+		newFile = strings.TrimSuffix(arg, ".c")
+		newFile += ".cpp"
+		CopyFile(arg, newFile)
+		CppifyHeaderIncludesFromFile(newFile)
+		cmdline[i] = newFile
+		break
+	}
+	if newFile == "" {
+		return []string{}, 1, "", ""
+	}
+	cppBin := "clang++"
+	newCmdline := []string{"-stdlib=libc++"}
+	newCmdline = append(cmdline, newCmdline...)
+	newFullArgs := append([]string{cppBin}, newCmdline...)
+
+	retcode, out, err := Compile(cppBin, newCmdline)
+	if retcode == 0 {
+		return newFullArgs, retcode, out, err
+	}
+	correctedCmdline, corrected, _ := CorrectMissingHeaders(cppBin, newCmdline)
+	if corrected {
+		return append([]string{cppBin}, correctedCmdline...), 0, "", ""
+	}
+	return newFullArgs, retcode, out, err
+}
+
+func ExtractMissingHeader(compilerOutput string) (string, bool) {
+	r := regexp.MustCompile(`fatal error: ['|<](?P<header>[a-zA-z0-9\/\.]+)['|>] file not found`)
+	matches := r.FindStringSubmatch(compilerOutput)
+	if len(matches) == 0 {
+		return "", false
+	}
+	return matches[1], true
+}
+
+func ReplaceMissingHeaderInFile(srcFilename, curHeader, replacementHeader string) error {
+	srcFile, err := os.Open(srcFilename)
+	if err != nil {
+		return err
+	}
+	srcBytes, err := ioutil.ReadAll(srcFile)
+	if err != nil {
+		return err
+	}
+	src := string(srcBytes)
+	newSrc := ReplaceMissingHeader(src, curHeader, replacementHeader)
+	b := []byte(newSrc)
+	err = ioutil.WriteFile(srcFilename, b, 0644)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func ReplaceMissingHeader(src, curHeader, replacementHeader string) string {
+	re := regexp.MustCompile(`#include ["|<]` + curHeader + `["|>]\n`)
+	replacement := "#include \"" + replacementHeader + "\"\n"
+	return re.ReplaceAllString(src, replacement)
+}
+
+func GetHeaderCorrectedFilename(compilerErr string) (string, string, bool) {
+	re := regexp.MustCompile(`(?P<buggy>[a-z\/\-\_0-9A-z\.]+):.* fatal error: .* file not found`)
+	matches := re.FindStringSubmatch(compilerErr)
+	if len(matches) < 2 {
+		return "", "", false
+	}
+	oldFilename := matches[1]
+	base := filepath.Base(oldFilename)
+	root := filepath.Dir(oldFilename)
+	newFilename := root + "/jcc-corrected-" + base
+	return oldFilename, newFilename, true
+}
+
+func GetHeaderCorrectedCmd(cmd []string, compilerErr string) ([]string, string, error) {
+	oldFilename, newFilename, success := GetHeaderCorrectedFilename(compilerErr)
+	if !success {
+		return cmd, "", errors.New("Couldn't find buggy file")
+	}
+	// Make new cmd.
+	newCmd := make([]string, len(cmd))
+	for i, part := range cmd {
+		newCmd[i] = part
+	}
+	found := false
+	for i, filename := range newCmd {
+		if filename == oldFilename {
+			newCmd[i] = newFilename
+			found = true
+			break
+		}
+	}
+	CopyFile(oldFilename, newFilename)
+	if found {
+		return newCmd, newFilename, nil
+	}
+	return cmd, "", errors.New("Couldn't find file")
+}
+
+func CorrectMissingHeaders(bin string, cmd []string) ([]string, bool, error) {
+
+	_, _, stderr := Compile(bin, cmd)
+	cmd, correctedFilename, err := GetHeaderCorrectedCmd(cmd, stderr)
+	if err != nil {
+		return cmd, false, err
+	}
+	for i := 0; i < MaxMissingHeaderFiles; i++ {
+		fixed, hasBrokenHeaders := TryCompileAndFixHeadersOnce(bin, cmd, correctedFilename)
+		if fixed {
+			return cmd, true, nil
+		}
+		if !hasBrokenHeaders {
+			return cmd, false, nil
+		}
+	}
+	return cmd, false, nil
+}
+
+func ExecBuildCommand(bin string, args []string) (int, string, string) {
+	// Executes the original command.
+	cmd := exec.Command(bin, args...)
+	var outb, errb bytes.Buffer
+	cmd.Stdout = &outb
+	cmd.Stderr = &errb
+	cmd.Stdin = os.Stdin
+	cmd.Run()
+	return cmd.ProcessState.ExitCode(), outb.String(), errb.String()
+}
+
+func Compile(bin string, args []string) (int, string, string) {
+	// Run the actual command.
+	return ExecBuildCommand(bin, args)
+}
+
+func TryCompileAndFixHeadersOnce(bin string, cmd []string, filename string) (fixed, hasBrokenHeaders bool) {
+	retcode, _, err := Compile(bin, cmd)
+	if retcode == 0 {
+		fixed = true
+		hasBrokenHeaders = false
+		return
+	}
+	missingHeader, isMissing := ExtractMissingHeader(err)
+	if !isMissing {
+		fixed = false
+		hasBrokenHeaders = false
+		return
+	}
+
+	newHeaderPath, found := FindMissingHeader(missingHeader)
+	if !found {
+		fixed = false
+		hasBrokenHeaders = true
+		return false, true
+	}
+	ReplaceMissingHeaderInFile(filename, missingHeader, newHeaderPath)
+	return false, true
+}
+
+func FindMissingHeader(missingHeader string) (string, bool) {
+	envVar := "JCC_MISSING_HEADER_SEARCH_PATH"
+	var searchPath string
+	searchPath, exists := os.LookupEnv(envVar)
+	if !exists {
+		searchPath = "/src"
+	}
+	searchPath, _ = filepath.Abs(searchPath)
+	var headerLocation string
+	missingHeader = "/" + missingHeader
+	find := func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if d.IsDir() {
+			return nil
+		}
+		if strings.HasSuffix(path, missingHeader) {
+			headerLocation = path
+			return nil
+		}
+		return nil
+	}
+	filepath.WalkDir(searchPath, find)
+	if headerLocation == "" {
+		return "", false
+	}
+	return headerLocation, true
+}
+
+func CppifyHeaderIncludesFromFile(srcFile string) error {
+	contentsBytes, err := ioutil.ReadFile(srcFile)
+	if err != nil {
+		return err
+	}
+	contents := string(contentsBytes[:])
+	contents, err = CppifyHeaderIncludes(contents)
+	if err != nil {
+		return err
+	}
+	b := []byte(contents)
+	err = ioutil.WriteFile(srcFile, b, 0644)
+	return err
+}
+
+func CppifyHeaderIncludes(contents string) (string, error) {
+	shouldCppify, exists := os.LookupEnv("JCC_CPPIFY_PROJECT_HEADERS")
+	if !exists || strings.Compare(shouldCppify, "0") == 0 {
+		return contents, nil
+	}
+	if strings.Contains(contents, CppifyHeadersMagicString) {
+		return contents, nil
+	}
+	re := regexp.MustCompile(`\#include \"(?P<header>.+)\"\n`)
+	matches := re.FindAllStringSubmatch(contents, -1)
+	if len(matches) == 0 {
+		return "", nil // !!!
+	}
+	for i, match := range matches {
+		if i == 0 {
+			// So we don't cppify twice.
+			contents += CppifyHeadersMagicString
+		}
+		oldStr := match[0]
+		replacement := "extern \"C\" {\n#include \"" + match[1] + "\"\n}\n"
+		contents = strings.Replace(contents, oldStr, replacement, 1)
+		if strings.Compare(contents, "") == 0 {
+			panic("Failed to replace")
+		}
+	}
+	return contents, nil
+}
+
+func AppendStringToFile(filepath, new_content string) error {
+	// Appends |new_content| to the content of |filepath|.
+	file, err := os.OpenFile(filepath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	_, err = file.WriteString(new_content)
+	return err
+}
+
+func WriteStdErrOut(args []string, outstr string, errstr string) {
+	// Prints |outstr| to stdout, prints |errstr| to stderr, and saves |errstr| to err.log.
+	fmt.Print(outstr)
+	fmt.Fprint(os.Stderr, errstr)
+	// Record what compile args produced the error and the error itself in log file.
+	AppendStringToFile("/workspace/err.log", fmt.Sprintf("%s\n", args)+errstr)
+}
+
+func main() {
+	f, err := os.OpenFile("/tmp/jcc.log", os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		log.Println(err)
+	}
+	defer f.Close()
+	if _, err := f.WriteString(fmt.Sprintf("%s\n", os.Args)); err != nil {
+		log.Println(err)
+	}
+
+	args := os.Args[1:]
+	if args[0] == "unfreeze" {
+		fmt.Println("unfreeze")
+		unfreeze()
+	}
+	basename := filepath.Base(os.Args[0])
+	isCPP := basename == "clang++-jcc"
+	newArgs := append(args, "-w")
+
+	var bin string
+	if isCPP {
+		bin = "clang++"
+		newArgs = append(args, "-stdlib=libc++")
+	} else {
+		bin = "clang"
+	}
+	fullCmdArgs := append([]string{bin}, newArgs...)
+	if IsCompilingTarget(fullCmdArgs) {
+		WriteTargetArgsAndCommitImage(fullCmdArgs)
+		os.Exit(0)
+	}
+	retcode, out, errstr := Compile(bin, newArgs)
+	WriteStdErrOut(fullCmdArgs, out, errstr)
+	os.Exit(retcode)
+}
+
+type BuildCommand struct {
+	CWD string   `json:"CWD"`
+	CMD []string `json:"CMD"`
+}
+
+func WriteTargetArgsAndCommitImage(cmdline []string) {
+	log.Println("WRITE COMMAND")
+	f, _ := os.OpenFile("/out/statefile.json", os.O_CREATE|os.O_WRONLY, 0644)
+	wd, _ := os.Getwd()
+	buildcmd := BuildCommand{
+		CWD: wd,
+		CMD: cmdline,
+	}
+	jsonData, _ := json.Marshal(buildcmd)
+	f.Write(jsonData)
+	f.Close()
+	hostname, _ := os.Hostname()
+	dockerArgs := []string{"commit", hostname, "frozen"}
+	cmd := exec.Command("docker", dockerArgs...)
+	var outb, errb bytes.Buffer
+	cmd.Stdout = &outb
+	cmd.Stderr = &errb
+	cmd.Stdin = os.Stdin
+	cmd.Run()
+	fmt.Println(outb.String(), errb.String())
+	fmt.Println("COMMIT IMAGE")
+}
+
+func IsCompilingTarget(cmdline []string) bool {
+	for _, arg := range cmdline {
+		// This can fail if people do crazy things they aren't supposed
+		// to such as using some other means to link in libFuzzer.
+		if arg == "-fsanitize=fuzzer" {
+			return true
+		}
+		if arg == "-lFuzzingEngine" {
+			return true
+		}
+	}
+	return false
+}
+
+func parseCommand(command string) (string, []string) {
+	args := strings.Fields(command)
+	commandBin := args[0]
+	commandArgs := args[1:]
+	return commandBin, commandArgs
+}
+
+func unfreeze() {
+	content, err := ioutil.ReadFile("/out/statefile.json")
+	if err != nil {
+		log.Fatal(err)
+	}
+	var command BuildCommand
+	json.Unmarshal(content, &command)
+	bin, args := parseCommand(strings.Join(command.CMD, " "))
+	os.Chdir(command.CWD)
+	ExecBuildCommand(bin, args)
+	os.Exit(0)
+}

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/jcc/jcc_test.go

@@ -0,0 +1,186 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestExtractMissingHeader(t *testing.T) {
+	missingHeaderMessage := `path/to/file.cpp:8:10: fatal error: 'missingheader.h' file not found
+
+	#include "missingheader.h"
+
+		^~~~~~~~~~~~
+
+	1 error generated.
+	`
+
+	res, _ := ExtractMissingHeader(missingHeaderMessage)
+	expected := "missingheader.h"
+	if strings.Compare(res, expected) != 0 {
+		t.Errorf("Got: %s. Expected: %s.", res, expected)
+	}
+}
+
+func TestGetHeaderCorrectedFilename(t *testing.T) {
+	missingHeaderMessage := `path/to/file.cpp:8:10: fatal error: 'missingheader.h' file not found
+
+	#include "missingheader.h"
+
+		^~~~~~~~~~~~
+
+	1 error generated.
+	`
+	_, correctedFilename, _ := GetHeaderCorrectedFilename(missingHeaderMessage)
+	expected := "path/to/jcc-corrected-file.cpp"
+	if strings.Compare(correctedFilename, expected) != 0 {
+		t.Errorf("Got: %s. Expected: %s.", correctedFilename, expected)
+	}
+}
+
+func TestFindMissingHeader(t *testing.T) {
+	pwd, _ := os.Getwd()
+	t.Setenv("JCC_MISSING_HEADER_SEARCH_PATH", pwd)
+
+	location, _ := FindMissingHeader("header.h")
+	expected := pwd + "/testdata/path/to/header.h"
+	if strings.Compare(location, expected) != 0 {
+		t.Errorf("Got: %s. Expected: %s.", location, expected)
+	}
+}
+
+func TestCorrectMissingHeaders(t *testing.T) {
+	pwd, _ := os.Getwd()
+	t.Setenv("JCC_MISSING_HEADER_SEARCH_PATH", pwd)
+	cfile := pwd + "/testdata/cfile.c"
+	cmd := [4]string{"-fsanitize=address", cfile, "-o", "/tmp/blah"}
+	res, err := CorrectMissingHeaders("clang", cmd[:])
+	if !res {
+		fmt.Println(err)
+		t.Errorf("Expected successful compilation")
+	}
+}
+
+func TestGetHeaderCorrectedCmd(t *testing.T) {
+	compilerErr := `testdata/cpp.cc:8:10: fatal error: 'missingheader.h' file not found
+
+	#include "missingheader.h"
+
+		^~~~~~~~~~~~
+
+	1 error generated.
+	`
+
+	cmd := [3]string{"-fsanitize=address", "file.cpp", "path/to/cpp.cc"}
+	expectedFixedCmd := [3]string{"-fanitize=address", "file.cpp", "path/to/jcc-corrected-cpp.cc"}
+	fixedCmd, _, _ := GetHeaderCorrectedCmd(cmd[:], compilerErr)
+	if strings.Compare(fixedCmd[1], expectedFixedCmd[1]) != 0 {
+		t.Errorf("Expected %s, got: %s", expectedFixedCmd, fixedCmd)
+	}
+}
+
+func TestCppifyHeaderIncludes(t *testing.T) {
+	t.Setenv("JCC_CPPIFY_PROJECT_HEADERS", "1")
+	src := `// Copyright blah
+#include <stddef.h>
+
+#include "fuzz.h"
+#include "x/y.h"
+extern "C" LLVMFuzzerTestOneInput(uint8_t* data, size_t sz) {
+  return 0;
+}`
+	newFile, _ := CppifyHeaderIncludes(src)
+	expected := `// Copyright blah
+#include <stddef.h>
+
+extern "C" {
+#include "fuzz.h"
+}
+extern "C" {
+#include "x/y.h"
+}
+extern "C" LLVMFuzzerTestOneInput(uint8_t* data, size_t sz) {
+  return 0;
+}
+/* JCCCppifyHeadersMagicString */
+`
+	if strings.Compare(newFile, expected) != 0 {
+		t.Errorf("Expected: %s, got: %s", expected, newFile)
+	}
+}
+
+func TestCppifyHeaderIncludesShouldnt(t *testing.T) {
+	src := `// Copyright blah
+#include <stddef.h>
+
+#include "fuzz.h"
+#include "x/y.h"
+extern "C" LLVMFuzzerTestOneInput(uint8_t* data, size_t sz) {
+  return 0;
+}`
+	newFile, _ := CppifyHeaderIncludes(src)
+	if strings.Compare(newFile, src) != 0 {
+		t.Errorf("Expected: %s. Got: %s", src, newFile)
+	}
+}
+
+func TestCppifyHeaderIncludesAlready(t *testing.T) {
+	src := `// Copyright blah
+#include <stddef.h>
+
+#include "fuzz.h"
+#include "x/y.h"
+extern "C" LLVMFuzzerTestOneInput(uint8_t* data, size_t sz) {
+  return 0;
+}
+/* JCCCppifyHeadersMagicString */
+`
+	newFile, _ := CppifyHeaderIncludes(src)
+	if strings.Compare(newFile, src) != 0 {
+		t.Errorf("Expected %s, got: %s", src, newFile)
+	}
+}
+
+func TestExtractMissingHeaderNonHeaderFailure(t *testing.T) {
+	missingHeaderMessage := `clang: error: no such file or directory: 'x'
+clang: error: no input files`
+
+	header, res := ExtractMissingHeader(missingHeaderMessage)
+	if res {
+		t.Errorf("Expected no match, got: %s", header)
+	}
+}
+
+func TestReplaceMissingHeader(t *testing.T) {
+	cfile := `// Copyright 2035 Robots
+#include <stddef.h>
+
+#include <cstdint>
+
+// Some libraries like OpenSSL will use brackets for their own headers.
+#include <missingheader.h>
+
+int LLVMFuzzerTestOneInput(uint8_t* data,  size_t size) {
+  return 0;
+}
+`
+
+	res := ReplaceMissingHeader(cfile, "missingheader.h", "path/to/includes/missingheader.h")
+	expected := `// Copyright 2035 Robots
+#include <stddef.h>
+
+#include <cstdint>
+
+// Some libraries like OpenSSL will use brackets for their own headers.
+#include "path/to/includes/missingheader.h"
+
+int LLVMFuzzerTestOneInput(uint8_t* data,  size_t size) {
+  return 0;
+}
+`
+	if strings.Compare(res, expected) != 0 {
+		t.Errorf("Got: %s. Expected: %s.", res, expected)
+	}
+}

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/.gitignore

@@ -0,0 +1,2 @@
+jcc-corrected-cfile.c
+jcc-corrected-cfile.cpp

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/cfile.c

@@ -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.
+
+#include "header.h"
+int main() {
+  return 0;
+}

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/jcc/testdata/path/to/header.h

@@ -0,0 +1,15 @@
+// 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.
+
+int xhg(void);

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/LICENSE

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

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/README.md

@@ -0,0 +1,3 @@
+# pysecsan
+
+Security sanitizers for vulnerability detection during runtime.

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pysecsan"
+version = "0.1.0"
+authors = [
+  { name="David Korczynski", email="david@adalogics.com" },
+]
+description = "Sanitizers to detect security vulnerabilities at runtime."
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/google/oss-fuzz/tree/master/infra/sanitizers/pysecsan"
+"Bug Tracker" = "https://github.com/google/oss-fuzz/issues"

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/command_injection.py

@@ -0,0 +1,106 @@
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Sanitizers for capturing code injections."""
+
+from typing import Optional
+from pysecsan import sanlib
+
+
+def get_all_substr_prefixes(main_str, sub_str):
+  """Yields all strings prefixed with sub_str in main_str."""
+  idx = 0
+  while True:
+    idx = main_str.find(sub_str, idx)
+    if idx == -1:
+      return
+    yield main_str[0:idx]
+    # Increase idx the length of the substring from the current position
+    # where an occurence of the substring was found.
+    idx += len(sub_str)
+
+
+# pylint: disable=unsubscriptable-object
+def check_code_injection_match(elem, check_unquoted=False) -> Optional[str]:
+  """identify if elem is an injection match."""
+  # Check exact match
+  if elem == 'exec-sanitizer':
+    return 'Explicit command injection found.'
+
+  # Check potential for injecting into a string
+  if 'FROMFUZZ' in elem:
+    if check_unquoted:
+      # return true if any index is unquoted
+      for sub_str in get_all_substr_prefixes(elem, 'FROMFUZZ'):
+        if sub_str.count('\"') % 2 == 0:
+          return 'Fuzzer controlled content in data. Code injection potential.'
+
+      # Return None if all fuzzer taints were quoted
+      return None
+    return 'Fuzzer-controlled data in command string. Injection potential.'
+  return None
+
+
+# pylint: disable=invalid-name
+def hook_pre_exec_subprocess_Popen(cmd, **kwargs):
+  """Hook for subprocess.Popen."""
+
+  arg_shell = 'shell' in kwargs and kwargs['shell']
+
+  # Command injections depend on whether the first argument is a list of
+  # strings or a string. Handle this now.
+  # Example: tests/poe/ansible-runner-cve-2021-4041
+  if isinstance(cmd, str):
+    res = check_code_injection_match(cmd, check_unquoted=True)
+    if res is not None:
+      # if shell arg is true and string is tainted and unquoted that's a
+      # definite code injection.
+      if arg_shell is True:
+        sanlib.abort_with_issue('Code injection in Popen', 'Command injection')
+
+      # It's a maybe: will not report this to avoid false positives.
+      # TODO: add more precise detection here.
+
+  # Check for hg command injection
+  # Example: tests/poe/libvcs-cve-2022-21187
+  if cmd[0] == 'hg':
+    # Check if the arguments are controlled by the fuzzer, and this given
+    # arg is not preceded by --
+    found_dashes = False
+    for idx in range(1, len(cmd)):
+      if cmd[0] == '--':
+        found_dashes = True
+      if not found_dashes and check_code_injection_match(cmd[idx]):
+        sanlib.abort_with_issue(
+            'command injection likely by way of mercurial. The following'
+            f'command {str(cmd)} is executed, and if you substitute {cmd[idx]} '
+            'with \"--config=alias.init=!touch HELLO_PY\" then you will '
+            'create HELLO_PY', 'Command injection')
+
+
+def hook_pre_exec_os_system(cmd):
+  """Hook for os.system."""
+  res = check_code_injection_match(cmd)
+  if res is not None:
+    sanlib.abort_with_issue(f'code injection by way of os.system\n{res}',
+                            'Command injection')
+
+
+def hook_pre_exec_eval(cmd, *args, **kwargs):
+  """Hook for eval. Experimental atm."""
+  res = check_code_injection_match(cmd, check_unquoted=True)
+  if res is not None:
+    sanlib.abort_with_issue(f'Potential code injection by way of eval\n{res}',
+                            'Command injection')

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/sanlib.py

@@ -0,0 +1,227 @@
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Core routines for pysecsan library."""
+
+# pylint: disable=protected-access
+
+import re
+import os
+import functools
+import subprocess
+import traceback
+import importlib.util
+
+from typing import Any, Callable, Optional
+from pysecsan import command_injection, redos, yaml_deserialization
+
+LOG_DEBUG = 0
+LOG_INFO = 1
+PYSECSAN_LOG_LVL = LOG_INFO
+
+# Message that will be printed to stdout when an issue is found.
+PYSECSAN_BUG_LABEL = r'===BUG DETECTED: PySecSan:'
+
+
+# pylint: disable=global-statement
+def sanitizer_log(msg, log_level, force=False, log_prefix=True):
+  """Helper printing function."""
+  global PYSECSAN_LOG_LVL
+  if log_level >= PYSECSAN_LOG_LVL or force:
+    if log_prefix:
+      print(f'[PYSECSAN] {msg}')
+    else:
+      print(f'{msg}')
+
+
+def sanitizer_log_always(msg, log_prefix=True):
+  """Wrapper for sanitizer logging. Will always log"""
+  sanitizer_log(msg, 0, force=True, log_prefix=log_prefix)
+
+
+def is_module_present(mod_name):
+  """Identify if module is importable."""
+  # pylint: disable=deprecated-method
+  return importlib.util.find_spec(mod_name) is not None
+
+
+def _log_bug(bug_title):
+  sanitizer_log_always('%s %s ===' % (PYSECSAN_BUG_LABEL, bug_title),
+                       log_prefix=False)
+
+
+def abort_with_issue(msg, bug_title):
+  """Print message, display stacktrace and force process exit.
+
+  Use this function for signalling an issue is found and use the messages
+  logged from this function to determine if a fuzzer found a bug.
+  """
+  # Show breaker string using an ASAN approach (uses 65 =)
+  sanitizer_log_always("=" * 65, log_prefix=False)
+
+  # Log issue message
+  _log_bug(bug_title)
+  sanitizer_log_always(msg)
+
+  # Log stacktrace
+  sanitizer_log_always("Stacktrace:")
+  traceback.print_stack()
+
+  # Force exit
+  # Use os._exit here to force exit. sys.exit will exit
+  # by throwing a SystemExit exception which the interpreter
+  # handles by exiting. However, code may catch this exception,
+  # and thus to avoid this we exit the process without exceptions.
+  # pylint: disable=protected-access
+  sanitizer_log_always("Exiting")
+  os._exit(1)
+
+
+def is_exact_taint(stream) -> bool:
+  """Checks if stream is an exact match for taint from fuzzer."""
+  # The fuzzer has to get 8 characters right. This may be a bit much,
+  # however, when found it shows a high level of control over the data.
+  if stream == 'FROMFUZZ':
+    return True
+
+  return False
+
+
+def create_object_wrapper(**methods):
+  """Hooks functions in an object.
+
+  This is needed for hooking built-in types and object attributes.
+
+  Example use case is if we want to find ReDOS vulnerabilities, that
+  have a pattern of
+
+  ```
+  import re
+  r = re.compile(REGEX)
+  for _ in r.findall(...)
+  ```
+
+  In the above case r.findall is a reference to
+  re.Pattern.findall, which is a built-in type that is non-writeable.
+
+  In order to hook such calls we need to wrap the object, and also hook the
+  re.compile function to return the wrapped/hooked object.
+  """
+
+  class Wrapper():
+    """Wrap an object by hiding attributes."""
+
+    def __init__(self, instance):
+      object.__setattr__(self, 'instance', instance)
+
+    def __setattr__(self, name, value):
+      object.__setattr__(object.__getattribute__(self, 'instance'), name, value)
+
+    def __getattribute__(self, name):
+      instance = object.__getattribute__(self, 'instance')
+
+      def _hook_func(self, pre_hook, post_hook, orig, *args, **kargs):
+        if pre_hook is not None:
+          pre_hook(self, *args, **kargs)
+        # No need to pass instance here because when we extracted
+        # the function we used instance.__getattribute__(name) which
+        # seems to include it. I think.
+        orig_retval = orig(*args, **kargs)
+
+        if post_hook is not None:
+          post_hook(self, *args, **kargs)
+        return orig_retval
+
+      # If this is a wrapped method, return a bound method
+      if name in methods:
+        pre_hook = methods[name][0]
+        post_hook = methods[name][1]
+        orig = instance.__getattribute__(name)
+        return (lambda *args, **kargs: _hook_func(self, pre_hook, post_hook,
+                                                  orig, *args, **kargs))
+
+      # Otherwise, just return attribute of instance
+      return instance.__getattribute__(name)
+
+  return Wrapper
+
+
+# pylint: disable=unsubscriptable-object
+def add_hook(function: Callable[[Any], Any],
+             pre_exec_hook: Optional[Callable[[Any], Any]] = None,
+             post_exec_hook: Optional[Callable[[Any], Any]] = None):
+  """Hook a function.
+
+    Hooks can be placed pre and post function call. At least one hook is
+    needed.
+
+    This hooking is intended on non-object hooks. In order to hook functions
+    in objects the `create_object_wrapper` function is used in combination
+    with function hooking initialisation functions post execution.
+    """
+  if pre_exec_hook is None and post_exec_hook is None:
+    raise Exception('Some hooks must be included')
+
+  @functools.wraps(function)
+  def run(*args, **kwargs):
+    sanitizer_log(f'Hook start {str(function)}', LOG_DEBUG)
+
+    # Call hook
+    if pre_exec_hook is not None:
+      pre_exec_hook(*args, **kwargs)
+
+    # Call the original function in the even the hook did not indicate
+    # failure.
+    ret = function(*args, **kwargs)
+
+    # Post execution hook. Overwrite return value if anything is returned
+    # by post hook.
+    if post_exec_hook is not None:
+      tmp_ret = post_exec_hook(ret, *args, **kwargs)
+      if tmp_ret is not None:
+        sanitizer_log('Overwriting return value', LOG_DEBUG)
+        ret = tmp_ret
+    sanitizer_log(f'Hook end {str(function)}', LOG_DEBUG)
+    return ret
+
+  return run
+
+
+def add_hooks():
+  """Sets up hooks."""
+  sanitizer_log('Starting', LOG_INFO)
+  os.system = add_hook(os.system,
+                       pre_exec_hook=command_injection.hook_pre_exec_os_system)
+  subprocess.Popen = add_hook(
+      subprocess.Popen,
+      pre_exec_hook=command_injection.hook_pre_exec_subprocess_Popen)
+
+  __builtins__['eval'] = add_hook(
+      __builtins__['eval'], pre_exec_hook=command_injection.hook_pre_exec_eval)
+
+  re.compile = add_hook(re.compile,
+                        pre_exec_hook=redos.hook_pre_exec_re_compile,
+                        post_exec_hook=redos.hook_post_exec_re_compile)
+
+  # Hack to determine if yaml is elligible, because pkg_resources does
+  # not seem to work from pyinstaller.
+  # pylint: disable=import-outside-toplevel
+  if is_module_present('yaml'):
+    import yaml
+    sanitizer_log('Hooking pyyaml.load', LOG_DEBUG)
+    yaml.load = add_hook(
+        yaml.load,
+        pre_exec_hook=yaml_deserialization.hook_pre_exec_pyyaml_load,
+    )

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/pysecsan/yaml_deserialization.py

@@ -0,0 +1,42 @@
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Catches vulnerable yaml desrializations that can potentially lead to
+arbitrary code execution."""
+from pysecsan import sanlib
+
+try:
+  import yaml
+# pylint: disable=broad-except
+except Exception:
+  pass
+
+
+def hook_pre_exec_pyyaml_load(stream, loader):
+  """Hook for pyyaml.load_yaml.
+
+    Exits if the loader is unsafe or vanilla loader and the stream passed
+    to the loader is controlled by the fuzz data
+    """
+  # Ensure loader is the unsafe loader or vanilla loader
+  if loader not in (yaml.loader.Loader, yaml.loader.UnsafeLoader):
+    return
+
+  # Check for exact taint in stream
+  if sanlib.is_exact_taint(stream):
+    msg = (
+        'Yaml deserialization issue.\n'
+        'Unsafe deserialization can be used to execute arbitrary commands.\n')
+    sanlib.abort_with_issue(msg, 'Yaml deserialisation')

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/os_command_injection.py

@@ -0,0 +1,52 @@
+#!/usr/bin/python3
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Fuzzer targetting command injection of os.system."""
+
+import os
+import sys
+import atheris
+import pysecsan
+
+
+def list_files_perhaps(param, magicval):
+  """Pass fuzzer data into os.system."""
+  if 'B' not in param:
+    return
+  if magicval == 1338:
+    os.system('exec-san')
+  elif magicval == 1339:
+    os.system('ls -la FROMFUZZ')
+  else:
+    os.system('ls -la ./')
+
+
+def test_one_input(data):
+  """Fuzzer entrypoint."""
+  fdp = atheris.FuzzedDataProvider(data)
+  list_files_perhaps(fdp.ConsumeUnicodeNoSurrogates(24),
+                     fdp.ConsumeIntInRange(500, 1500))
+
+
+def main():
+  """Set up and start fuzzing."""
+  pysecsan.add_hooks()
+
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-builder/sanitizers/pysecsan/tests/poe/python-ldap-GHSL-2021-117/fuzz_ldap.py

@@ -0,0 +1,42 @@
+#!/usr/bin/python3
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Targets: https://github.com/python-ldap/python-ldap/security/advisories/GHSA-r8wq-qrxc-hmcm"""  # pylint: disable=line-too-long
+
+import sys
+import atheris
+import pysecsan
+import ldap.schema
+
+pysecsan.add_hooks()
+
+
+def test_one_input(data):
+  """Fuzzer targetting regex dos in ldap."""
+  fdp = atheris.FuzzedDataProvider(data)
+  try:
+    ldap.schema.split_tokens(fdp.ConsumeUnicodeNoSurrogates(1024))
+  except ValueError:
+    pass
+
+
+def main():
+  """Set up and start fuzzing."""
+  atheris.instrument_all()
+  atheris.Setup(sys.argv, test_one_input, enable_python_coverage=True)
+  atheris.Fuzz()
+
+
+if __name__ == '__main__':
+  main()

local-test-commons-compress-full-01-vuln_2/fuzz-tooling/infra/base-images/base-clang/checkout_build_install_llvm.sh

@@ -0,0 +1,246 @@
+#!/bin/bash -eux
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+NPROC=$(nproc)
+
+TARGET_TO_BUILD=
+case $(uname -m) in
+    x86_64)
+      TARGET_TO_BUILD=X86
+      ARCHITECTURE_DEPS="g++-multilib"
+      # Use chromium's clang revision.
+      export CC=$WORK/llvm-stage1/bin/clang
+      export CXX=$WORK/llvm-stage1/bin/clang++
+      ;;
+    aarch64)
+      TARGET_TO_BUILD=AArch64
+      # g++ multilib is not needed on AArch64 because we don't care about i386.
+      # We need to install clang and lld using apt because the binary downloaded
+      # from Chrome's developer tools doesn't support AArch64.
+      # TODO(metzman): Make x86_64 use the distro's clang for consistency once
+      # we support AArch64 fully.
+      ARCHITECTURE_DEPS="clang lld g++"
+      export CC=clang
+      export CXX=clang++
+      ;;
+    *)
+      echo "Error: unsupported target $(uname -m)"
+      exit 1
+      ;;
+esac
+
+INTROSPECTOR_DEP_PACKAGES="texinfo bison flex"
+# zlib1g-dev is needed for llvm-profdata to handle coverage data from rust compiler
+LLVM_DEP_PACKAGES="build-essential make ninja-build git python3 python3-distutils binutils-dev zlib1g-dev $ARCHITECTURE_DEPS $INTROSPECTOR_DEP_PACKAGES"
+
+apt-get update && apt-get install -y $LLVM_DEP_PACKAGES --no-install-recommends
+
+# For manual bumping.
+# On each bump a full trial run for everything (fuzzing engines, sanitizers,
+# languages, projects, ...) is needed.
+# Check CMAKE_VERSION infra/base-images/base-clang/Dockerfile was released
+# recently enough to fully support this clang version.
+OUR_LLVM_REVISION=llvmorg-18.1.8
+
+mkdir $SRC/chromium_tools
+cd $SRC/chromium_tools
+git clone https://chromium.googlesource.com/chromium/src/tools/clang
+cd clang
+# Pin clang script due to https://github.com/google/oss-fuzz/issues/7617
+git checkout 9eb79319239629c1b23cf7a59e5ebb2bab319a34
+
+LLVM_SRC=$SRC/llvm-project
+# Checkout
+CHECKOUT_RETRIES=10
+function clone_with_retries {
+  REPOSITORY=$1
+  LOCAL_PATH=$2
+  CHECKOUT_RETURN_CODE=1
+
+  # Disable exit on error since we might encounter some failures while retrying.
+  set +e
+  for i in $(seq 1 $CHECKOUT_RETRIES); do
+    rm -rf $LOCAL_PATH
+    git clone $REPOSITORY $LOCAL_PATH
+    CHECKOUT_RETURN_CODE=$?
+    if [ $CHECKOUT_RETURN_CODE -eq 0 ]; then
+      break
+    fi
+  done
+
+  # Re-enable exit on error. If checkout failed, script will exit.
+  set -e
+  return $CHECKOUT_RETURN_CODE
+}
+clone_with_retries https://github.com/llvm/llvm-project.git $LLVM_SRC
+
+git -C $LLVM_SRC checkout $OUR_LLVM_REVISION
+echo "Using LLVM revision: $OUR_LLVM_REVISION"
+
+# For fuzz introspector.
+echo "Applying introspector changes"
+OLD_WORKING_DIR=$PWD
+cd $LLVM_SRC
+cp -rf /fuzz-introspector/frontends/llvm/include/llvm/Transforms/FuzzIntrospector/ ./llvm/include/llvm/Transforms/FuzzIntrospector
+cp -rf /fuzz-introspector/frontends/llvm/lib/Transforms/FuzzIntrospector ./llvm/lib/Transforms/FuzzIntrospector
+
+# LLVM currently does not support dynamically loading LTO passes. Thus, we
+# hardcode it into Clang instead. Ref: https://reviews.llvm.org/D77704
+/fuzz-introspector/frontends/llvm/patch-llvm.sh
+cd $OLD_WORKING_DIR
+
+mkdir -p $WORK/llvm-stage2 $WORK/llvm-stage1
+python3 $SRC/chromium_tools/clang/scripts/update.py --output-dir $WORK/llvm-stage1
+
+cd $WORK/llvm-stage2
+cmake -G "Ninja" \
+  -DLIBCXX_ENABLE_SHARED=OFF \
+  -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON \
+  -DLIBCXXABI_ENABLE_SHARED=OFF \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DLLVM_ENABLE_RUNTIMES="compiler-rt;libcxx;libcxxabi" \
+  -DLLVM_TARGETS_TO_BUILD="$TARGET_TO_BUILD" \
+  -DLLVM_ENABLE_PROJECTS="clang;lld" \
+  -DLLVM_BINUTILS_INCDIR="/usr/include/" \
+  -DLIBCXXABI_USE_LLVM_UNWINDER=OFF \
+  $LLVM_SRC/llvm
+
+ninja -j $NPROC
+ninja install
+rm -rf $WORK/llvm-stage1 $WORK/llvm-stage2
+
+# libFuzzer sources.
+cp -r $LLVM_SRC/compiler-rt/lib/fuzzer $SRC/libfuzzer
+
+# Use the clang we just built from now on.
+export CC=clang
+export CXX=clang++
+
+function free_disk_space {
+    rm -rf $LLVM_SRC $SRC/chromium_tools
+    apt-get autoremove --purge -y $LLVM_DEP_PACKAGES
+    # Delete unneeded parts of LLVM to reduce image size.
+    # See https://github.com/google/oss-fuzz/issues/5170
+    LLVM_TOOLS_TMPDIR=/tmp/llvm-tools
+    mkdir $LLVM_TOOLS_TMPDIR
+    # Move binaries with llvm- prefix that we want into LLVM_TOOLS_TMPDIR.
+    mv \
+      /usr/local/bin/llvm-ar \
+      /usr/local/bin/llvm-as \
+      /usr/local/bin/llvm-config \
+      /usr/local/bin/llvm-cov \
+      /usr/local/bin/llvm-objcopy \
+      /usr/local/bin/llvm-nm \
+      /usr/local/bin/llvm-profdata \
+      /usr/local/bin/llvm-ranlib \
+      /usr/local/bin/llvm-symbolizer \
+      /usr/local/bin/llvm-undname \
+      $LLVM_TOOLS_TMPDIR
+
+    # Delete remaining llvm- binaries.
+    rm -rf /usr/local/bin/llvm-*
+
+    # Restore the llvm- binaries we want to keep.
+    mv $LLVM_TOOLS_TMPDIR/* /usr/local/bin/
+    rm -rf $LLVM_TOOLS_TMPDIR
+
+    # Remove binaries from LLVM build that we don't need.
+    rm -f \
+      /usr/local/bin/bugpoint \
+      /usr/local/bin/llc \
+      /usr/local/bin/lli \
+      /usr/local/bin/clang-check \
+      /usr/local/bin/clang-refactor \
+      /usr/local/bin/clang-offload-wrapper \
+      /usr/local/bin/clang-offload-bundler \
+      /usr/local/bin/clang-repl \
+      /usr/local/bin/clang-check \
+      /usr/local/bin/clang-refactor \
+      /usr/local/bin/c-index-test \
+      /usr/local/bin/clang-rename \
+      /usr/local/bin/clang-scan-deps \
+      /usr/local/bin/clang-extdef-mapping \
+      /usr/local/bin/diagtool \
+      /usr/local/bin/sanstats \
+      /usr/local/bin/dsymutil \
+      /usr/local/bin/verify-uselistorder \
+      /usr/local/bin/clang-format
+
+    # Remove unneeded clang libs, CMake files from LLVM build, lld libs, and the
+    # libraries.
+    # Note: we need fuzzer_no_main libraries for atheris. Don't delete.
+    rm -rf \
+      /usr/local/lib/libclang* \
+      /usr/local/lib/liblld* \
+      /usr/local/lib/cmake/
+}
+
+if [ "$TARGET_TO_BUILD" == "AArch64" ]
+then
+  free_disk_space
+  # Exit now on AArch64. We don't need to rebuild libc++ because on AArch64 we
+  # do not support MSAN nor do we care about i386.
+  exit 0
+fi
+
+function cmake_libcxx {
+  extra_args="$@"
+  cmake -G "Ninja" \
+      -DLIBCXX_ENABLE_SHARED=OFF \
+      -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON \
+      -DLIBCXXABI_ENABLE_SHARED=OFF \
+      -DLIBCXXABI_USE_LLVM_UNWINDER=OFF \
+      -DCMAKE_BUILD_TYPE=Release \
+      -DLLVM_ENABLE_PIC=ON \
+      -DLLVM_TARGETS_TO_BUILD="$TARGET_TO_BUILD" \
+      -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi" \
+      -DLLVM_BINUTILS_INCDIR="/usr/include/" \
+      $extra_args \
+      -S $LLVM_SRC/runtimes
+}
+
+# 32-bit libraries.
+mkdir -p $WORK/i386
+cd $WORK/i386
+cmake_libcxx \
+    -DCMAKE_INSTALL_PREFIX=/usr/i386/ \
+    -DCMAKE_C_FLAGS="-m32" \
+    -DCMAKE_CXX_FLAGS="-m32"
+
+ninja -j $NPROC cxx
+ninja install-cxx
+rm -rf $WORK/i386
+
+# MemorySanitizer instrumented libraries.
+mkdir -p $WORK/msan
+cd $WORK/msan
+
+# https://github.com/google/oss-fuzz/issues/1099
+cat <<EOF > $WORK/msan/ignorelist.txt
+fun:__gxx_personality_*
+EOF
+
+cmake_libcxx \
+    -DLLVM_USE_SANITIZER=Memory \
+    -DCMAKE_INSTALL_PREFIX=/usr/msan/ \
+    -DCMAKE_CXX_FLAGS="-fsanitize-ignorelist=$WORK/msan/ignorelist.txt"
+
+ninja -j $NPROC cxx
+ninja install-cxx
+rm -rf $WORK/msan
+
+free_disk_space