v vanemmerik.ai / SUPPLY-CHAIN
Supply Chain · Watch Wednesday · 02 September 2026 End-of-day synthesis 4 watches · 85 items

From the watchtower — what crossed the wire today.

A four-times-a-day standing watch on the open-source supply chain. Each pass pulls newly disclosed CVEs, freshly catalogued KEV adds, and active attacks reported in the wild — then ranks them by severity for the day.

The story of the day — A late four-CVE OpenChoreo disclosure — headlined by an unauthenticated cluster-gateway bypass — landed alongside a second Omnigent guardrail failure, turning today's AI-agent execution-layer story into a platform-trust story before midnight.

First Watch locked in a day that opened with two critical Orval import-time RCEs and a four-bug fast-uri SSRF cluster, then escalated at 18:00 ET when CISA confirmed active exploitation of an AI-agent MCP auth bypass the same day three new Omnigent agent-bundle CVEs landed — the AI-agent execution layer became a live target, not a hypothetical one.

Late escalation at 21:00 ET: a four-CVE OpenChoreo disclosure closed out the evening, headlined by an unauthenticated bypass that lets anyone reach the cluster-gateway's externally published listener, proxy the Kubernetes data plane, and exec into workload pods with zero authentication. A second Omnigent Guardrail bug landed in the same window: the shared shell-command parser fails open, so any command it doesn't recognize is silently allowed — defeating both of the product's core safety guarantees for confined agents, and extending tonight's trust question from the agent bundle straight into the policy engine meant to contain it. Two more OpenChoreo bugs — cross-project exec/log access from a single project grant, and an unauthenticated webhook-signature bypass — round out what reads as one coordinated multi-CVE disclosure rather than four unrelated bugs; the rest of the late batch (Mailpit, SeaweedFS, Scrapy, Handlebars.java, Plate, Hurl, DiceBear, Mail) is routine parser and transport hardening, not a second active campaign.

→ Operational priority for the night if you run OpenChoreo's multi-cluster topology, confirm the cluster-gateway listener isn't published externally before your next standup — that single check closes the worst of tonight's four bugs — and if you run Omnigent-gated agents, treat every allowlist as advisory until the shell-parser fix lands, re-verifying against the disclosed bypass classes (bash -lc wrappers, timeout/nice/setsid, git worktree escapes).

21:00 ET · Last Watch

OpenChoreo: Unauthenticated access to data-plane operations via cluster-gateway management APIs (CVE-2026-73843)

OpenChoreo's cluster-gateway serves its caller-facing management APIs on the same listener that accepts data-plane agent connections, and in the multi-cluster topology that listener is published outside the cluster with no authentication on the management APIs at all. Anyone who can reach it can proxy the data plane's Kubernetes API and exec into workload pods without a token — full compromise of every workload on that data plane. Patch to 1.0.2 / 1.1.2 / 1.2.0 tonight if you run the multi-cluster topology with an externally published cluster-gateway; single-cluster deployments that never publish the listener are not affected.

OpenChoreo: Authenticated OS command injection via Workflow Plane templates (CVE-2026-73667)

Workflow Plane templates interpolate developer-supplied parameters directly into `sh -c` shell text, so an authenticated user who can trigger a workflow can break out via shell metacharacters — and because some build/publish templates run privileged Podman containers without user-namespace isolation, the injected command executes as UID 0 mapped straight to the host. Audit which workflow templates run privileged containers before the next scheduled build; the fix moves parameters through container.env as quoted data instead of reconstructed shell strings.

OpenChoreo: Cross-project command execution and wirelog access via openchoreo-api exec/wirelogs endpoints (CVE-2026-73841)

openchoreo-api authorizes exec and wirelogs requests against whatever project the caller supplies in the request rather than the target component's actual owning project, so one project-scoped exec grant lets a tenant run commands and read logs in every other project's pods in the same namespace. That's env vars and mounted Secrets across the whole namespace, reachable from a single legitimate grant — rotate anything a cross-tenant workload could have touched and patch before granting new project-scoped exec access.

Mailpit: SMTP command parser buffers unbounded command lines before syntax rejection (CVE-2026-67445)

Mailpit's SMTP loop buffers each command line with an unbounded `ReadString('\n')` before enforcing RFC 5321's 512-byte command limit, so one remote oversized line forces unbounded memory allocation before Mailpit ever returns a syntax error. Mailpit ships SMTP on by default on port 1025 — if that's reachable from anything but trusted senders, it's a cheap DoS knob; patch or firewall the listener.

Mailpit: Thumbnail generation decodes unbounded image dimensions before scaling (CVE-2026-67446)

The thumbnail endpoint decodes an attachment's full raster before checking declared dimensions, so a compact high-dimension image forces disproportionate CPU/memory work just to produce a 180x120 thumbnail — a classic decompression-bomb shape. Same root gap as the SMTP buffering bug above: Mailpit has no pre-parse resource budget anywhere on the attacker-reachable path, worth treating as one upgrade rather than two.

SeaweedFS: Filer JWT allowed_prefixes literal-match allows cross-tenant access to sibling paths (CVE-2026-72921)

The filer JWT `allowed_prefixes` check does a literal byte-prefix match, so a token scoped to `/tenant1` also authorizes `/tenant1234`, `/tenant1-old`, and any other path that happens to share the string prefix. In multi-tenant deployments that's a straightforward cross-tenant read/write bypass with nothing more than a valid scoped token; upgrade to 4.24, and until then avoid tenant-prefix names that are string-prefixes of one another.

Scrapy: S3DownloadHandler sends signed S3 requests over plaintext HTTP by default (CVE-2026-84366)

Scrapy's S3DownloadHandler defaults `s3://` requests to plaintext HTTP unless `request.meta['is_secure']` is set explicitly, then signs the request with your AWS credentials anyway — Authorization header, security token, and object contents all cross the wire in the clear. Anyone on the network path (public wifi, a compromised router, ARP spoofing) can read or MITM the response; grep your spiders for `s3://` requests and set `is_secure` explicitly until a patched release ships.

Omnigent Guardrail policy bypass: shell-command parser fails open in policies/builtins/_shell.py (CVE-2026-62676)

Omnigent's shared shell-command parser fails open: any command it doesn't recognize returns no match, the policy evaluator reads that as abstain, and abstain means allow — silently defeating both of the product's core safety guarantees (GitHub repo/branch allowlisting and workspace confinement). A prompt-injected or misaligned agent can `git push` to an attacker repo or escape its workspace via unlisted wrappers like `timeout`/`nice`/`setsid` or `git worktree add`. This is the same AI-agent-guardrail trust gap as today's earlier Omnigent bundle RCEs — if you run Omnigent-gated agents, treat every allowlist as advisory until patched, and re-test with the disclosed bypass classes.

Plate: SSRF with response disclosure in DOCX image embedding (CVE-2026-65842)

`@platejs/docx-io` fetches remote image URLs while converting HTML to DOCX with no allowlist, so server-side conversion of attacker-controlled HTML becomes an SSRF primitive that also echoes fetched image bytes back into the generated document. Sanitize remote image references out of untrusted HTML before DOCX export, or run conversion in a network-restricted environment; upgrade to 53.3.2 or later.

Handlebars.java: Arbitrary file read in SpringTemplateLoader via URL-fragment suffix bypass (CVE-2026-63490)

SpringTemplateLoader skipped the path-containment check every other Handlebars.java loader got hardened with, leaving the auto-appended `.hbs` suffix as the only thing stopping `view=file:/etc/passwd` from reading arbitrary files — and a trailing `#` fragment character makes both Spring's and the JDK's URL handling silently drop that suffix. One character defeats a boundary meant to hold across the whole loader family: unauthenticated, network-reachable file read wherever Spring MVC view names are attacker-influenced.

OpenChoreo: Unauthenticated build/workflow trigger via git-provider confusion (CVE-2026-73840)

The autobuild webhook picks its git-provider verifier from a client-supplied `X-Event-Key` header instead of the component's own config, and the Bitbucket path accepts requests with no signature at all — so spoofing that header skips the HMAC check that's supposed to protect GitHub/GitLab components too. Anyone who knows a repo URL and branch can trigger an unauthenticated build (and deploy, if auto-deploy is on) against any matching `spec.autoBuild: true` component in the cluster; firewall or rate-limit the endpoint until patched.

DiceBear: SVG injection via unescaped rotate option in @dicebear/core (CVE-2026-68921)

The prior DiceBear fix (CVE-2026-33311) escaped `backgroundColor`/`fontFamily`/`textColor` but missed the numeric `rotate` option — same root cause, same bypass shape, just an uncovered field (plus `fontSize`/`fontWeight` in `@dicebear/initials`). Only exploitable if untrusted input reaches those specific options rather than just `seed`; check your avatar call sites and upgrade regardless.

Hurl: Cookies in [Cookies] section leak when redirecting to a different host (CVE-2026-63481)

Hurl correctly strips Authorization, Cookie header, and basic-auth on cross-host redirects, but only for cookies set via the `Cookie:` header — cookies declared in a `[Cookies]` section still ride along to the new host unchanged. If your `.hurl` test files carry secrets in `[Cookies]`, switch to the `Cookie:` header form until 8.0.1+ ships the fix.

Mail: Email address spoofing via malformed RFC 2047 encoded-words (CVE-2026-63435)

Ruby's `mail` gem decodes only the first RFC 2047 encoded-word in a header and uses an overly greedy charset match, so a malformed encoded-word in a From/To/Reply-To display name can make the decoded address a human or downstream parser sees differ from the raw header. Anything that authorizes or displays based on decoded sender/recipient addresses is a spoofing target — patch before trusting parsed `mail` addresses for authorization decisions.

18:00 ET · First Watch

Omnigent: Shared agent bundle overwrite leads to authenticated runner RCE (CVE-2026-62674)

An authenticated user with only edit access to their own session can upload a full agent bundle through PUT /sessions/{id}/agent and overwrite a shared/template agent — a path the direct MCP-edit endpoint blocks but this bulk-upload route forgot to guard. Planting a stdio MCP server in the shared agent means every future runner session that loads it starts an attacker-controlled command, turning one low-privilege account into ongoing RCE against everyone who uses that shared agent. If you run Omnigent with shared or template agents, patch now and audit whether any shared agent's MCP server list changed recently.

CISA KEV: JFrog Artifactory default-config admin bypass (CVE-2026-82329)

CISA added JFrog Artifactory's improper-authentication bug to KEV today: under default configuration, an unauthenticated attacker with network access can obtain administrative privileges outright. Artifactory is registry infrastructure for a huge number of build pipelines, so admin-level compromise there is a direct path to poisoning artifacts at the source rather than attacking any one downstream consumer. Check your Artifactory instance's exposure and patch before the Sept 5 due date — don't wait to confirm you're on the default config, just verify the fix is applied.

CISA KEV: BerriAI LiteLLM MCP auth bypass, confirmed active exploitation (CVE-2026-59822)

CISA confirmed active exploitation of LiteLLM's MCP Streamable HTTP endpoint today: it accepts an arbitrary Bearer token as authentication, letting an unauthenticated caller open a fully-authenticated MCP session. LiteLLM sits in front of a lot of production LLM traffic as a gateway/proxy, so this is unauthenticated access to whatever tools and data that MCP session exposes — the same 'trust the agent-layer client' failure mode as today's Omnigent bundle bugs, just in the gateway instead of the runner. Patch now; this one's confirmed exploited in the wild, not theoretical.

CISA KEV: Kestra OSS unauthenticated workflow-creation RCE (CVE-2026-49869)

CISA added Kestra OSS's OS command injection bug to KEV: an unauthenticated remote attacker can create and execute arbitrary workflows with no credentials at all, which on a workflow orchestrator is close to unauthenticated RCE by design. Due date is Sept 5 — a short fuse for a bug this direct. If Kestra is reachable without auth in front of it, that's the finding; patch or put auth in front of it today.

CISA KEV: Starlette HTTP request/response smuggling, chains with CVE-2026-42271 (CVE-2026-48710)

CISA added Starlette's HTTP request/response smuggling bug to KEV: a crafted request can inject a path into the host portion of a URL, corrupting any authentication logic that depends on the reconstructed path — and CISA notes it chains with a second smuggling bug, CVE-2026-42271. Starlette underpins FastAPI and a large share of modern Python API services, so this is a wide blast radius for an auth-bypass primitive. Patch Starlette directly; pinning FastAPI alone won't necessarily pull the fix.

Omnigent: Uploaded agent bundle allows authenticated runner RCE via Python callable tools (CVE-2026-62675)

A second Omnigent bundle-upload path lets any authenticated user define a server-side Python callable tool with an attacker-chosen dotted path — including subprocess.check_output — so invoking the tool runs an arbitrary local command on the runner. The bundle validator already treats uploads as partly untrusted (it disables env expansion and supports a handler allowlist) but never blocked dangerous callable: targets, so this is a missing check, not a missing framework. Enforce a callable allowlist on uploaded bundles before any of this reaches a shared runner host.

Omnigent: Unvalidated os_env.cwd in agent bundle yields arbitrary host filesystem access (CVE-2026-62677)

Third Omnigent finding from the same bundle-upload vector: an agent spec's os_env.cwd field is stored and used verbatim with no boundary check, so a bundle pointing cwd at / or another user's home directory gets arbitrary host filesystem read/write on any runner that doesn't set OMNIGENT_RUNNER_WORKSPACE. That env var neutralizes the attack by overriding the spec's cwd, so this is deployment-gated rather than universal — check now whether your runners set it, since that's the one config knob standing between this and unrestricted host access.

Grav: 2FA bypass via login.regenerate2FASecret during pending TOTP challenge (CVE-2026-62669)

Grav's login plugin marks a session as the target user before TOTP verification completes, and the task that regenerates a 2FA secret only checks $user->exists() rather than $user->authorized() — so an attacker holding the victim's password can call it during the pending-2FA window, overwrite the secret, and read it back with no CSRF nonce required. That reduces the second factor to password-only, and the exploit was confirmed live against a real 2FA-enabled account. Upgrade the login plugin; treat any Grav site with app-based 2FA as bypassable until you do.

link-preview-js: DNS rebinding SSRF bypass, incomplete fix for CVE-2026-43897 (CVE-2026-61704)

link-preview-js's documented SSRF mitigation validates one resolved IP through resolveDNSHost, then makes the actual fetch() against the hostname again with no pinning — so a malicious DNS server can answer the validation lookup with a public IP and the real connection with a loopback or internal one. This is an incomplete fix for a previously-patched SSRF, not a new bug class; if you rely on link-preview-js's DNS-rebinding guard as an SSRF boundary, it isn't one yet. Don't trust the mitigation until a further fix lands.

CISA KEV batch-adds three appliance bugs: Sangoma Switchvox SQLi, SonicWall SMA1000 SSRF + command injection

CISA also added three appliance bugs to KEV today: unauthenticated SQL injection in Sangoma Switchvox with a path to RCE against the backend Postgres, and a pair in SonicWall SMA1000 — unauthenticated SSRF (CVE-2026-83548) and authenticated-admin OS command injection (CVE-2026-83549). All three are closed-source network/telephony appliances rather than open-source supply-chain components, but a KEV add means confirmed active exploitation regardless; if you run either product, patch against the Sept 5 due date.

Grav: Twig sandbox config exfiltration via grav.offsetGet + dump filter, bypassing prior fix (CVE-2026-61842)

Grav's Twig content sandbox blocks {{ config.get(...) }} from leaking secrets, but grav.offsetGet('config') returns the raw, unredacted Config object, and allow-listed filters like json_encode serialize it at the PHP level without ever hitting the sandbox's method gate — an incomplete fix for a prior sandbox-escape advisory. Any editor who can write Twig-processed content, including a modular page's body, can dump every plugins.* secret this way. Patch when available; until then, treat editor-level Twig access as equivalent to config-file access.

Grav: Decompression bomb via ZipArchiver — missing extraction limits (CVE-2026-61690)

Grav's ZipArchiver::extract() checks for zip-slip path traversal but has no limit on uncompressed size, file count, or nesting depth — the same zip-bomb bug class already fixed in the parallel Installer::unZip() path, just left open here. Any admin-facing feature that extracts an uploaded zip through this code path is a one-file DoS. Patch when available, or front zip uploads with your own size/count limits until then.

12:00 ET · Forenoon Watch

SeaweedFS: Unauthenticated filer IAM gRPC service grants full S3 administrative control (CVE-2026-72920)

SeaweedFS's filer registers its IAM gRPC service (CreateUser, CreateAccessKey, PutUserPolicy) with no authentication check, so any client that can reach the filer gRPC port can mint its own S3 credentials and grant itself administrative access — full read/write/delete over every stored object. Enabling JWT signing keys doesn't help; the IAM RPCs weren't gated by that mechanism, and even mTLS's allowed_commonNames ACL protects the port, not individual calls. Firewall the filer gRPC port to trusted hosts now and upgrade to 4.24, which requires a signed Bearer token on every IAM call.

Orval: Import-time RCE via unescaped query-parameter default in generated zod client (CVE-2026-72716)

Orval's zod codegen writes a query parameter's `default` value straight into a module-level JS template literal without escaping `${` or backticks, so a spec default like `v${globalThis.pwn()}w` executes arbitrary JS the moment the generated schema module is imported — no request needed. Anyone who generates a zod client from an attacker-influenced OpenAPI spec and imports it is compromised at import time; don't import a generated client built from a spec you don't fully control until you're on a patched Orval.

Orval: Import-time RCE via unescaped schema property name in generated zod client (CVE-2026-71866)

Same failure mode as the query-default bug above, different sink: a schema property name with an unescaped double-quote breaks out of the generated `zod.object({...})` key and injects a computed property key that's evaluated at module import, giving the same pre-request RCE. Both are from the same Orval zod-client audit — one fix (escape all string interpolation into generated code) should close both; don't import a generated client until the patch lands.

fast-uri: Host confusion via skipped IDN canonicalization on scheme-relative references (CVE-2026-75931)

fast-uri only canonicalizes a host to ASCII when the input carries an explicit scheme, so resolving a scheme-relative reference (`//host/`) against a scheme-bearing base returns a host that re-parses to something different the second time — an incomplete fix for CVE-2026-13676. First of four fast-uri host-confusion/SSRF bugs disclosed today in a URI parser that sits transitively under ajv and much of the npm ecosystem; an app that resolves an untrusted reference and then makes a host-policy decision on the result can act on one host and reach another. Upgrade to 2.4.5/3.1.6/4.1.3.

fast-uri: SSRF via malformed IPv6 literal silently truncated to a valid address (CVE-2026-75975)

Second in the same-day cluster: a malformed bracketed IPv6 literal like `[::not-valid]` gets silently truncated to a valid address such as `[::]` (loopback) instead of erroring, and `parse().error` stays unset so checking it gives no protection. Normalizing an untrusted URL before an outbound request or host-allowlist check can route you to loopback, unique-local, or link-local addresses; same fix versions as the others (2.4.5/3.1.6/4.1.3).

fast-uri: SSRF via repeated hostname percent-decoding (double-decode bypass) (CVE-2026-75899)

Third in the cluster: fast-uri decodes a hostname's percent escapes twice — once during parsing, again during authority recomposition — so a nested-encoded host like `%256c%256f...` survives the first decode and resolves to `localhost` on the second. This is itself an incomplete fix for CVE-2026-6322; any SSRF or redirect check performed against the pre-normalization string is bypassed. Same patched versions as above.

fast-uri: Host confusion and CRLF injection via unescaped scheme percent-decoding (CVE-2026-76172)

Fourth in the cluster: fast-uri decodes percent-escapes in the scheme with the legacy `unescape()` and re-serializes without validating the result, so a scheme that decodes to `//evil.example:` injects an authority the original input didn't have, and a scheme containing `%0d%0a` reaches output as raw CRLF. Same root pattern as the other three — decode without re-validating — and the same fix versions close all four; if fast-uri touches any URI in your app, patch once rather than four times.

Orval: Generation-time SSRF and remote/local file inclusion via unrestricted $ref (CVE-2026-62680)

Orval resolves `$ref` in an OpenAPI spec without restricting scheme or path, so a spec with a `$ref` pointing at an internal URL or an arbitrary local file gets fetched or read during code generation — before either of the import-time RCE bugs above even comes into play. Same root cause as the two critical Orval RCEs (trusting spec content), different stage of the pipeline; don't run `orval generate` against a spec you don't control, and upgrade to 8.22.0+.

NLTK: pathsec module defaults to ENFORCE=False, silently disabling all path/SSRF/pickle guards (CVE-2026-62388)

NLTK's pathsec module — introduced to fix the CVE-2024-39705 pickle-RCE and CVE-2026-0846 path-traversal bugs — ships with ENFORCE=False by default, so every one of its 8 validation functions only emits a RuntimeWarning instead of raising; `pathsec.open('/etc/passwd')`, SSRF checks against 169.254.169.254, and unsafe pickle loads via nltk.data.load() all proceed with just a warning. If you upgraded NLTK expecting those CVE fixes to actually block anything, they don't unless you set NLTK_PATHSEC_ENFORCE=1 — set that env var now.

NLTK: Model-artifact save/load APIs bypass pathsec even with enforcement enabled (CVE-2026-81726)

Even with NLTK_PATHSEC_ENFORCE=1 set from the fix above, TransitionParser.train/parse and AveragedPerceptron.save/load still call raw open() on caller-controlled model paths instead of the guarded pathsec helpers, so outside-root reads and writes go through regardless. Same audit as the ENFORCE=False finding — enforcing pathsec is necessary but not sufficient; don't let untrusted input choose model import/export paths (no fix version yet).

ApostropheCMS: Second-order prototype pollution via PATCH causes persistent single-request DoS (CVE-2026-71553)

A single authenticated PATCH with a body like `{"toString.call": "x"}` overwrites the global `Object.prototype.toString`, and because the corruption persists in the process, the app stays broken for every subsequent request until restarted — one request takes down the whole server, not just the caller's session. Upgrade off 4.32.0 and audit any PATCH handler that merges request bodies into objects without a prototype-pollution guard.

Grav: RCE via unrestricted callable in Blueprint::dynamicData() (CVE-2026-64850)

An account with admin.pages permission can save a page whose frontmatter carries a `Class::method` callable string that Blueprint::dynamicData() passes straight to call_user_func_array() with no allowlist; the payload then executes for every visitor who opens that page, authenticated or not. This turns one compromised or malicious editor account into RCE against your entire visitor base — upgrade to 2.0.7 and review who holds admin.pages.

EasyAdmin: Custom-action route dispatch bypasses access_control on the target route (CVE-2026-81892)

EasyAdmin serves every backend request through one dashboard route and swaps in the real controller after Symfony's firewall has already evaluated access_control against the dashboard URL, not the target route — so a low-privilege backend user who knows a restricted route's name can reach it by URL parameter, bypassing any path-based access_control rule protecting it. Routes that enforce their own #[IsGranted] checks are unaffected; if you rely on path-based access_control near EasyAdmin routes, upgrade to 4.29.16/5.5.1.

Tornado: Missing max_num_fields on urlencoded body parsing stalls the event loop (CVE-2026-82397)

Tornado parses form bodies with urllib.parse.parse_qs but never passes max_num_fields, so a ~100MB body of separators produces on the order of fifty million fields and the synchronous parse — which runs on the event loop before any handler executes — stalls every connection on the process, not just the attacker's. No auth needed if any route accepts a form POST, which is the common case; second Tornado disclosure on today's board alongside the cookie-injection bypass. Upgrade past 6.5.7.

elFinder: ZIP extraction bypasses uploadDeny MIME filter, enabling PHP upload and RCE (CVE-2026-81891)

Direct upload correctly blocks .phtml/.phar/.php5 via the uploadDeny MIME filter, but the ZIP extract command detects MIME type with mimetypeInternalDetect() directly, skipping the mimeTypeNormalize() step that maps those extensions to text/x-php — so an attacker who can upload a ZIP can extract PHP-executable files straight into the web-accessible files/ directory. On the common Apache/Nginx configs that execute .phtml or .phar as PHP, that's RCE from an upload permission most admins consider low-risk; upgrade to 2.1.70 and audit whether elFinder needs ZIP uploads enabled at all.

pnpm: Virtual store linker path traversal via unvalidated depPath name (CVE-2026-82392)

pnpm's virtual-store linker builds install paths with path.join(modules, pkgName) where pkgName comes straight from a lockfile depPath key with no validation, so a crafted pnpm-lock.yaml with `../../../tmp/[email protected]` as a key writes package contents outside node_modules during `pnpm install`. This is an incomplete fix of GHSA-fr4h-3cph-29xv — the safeJoinModulesDir containment guard was applied to the hoisted linker and symlinkDependency but missed this exact sink; treat any pnpm-lock.yaml from an untrusted source like untrusted code, and upgrade to 10.34.5/11.11.0.

pnpm: Tarball manifest name escapes node_modules, arbitrary file write on install (CVE-2026-82393)

Same audit, adjacent sink: pnpm uses a resolved package.json `name` as a raw path segment for the isolated-linker import target, so a tarball dependency named `@x/../../../<path>` extracts outside node_modules and can overwrite files like ~/.zshrc or a git hook — and it works even with --ignore-scripts, defeating that mitigation entirely. Same class as two already-patched pnpm traversal bugs (GHSA-hwx4, GHSA-v23m) in a sink their fixes didn't cover; upgrade to 10.34.5/11.11.0 and don't rely on --ignore-scripts as a safety net for untrusted dependencies.

SiYuan: Authenticated path traversal in /snippets/ leaks kernel API token and document database (CVE-2026-59832)

The /snippets/*filepath handler joins the request path directly with no IsSubPath containment or sensitive-path denylist — unlike its sibling /export/ and /appearance/ handlers — so an authenticated request to /snippets/%2e%2e/%2e%2e/conf/conf.json leaks the kernel API token and AccessAuthCode, the same secrets CVE-2026-30869 leaked from /export/. A prior fix to /assets/ and /export/ never reached this handler; don't assume a sibling endpoint's traversal fix covers the whole family, patch when available.

SiYuan: SQL injection in block search exposes hidden published-document content (CVE-2026-59834)

SiYuan's publish service forwards unauthenticated visitors to the kernel search API with a reader-role token, and non-SQL search modes concatenate the caller-controlled paths[] value into a SQL predicate — a UNION SELECT can pull rows from hidden documents while projecting an allowed box/path, which the post-query access filter then trusts and returns. Same-day companion to the /snippets/ traversal above, different root cause; if you run SiYuan's publish feature, this is unauthenticated data exposure until patched.

gRPC-Go: Heap exhaustion DoS via HTTP/2 DATA frame fragmentation (CVE-2026-84304)

An unauthenticated caller who fragments a gRPC payload into millions of 1-byte HTTP/2 DATA frames inflates per-frame tracking-structure overhead far beyond the actual payload size, even while staying inside configured flow-control windows — multiplexed across streams, this exhausts heap and forces an OOM panic. Fixed in 1.83.1 with automatic receive-buffer compaction (coalescing small frames); the GRPC_GO_EXPERIMENTAL_ENABLE_RECEIVE_BUFFER_COMPACTION escape hatch exists but the fix is on by default — just upgrade.

TYPO3: Backend/Install Tool referrer check broken since v13.0, enabling XSS-to-privileged-action chains (CVE-2026-19418)

TYPO3's 2020 referrer-based protection for backend and Install Tool endpoints compared the request referrer against the backend's own directory, but since v13.0 the backend is served from the site's main entry script — the site root — so any script running on the same domain, including a frontend page, now passes the check. An attacker with an XSS foothold anywhere on the domain can invoke backend/Install Tool endpoints with a logged-in victim's session; upgrade to 13.4.34 LTS / 14.3.6 LTS.

Faker.js: helpers.fake() template strings allow arbitrary code execution (CVE-2026-73231)

faker.helpers.fake()'s fakeEval.resolveProperty resolves a function's properties before resolving the function itself, so a template like `{{test.constructor(alert(1))}}` reaches the global Function constructor — directly contradicting Faker's own docs, which claim plain JS isn't reachable through fake strings. If any code path feeds user-controlled strings into faker.helpers.fake() (test-data generators exposed to user input, templated fixtures), treat it as eval() and stop doing that until a patch lands.

Filament: App-based MFA can be bypassed when recovery codes are enabled (CVE-2026-77567)

A flaw in app-based MFA challenge handling lets the second factor be skipped entirely, but only when recovery codes are enabled and only for app-based (not email) MFA — the third Filament MFA-adjacent disclosure this batch, after the replay and password-disclosure bugs already on today's board. If you run Filament with app-based MFA and recovery codes turned on, patch to 4.12.0/5.7.0 alongside the other two.

NLTK: SSRF fail-open in validate_network_url() on DNS resolution failure (CVE-2026-63311)

When DNS resolution fails, validate_network_url() fails open instead of closed, so a URL that resolves inconsistently (DNS rebinding, transient failure) can slip past the SSRF check it's supposed to enforce. Same NLTK pathsec audit as the ENFORCE=False and model-artifact bugs above — one of eight findings from what looks like a single security review of the pathsec module; patch alongside the rest.

NLTK: Downloader.download follows hardlinks and overwrites files outside the download root (CVE-2026-81727)

Downloader.download() follows hardlinks without checking whether they point outside the intended download root, so a pre-planted hardlink in the cache directory gets its target overwritten during a download. Requires an attacker to have already planted the hardlink — narrower than the other pathsec findings in this same audit batch, but worth the same patch cycle.

Sulu: Stored XSS via media download inline-disposition override (CVE-2026-82396)

The media download endpoint's `?inline=1` parameter forces `Content-Disposition: inline` for any MIME type with no X-Content-Type-Options or CSP set, so an editor with only media-add permission can upload an HTML file and get it served as a same-origin page — stored XSS in the session of anyone who opens the link, including an admin. Patch, and if you can't yet, strip or ignore the inline query parameter at a proxy layer for uploaded media.

Sulu: Missing authorization check lets any backend user create a public preview link for content they can't view (CVE-2026-82394)

PreviewLinkController never checked VIEW permission on the target resource, so any authenticated backend user could generate a public, token-only preview URL for a page or article in a webspace they have no rights to — no further auth needed to read it once the link exists. Fixed in 2.6.x/3.0.x, which now enforces VIEW before issuing a link; same Sulu patch batch as the other two Sulu items here.

Sulu: Media move/update authorization bypass via IDOR (CVE-2026-82395)

MediaManager::move() checks permission against the collection named in the request rather than the media's actual source collection, so a user with edit rights on collection A can move — and then read — media that actually lives in restricted collection B by just naming A. Same Sulu release batch as the XSS and preview-link bugs above; fixed in 2.6.25/3.0.8.

fastify: X-Forwarded-* header spoofing under trustProxy hop-count configuration (CVE-2026-16732)

fastify's trustProxy hop-count logic can be miscounted, letting a client-supplied X-Forwarded-* header spoof the trusted value fastify hands to your app for client IP or protocol decisions. If you gate rate limits, geo-blocking, or auth on request.ip behind a reverse proxy, verify your trustProxy count matches your actual proxy chain depth and upgrade to 5.12.1.

fastify: Schema validation bypass via root primitive coercion mismatch (CVE-2026-18504)

A root-level primitive schema (a plain string or number body, not an object) can be coerced in a way that bypasses the validation fastify is supposed to enforce. Same fastify release as the header-spoofing fix above; if any route schema validates a root primitive rather than an object, patch to 5.12.1 and re-check that route's validation actually rejects malformed input.

qs: arrayLimit / throwOnLimitExceeded bypass via bracket-key comma parsing (CVE-2026-82562)

With `comma: true`, qs enforces arrayLimit for plain keys but not the `a[]=1,2,3,4` bracket form, so a single parameter can materialize an unbounded array regardless of the configured limit — a million-element array from one query string, no error thrown. If you rely on arrayLimit/throwOnLimitExceeded as a DoS guard on qs.parse, upgrade off 6.15.3.

qs: DoS via unchecked isBuffer() call during stringify (CVE-2026-82417)

qs.stringify() calls obj.constructor.isBuffer(obj) without checking it's callable, and qs.parse() itself — with plainObjects or allowPrototypes set, qs's own documented mitigation — can produce values whose constructor.isBuffer is non-callable. That makes a pure parse-then-stringify round-trip on an unauthenticated query string throw an uncaught TypeError; if you use plainObjects/allowPrototypes and later re-stringify parsed input, upgrade past 6.16.0.

ApostropheCMS: Arbitrary file read via import-export attachment-name path traversal (CVE-2026-63667)

The import-export module's zip-slip guard checks tar entry names during extraction but not the separate path it builds afterward from an aposAttachments.json `name`/`extension` pair, so a `../` in that metadata reads a file outside the extraction directory and republishes it at an anonymous public URL. An authenticated contributor with only import permission can exfiltrate any file on the host with an allowlisted extension — second ApostropheCMS bug on today's board alongside the prototype-pollution DoS above, unrelated root cause. Upgrade @apostrophecms/import-export past 3.6.1.

elFinder: CSRF in netmount allows forced FTP mounts and server-side FTP connections (CVE-2026-81890)

The netmount action has no CSRF protection, so a crafted cross-origin request can force a logged-in elFinder session to mount an attacker-controlled FTP server and make the server itself connect to it — useful for internal network probing or credential capture via a rogue FTP endpoint. Lower severity than the ZIP-upload RCE above but same elFinder release; upgrade both together to 2.1.70.

xmldom: XML fragment injection via invalid EntityReference.nodeName during requireWellFormed serialization (CVE-2026-83610)

Serializing a DOM tree with requireWellFormed enabled doesn't validate an EntityReference's nodeName before writing it out, so a crafted node name injects arbitrary markup into the serialized XML fragment — breaking the well-formedness guarantee the option exists to provide. If you build XML programmatically from untrusted node names and rely on requireWellFormed as a safety net, it isn't one until you patch.

CKAN MCP Server: MQA server allowlist bypass via unanchored regex in isValidMqaServer (CVE-2026-73845)

isValidMqaServer's allowlist regex isn't anchored, so a hostname that merely contains an allowlisted substring — rather than matching it exactly — passes the check, letting the MCP server be pointed at an attacker-controlled MQA endpoint. Low blast radius (niche MCP connector, low CVSS) but the anchoring-bug pattern is worth grepping for in any other allowlist checks in the same codebase; upgrade past 0.4.112.

Tiptap: mergeAttributes() turns an own __proto__ key into inherited executable DOM attributes

mergeAttributes() doesn't guard against an own `__proto__` key in its input, so a crafted attributes object pollutes the prototype chain and the polluted properties render as live, executable DOM attributes rather than staying inert data. If your editor extensions merge attributes from untrusted content (collaborative editing, pasted HTML, imported documents), this is an XSS path via prototype pollution rather than the usual sanitizer bypass; patch @tiptap/core past 3.30.4.

pypdf: Inefficient handling of non-whitespace input in read_until_whitespace (CVE-2026-82398)

A crafted PDF token with a long run of non-whitespace characters makes read_until_whitespace() scan inefficiently, adding to the resource-exhaustion pile pypdf disclosed today — three separate perf bugs (this one, outlines, XForm objects) all fixed together in 6.15.0/6.16.1. If you parse untrusted PDFs, one upgrade closes all three; put a timeout around parsing regardless.

humanfs: Recursive copy follows symlinked files and copies data from outside the source tree

@humanfs/node's recursive copy dereferences symlinks instead of skipping or erroring on them, so a symlink planted inside a directory you're copying pulls file contents from anywhere else on the filesystem into the copy destination. If you recursively copy user-supplied or untrusted directory trees, a planted symlink is a path-traversal-style read; upgrade past 0.16.8.

06:00 ET · Morning Watch

league/commonmark: Denial of service in the SmartPunct and Attributes extensions

league/commonmark's SmartPunctExtension and AttributesExtension each carry a quadratic parsing path — a string-concatenation bug in quote-merging and a matching hot loop in Attributes — but neither ships in the default CommonMarkConverter or GFM converters, so only apps that explicitly register one of the two extensions are exposed. If you render user-supplied Markdown through either extension, a crafted single-line input can pin a worker on CPU; audit your Environment's registered extensions and upgrade to 2.9.1 if either is on the list.

league/commonmark XSS: on* event-handler filter in AttributesExtension bypassed with a form-feed byte

A single U+000C form-feed byte prefixed to an attribute name (`{<FF>onclick=...}`) slips past AttributesExtension's on*-handler blocklist and its unsafe-link check, reopening the exact XSS that the 2.7.0 security release shipped as a fix. This is a bypass of a bypass fix, not a new class of bug — treat any app that renders untrusted Markdown through AttributesExtension as exploitable until patched to 2.9.1.

league/commonmark: Denial of service via crafted code fences, reference links, and emphasis delimiters

Unlike the two extension-only bugs above, this one hits the stock converter: three independent super-linear parsing paths — fenced code block detection, reference-link label lookup, and emphasis/strikethrough delimiter matching — are each triggerable with a single crafted line and no extensions registered. Any service that converts untrusted Markdown with a default CommonMarkConverter is exposed; upgrade to 2.9.1 and put a timeout around Markdown rendering in the meantime.

Browserslist: Uncaught crash / prototype write via untrusted browserslist-stats.json custom stats

browserslist's normalizeStats() runs unconditionally on every browserslist() call and treats a discovered browserslist-stats.json — auto-found by walking up the directory tree — as trusted, so a malicious stats file can crash the process or write to Object.prototype. browserslist sits transitively under nearly every JS build, so this is a build-time supply-chain vector via a config file rather than a package; treat a repo-local browserslist-stats.json from forked PRs or third-party templates the same way you'd treat an untrusted lockfile, and upgrade past 4.28.6.

Filament: Multi-factor authentication (app) codes can still be used after a newer code has been accepted (CVE-2026-84306)

Filament's app-based MFA blocks exact-duplicate code resubmission but still accepts any other code inside the ~4-minute validity window, even after a newer code has already been used to log in. An attacker holding a password plus one intercepted TOTP code gets a multi-minute replay window that outlives the legitimate login; upgrade to 4.12.6 / 5.7.6 if you run Filament with app-based MFA.

pypdf: Possible long runtimes/large memory usage when retrieving outlines (CVE-2026-84310)

A PDF with many outline entries, or nested outlines reusing long nesting paths, drives pypdf's outline retrieval into large runtime and memory use — the second pypdf resource-exhaustion disclosure today, alongside the XForm bug below, both fixed in 6.16.1. If you extract outlines from untrusted PDFs, upgrade now; PR #3966 is the interim patch if you can't.

Django REST framework: AdminRenderer may disclose GET-protected data when rendering invalid write requests (CVE-2026-73229)

DRF's AdminRenderer renders a 400 response for an invalid write request by internally re-invoking the view's GET handler, so a view that allows POST but denies GET can leak GET-protected data into the browsable-API error page. Only the AdminRenderer path is affected, not JSON responses; if the browsable API is reachable outside a trusted network, patch or disable it for endpoints with asymmetric GET/POST permissions.

Appium: Reflected XSS / arbitrary JS in @appium/base-driver /test/guinea-pig* routes (CVE-2026-58191)

@appium/base-driver mounts unauthenticated /test/guinea-pig* debug routes on every server by default and reflects the throwError param, comments field, and User-Agent header into HTML via an unescaped Lodash template — including inside a <script> block, so no auth or session is needed to run arbitrary JS on the server's origin. Appium servers commonly bind 0.0.0.0 for device-farm access; if yours is reachable from anything less trusted than the test network, patch past 10.6.0 now.

Filament: Password validity disclosure for accounts denied panel access on login page (CVE-2026-84307)

Filament's login flow renders the MFA challenge before checking canAccessPanel(), so for MFA-enabled accounts that are otherwise denied panel access, a correct password produces a different response than an incorrect one — letting an unauthenticated caller confirm a valid password for an account that can't log in anyway. No session is created and the access check still runs after; low urgency, but worth folding into the same Filament patch cycle as the MFA replay bug above.

Tornado: Incomplete fix for CVE-2026-35536 — cookie attribute injection re-opened via the legacy case-insensitive **kwargs path in set_cookie

The CVE-2026-35536 fix validated only the lowercase name/domain/path/samesite kwargs, but the deprecated **kwargs path in set_cookie() is case-insensitive, so a capitalized Domain= or SameSite= kwarg routes to the same reserved Morsel attribute while skipping the new check — reopening the original `;`-delimited attribute-injection bug. If any call site in your codebase sets Tornado cookies with a capitalized kwarg name, that call is still exploitable; grep for it and upgrade past 6.5.8.