critical

CVE

CVE-2026-97033, CVE-2026-97034, CVE-2026-97035, CVE-2026-97036, CVE-2026-97037, CVE-2026-97038, CVE-2026-97039, CVE-2026-97040, CVE-2026-97041, CVE-2026-97042, CVE-2026-97043, CVE-2026-97054, CVE-2026-105437, CVE-2026-111760, CVE-2026-113408, CVE-2026-114466, CVE-2026-114467, CVE-2026-114469, CVE-2026-126799, CVE-2026-126065, CVE-2026-64678, CVE-2026-125331, CVE-2026-125330, CVE-2026-125320, CVE-2026-125321, CVE-2026-125322, CVE-2026-125323, CVE-2026-125327, CVE-2026-126196, CVE-2026-126197

CWE

CWE-78, CWE-88, CWE-190, CWE-787, CWE-287, CWE-59, CWE-502, CWE-362, CWE-908, CWE-918, CWE-89

Affected Surface

  • Go toolchain (`cmd/go`, `cmd/cgo`, `cmd/compile`, `cmd/link`, and `net/http`) versions `< 1.26.11` and `>= 1.27.0-0, < 1.27.4` (`CVE-2026-97033` through `CVE-2026-97043` and `CVE-2026-97054` / `GO-2026-6848` through `GO-2026-6859`, fixed in `go1.26.11` and `go1.27.4`)
  • Git (`git/git`) versions `< 2.50.2`, `2.51.x < 2.51.3`, `2.52.x < 2.52.1`, `2.53.x < 2.53.1`, `2.54.x < 2.54.1`, `2.55.x < 2.55.1`, and `2.56.0` (`CVE-2026-111760` recursive clone `ce_namelen` 32-bit truncation RCE, `CVE-2026-105437` CVSS 7.5 High `xdiff` merge heap overflow, `CVE-2026-113408` protocol v2 `ls-refs` unborn `HEAD` symref traversal, `CVE-2026-114466` `fast-import` `--allow-unsafe-features`, `CVE-2026-114467` `remove_signature` stack overflow, and `CVE-2026-114469` binary patch delta OOB read, fixed in `v2.56.1`)
  • Gotenberg (`github.com/gotenberg/gotenberg/v8`, Docker image `gotenberg/gotenberg`) versions `< 8.39.0` (`GHSA-gpf4-wmvf-cgjw` CVSS 9.8 Critical ExifTool `-j` RCE, fixed in `8.39.0`, and `CVE-2026-126799` / `GHSA-fqg9-x2xw-5crx` in `8.31.0`..`8.37.0` where IPv6 zone identifiers `[::%251]` bypassed `IsPublicIP()`, fixed in `8.38.0`) and OpenObserve (`openobserve/openobserve`) versions `< 1.1.0` (`CVE-2026-126065` / `GHSA-7w4v-2c9r-q94v`, CVSS 9.8 Critical, fixed in `1.1.0`)
  • crates.io `cap-primitives` and `cap-std` versions `<= 3.4.5` and `>= 4.0.0, <= 4.0.2` (`RUSTSEC-2026-0482` / `GHSA-hp8f-xmx4-4qrg`, CVSS 9.0 Critical, fixed in `3.4.6` and `4.0.3`), and `rustix` versions `>= 1.0.0, < 1.1.6` (`RUSTSEC-2026-0486` / `GHSA-jh2m-fhpj-3vr7`, fixed in `1.1.6`)
  • Maven `org.dizitart:nitrite-mvstore-adapter` (`nitrite/nitrite-java`) versions `< 4.4.1` (`CVE-2026-64678` / `GHSA-9297-g93h-86gg`, CVSS 9.8 Critical), HarnessRouter `< 0.31.8` (`CVE-2026-125331` / `GHSA-p6cq-54cg-8mpv` CVSS 9.1 Critical and `CVE-2026-125330`), and pgEdge Postgres MCP Server `< 1.1.0` (`CVE-2026-125320` to `125322`, plus `CVE-2026-126196` CVSS 8.1 and `CVE-2026-126197` CVSS 8.8 read-only bypasses), Control Plane `< 0.11.0` (`CVE-2026-125323` CVSS 7.8 High), and RAG Server `< 2.0.0` (`CVE-2026-125327`)

TL;DR

Update, 12 November 2026 (pgEdge Postgres MCP Server CVE-2026-126196 and CVE-2026-126197): At 18:17 UTC on 12 November 2026, NVD published two more CVEs for pgedge-postgres-mcp before 1.1.0, both about getting writes past the server’s read_only mode. CVE-2026-126196 (GHSA-j7mp-839j-jrm7, CVSS 8.1) covers statements sent over the simple query protocol: a multi-statement string can end the read-only transaction and run writes after it. CVE-2026-126197 (GHSA-r5pp-jx86-r6r9, CVSS 8.8) covers pl-do custom tools, which wrapped the tool body in DO $mcp_custom_tool$ ... $mcp_custom_tool$ and passed arguments as $mcp_args$%s$mcp_args$::jsonb. JSON encoding does not escape $, so an argument containing $mcp_args$ closed the quoting early and the rest of the value ran as SQL. Commit b5b929305de7 (“Harden the read-only guardrails against transaction-mode bypass”) generates per-call tags such as $mcp_do_<nonce>$ and rejects any argument that contains them, and it sets read-only at the session level. Both are fixed in 1.1.0, the same release as CVE-2026-125320 to 125322 below. If an MCP client can reach this server with untrusted prompts, treat read_only on older builds as advisory only.

Update, 12 November 2026 (Gotenberg CVE-2026-126799 / GHSA-fqg9-x2xw-5crx IPv6 zone-ID SSRF bypass): On 11 November 2026 (21:16 UTC), NVD published CVE-2026-126799 (GHSA-fqg9-x2xw-5crx, CVSS 6.9 Medium) for Gotenberg 8.31.0 before 8.38.0 (commit 8e850b1c9324). In pkg/gotenberg/outbound.go, IsPublicIP(addr netip.Addr) called addr.Unmap() without stripping the IPv6 zone identifier (addr.WithZone("")). Because Go’s netip.Prefix.Contains() never matches a zoned netip.Addr and netip.Addr.IsUnspecified() also compares the zone string, supplying a zoned IPv6 literal such as http://[::%251]:9999/ or http://[fc00::1%251]/ bypassed --chromium-deny-private-ips and classified loopback, unspecified, and unique-local addresses as public. Fixed in 8.38.0 (8.39.0 also includes the GHSA-gpf4-wmvf-cgjw ExifTool -j RCE fix below).

Update, 11 November 2026 (five additional Git v2.56.1 CVE assignments on oss-security 2026/11/11/10): On 11 November 2026 (14:24 UTC), Johannes Schindelin published the full six-CVE advisory for Git v2.56.1 (v2.50.2 through v2.55.1) on oss-security (2026/11/11/10), assigning five CVE IDs alongside CVE-2026-105437 (and noting that on GitLab, CVE-2026-105437 can be escalated to remote code execution via the Git process spawned by Gitaly during mergeability checks):

  • CVE-2026-111760 (Recursive clone RCE via 32-bit ce_namelen wrap): A cache entry’s name length is computed as size_t and stored in the 32-bit ce_namelen field. A crafted tree entry named .gitz/z...z/z with $2^{32}$ bytes following .git wraps ce_namelen to 4. Path-safety validation walks the full NUL-terminated string (.gitz/...), while checkout writes only ce_namelen (4) bytes (.git). Because a freshly cloned submodule’s .git is a gitfile rather than a directory, git clone --recurse-submodules replaces the submodule’s .git gitfile with an attacker-controlled symlink and executes hooks/config from the target.
  • CVE-2026-113408 (Protocol v2 ls-refs unborn HEAD symref traversal): During a protocol v2 clone, the client copied the server’s symref-target verbatim into .git/HEAD. Advertising HEAD as refs/heads/../../../TARGET caused a subsequent git commit under the files ref backend to write the ref file to TARGET in the repository working tree.
  • CVE-2026-114467 (remove_signature() stack buffer overflow on $>2$ GPG signatures): remove_signature() stored signature start/end offsets in a fixed two-slot stack array, so merging a tag or commit message carrying three or more PGP signatures wrote past the stack buffer (reachable on Git forges when merging a pushed tag).
  • CVE-2026-114466 (git fast-import arbitrary file read/append via rewrite-submodules-* and export-pack-edges) and CVE-2026-114469 (patch_delta() OOB read on compressed binary patches inflating past 1 GiB).

On 10 and 11 November 2026, the Go security team, the Git project, Gotenberg, OpenObserve, Bytecode Alliance, Nitrite, pgEdge, and HarnessRouter published a major set of compiler, version-control, document-conversion, observability, and filesystem-sandbox advisories:

  1. Go 1.26.11 and 1.27.4 fix 11 cgo build-time code execution flaws (CVE-2026-97033 through CVE-2026-97043) and an net/http MaxBytesReader server crash (CVE-2026-97054): Building an untrusted Go module with cgo enabled could execute arbitrary commands at compile or link time through 11 distinct bypasses in cmd/go, cmd/cgo, cmd/compile, and cmd/link:
    • Quoting mismatch on //go:cgo_ldflag (CVE-2026-97043): cmd/cgo emitted #cgo LDFLAGS arguments into _cgo_gotypes.go using strconv.Quote, but cmd/go and cmd/compile stripped quotes with strings.Trim(flag, "\"") without unescaping \", allowing escaped quotes inside a single validated flag to split into unvalidated linker flags.
    • .syso archives disguised as Go objects or GNU ld linker scripts (CVE-2026-97040 and CVE-2026-97038): When loading .syso files, ldobj checked only for ELF, Mach-O, PE, and XCOFF magic headers before falling through to Go compiler object parsing (ldpkg), allowing a .syso file beginning with "go object" to inject arbitrary cgo_ldflag or cgo_dynamic_linker directives without security.go checks (CVE-2026-97040). Similarly, .syso files and -L libraries were passed to the host linker without binary header validation, allowing GNU ld implicit linker scripts (INPUT, GROUP, PLUGIN) to run code at link time (CVE-2026-97038).
    • macOS -l to_library recombination (CVE-2026-97036), GCC *.spec files (CVE-2026-97034), Clang -gen-* / GCC -gnat* (CVE-2026-97035), --sysroot / -target (CVE-2026-97033), split -Wl, flags (CVE-2026-97037), #cgo pkg-config: (CVE-2026-97039), commas in //go:cgo_* (CVE-2026-97041), and PE DLL names (CVE-2026-97042): On Darwin, passing -l to_library <path> in #cgo LDFLAGS recombined in Apple’s linker into -lto_library <path>, loading an arbitrary LTO plugin dynamic library during go build.
    • net/http MaxBytesReader concurrent header race (CVE-2026-97054): Exceeding MaxBytesReader’s limit called w.Header().Set("Connection", "close") from the body-read goroutine without synchronization, crashing HTTP/1 servers (including httputil.ReverseProxy wrapped in MaxBytesHandler) with a concurrent map write panic when a handler read the request body concurrently with writing response headers.
  2. Git 2.56.1 (2.50.2 through 2.55.1) patches a 32-bit xdiff merge buffer integer overflow (CVE-2026-105437, CVSS 7.5 High): In xdiff/xmerge.c, xdl_fill_merge_buffer() and fill_conflict_hunk() accumulated the merged output size in a signed 32-bit int size. Because .gitattributes allows conflict-marker-size to be set to any positive integer and each conflict writes 3 or 4 marker lines, a small repository with a large conflict-marker-size and multiple conflicts overflows size past 4 GiB, allocates a tiny buffer via xdl_malloc(size), and writes gigabytes of attacker-controlled merge output onto the heap during git merge, git rebase, or server-side git merge-tree mergeability checks on Git hosting platforms.
  3. Gotenberg 8.39.0 fixes unauthenticated single-request RCE via ExifTool’s -j alias (GHSA-gpf4-wmvf-cgjw, CVSS 9.8 Critical): pkg/modules/exiftool/exiftool.go blocked json in controlOptions but omitted its short alias j. An unauthenticated caller submitting an HTML conversion job (/forms/chromium/convert/html) could use local fetch() to POST /forms/pdfengines/metadata/write with metadata={"j": "<dir>/db.json"} and "HardLink": "/home/gotenberg/.ExifTool_config", planting a Perl file that the outer conversion’s ExifTool invocation immediately executed as uid=1001(gotenberg).
  4. OpenObserve 1.1.0 (CVE-2026-126065, CVSS 9.8 Critical), Bytecode Alliance cap-primitives 4.0.3 / 3.4.6 (RUSTSEC-2026-0482 / GHSA-hp8f-xmx4-4qrg, CVSS 9.0 Critical) & rustix 1.1.6 (RUSTSEC-2026-0486), Nitrite 4.4.1 (CVE-2026-64678, CVSS 9.8), HarnessRouter 0.31.8 (CVE-2026-125331, CVSS 9.1), and pgEdge Postgres MCP Server 1.1.0 / Control Plane 0.11.0 (CVE-2026-125320..125327): OpenObserve accepted empty HTTP Basic passwords on non-ingestion routes for SSO/migrated accounts whose password_ext was blank, leading to pre-auth file write via DataFusion COPY ... TO; cap-primitives re-appended a trailing / to the final path component before calling openat(..., O_NOFOLLOW), causing the Unix kernel to follow symlinks outside the sandbox; and Nitrite automatically deserialized legacy v1 MVStore values via ObjectInputStream.readObject() without an ObjectInputFilter.

What to do now: Upgrade Go toolchains to 1.26.11 or 1.27.4, Git clients and forge servers to >= 2.56.1 (or 2.50.2 / 2.51.3 / 2.52.1 / 2.53.1 / 2.54.1 / 2.55.1), Gotenberg to >= 8.39.0, OpenObserve to >= 1.1.0, cap-primitives and cap-std to >= 4.0.3 (3.4.6), rustix to >= 1.1.6, org.dizitart:nitrite-mvstore-adapter to >= 4.4.1, HarnessRouter to >= 0.31.8, and pgedge-postgres-mcp to >= 1.1.0 (control-plane >= 0.11.0).

Affected packages and components

EcosystemPackage / ProjectCVE / AdvisorySeverityAffected versionsFixed version
GoGo toolchain (cmd/go, cmd/cgo, cmd/compile, cmd/link) and net/httpCVE-2026-97033..97043, CVE-2026-97054 (GO-2026-6848..6859)High (build-time RCE / HTTP/1 DoS)< 1.26.11; >= 1.27.0-0, < 1.27.41.26.11, 1.27.4
C / GitGit (git/git)CVE-2026-105437 (plus fast-import, read-cache, ls-refs fixes)CVSS 7.5 High< 2.50.2, 2.51.x < 2.51.3, 2.52.x < 2.52.1, 2.53.x < 2.53.1, 2.54.x < 2.54.1, 2.55.x < 2.55.1, 2.56.02.50.2, 2.51.3, 2.52.1, 2.53.1, 2.54.1, 2.55.1, 2.56.1
Go / Dockergithub.com/gotenberg/gotenberg/v8 (gotenberg/gotenberg)GHSA-gpf4-wmvf-cgjwCVSS 9.8 Critical<= 8.38.1 (< 8.39.0)8.39.0
RustOpenObserve (openobserve/openobserve)CVE-2026-126065 (GHSA-7w4v-2c9r-q94v)CVSS 9.8 Critical< 1.1.01.1.0
crates.iocap-primitives, cap-std (bytecodealliance/cap-std)RUSTSEC-2026-0482 (GHSA-hp8f-xmx4-4qrg)CVSS 9.0 Critical<= 3.4.5; >= 4.0.0, <= 4.0.23.4.6, 4.0.3
crates.iorustix (bytecodealliance/rustix)RUSTSEC-2026-0486 (GHSA-jh2m-fhpj-3vr7)High (unsound assume_init UB)>= 1.0.0, <= 1.1.51.1.6
Mavenorg.dizitart:nitrite-mvstore-adapter (nitrite/nitrite-java)CVE-2026-64678 (GHSA-9297-g93h-86gg)CVSS 9.8 Critical< 4.4.14.4.1
Go / AIHarnessRouter (HarnessRouter/harnessrouter)CVE-2026-125331 (GHSA-p6cq-54cg-8mpv), CVE-2026-125330CVSS 9.1 Critical / 7.5 High< 0.31.8 (< 0.31.7 for 125330)0.31.8
Go / MCPpgedge-postgres-mcp, pgEdge/control-plane, pgEdge/rag-serverCVE-2026-125320..125322, CVE-2026-125323, CVE-2026-125327, CVE-2026-126196, CVE-2026-126197CVSS 8.8 High to 5.3 Mediumpgedge-postgres-mcp < 1.1.0; control-plane < 0.11.0; rag-server < 2.0.01.1.0, 0.11.0, 2.0.0

Technical analysis

1. Go 1.26.11 and 1.27.4 (CVE-2026-97033 to CVE-2026-97043 and CVE-2026-97054): how 11 cgo and .syso primitives bypassed security.go

Go’s cmd/go/internal/work/security.go restricts which compiler and linker flags a package can specify in #cgo CFLAGS and #cgo LDFLAGS so that running go build or go test on untrusted code does not execute arbitrary commands. The 11 toolchain advisories fixed in go1.26.11 and go1.27.4 (commits 3eb71096ddd9 through 8e7ba03754ee) expose systematic parser differentials across cmd/cgo, cmd/go, cmd/compile, cmd/link, and host C toolchains:

  1. Escaped quotes in //go:cgo_ldflag (CVE-2026-97043 / GO-2026-6848, commit 3eb71096ddd9): When cmd/cgo generates _cgo_gotypes.go, it formats each #cgo LDFLAGS token using %q (strconv.Quote) inside a //go:cgo_ldflag "..." pragma. However, both processCgoOutputs() in cmd/go/internal/work/exec.go and pragcgo() in cmd/compile/internal/noder/lex.go split pragma lines on raw " bytes and called strings.Trim(flag, "\"") without handling backslash escapes (\"). A single #cgo LDFLAGS token containing escaped quotes passed checkLinkerFlags() as one benign argument, and was then split by pragmaFields into multiple unvalidated linker flags.
  2. .syso files parsed as Go compiler objects (CVE-2026-97040 / GO-2026-6851, commit b207530349f4) or GNU ld linker scripts (CVE-2026-97038 / GO-2026-6853, commit 51dadca52c36): .syso files in a package directory are packed directly into the package archive without invoking cmd/cgo. In src/cmd/link/internal/ld/lib.go, ldobj() checked whether an archive member matched ELF, Mach-O, PE, or XCOFF magic bytes; if none matched and the file began with "go object", ldobj() parsed it as a trusted Go compiler output, reading embedded cgo_ldflag and cgo_dynamic_linker metadata that never went through checkLinkerFlags(). Furthermore, when an archive member name exceeded 16 bytes, packInternal() truncated aaaaaaaaaaaa.syso to 16 bytes, stripping the .syso suffix. Even for valid external-linker inputs, GNU ld treats any input file that is not a binary object as an implicit linker script, executing PLUGIN or OUTPUT directives unless cmd/go verifies binary headers first (checkLinkerInputFile).
  3. macOS -l to_library recombination (CVE-2026-97036 / GO-2026-6855), GCC *.spec inclusion (CVE-2026-97034 / GO-2026-6857), and Clang -gen-* / GCC -gnat* arity desynchronization (CVE-2026-97035 / GO-2026-6856):
    • security.go explicitly blocked -lto_library (which causes Apple’s ld to load and execute a dynamic library as an LTO plugin), but allowed two-token -l <arg> in validLinkerFlagsWithNextArg. Passing #cgo LDFLAGS: -l to_library payload.dylib passed checkLinkerFlags() and was recombined by Apple’s driver into -lto_library payload.dylib.
    • Passing -fopenmp, -fopenacc, or -fsanitize=* -static-lib* in #cgo LDFLAGS causes GCC’s built-in link spec to evaluate %:include(libgomp.spec) or %:include(libsanitizer.spec), searching -L directories (and sibling ../lib64 multilib paths) for untrusted .spec files that can run arbitrary shell commands.
    • Because validCompilerFlags and validLinkerFlags allowed -g* as a 1-argument wildcard, Clang’s 2-argument -gen-cdb-fragment-path <dir> and GCC’s 2-argument -gnatO <file> matched as 1-argument flags, writing files to arbitrary paths and shifting flag-pair alignment in checkFlags().
  4. net/http MaxBytesReader concurrent header write panic (CVE-2026-97054 / GO-2026-6859, commit 4c1752a033ae): In src/net/http/server.go, when a request body wrapped in MaxBytesReader or MaxBytesHandler exceeded its byte limit, requestTooLarge() mutated w.Header().Set("Connection", "close") directly:
    --- a/src/net/http/server.go
    +++ b/src/net/http/server.go
    @@ -564,11 +564,7 @@ func (w *response) declareTrailer(k string) {
     func (w *response) requestTooLarge() {
    -	w.closeAfterReply = true
    -	w.requestBodyLimitHit = true
    -	if !w.wroteHeader {
    -		w.Header().Set("Connection", "close")
    -	}
    +	w.requestBodyLimitHit.Store(true)
     }
    In handlers that read req.Body in one goroutine while writing w.Header() in another (such as httputil.ReverseProxy streaming a request body while copying response headers from an early upstream reply), hitting the body limit triggered fatal error: concurrent map writes and crashed the entire Go server process.

2. Git 2.56.1 (CVE-2026-105437): 32-bit int overflow in xdiff/xmerge.c via .gitattributes conflict-marker-size

When Git performs a textual three-way merge (git merge, git rebase, git cherry-pick, or server-side git merge-tree used by GitHub/GitLab to test PR mergeability), xdl_do_merge() in xdiff/xmerge.c runs two passes through xdl_fill_merge_buffer(): a sizing pass with dest = NULL to compute the output buffer length, followed by result->ptr = xdl_malloc(size) and a second pass with dest = result->ptr to write the merged bytes.

Prior to Git 2.56.1 (commit 03b41523c576), xdl_fill_merge_buffer(), fill_conflict_hunk(), and xdl_recs_copy_0() tracked size as a signed 32-bit int:

--- a/xdiff/xmerge.c
+++ b/xdiff/xmerge.c
@@ -208,11 +208,11 @@ static size_t fill_conflict_hunk(xdfenv_t *xe1, const char *name1,
 	/* Before conflicting part */
-	size += xdl_recs_copy(xe1, i, m->i1 - i, 0, 0,
-			      dest ? dest + size : NULL);
+	size = st_add(size, xdl_recs_copy(xe1, i, m->i1 - i, 0, 0,
+					  dest ? dest + size : NULL));
 
 	if (!dest) {
-		size += marker_size + 1 + needs_cr + marker1_size;
+		size = st_add5(size, marker_size, 1, needs_cr, marker1_size);
 	} else {
 		memset(dest + size, '<', marker_size);

Because a committed .gitattributes file can set conflict-marker-size to any positive integer (up to INT_MAX) and each conflict hunk emits three or four marker lines (<, |, =, >), a small file with multiple conflicts pushes the 32-bit size sum past $2^{32}$, wrapping it to a small positive integer. xdl_malloc(size) then allocates a small heap buffer while the second pass writes gigabytes of </=/> markers and attacker-controlled conflict lines past the end of the buffer. Git 2.56.1 converts the merge sizing path to size_t with st_add() / st_add5() overflow guards and also gates git fast-import’s rewrite-submodules-to, rewrite-submodules-from, and export-pack-edges directives behind --allow-unsafe-features.

In Gotenberg <= 8.38.1, the PDF metadata writer (pkg/modules/exiftool/exiftool.go) passes each key in the caller’s metadata JSON map to ExifTool as -<key>=<value>. To stop callers from passing ExifTool command-line flags as metadata keys, Gotenberg checked unprefixed keys against controlOptions. While controlOptions blocked "json" (-json=<file>, which imports tags from a JSON file), it omitted ExifTool’s short alias "j" (-j=<file>):

--- a/pkg/modules/exiftool/exiftool.go
+++ b/pkg/modules/exiftool/exiftool.go
@@ -88,11 +102,11 @@ var dangerousTags = []string{
 var controlOptions = []string{
-	"api", "argfile", "charset", "common_args", "config", "csv", "diff",
-	"echo", "efile", "execute", "ext", "fileorder", "geotag", "geosync",
-	"htmldump", "if", "json", "lang", "listitem", "o", "out", "p", "php",
+	"addtagsfromfile", "alltagsfromfile", "api", "argfile", "charset",
+	"common_args", "config", "csv", "diff", "echo", "efile", "execute", "ext",
+	"fileorder", "geotag", "geosync", "htmldump", "if", "j", "json", "lang",

Because ExifTool’s JSON import mode bypasses Gotenberg’s dangerousTags filter, an imported JSON array containing [{"SourceFile": "*", "HardLink": "/home/gotenberg/.ExifTool_config"}] instructs ExifTool (Writer.pl) to hardlink an uploaded file containing Perl BEGIN { ... } code to /home/gotenberg/.ExifTool_config. On the very next ExifTool invocation, ExifTool automatically loads ~/.ExifTool_config as Perl code. By submitting a single POST /forms/chromium/convert/html request whose HTML discovers its temporary working directory via new URL('.', location.href).pathname and posts db.json and payload.pdf to http://127.0.0.1:3000/forms/pdfengines/metadata/write before the outer conversion writes "Title": "demo", an unauthenticated client executes arbitrary OS commands as uid=1001(gotenberg) in a single HTTP request (commit e7f67e1d3986). Version 8.39.0 blocks j, addtagsfromfile, and alltagsfromfile and always passes -config "" to ExifTool.

4. OpenObserve 1.1.0 (CVE-2026-126065), cap-primitives 4.0.3 (RUSTSEC-2026-0482), rustix 1.1.6 (RUSTSEC-2026-0486), Nitrite 4.4.1 (CVE-2026-64678), HarnessRouter 0.31.8 (CVE-2026-125331), and pgEdge MCP (CVE-2026-125320..125323)

  • OpenObserve < 1.1.0 empty HTTP Basic password bypass (CVE-2026-126065 / GHSA-7w4v-2c9r-q94v, CVSS 9.8 Critical, commit 46678ea8daba): In src/api/common/src/auth/validator.rs, validate_credentials() checked if is_ingestion_path && user_password.is_empty() and then compared user_password against user.password_ext. For SSO-provisioned or migration-created users whose password_ext is empty, sending an HTTP Basic request with an empty or whitespace-only password to any non-ingestion API route matched "" == "" and authenticated as that user. An account with search permission could then submit a DataFusion COPY ... TO SQL statement to write attacker-controlled files on the server.
  • Bytecode Alliance cap-primitives < 4.0.3 / < 3.4.6 trailing-slash O_NOFOLLOW sandbox escape (RUSTSEC-2026-0482 / GHSA-hp8f-xmx4-4qrg, CVSS 9.0 Critical) and rustix < 1.1.6 (RUSTSEC-2026-0486 / GHSA-jh2m-fhpj-3vr7): In cap-primitives/src/fs/manually/open.rs:228-234, when opening a path that ended in /, manually::open re-appended "/" to the final component (p.push("/")) before calling openat(dirfd, use_path, O_NOFOLLOW | ...). On Unix kernels, a trailing slash causes openat to treat the symlink as a non-terminal component and follow the symlink despite O_NOFOLLOW, escaping the capability directory for both reads and writes. In rustix 1.0.0 to 1.1.5 (src/fs/xattr.rs, commit 8e6aaa6713d2), calling getxattr / listxattr with a zero-length Vec::spare_capacity_mut() buffer passed the kernel’s positive attribute-size return value directly to value.assume_init(len), calling Vec::set_len() past the vector’s capacity.
  • Nitrite (NO2) < 4.4.1 (CVE-2026-64678, CVSS 9.8 Critical), HarnessRouter < 0.31.8 (CVE-2026-125331, CVSS 9.1 Critical), and pgEdge Postgres MCP Server < 1.1.0 / Control Plane < 0.11.0 (CVE-2026-125320..125323): Nitrite’s MVStoreUtils.openOrCreate() automatically invoked NitriteDataType.deserialize(), which passed legacy v1 store bytes straight to ObjectInputStream.readObject() without a JEP 290 ObjectInputFilter. HarnessRouter attached the server’s internal key to any request carrying an Authorization header before validating the bearer token (commit 28609ec65ed6), allowing a bogus bearer token to overwrite /v1/orgs/{org}/connections/{name}. And pgEdge/control-plane < 0.11.0 (commit 88659f7388fc) prepended hardcoded trust entries for local Unix sockets and 127.0.0.1/::1 to the top of generated pg_hba.conf files (CVE-2026-125323), while pgedge-postgres-mcp < 1.1.0 lacked HTTP Origin validation (CVE-2026-125320) and allowed arbitrary WHERE subqueries in count_rows (CVE-2026-125322).

Detection and remediation

# 1. Check Go, Git, and Gotenberg versions
go version 2>/dev/null || true
git --version 2>/dev/null || true
docker ps --format '{{.Image}}' 2>/dev/null | rg 'gotenberg|openobserve' || true

# 2. Check Rust Cargo.lock and Java Maven/Gradle manifests for cap-primitives, cap-std, rustix, and nitrite
rg -n -A 2 'name = "(cap-primitives|cap-std|rustix)"' Cargo.lock 2>/dev/null
rg -n 'nitrite|gotenberg|pgedge-postgres-mcp|harnessrouter' go.mod pom.xml build.gradle* 2>/dev/null

# 3. Check PostgreSQL pg_hba.conf files generated by pgEdge Control Plane (< 0.11.0) for leading trust rules
rg -n '^\s*(local|host)\s+all\s+all\s+.*trust' /var/lib/postgresql/*/data/pg_hba.conf /etc/postgresql/*/*/pg_hba.conf 2>/dev/null || true
  1. Upgrade Go to 1.26.11 or 1.27.4 and rebuild HTTP/1 services using MaxBytesReader / MaxBytesHandler: Never run go build, go test, or go list -export with CGO_ENABLED=1 on untrusted third-party modules on older Go releases.
  2. Upgrade Git to >= 2.56.1 (2.50.2..2.55.1): On Git servers or CI runners that run git merge or git merge-tree on untrusted repositories and cannot upgrade immediately, add * conflict-marker-size=7 to $GIT_DIR/info/attributes to override in-tree .gitattributes files.
  3. Upgrade Gotenberg to >= 8.39.0 and OpenObserve to >= 1.1.0: On Gotenberg < 8.39.0 containers exposed to untrusted callers, check /home/gotenberg/.ExifTool_config for unauthorized files and rebuild the container on gotenberg/gotenberg:8.39.0. On OpenObserve < 1.1.0, set a strong 16-to-48-byte ZO_EXT_AUTH_SALT and audit logs for HTTP Basic requests with empty passwords or COPY ... TO search queries.
  4. Update cap-primitives / cap-std to >= 4.0.3 (3.4.6), rustix to >= 1.1.6, Nitrite to >= 4.4.1, HarnessRouter to >= 0.31.8, and pgedge-postgres-mcp to >= 1.1.0 (control-plane >= 0.11.0).

Timeline

  • 2026-08-20 to 2026-10-27: Bytecode Alliance releases cap-primitives / cap-std 4.0.3 and 3.4.6 (2026-08-20) and rustix 1.1.6 (2026-10-27, 8e6aaa6713d2); Gotenberg releases v8.39.0 (2026-10-27, e7f67e1d3986); and Git tags v2.50.2 through v2.56.1 (2026-10-23).
  • 2026-11-10 (16:23 to 21:19 UTC): Go commits the 12 security fixes and tags go1.26.11 and go1.27.4; NVD publishes CVE-2026-125320 through CVE-2026-125327 (pgEdge), CVE-2026-105437 (Git xdiff), CVE-2026-125330 and CVE-2026-125331 (HarnessRouter), and CVE-2026-126065 (OpenObserve 1.1.0), while Gotenberg publishes GHSA-gpf4-wmvf-cgjw.
  • 2026-11-11 (02:51 to 08:37 UTC): golang/vulndb (e91d849153) and NVD publish GO-2026-6848 through GO-2026-6859 (CVE-2026-97033 through CVE-2026-97043 and CVE-2026-97054) and CVE-2026-64678 (Nitrite 4.4.1), and RustSec publishes RUSTSEC-2026-0482 (cap-primitives) and RUSTSEC-2026-0486 (rustix).

From research to remediation

Check whether this pattern exists in your codebase

Turn this research into a remediation workflow. Scan dependencies and package manifests for similar supply-chain risk, then prioritize fixes with reachability context.

References