Back to dashboard

Tech News

Curated security, hosting and development news with vulnerability warnings from fixed trusted sources.

CISA KEVGHSACERT.atHosting

Updated

About these news

Articles are collected periodically from a fixed source list. D4rC Tools stores the headline, source summary and source link only; linked articles are not fetched on page view.

Security

New Unpatched Windows 0-Day FastUnlock Lets Someone Holding a Locked PC Run Programs on It

The Hacker News

A newly disclosed unpatched zero-day technique called FastUnlock lets someone with physical access to a locked Windows computer start programs without signing in. Whoever uses it gets only a limited account, not administrator control of the machine. The method was posted yesterday by a researcher who uses the handles MSNightmare and Nightmare Eclipse, and the endpoint-security firm ThreatLocker

Hosting & Network

nginx2root: Five new nginx vulnerabilities, and how Cloudflare protects origins from the worst of them

Cloudflare

Five memory corruption bugs in nginx, called nginx2root, can let an unauthenticated attacker run code on a server. Here’s how they work, and why origins behind Cloudflare's proxy are shielded from the most serious of these bugs.

Security Severity: Critical CVE-2026-114516 GHSA-MC8W-WJHW-45X5

Etherpad: Pre-auth arbitrary file read

GitHub Advisories

### Summary An unauthenticated path‑traversal / arbitrary file read vulnerability in Etherpad's /static/* handler allows any remote, unauthenticated user to read any file on the server's filesystem (e.g. GET /static/plugins/ep_etherpad-lite/static/..%5C..%5C..%5C..%5C..%5C..%5C..%5Cetc/passwd returns /etc/passwd) available to the user running the etherpad software. Because the endpoint is mounted before the authentication middleware, no credentials, session, or configuration change are required. The read primitive could escalate to a full server compromise: on a typical deployment by disclosing settings.json / credentials.json / /proc/self/environ, which contain the admin password, giving an attacker an admin session and, through the admin plugin installer, remote code execution. ### Deta…

Security Severity: Medium CVE-2026-103033 GHSA-GFWJ-45PC-W6R5

ALTCHA: Nil-map panic (pre-verification DoS) in v1 parseServerSignature on malformed VerificationData

GitHub Advisories

### Summary parseServerSignature in the v1 module only initializes ServerSignatureVerificationData.Extra inside the if err == nil branch after url.ParseQuery(parsedPayload.VerificationData). Go's url.ParseQuery returns the successfully-parsed pairs together with a non-nil error when the query string contains a malformed percent-escape. A subsequent loop unconditionally writes unknown keys into Extra, regardless of err, causing a nil-map write panic (assignment to entry in nil map) whenever an attacker supplies a VerificationData string with a bad %-escape (e.g. x=1&%zz=2). This is reachable pre-authentication: parseServerSignature is called by the exported VerifyServerSignature / VerifyServerSignatureSafe before any HMAC/signature check, and VerificationData is a…

Security Severity: High CVE-2026-103025 GHSA-7HVW-3C2Q-45QG

bep/imagemeta: Unbounded memory allocation decoding PNG `zTXt` "Raw profile type iptc" chunks

GitHub Advisories

A crafted PNG can make imagemeta.Decode allocate memory far in excess of the input file's size, leading to memory exhaustion. Two separate paths in the zTXt "Raw profile type iptc" branch are affected: the declared chunk length drives an allocation directly, and the embedded zlib stream is decompressed without an output bound. A 42-byte file allocated 256 MB, and a 127 KB file allocated 460 MB. ### Impact Denial of service by memory exhaustion against any application that decodes untrusted PNG images with this library. The decompression bomb is the more reliable vector, since it produces genuinely resident memory; the effect of the oversized make depends on the platform's overcommit behavior and any configured GOMEMLIMIT or cgroup limit. ### Patches Fixed in v0.17.3. ### Workaroun…

Security Severity: Medium CVE-2026-102945 GHSA-V6W5-38CF-PCV8

Aether Project amf: panic on an unrecovered NGAP goroutine

GitHub Advisories

## Summary HandlePathSwitchRequest guards the UESecurityCapabilities IE for presence but never for length, and the extensible APER type silently yields an empty bit string, so six unguarded index-zero reads panic on an unrecovered goroutine and terminate the AMF. The AMF is the control-plane entry point for a 5G core, so terminating it drops mobility management for every subscriber. Confirmed at HEAD daed5a2 (present in v3.1.5). ## The defect ngap/handler.go: ``go if uESecurityCapabilities != nil { // line 3267, PRESENCE only amfUe.UESecurityCapability.SetEA1_128_5G((uESecurityCapabilities.NRencryptionAlgorithms.Value.Bytes[0] & 0x80) >> 7) // line 3268 ... (five more Bytes[0] reads, lines 3269-3273) } `` Six index-zero reads, all guarded only by a nil check on the containing IE. Why th…

Security Severity: Medium CVE-2026-63012 GHSA-WGVX-X5G3-9V29

baserCMS administrative API authorization bypass through session fallback

GitHub Advisories

### Summary An authorization bypass occurs against the API endpoint /baser/api/admin/ by abusing the session authentication fallback. ### Details The mail settings are used here as an example. Admin side: https://github.com/baserproject/basercms/blob/master/plugins/baser-core/config/permission.php#L100 With auth => false, it is not accessible with operator privileges. API side: https://github.com/baserproject/basercms/blob/master/plugins/baser-core/config/permission.php#L286 With auth => true, it is accessible even with operator privileges. --- First, the default group for operators has auth_prefix = 'Admin', which does not include Api/Admin. https://github.com/baserproject/basercms/blob/master/plugins/baser-core/src/Model/Table/UsersTable.php#L389 Because of this condition, whe…

Security Severity: High CVE-2026-62955 GHSA-2PJ4-V76F-WJVX

baserCMS: Path Traversal Bypass via realpath() in BcThemeFileService (CVE-2026-30940 Patch Bypass)

GitHub Advisories

### Summary The security patch introduced in baserCMS 5.2.3 to address CVE-2026-30940 / [GHSA-c5c6-37vq-pjcq](https://github.com/baserproject/basercms/security/advisories/GHSA-c5c6-37vq-pjcq) is **incomplete**. The patch added a realpath()-based directory traversal check in BcThemeFileService::getFullpath(), but the check is **entirely skipped** when realpath($baseDir) returns false — which occurs whenever the target subdirectory does not physically exist on disk. An authenticated administrator can bypass the patch by supplying a type value (e.g., js) that maps to a non-existent directory in the theme. The absence of the directory causes realpath() to return false, the validation block is skipped, and the raw path parameter containing ../ sequences is returned unvalida…

Security Severity: Medium CVE-2026-77382 GHSA-25RM-9WVM-M38V

falcon-rust: Discrete-Gaussian sampler runs at 2^-33 precision, far below Falcon's requirement (reference KAT vectors no longer pass)

GitHub Advisories

**Reporter:** Connor Webber **Package:** falcon-rust (crates.io), repository github.com/aszepieniec/falcon-rust **Affected:** v0.1.3 and the current master (HEAD cfa1b35). Regression introduced in commit bf2cf00. **Component:** discrete-Gaussian sampler, src/samplerz.rs (approx_exp, ber_exp, sampler_z) **Status:** Confirmed by source review and by empirical measurement of the crate's own compiled code. ## Summary falcon-rust's discrete-Gaussian rejection sampler evaluates its exp() acceptance step at only 32 bits of fractional precision. Measured directly against the crate's own compiled code, approx_exp has a maximum relative error of 2^-33. For comparison, the Falcon reference implementation achieves about 2^-63, and the f64 code this crate replaced achieved about…

Security Severity: Medium CVE-2026-77378 GHSA-R7H9-QX4H-77J5

Bolt ListFormatHelper SQL injection

GitHub Advisories

### Impact SQL Injection in ListFormatHelper allows authenticated users with the upload permission to execute arbitrary SQL queries and exfiltrate sensitive database contents through the /async/select-options endpoint when general/caching/list_format is enabled. ### Patches This has been patched in Bolt 6.1.4.

Security Severity: Medium CVE-2026-77380 GHSA-3XJF-9Q55-VXW4

Bolt: Prevent SSRF due to unchecked followed redirects

GitHub Advisories

### Impact The /bolt/async/upload-url and /bolt/async/embed endpoints validated only the **submitted** URL before fetching it server-side, but the fetch then **followed redirects to destinations that were never re-validated**. This allowed an authenticated user to bypass the SSRF guard (UrlSafetyChecker) and make the server issue requests to internal/cloud-metadata addresses. ### Patches This issue has been patched with Bolt 6.1.5.

Security Severity: Medium CVE-2026-77379 GHSA-6358-JG5P-HMJJ

Bolt: Information disclosure through unfiltered public relation API endpoint

GitHub Advisories

### Impact A missing access-control filter in the public Relation API allowed unauthenticated users to discover metadata about unpublished, draft, and viewless content through REST and GraphQL endpoints. ### Patches This has been patched in Bolt 6.1.4.

Security Severity: Medium CVE-2026-77377 GHSA-2535-J2PQ-QQ4R

Bolt: Server-Side Request Forgery (SSRF) in URL-upload and embed endpoints

GitHub Advisories

### Impact Two authenticated backend endpoints fetched a user-supplied URL server-side with no protection against internal targets. ### Patches This has been patched in Bolt 6.1.4.

Security Severity: Medium CVE-2026-77376 GHSA-XR6G-7G83-J865

Bolt: Open redirect enables post-authentication redirection to arbitrary domains

GitHub Advisories

### Impact Open redirect vulnerabilities in LoginFormAuthenticator allow attackers to redirect users to attacker-controlled domains after login success or login failure, enabling phishing attacks and potential token theft. ### Patches This has been patched in Bolt 6.1.4.

Security Severity: Critical CVE-2026-77369 GHSA-WJ7X-58C2-5793

Daptin: Broken Access Control (IDOR) in the generic YJS collaboration endpoint

GitHub Advisories

### Summary Daptin registers a generic WebSocket endpoint, GET /yjs/:documentName, for real-time collaborative document editing (YJS/CRDT). Unlike its purpose-built sibling route, this generic endpoint performs no per-resource authorization check - it only verifies that *some* user session exists. Because the document store parses :documentName as typename.referenceId.columnName and fetches that row's real column content unconditionally, any authenticated user (including a brand-new, zero-privilege, self-registered account) can read - and, since YJS sync is bidirectional, also write - the content of any file.*-typed column on any row of any table, including tables that are admin-only by default. ### Details InitializeYjsResources (server/endpoint_yjs.go) registers two routes.…

Security Severity: Critical CVE-2026-77367 GHSA-HQ2P-F2VJ-V3CM

Daptin: Unauthenticated SQL Injection via the `sort` query parameter on every entity list endpoint

GitHub Advisories

### Summary An unauthenticated attacker can inject arbitrary SQL through the sort query parameter accepted by Daptin's generic entity list endpoint (GET /api/), which every table in a Daptin instance exposes. The parameter is concatenated into raw SQL identifiers with no validation that the referenced column exists, unlike a sibling code path in the same file that received exactly this validation as the fix for a previously published advisory ([GHSA-rw2c-8rfq-gwfv](https://github.com/daptin/daptin/security/advisories/GHSA-rw2c-8rfq-gwfv)). Impact ranges from unauthenticated denial of service (a single crafted request 500s the query) to blind/error-based extraction of data from tables the requester has no permission to read. ### Details PaginatedFindAllWithoutFilters in `server/resou…

Security Severity: Critical CVE-2026-77359 GHSA-9X8X-CRJQ-G64H

Jupyter MCP Server: Browser DNS rebinding can hijack the Jupyter backend through management routes

GitHub Advisories

Standalone streamable-http mode in datalayer/jupyter-mcp-server rejects forged Host and Origin headers on /mcp, but custom management routes mounted on the same application do not get the same browser-origin protection. A malicious website can keep an attacker origin while its hostname resolves to 127.0.0.1 or a private target address, then send PUT /api/connect to replace the MCP server's active Jupyter backend. The route accepts the browser-shaped request and makes the server start a kernel client against attacker-controlled infrastructure. The protected /mcp endpoint shows the intended browser-origin boundary. With MCP_TOKEN configured, /mcp rejects forged browser headers: ```text POST /mcp with Authorization: Bearer SCAN_MCP_TOKEN Host: attacker.example:8142 Origin…

Security Severity: High CVE-2026-77318 GHSA-24PW-RF5P-MGP7

Jupyter MCP Server: Unauthenticated management routes can hijack the Jupyter backend in standalone HTTP mode

GitHub Advisories

Standalone streamable-http mode in datalayer/jupyter-mcp-server requires MCP_TOKEN for /mcp, but the custom management routes mounted on the same application do not enforce that token. An unauthenticated network caller can invoke PUT /api/connect, choose the Jupyter backend URL and token fields, reset the server context, and make the MCP server start a kernel client against attacker-controlled infrastructure. The same missing authentication affects the state-changing DELETE /api/stop route. The intended authentication boundary is documented in the security guide and enforced during startup: ```text docs/docs/reference/security/index.mdx:15 All MCP endpoints require Bearer token authentication. docs/docs/reference/security/index.mdx:25 Starting with version 1.0.0, MCP client au…

Security Severity: High CVE-2026-77316 GHSA-6PM8-6F34-9V3G

Flyto2 Core: SSRF guard bypass via DNS rebinding (validate_url_ssrf resolves-then-connects without pinning)

GitHub Advisories

# [MEDIUM] SSRF guard bypass via DNS rebinding — validate_url_ssrf resolves-then-connects without pinning - **CWE:** CWE-918 (SSRF) / CWE-367 (TOCTOU). - **CVSS v3.1:** AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:L/A:N = **6.8 Medium** (AC:H — needs attacker-controlled DNS with a low/zero TTL and to flip the answer between the guard's lookup and the connection's lookup; S:C — reaches internal/metadata services the guard is meant to block; C:H — e.g. cloud metadata credentials at 169.254.169.254). - **Affected component:** flyto-core (PyPI flyto-core), HEAD ae2b38e (v2.26.7). src/core/utils.py::validate_url_ssrf (resolution at getaddrinfo ~L512, is_private_ip check ~L515) and every consumer: guarded_aiohttp_request(), enforce_outbound_url()/validate_url_with_env_config() — i.e. `http…

Security Severity: High CVE-2026-77315 GHSA-2MR3-RXRQ-238C

Flyto2 Core: http.paginate follows server-supplied next-page URLs (Link header / cursor) without SSRF revalidation

GitHub Advisories

## Summary http.paginate validates only the initial base_url, then follows server-supplied pagination targets (RFC 5988 Link: rel="next" headers, cursor/offset URLs) in a loop **without revalidating each follow-up URL**. An attacker's first-page response can point next at an internal address, causing a second-order SSRF whose internal body is aggregated into the returned items. ## Root Cause src/core/modules/atomic/http/paginate.py:495 validates base_url (first URL only). The pagination loop _paginate_link_header reads next_url via _parse_link_header (:203), sets url=next_url (:208), and calls session.request(method, url) (:196) with NO validate call in the loop (:186-208 has zero guard calls). ## Impact Readable second-order SSRF that bypasses the SSRF control; inte…

Security Severity: High CVE-2026-77313 GHSA-PFG2-W999-497V

Flyto2 Core: SSRF guard validates the resolved IP but connects by hostname, allowing DNS-rebinding TOCTOU

GitHub Advisories

## Summary validate_url_ssrf resolves the hostname, checks the IP against private ranges, then **discards the IP and returns the hostname URL string**. aiohttp performs a fresh, independent DNS resolution at connect time. An attacker controlling DNS for a hostname (TTL 0, alternating public IP and internal IP) passes validation on the first lookup and connects to the internal IP on the second — a classic check-then-use race. SECURITY_SSRF.md line 63 explicitly claims DNS-rebinding is prevented; it is not. ## Root Cause src/core/utils.py:523 returns the hostname URL after validation; the resolved IP is never pinned. A repo grep of http/ and utils.py for TCPConnector / resolver / response.history / on_request_redirect / IP-pinning returns NONE. Each module builds a fresh `Cl…

Security Severity: Critical CVE-2026-77312 GHSA-P34X-FMPH-9FJX

Flyto2 Core: Arbitrary file write via unguarded data.*/file.* modules (incomplete fix of CVE-2026-67429)

GitHub Advisories

# [CRITICAL] Arbitrary file write via unguarded data.* / file.* write modules — incomplete fix of GHSA-2956 - **CWE:** CWE-22 (Path Traversal) / CWE-73 (External Control of File Name or Path); impact reaches CWE-94 (code execution via file overwrite). - **CVSS v3.1:** AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H = **9.3 Critical** (S:C because a write escapes the intended sandbox confinement into the host filesystem / other components). - AV:N — reachable via the MCP server / recipe engine (execute_module). AC:L — deterministic. PR:L — any client able to run a module/recipe (the same attacker model as GHSA-2956; unauthenticated on the HTTP MCP surface per CVE-2026-55786). UI:N. S:C — escapes FLYTO_SANDBOX_DIR. C/I/A:H — arbitrary-content write to any absolute path → overwrite app code /…

Security Severity: High CVE-2026-59988 GHSA-86MF-Q4H5-69GP

django-docutils unsafe Docutils defaults allow local file disclosure, SSRF, and stored XSS

GitHub Advisories

## Summary django-docutils before 0.30.0 rendered reStructuredText through Docutils without protected web-safe defaults. Public rendering paths, including publish_doctree, publish_html_from_source, publish_html_from_doctree, publish_parts_from_doctree, the {% rst %} template tag, the rst template filter, DocutilsTemplates, and DocutilsView, could process attacker-controlled RST with Docutils directives that read local files, fetch URL-backed content, or emit raw HTML. The issue is fixed in 0.30.0 by disabling Docutils file insertion, raw directives, local docutils.conf processing, and unsafe URI schemes by default, and by sanitizing doctrees before HTML is emitted. Applications are affected when they render attacker-controlled or lower-trust RST through django-docuti…

Security Severity: High CVE-2026-63415 GHSA-C3CJ-3P6P-J822

Jane: $ref resolution performs SSRF + LFI (path traversal) at code-generation time (jane-php)

GitHub Advisories

### Summary jane-php resolves external $ref targets at code-generation time via file_get_contents($ref) (jane-php/json-schema-runtime/Reference.php::doResolve) with no scheme/path restriction. An attacker-controlled OpenAPI document can therefore cause: $ref: 'http://attacker/x' -> SSRF (HTTP GET at gen time; response inlined = RFI); $ref: '/abs/file' -> LFI; $ref: '../secret.yaml' -> path-traversal LFI (CWE-22, arbitrary local JSON/YAML read). Verified 7.11.2/PHP8.1 (listener records the fetch; remote + ../ local content inlined into the generated code). file:// rejected. CWE-918/CWE-98/CWE-611/CWE-22. ### Details ``php // Reference.php::doResolve() $contents = file_get_contents($fragment); // $fragment = attacker-controlled $ref URI `` ### Impact Generating PHP with jane…

Security Severity: Critical CVE-2026-63344 GHSA-P32V-8V8J-J534

Refitter allows arbitrary code execution through unescaped OpenAPI content-type values

GitHub Advisories

### Summary Refitter emits the spec's content-type key (content map key in requestBody/responses) verbatim into a Refit [Headers("Accept: ", "Content-Type: ")] attribute string without escaping ". A crafted value survives Refitter's default OpenAPI validation, breaks out of the attribute and the enclosing interface + namespace, injects a top-level file class with a [ModuleInitializer] method, and reopens so the file stays valid. .NET runs [ModuleInitializer] methods at assembly load, so the attacker's code executes at application startup. Verified on Refitter 2.0.0 / .NET 8. The malicious input is a content-type KEY such as: content: { 'application/': {schema} }. No --skip-validation is required. ### PoC reproduce.sh (+ make_spec.py) attached: generates with default valida…

Security Severity: Critical CVE-2026-63346 GHSA-58X9-VJVP-6MX8

Refitter allows code execution through unescaped OpenAPI header parameter names

GitHub Advisories

### Summary Refitter emits the spec's header parameter name (parameters[].name with in: header) verbatim into a Refit [Header("")] attribute string without escaping ". A crafted value survives Refitter's default OpenAPI validation, breaks out of the attribute and the enclosing interface + namespace, injects a top-level file class with a [ModuleInitializer] method, and reopens so the file stays valid. .NET runs [ModuleInitializer] methods at assembly load, so the attacker's code executes at application startup. Verified on Refitter 2.0.0 / .NET 8. Notable: the breakout starts from a PARAMETER-LIST position (it closes the params and method first). The malicious input is a header parameter name. No --skip-validation is required. The query AliasAs and value sinks (enum, default)…

Security Severity: Critical CVE-2026-63345 GHSA-3FHM-P725-H3G3

Refitter allows arbitrary code execution through unescaped OpenAPI paths

GitHub Advisories

### Summary Refitter emits each OpenAPI path (the paths-object key) verbatim into a Refit [Get("")] attribute string, without escaping " or restricting characters. A crafted single-line, /-prefixed path survives Refitter's default OpenAPI validation yet closes the attribute string and the enclosing interface + namespace, injects a top-level file class with a [ModuleInitializer] method, and reopens a namespace + interface so the file stays valid. .NET runs [ModuleInitializer] methods when the generated assembly is loaded, so the attacker's code executes at application startup. Verified on Refitter 2.0.0 / .NET 8. ### Details ``` [Get("/p")] Task Dummy(); } } file class Evil { [System.Runtime.CompilerServices.ModuleInitializer] internal static void Init(){ /* attacker code */ } }…

Security Severity: Medium CVE-2026-58208 GHSA-P957-7V2W-G93G

NATS Server: MQTT-over-WebSocket Path Can Crash WebSocket-Only JetStream Servers Before MQTT Is Enabled

GitHub Advisories

### Background NATS.io is a high performance open source pub-sub distributed communication technology, built for the cloud, on-premise, IoT and edge computing. The NATS Server can accept client connections over WebSocket and can also support MQTT over WebSocket when MQTT is configured. ### Problem Description A WebSocket listener could route requests for the MQTT-over-WebSocket path into MQTT handling even when MQTT was not configured. On affected deployments, an unauthenticated client with access to the WebSocket listener could reach uninitialized MQTT state and crash the server process. This affects deployments that enable WebSocket while leaving MQTT disabled. Deployments where MQTT is intentionally configured initialize the MQTT state and are not affected in the same way. ### Affected…

Security Severity: High CVE-2026-58210 GHSA-R72H-J7QQ-V6QG

NATS Server allows unauthenticated memory exhaustion through incomplete MQTT CONNECT packets

GitHub Advisories

### Background NATS.io is a high performance open source pub-sub distributed communication technology, built for the cloud, on-premise, IoT and edge computing. The NATS Server supports MQTT clients, including authentication and parsing of MQTT CONNECT packets. ### Problem Description An unauthenticated MQTT client could cause the server to retain large incomplete MQTT CONNECT packets before authentication completed. The parser retained partial pre-authentication packet data while waiting for the advertised MQTT packet length to be completed. An attacker could therefore consume server memory until authentication timeouts closed the connections. ### Affected Versions Versions v2.14.2, v2.12.11 and below are vulnerable. The issue is fixed in v2.14.3 and v2.12.12. ### Workarounds Deployme…

Security Severity: Medium CVE-2026-58209 GHSA-7QMQ-8CC4-HXWG

NATS Server MQTT retained messages and QoS replay bypass subscription deny rules

GitHub Advisories

### Background NATS.io is a high performance open source pub-sub distributed communication technology, built for the cloud, on-premise, IoT and edge computing. The NATS Server MQTT support includes retained messages and QoS1+ durable delivery. NATS subscription permissions can allow broad wildcard subscriptions while denying more sensitive subjects. ### Problem Description MQTT retained message delivery and QoS1+ durable replay could deliver messages whose original topics matched a subscriber's configured subscribe deny rules. Normal live delivery applied the delivery-time deny check. These MQTT delivery paths did not consistently recheck the concrete original topic before sending the MQTT PUBLISH to the subscriber. The issue affects MQTT subscribers with broad wildcard subscribe permis…

Security Severity: Medium CVE-2026-62337 GHSA-X26X-7F4V-CQX7

snark-verifier: Halo 2 aggregation circuit mishandles point-at-infinity proof elements

GitHub Advisories

### Summary The Halo 2 aggregation circuit could mishandle proof elements encoded as the point at infinity. When an assigned proof point appeared in an MSM term with constant scalar one, the Halo 2 loader used a scalar-one shortcut that passed the assigned point directly into the EC sum helper. The EC sum implementation used by that path assumed its inputs were non-identity points, while assigned proof points could represent the encoded identity (0, 0). ### Details EcPointLoader::multi_scalar_multiplication partitions MSM terms by scalar and base type. For (Value::Constant(ONE), Value::Assigned(_)), the loader placed the assigned base into the non-scaled variable-base list and later passed those points to sum_with_const. The default Halo 2 shim delegates sum_with_const to halo2-…

Security Severity: High CVE-2026-128135 GHSA-WR3G-J6QJ-XPGH

NLTK: ZIP package extraction follows in-root hardlinks and overwrites files outside the NLTK data root

GitHub Advisories

## Summary NLTK ships a security wrapper, nltk.pathsec.ZipFile, that is meant to confine archive extraction to trusted data roots and to block link-based escapes. When nltk.download() installs a package, the extraction write opens each member's target path without checking whether that path is a hardlink to a file located outside the data root. A local actor who can write inside a shared or predictable NLTK data root (for example ~/nltk_data, a group-writable /usr/share/nltk_data, or a shared container volume) can pre-plant an in-root hardlink at a member path that a soon-to-be-installed package will write. When the victim later runs the download, extraction truncates and overwrites the outside-root target through that hardlink. This is the same weakness class as the previously fi…

Security Severity: Medium CVE-2026-128136 GHSA-C59X-VH6J-3W8V

NLTK: AllowlistUnpickler does not deny numpy submodule-local file-I/O sinks

GitHub Advisories

### Summary nltk.picklesec.allowlisted_pickle_load keyed its denylist of dangerous globals by export name, so numpy's file-I/O callables that live in submodules and are not re-exported under __module__ == "numpy" were never matched. Under the broad allowed_modules=("numpy", "scipy", "sklearn") allowance that TransitionParser.parse(depgraphs, modelFile) granted for model files, a crafted protocol 4 pickle could name numpy.lib._npyio_impl.recfromtxt (arbitrary file read, result returned to the caller of allowlisted_pickle_load) or numpy.lib.format.open_memmap (attacker-chosen file create), and the REDUCE opcode invoked them during the load. ### Affected nltk >= 3.10.0 and

Security Severity: Medium CVE-2026-128137 GHSA-G58V-J9G9-5GFG

NLTK corpus-reader view methods bypass the scoped root sandbox via intermediate-directory symlinks

GitHub Advisories

> **affected**: PyPI nltk >= 3.9.4 — CorpusReader.abspaths()/abspath() and the PlaintextCorpusReader / SyntaxCorpusReader view methods > **dynamically reproduced**: nltk 3.9.4 (8/9, scoped-escape checks), 3.10.3 (wheel, 9/9 checks) and master 6818767b9 (9/9 checks) --- _Source references (file:line) are to commit 303f6e2b (release tag v3.10.3). Line numbers in the released nltk wheel match this tag exactly; master 6818767b9 contains the same code (pathsec.py renumbered by +44 lines from added hardening comments). In 3.9.4 the same logic exists at earlier line numbers (api.py:222-236 for open(), api.py:161-203 for abspath()/abspaths(), data.py:382-388 for the pointer open, pathsec.py:105-114 for the scoped branch); the affected code is iden…

Security Severity: Critical CVE-2026-128138 GHSA-X8Q7-6C7M-52GW

NLTK incomplete fix: additional JVM/JAR sandbox bypass through unvalidated launcher tokens in java() command arguments

GitHub Advisories

## Summary NLTK 3.10.3 contains security hardening intended to close JVM argument-injection and untrusted JAR/classpath execution paths in nltk.internals.java(), including the issue published as GHSA-m4rf-3fr8-xwx3. The patched options channel correctly rejects Java argument-file references such as @/path/to/args and launcher modes such as -jar. However, an additional argument channel remains: the caller-provided cmd sequence is appended to the Java command after the validated option and classpath channels, without enforcing that its first item is a Java main-class name. I am reporting this as an additional post-fix bypass / incomplete-fix path affecting the 3.10.3 remediation, rather than as an unrelated vulnerability family. As a result, the same launcher token that is rejecte…

Security Severity: High CVE-2026-128139 GHSA-J8G8-J4J7-8J54

NLTK: XMLCorpusView comment and CDATA parsing permits quadratic CPU denial of service

GitHub Advisories

> **affected**: PyPI nltk >= 3.6 — nltk.corpus.reader.xmldocs.XMLCorpusView streaming read (and the nps_chat / framenet readers built on it) > **dynamically reproduced**: 3.6 (6/6 checks), 3.9.2 (6/6), 3.10.3 (6/6) and develop 6818767b9 (6/6) --- _Source references (nltk/corpus/reader/xmldocs.py:NNN) are to commit 6818767b99c24659107eb2be9bccd32a3d4bf045 (develop, v3.10.3-15-g6818767b9). The released v3.10.3 wheel's xmldocs.py is byte-identical to that commit, so the same line numbers apply to the released wheel._ ### Summary **An attacker who can make a victim read a well-formed XML corpus file whose body contains one large comment or CDATA section can pin a CPU core for a time quadratic in the file size, because XMLCorpusView._read_xml_fragment (`nltk/c…

Security Severity: Medium CVE-2026-128140 GHSA-PCM8-FQJX-RVX8

NLTK: Downloader cyclic collection indices cause an infinite closure walk

GitHub Advisories

> **affected**: PyPI nltk >= 3.6.7 — nltk.downloader index parsing (Downloader._update_index) > **dynamically reproduced**: nltk 3.6.7 (4/4 checks), 3.9.2 (4/4), 3.10.3 (4/4), and develop 6818767b9 (4/4) --- _Source references (nltk/downloader.py:NNN) are to commit 6818767b9 (develop, v3.10.3-15-g6818767b9). The v3.10.3 tag and the released 3.10.3 wheel carry the identical code at the identical line numbers (the vulnerable closure BFS sits at downloader.py:1300-1310). Dynamically verified wheels additionally show the same defect at downloader.py:972 (3.9.2) and downloader.py:987 (3.6.7)._ ### Summary Downloader._update_index (nltk/downloader.py:1253-1313) is the mandatory first step of every downloader operation (download(), info(), `packa…

Security Severity: Medium CVE-2026-129221 GHSA-9FFX-RRGX-MHGX

NLTK: ARFF_Formatter Injects Weka ARFF Schema Directives via Attacker-Controlled Class Labels

GitHub Advisories

## Description ### Summary nltk.classify.weka.ARFF_Formatter writes class labels directly into the Weka ARFF @ATTRIBUTE '-label-' {...} declaration without any ARFF quoting or escaping. An attacker who can contribute class labels to a training dataset can include ARFF metacharacters such as }, newlines, @ATTRIBUTE, and @DATA to break out of the nominal label list and inject attacker‑controlled ARFF schema and data directives. This vulnerability is reachable in any application that calls WekaClassifier.train() or ARFF_Formatter.from_train() with attacker‑influenced training data. The victim does not need to manually edit the ARFF file; the normal training workflow writes the malformed ARFF automatically. ### Technical Details The vulnerable code path is: 1. `WekaClassifier.tr…

Security Severity: High CVE-2026-129222 GHSA-RH8M-WQHC-QMRF

Natural Language Toolkit (NLTK): Uncontrolled recursion (crash DoS) in DependencyGraph.tree()/triples()

GitHub Advisories

### Summary DependencyGraph.tree()/triples() walk the parsed dependency structure using plain, unbounded Python recursion — one stack frame per edge in the graph — and never use the class's own cycle detector. A crafted dependency-parse file with a few thousand chained tokens (an entirely ordinary-looking long sentence) crashes the process with an unhandled RecursionError the moment .tree() or .triples() is called — which is NLTK's own documented usage pattern immediately after loading such a file. ### Details DependencyGraph._tree() (~lines 393-406), .tree() (~408-417), and .triples() (~419-432) in nltk/parse/dependencygraph.py rebuild/walk the graph with Tree(word, [self._tree(dep) for dep in deps]) and yield from self.triples(node=dep) — ordinary recursive calls, one per ed…

Security Severity: High CVE-2026-129223 GHSA-8846-P9W9-5FRF

Natural Language Toolkit (NLTK): Uncontrolled recursion (crash DoS) in Synset.tree()/acyclic_tree() via WordNet relation traversal

GitHub Advisories

### Summary The recursive traversal engines behind WordNetCorpusReader's Synset.tree() and Synset.acyclic_tree() have no maximum call-depth safeguard and default to unlimited depth. They guard against literal cycles, but not against a long, genuinely acyclic relation chain — which exhausts the Python call stack the same way as the sibling DependencyGraph finding I reported separately. Real-world exploitability requires the host application to load a custom/foreign WordNet-format lexical resource rather than NLTK's bundled default corpus — flagging that narrower scope honestly up front since it affects severity, not validity. ### Details nltk/util.py's acyclic_depth_first() (~lines 471-541) and acyclic_branches_depth_first() (~lines 544-625) recurse once per graph edge, default to `d…

Security Severity: Medium CVE-2026-129224 GHSA-3H95-X772-4765

NLTK: Uncontrolled recursion in CCG lexicon parser causes denial of service via deeply nested category input

GitHub Advisories

## Root Cause The CCG lexicon parser recurses on nested parenthesised categories without any depth bound. matchBrackets (nltk/ccg/lexicon.py:154) calls itself once per nested (, and augParseCategory (nltk/ccg/lexicon.py:228,242) recurses once per bracketed sub-category. Neither function tracks recursion depth nor checks sys.getrecursionlimit(), and the public entry point fromstring (nltk/ccg/lexicon.py:252, also re-exported via nltk.ccg.chart.fromstring) applies no length or nesting cap before handing the text to the parser. ## Impact An application that parses an untrusted lexicon string aborts with an unhandled RecursionError, terminating the affected parse operation or request worker (denial of service, CWE-674). The recursion is pure Python, so CPython raises a cat…

Security Severity: Medium CVE-2026-129225 GHSA-XFCV-M889-FMQG

NLTK: Uncontrolled recursion in DependencyGraph traversal causes denial of service via deep dependency chains

GitHub Advisories

## Root Cause The dependency-graph traversal helpers recurse over dependency links without any depth bound or visited set. DependencyGraph._tree (nltk/parse/dependencygraph.py:404) recurses once per dependency link, triples (nltk/parse/dependencygraph.py:432) is a recursive generator, and get_cycle_path (nltk/parse/dependencygraph.py:520) recurses over dependencies. The neighbouring contains_cycle method was deliberately rewritten as an iterative depth-first search, but these sibling helpers on the public traversal path were left recursive with no depth counter. ## Impact An application that parses an untrusted CoNLL/Malt-TAB dependency structure and then walks it via tree() or triples() aborts with an unhandled RecursionError, terminating the affected operation or req…

Security Severity: Medium CVE-2026-129226 GHSA-W3PV-XFW4-GHR7

NLTK: Uncontrolled recursion in semantic-logic type parser causes denial of service via nested type strings

GitHub Advisories

## Root Cause The semantic-logic type parser read_type (nltk/sem/logic.py:866) recurses on both halves of every `` complex type (nltk/sem/logic.py:882-884) with no depth or length bound — only an isinstance assertion and a parenthesis-balance assertion. The LogicParser.MAX_PARSE_DEPTH guard (nltk/sem/logic.py:107,294) protects the expression parser but never runs on the read_type path, which is reached directly by the public Type.fromstring classmethod and by signature-string type checking. ## Impact An application that parses an untrusted type string, or type-checks an expression against an attacker-influenced signature, aborts with an unhandled RecursionError, terminating the affected operation or request worker (denial of service, CWE-674). The recursion is pure Pytho…

Security Severity: Medium CVE-2026-129227 GHSA-63WH-5R5M-WXR7

NLTK: Uncontrolled recursion in Tree.fromlist causes denial of service via deeply nested list input

GitHub Advisories

## Root Cause Tree.fromlist (nltk/tree/tree.py:767) converts a nested list into a Tree by recursing once per nesting level (nltk/tree/tree.py:780) with no depth bound — its only validation is type(l) == list and len(l) > 0. The sibling constructor Tree.fromstring was hardened with a MAX_TREE_DEPTH cap (nltk/tree/tree.py:31,695) that rejects adversarially deep input with a bounded ValueError, but that guard was not applied to fromlist, which builds Tree objects identically. ## Impact An application that builds a Tree from an attacker-controlled nested list — for example Tree.fromlist(json.loads(untrusted)) — aborts with an unhandled RecursionError, terminating the affected operation or request worker (denial of service, CWE-674). Any later recursive traversal of…

Security Severity: Medium CVE-2026-129228 GHSA-F2H2-F4FC-P978

NLTK: Uncontrolled recursion in Toolbox settings helpers causes denial of service via deeply nested input

GitHub Advisories

## Root Cause The Toolbox settings-tree helpers recurse over the parsed element tree without any depth bound. _to_settings_string (nltk/toolbox.py:418), remove_blanks (nltk/toolbox.py:432), add_default_fields (nltk/toolbox.py:451), _sort_fields (nltk/toolbox.py:484), and add_blank_lines (nltk/toolbox.py:502,516) each recurse once per element level with no depth counter or explicit stack. The producer ToolboxSettings.parse builds the element tree iteratively, so nesting depth is driven entirely by attacker-supplied \+marker / \-marker pairs. ## Impact An application that parses an untrusted Toolbox settings file and then serialises or transforms it through any of the public helper functions aborts with an unhandled RecursionError, terminating the affected operat…

Security Severity: High CVE-2026-129229 GHSA-32P6-CWHC-8R78

NLTK: Compile-time regex DoS in NLTK search/tokenizer sinks: quadratic regex-engine compile bypasses the match-only timeout

GitHub Advisories

## Summary NLTK exposes a compile-time regular-expression denial of service in its regex-search helpers. When an application passes untrusted text as the search pattern to TokenSearcher.findall() / Text.findall(), or as the tokenizer pattern to RegexpTokenizer, the pattern is handed to the third-party regex engine, whose compilation cost is roughly quadratic in the number of capturing groups. A short pattern of the form () repeated many times (for example "()" * 25000, about 50 KB) forces tens of seconds of synchronous CPU work before any match begins. The wall-clock timeout that NLTK added to guard matching does not apply during compilation, so a single small request pins a CPU core, and repeated or concurrent requests exhaust all cores and deny service. ## Root Cause The rem…

Security Severity: Medium CVE-2026-129230 GHSA-53PG-5QP8-MHVR

NLTK: Uncontrolled recursion in WordNet Synset hypernym walkers (max_depth/min_depth/hypernym_paths/hypernym_distances) causes DoS

GitHub Advisories

## Summary Four hypernym-walking methods on the WordNet Synset class in nltk/corpus/reader/wordnet.py (max_depth, min_depth, hypernym_paths, and hypernym_distances) traverse the hypernym pointer graph by direct recursion with no visited-node set and no depth cap. WordNet data. file content is untrusted corpus input in NLTK, the same trust boundary the project already treats as attacker-controlled across its corpus-content hardening work. When the parsed hypernym graph contains a cycle, or a chain deeper than the interpreter recursion limit, these methods recurse without bound and raise an uncaught RecursionError, aborting the traversal and any worker that does not catch it. No special privileges are needed; the victim only has to load an attacker-supplied corpus and call a…

Security Severity: Medium CVE-2026-129231 GHSA-Q4C8-9GWF-255X

NLTK: Quadratic-time DoS in SeekableUnicodeStreamReader.readline on an unterminated corpus line via per-iteration full-buffer rescan

GitHub Advisories

## Summary SeekableUnicodeStreamReader.readline in nltk/data.py assembles a line by repeatedly reading a block, appending it to a growing chars buffer, and recomputing chars.splitlines(True) over the entire buffer on every loop iteration. The read block size doubles only until it caps at 8000 characters, so for a single unterminated line of N characters the loop runs about N/8000 iterations and iteration k re-scans roughly 8000*k characters, giving O(N^2) total work. The default size=None used on the line-oriented corpus-reader read path means the early break never fires before end of file. An attacker who supplies a corpus file containing one very long line with no newline can force quadratic CPU consumption in the reader's process. This is the same growing-buffer re-scan algor…

Security Severity: Medium CVE-2026-129232 GHSA-CJ8F-5FP3-6M88

NLTK: Quadratic CPU exhaustion in NLTK XMLCorpusView.read_block via deeply nested XML corpus tags

GitHub Advisories

## Summary NLTK's XMLCorpusView.read_block rebuilds the full root-to-node context path with "/".join(context) on every start tag while it is still searching for a matching element. Because the context stack grows with XML nesting depth and the join is repeated once per start tag, a single corpus file containing deeply nested tags forces O(n^2) pure-Python work, where n is the number of nested elements. Any application that parses attacker-influenced XML corpus data through an XMLCorpusView subclass (for example the nps_chat, framenet, bnc, mte, nkjp, or semcor readers) can be driven to exhaust a CPU core for an extended period, producing a denial of service without any authentication or special privilege. ## Root Cause read_block maintains a context list that is appe…

Security Severity: Medium CVE-2026-129233 GHSA-W674-VQHW-G3PG

NLTK: StreamBackedCorpusView constructor os.stat leaks out-of-root file existence, size, and mtime bypassing pathsec ENFORCE

GitHub Advisories

## Summary StreamBackedCorpusView, a public API in nltk/corpus/reader/util.py, applies the pathsec sandbox to the file content it reads but not to the file metadata it probes in its constructor. When the view is created with a plain string fileid, __init__ calls os.stat(self._fileid).st_size with no pathsec validation, so an application that passes an attacker influenced path to the constructor discloses whether an arbitrary out of root file exists and, if it does, its exact byte size and modification time, even when nltk.pathsec.ENFORCE is True. This is the residual metadata channel left open by the fix for CVE-2026-63312 (GHSA-x5ph-mj9p-rfr8), which closed arbitrary content read on the same code path but did not bring the sibling os.stat under the sandbox. ## Root Cause Th…

Security Severity: High CVE-2026-129234 GHSA-CC5R-64RF-75HG

NLTK: Untrusted search path in prover9/mace4 config allows local code execution via relative binary_location

GitHub Advisories

## Summary Prover9Parent.config_prover9(binary_location=...) (and Mace, which inherits it) accepts a relative binary_location and passes it as path_to_bin to find_binary, which disables the CWD-relative rejection guard. Unlike the boxer/senna/malt/repp siblings, prover9/mace apply no os.path.isabs() filter, so the resolved relative program path (e.g. ./prover9) is executed from the current working directory via subprocess.Popen. A local attacker who can plant ./prover9 (or ./mace4) in the resolved directory achieves local code execution. ## Root Cause nltk/inference/prover9.py:121-135 calls find_binary(name, path_to_bin=binary_location, env_vars=["PROVER9"], ...). A truthy path_to_bin sets searching_bare_name = not path_to_bin and ... → False (`internals.py:935…

Security Severity: Medium CVE-2026-129304 GHSA-GM9R-HVC9-96GV

Guard Core: Unvalidated X-Forwarded-For-derived string used as a Redis key component and interpolated into a KEYS glob pattern

GitHub Advisories

### Summary _extract_from_forwarded_header() (guard_core/utils.py:172-181 in 3.12.0; :179 on master 08780f1) returns the selected X-Forwarded-For entry **without any ipaddress validation**. When that entry is attacker-controlled, an arbitrary string becomes client_ip and flows into BehaviorTracker (guard_core/handlers/behavior_handler.py:83-102), which interpolates it verbatim into both a Redis key name and a KEYS glob pattern: ``python key = f"behavior:usage:{endpoint_id}:{client_ip}" await self.redis_handler.set_key("behavior_usage", f"{key}:{current_time}", "1", ttl=rule.window) pattern = f"behavior_usage:{key}:*" keys = await self.redis_handler.keys(pattern) # blocking KEYS, O(N) over keyspace `` Same shape in track_return_pattern() (`behavior_handler.py:135-14…

Security Severity: Low CVE-2026-129303 GHSA-W7WG-6Q7V-44F2

Guard Core: Whitespace-collapse preprocessing permanently disables the CRLF-anchored http-splitting and command-injection detectors in the default detection mode

GitHub Advisories

### Summary In the default "enhanced" detection mode, ContentPreprocessor.preprocess() collapses all whitespace (re.sub(r"\s+", " ", content), guard_core/detection_engine/preprocessor.py:137 on master 08780f1; :384 in the 3.12.0 sdist) **before** pattern matching. This erases every \r and \n from the scanned value, rendering two built-in detectors structurally unmatchable regardless of input: - http_split — guard_core/handlers/suspatterns_handler.py:540: r"[\r\n]\s*(?:HTTP\/[0-9.]+|Location:|Set-Cookie:)" requires a literal \r or \n, which no longer exists after preprocessing; - cmd_injection — r"\n\s*(?:bash|sh|...)\s+-c\b" — same structural death. The downstream application receives the **raw** value with CRLF intact (Starlette percent-decodes %0d%0a in query p…

Security Severity: High CVE-2026-129302 GHSA-R7HM-RJVG-XX7J

Guard Core: Quadratic ReDoS in built-in detection pattern freezes the event loop with a single request

GitHub Advisories

### Summary A polynomial (quadratic) regular-expression denial of service in guard-core's built-in penetration-detection patterns allows any unauthenticated remote client to freeze **every** endpoint of an application for seconds per request, using only the default configuration. The triggering request completes without any detection match — no ban counter increments, no rate-limit violation is recorded — so it can be repeated indefinitely. Since guard-core 3.5.0, only *custom* patterns are executed through the compiler's timeout-protected create_safe_matcher(); all built-in patterns run as a bare, inline pattern.search(content) directly on the asyncio event loop. guard-core ≤ 3.4.0 ran built-ins through the safe matcher (verified in the 3.4.0 wheel, _check_regex_pattern), so this i…

Security Severity: High CVE-2026-130007 GHSA-M932-63JC-4JQQ

k8s-mcp-server: Missing authentication on default SSE/HTTP transport allows unauthenticated Kubernetes tool execution

GitHub Advisories

## Summary When k8s-mcp-server runs in its default SSE transport mode, the MCP tools/call endpoint is dispatched with no authentication, session token, or Origin check. Any client that can reach the listening port can enumerate and invoke the server's Kubernetes tools (including destructive/write tools) without credentials, executing with the server's configured cluster privileges. ## Affected Commit be87a6dd72bb6ec1d4886b8548843b99a4638b12 (Merge PR #130) MCP library: github.com/mark3labs/mcp-go v0.57.0 Default mode: sse (SERVER_MODE default), default port 8080, bind 0.0.0.0 ## Root cause (static trace: handleSSE -> handleMessage -> tools/call) - main.go L129: server.NewSSEServer(s) is created with no auth option and no contextFunc; L130 sse.Start(":"+port) binds all interfaces (0.…

Security Severity: High CVE-2026-83816 GHSA-3MGH-93R5-R7JF

CodeWhale: exec_shell parallel-readonly classifier auto-approves fd/rg/git grep exec flags enabling silent RCE

GitHub Advisories

### Maintainer resolution The CodeWhale maintainers validated this report. CodeWhale 0.8.67 and earlier are affected. Version 0.9.0 contains the fix in commit 208421b9d23d81cea3311a1eeb2a2ea81d637686. Users should upgrade to 0.9.0 or later. The original reporter analysis is preserved below. ## Summary The interactive Agent profile of DeepSeek-TUI (CodeWhale) is explicitly documented to gate **every** shell command behind an approval prompt (config.rs:3725-3736). However, ExecShellTool::approval_requirement_for(&tool_input) downgrades the requirement from Required to Auto for any command the classifier deems "parallel read-only" (shell.rs:2314-2320). registered_tool_approval_required returns false for Auto **before** the auto_approve check runs (turn_loop.rs:37-38), so no pro…

Security Severity: High CVE-2026-83817 GHSA-8HP3-XXRG-V9C8

CodeWhale: Automation auto_approve defaults to true, bypassing the task-path hardening fix for silent recurring agent execution

GitHub Advisories

### Maintainer resolution The CodeWhale maintainers validated this report. CodeWhale 0.8.67 and earlier are affected. Version 0.9.0 contains the fix in commit 208421b9d23d81cea3311a1eeb2a2ea81d637686. Users should upgrade to 0.9.0 or later. The original reporter analysis is preserved below. ## Summary CVE-2026-45374 (GHSA-72w5-pf8h-xfp4) hardened the task path so auto-approval must be opted into explicitly: add_task uses req.auto_approve.unwrap_or(false) (task_manager.rs:868). The automation subsystem was not hardened in kind. AutomationRecord::task_auto_approve() resolves an omitted auto_approve to DEFAULT_AUTOMATION_AUTO_APPROVE = true (automation_manager.rs:29, 101-103), and enqueue_run_task builds the NewTaskRequest with `auto_approve: Some(automation.task_auto_approve()…

Security Severity: Medium CVE-2026-129307 GHSA-M4G8-47F9-H588

eml_parser: Algorithmic-complexity DoS (O(n^4) regex backtracking) in Received-header parsing

GitHub Advisories

### Summary eml_parser.routing.parserouting() dynamically builds a regex from up to four greedy .* groups (from (?P.*)by (?P.*)with (?P.*)for (?P.*)) terminated by an escaped literal of the date extracted from a **normalized** copy of the Received header. Because the date literal comes from the normalized text but is searched in the original line, a crafted header can make the trailing literal unmatchable; the search then fails at every start position only after exhaustively backtracking the four nested greedy groups — **O(n^4)** in header length. A single ~5.9 KB email pins one CPU core for ~12 seconds; doubling the input multiplies the cost ~25x, so a ~13 KB header takes minutes and a ~25 KB header effectively hangs the parse worker. ### Details Root cause: `eml_parser/routing.p…

Security Severity: High CVE-2026-95839 GHSA-VWHP-8P66-MQ4F

containerd image-triggered daemon crash via malformed digest in subject-annotated descriptor

GitHub Advisories

### Impact A bug in containerd's image manifest processing causes an unrecovered panic when a child descriptor contains the io.containerd.manifest.subject annotation and a malformed digest. Pulling or importing such an image through the transfer service (including default CRI PullImage requests) crashes the containerd daemon. In Kubernetes environments, kubelet retries failed image pulls with backoff, allowing a pod referencing an untrusted image to repeatedly crash containerd and disrupt container operations on the worker node. ### Patches This bug has been fixed in containerd 2.4.2, 2.3.7, and 2.2.10. Users should update to these versions to resolve the issue. ### Workarounds Restrict pod image references to trusted registries (for example, using a Kubernetes `ValidatingAdmissionP…

Security Severity: High CVE-2026-115563 GHSA-QX49-FQC8-XW99

Model Context Protocol Python SDK: OAuth client could send credentials to an authorization server chosen by the MCP server

GitHub Advisories

### Summary In affected versions, the SDK's OAuth client support (mcp.client.auth) let the MCP server a client connected to decide where the client's OAuth credentials were sent: - the authorization server metadata issuer was not validated on every discovery path, and - stored or pre-provisioned client credentials were not bound to the authorization server they belong to. A malicious or compromised MCP server could therefore direct them to a token endpoint of its choosing: - by naming its own authorization server in its protected resource metadata, or - by publishing none and serving metadata that presents the user's real authorization server as the issuer. It would then receive the client_secret, authorization code and PKCE code_verifier meant for that real server (or, with `Pr…

Security Severity: High CVE-2026-97698 GHSA-PHMP-HRW4-R36R

Mistune: Quadratic-time DoS in parse_link_href via unbounded parenthesis scan on empty-label links

GitHub Advisories

## Resolution **Fixed in Mistune 3.3.4.** Upgrade to 3.3.4 or later. - Affected versions: < 3.3.4 - First patched version: 3.3.4 - Fix: https://github.com/lepture/mistune/compare/v3.3.3...v3.3.4 The reported payload was reproduced against the 3.3.3 release tag and verified to scale approximately linearly against the 3.3.4 release tag. ## Original report The following report describes the issue before the fix. ## Summary parse_link_href in mistune performs an unbounded parenthesis-balancing scan that runs to end-of-document on each unmatched (. Because the empty label [] bypasses the no_close_bracket_before high-water-mark guard, a single small document of the form "[](" * N causes O(N) openers to each drive an O(N) scan, producing O(N²) CPU on the **default** `mistune.html()…

Security Severity: High CVE-2026-97699 GHSA-WW7Q-MXRJ-5FFG

Mistune: Quadratic-time DoS in inline image parsing (precedence_scan) bypasses not-is-image guards

GitHub Advisories

## Resolution **Fixed in Mistune 3.3.4.** Upgrade to 3.3.4 or later. - Affected versions: < 3.3.4 - First patched version: 3.3.4 - Fix: https://github.com/lepture/mistune/compare/v3.3.3...v3.3.4 The reported payload was reproduced against the 3.3.3 release tag and verified to scale approximately linearly against the 3.3.4 release tag. ## Original report The following report describes the issue before the fix. ## Summary mistune's inline image parsing reaches precedence_scan for ![ openers because the two guards that keep the link path linear are both gated behind not is_image. A small default-renderer document of the form "![" * N + "x" + "]" * N produces O(N²) CPU with no plugins. ## Root Cause For ![ openers, is_image is True, so both linearizing guards are skipped: `if…

Security Severity: Medium CVE-2026-107853 GHSA-HJ9C-QX2W-G7MH

tiny-secp256k1: Stale buffer after ignored wasm failure accepts invalid infinity tweak

GitHub Advisories

### Summary The three-argument xOnlyPointAddTweakCheck path ignores the wasm failure return and compares an unchanged input buffer. When the tweak result is the point at infinity, this stale-buffer comparison can return true for an invalid derivation. ### Details xOnlyPointAddTweakCheck in index.ts has two code paths. The path taken when the caller omits tweakParity discards the return value of the wasm call and compares whatever the shared input buffer holds. ```ts try { X_ONLY_PUBLIC_KEY_INPUT.set(point); X_ONLY_PUBLIC_KEY_INPUT2.set(resultToCheck); TWEAK_INPUT.set(tweak); if (hasParity) { return wasm.xOnlyPointAddTweakCheck(tweakParity) === 1; } else { wasm.xOnlyPointAddTweak(); const newKey = X_ONLY_PUBLIC_KEY_INPUT.slice( 0, validate.X_ONLY_PUBLIC_KEY_SIZE ); return compare…

Security Severity: Medium CVE-2026-121717 GHSA-7RJ6-7PQX-V7RM

fzf: Predictable FIFO path in zsh completion allows local symlink attack / arbitrary file overwrite as the victim user (_fzf_feed_fifo)

GitHub Advisories

### Summary shell/completion.zsh feeds every trigger-driven zsh completion through a FIFO at a predictable, PID-based path in shared /tmp (fzf-complete-fifo-$$), without checking the failure of rm -f/mkfifo. On a multi-user host, another local user can pre-create that path as a symlink to a victim-writable file (e.g. ~/.bashrc), causing the victim's own completion to overwrite it with the completion stream — with attacker-influenced content (e.g. via process names in ps output), escalating to code execution at the victim's next login. A pre-created plain FIFO instead leaks/blocks on the completion stream. ### Reporter / Credits: Sai Sreewathsa Kovalluri, Shon Babu and Kannan K (Researchers), Innspark Solutions https://innspark.in/ ### Details shell/completion.zsh (tag 0.74…

Security Severity: High CVE-2026-121716 GHSA-W6X2-F5M4-XW82

fzf: Arbitrary command execution via bash arithmetic expansion on unvalidated layout size in fzf-tmux (-l/-u attached value)

GitHub Advisories

### Summary bin/fzf-tmux fails to validate layout size values given in the *attached* form (e.g. -l50). For -l/-u these values reach bash arithmetic expansion ($(( max - size ))), where an operand like a[$(cmd)] executes cmd as the invoking user during option parsing — before any tmux interaction and even outside tmux. A second sink embeds unvalidated popup geometry (-x/-y/-w/-h/-p) into an unquoted tmux popup ... $opt ... invocation, allowing injection of tmux flags such as -e BASH_ENV= (command execution via non-interactive bash sourcing $BASH_ENV). ### Reporter / Credits: Sai Sreewathsa Kovalluri, Shon Babu and Kannan K (Researchers), Innspark Solutions https://innspark.in/ ### Details In bin/fzf-tmux (tag 0.74.4, commit a140afeb), the option parser validates si…

Security Severity: High CVE-2026-130008 GHSA-Q433-MP6C-8V4F

sqlite-mcp: Read-only mode bypass via statement chaining and SQL injection in describe_table

GitHub Advisories

### Summary In read-only mode (the default), a client that can call the MCP tools can write to the database the server is meant to expose read-only, read other SQLite files, and create new SQLite files anywhere the server process can write. There are two ways in: statement chaining through execute_query, and SQL injection through describe_table. ### Details - **Statement chaining in execute_query.** The only check was that the query starts with SELECT. The modernc.org/sqlite driver runs every ;-separated statement in one call, so anything after SELECT 1; ran unchecked. - **SQL injection in describe_table.** The table_name argument was interpolated into PRAGMA table_info(%s) with no guard. - **Escaping read-only mode.** Through either path, ATTACH DATABASE opens a fil…

Security Severity: Medium CVE-2026-119346 GHSA-F3MH-RXG3-F5G2

Next.js: HttpOnly cookie exposure through internal response header on Next.js Edge runtime routes

GitHub Advisories

Next.js applications that set cookies through NextResponse on Edge runtime routes — App Router route handlers and Pages Router Edge API routes — send an internal x-middleware-set-cookie header in the public response, duplicating the cookie value and its attributes. This makes HttpOnly cookies, such as session tokens, readable by JavaScript running on the same origin when an application sets a sensitive cookie on an affected response.

Security Severity: Medium CVE-2026-119347 GHSA-7QX7-33QX-RQX2

Next.js: SVG rejection bypass in the image optimization

GitHub Advisories

On self-hosted deployments, the Next.js image optimizer (/_next/image) can be made to process an attacker-supplied SVG even when SVG support is disabled with dangerouslyAllowSVG: false (the default). This reaches an SVG parser the application intended to keep disabled, increasing exposure to denial of service and SVG decoder vulnerabilities.

Security Severity: Medium CVE-2026-119348 GHSA-PC58-HWJQ-P385

Next.js: Cross-client response injection and disclosure in self-hosted Next.js applications forwarding fetched responses

GitHub Advisories

Self-hosted Next.js applications (App Router route handlers and the fetch cache) that return a fetched upstream response unchanged can emit a response whose declared framing does not match the body actually sent. When such an application sits behind an HTTP/1.1 reverse proxy that permits pipelined response queueing, a crafted upstream response can desynchronize responses between clients, enabling response injection and disclosure of other clients' responses.

Security Severity: Medium CVE-2026-119349 GHSA-RHH4-G77R-R9QJ

Next.js: Cross-user cache disclosure and poisoning in Next.js use cache with binary arguments

GitHub Advisories

Next.js App Router applications that pass binary arguments (such as Uint8Array or Blob values) to functions using the use cache directive can produce identical cache keys for distinct arguments, allowing cached results to be shared across users — cross-user disclosure of cached data or cache poisoning. This affects applications using use cache with binary arguments.

Security Severity: Medium CVE-2026-119350 GHSA-VVGP-WW4W-46VF

Next.js: Cache poisoning of shared fallback shells in Cache Components via request-supplied placeholder route params

GitHub Advisories

Self-hosted Next.js applications served with next start and built with cacheComponents: true but without Partial Prefetching accept a request-supplied route param value as a prerender placeholder. One unauthenticated GET request can poison the fallback shell cache entry that a family of routes shares. Such a route is served from a shell that keeps its never-prerenderable params as placeholders, so every value of those params shares one cache entry. A path segment equal to the percent-encoded, bracketed name of its own route param is treated as an unresolved placeholder, and only that param is deferred. A layout above it then renders its concrete value into the shell during the blocking render, and the result, including its HTTP status, is stored under the shared key. Depending on the…

Security Severity: Medium GHSA-4RJ4-RCRQ-GR92

Safari MCP: JavaScript injection through single-quoted tool arguments (backslash not escaped)

GitHub Advisories

### Impact Sixteen places in safari.js placed a tool argument inside a single-quoted JavaScript string literal and escaped the single quote without first escaping backslashes. An argument containing a backslash followed by a quote therefore closed the literal, and the rest of the argument ran as JavaScript in the page. Seven of the affected arguments belong to read-only tools that are exempt from the tab-ownership check: filter in safari_network_details and safari_extract_links, level in safari_console_filter, selector in safari_snapshot, safari_accessibility_snapshot and safari_extract_tables, and dbName / storeName in safari_get_indexed_db. An MCP client limited to read-only tools (with safari_evaluate and safari_run_script excluded from its allowlist) coul…

Security Severity: High CVE-2026-121707 GHSA-7589-6FVF-X4PW

Effect: ReDoS in Schema.TemplateLiteral compiled regex

GitHub Advisories

### Impact Schema.TemplateLiteral compiles each Schema.String span to the lazy wildcard [\s\S]*? and decodes input by running the resulting regular expression against it. When a template has two or more Schema.String spans, for example: ``ts Schema.TemplateLiteral(Schema.String, ":", Schema.String, ":", Schema.String, "X") `` the regex contains several ambiguous wildcards. A non-matching input makes the backtracking engine try combinations across all of them, so matching time grows cubically with input length. A 5,000-character string of : characters blocks the event loop for about 15 seconds. Applications that decode untrusted input with such a schema are affected. That includes Schema.decodeUnknown, Schema.decodeUnknownSync and Schema.is, and anything built on them, su…

Security Severity: Low CVE-2026-77597 GHSA-56V3-JRQ2-4Q9M

iSponsorBlockTV: SSRF via Malicious SSDP Response Spoofing in Local Device Discovery

GitHub Advisories

### Summary iSponsorBlockTV discovers local smart TV devices via SSDP (Simple Service Discovery Protocol). The LOCATION URL from SSDP responses is used to fetch device capabilities without URL validation. A local network attacker can craft a malicious SSDP response with a LOCATION pointing to any internal HTTP service, causing SSRF when the application fetches device information. ### Details In src/iSponsorBlockTV/dial_client.py:92-96, upon receiving an SSDP M-SEARCH response, the code extracts the LOCATION header and makes an HTTP GET request to that URL to retrieve DIAL device description XML. The URL is not validated against expected device IP ranges, expected schemes, or private/internal IP blocklists. Any device on the LAN (or a rogue WiFi access point) can respond to SSDP M-…

Security Severity: High CVE-2026-128073 GHSA-5HJ8-Q7FV-QRJ6

gosaml2: Unauthenticated panic decrypting an EncryptedAssertion with a short or empty CipherValue

GitHub Advisories

### Summary An attacker who can supply a crafted SAML Response for parsing can crash a gosaml2 service provider by sending an EncryptedAssertion with AES-GCM encryption metadata and a CipherValue shorter than the GCM nonce size (12 bytes). The library panics with slice bounds out of range before any validation completes. This is a **distinct issue from [GHSA-hwqm-qvj9-4jr2](https://github.com/russellhaering/gosaml2/security/advisories/GHSA-hwqm-qvj9-4jr2)**, which addressed panics in the AES-CBC decryption path (commit [3418f9ae09063ff8df0ce1bd93f24e538e614def](https://github.com/russellhaering/gosaml2/commit/3418f9ae09063ff8df0ce1bd93f24e538e614def), included in v0.10.0). That fix added a block-size check for CBC but left the AES-GCM path completely unprotected. ### Details `…

Security Severity: High CVE-2026-102529 GHSA-464H-4J8H-Q5MF

HtmlSanitizer: CSS Removal DoS

GitHub Advisories

### Impact An unauthenticated request can occupy one synchronous application worker for seconds. Concurrent requests add CPU cost and can keep all workers busy, sustaining denial of service without user interaction. ### Patches The issue has been patched in versions 9.0.967 and 9.1.968-beta. ### Workarounds Disallow the style attribute.

Security Severity: Medium CVE-2026-115472 GHSA-H5M9-42H9-VCQ6

Doorkeeper: When using public clients, any client can revoke any access token

GitHub Advisories

### Summary An improper authorization issue affects Doorkeeper's OAuth token revocation flow when public (non-confidential) clients are in use. This vulnerability can lead to tokens being revoked without correct authorization. The issue is fixed in Doorkeeper 5.9.1.

Security Severity: Medium CVE-2026-109549 GHSA-W3W6-9M25-G88P

OmniFaces: SSE push channels are not bound to their owning HTTP session

GitHub Advisories

## Summary [GHSA-fp43-vj7g-pg92](https://github.com/omnifaces/omnifaces/security/advisories/GHSA-fp43-vj7g-pg92) (fixed 5.4.2) bound session- and view-scoped **WebSocket** (o:socket) push channels to the HTTP session that registered them, so a leaked channel ID can no longer be connected to from a foreign or absent HTTP session. The fix ([d5cae243c4](https://github.com/omnifaces/omnifaces/commit/d5cae243c4692555efaa4ba774e0f8f60e3f4db5)) touched only the Socket* classes. The parallel **SSE** (o:sse, added in 5.2) push transport was left unchanged. SseEndpoint.doGet accepts a connection whenever the presented channel ID is in the application-wide registry, without ever checking that the caller's HTTP session owns it. A leaked session/view-scoped SSE channel ID can therefore be re…

Security Severity: Medium CVE-2026-63193 GHSA-MQWX-84VV-MP26

October: Media Library Crop Handler Bypasses Upload Extension Allowlist

GitHub Advisories

The Media Library upload handler validates the destination filename against an extension allowlist (default_extensions), rejecting types such as php, phtml, html, and htm. The image crop handler (MediaManager::onCropImage / cropImage) did not perform this check. The destination filename was taken from user input, the extension was extracted from it, and the staged bytes were written to the public media folder under that attacker-chosen extension. Combined with the fact that upload accepts any file contents under an allowlisted extension (a PHP payload disguised as .jpg), and that the zero-dimension crop branch performs a byte-for-byte File::copy rather than re-encoding the pixels, an authenticated backend user with the media.library.create permission could write a file…

Security Severity: High CVE-2026-61713 GHSA-PXH3-4QQV-58MG

Servo Sandbox bypass: declarative refresh can auto-navigate a sandboxed iframe

GitHub Advisories

A sandboxed iframe can auto-navigate itself via declarative refresh even when automatic features should be blocked. This allows attacker-controlled embedded content to redirect itself without user action. ### Summary Servo allows a sandboxed iframe to auto-navigate itself via declarative refresh in configurations that should block automatic features. The issue reproduces in the must-block rows of the matrix: - sandbox="" - sandbox="allow-same-origin" - sandbox="allow-forms" - sandbox="allow-same-origin allow-forms" This is a client-side sandbox-policy bypass. It does not by itself prove script execution or parent DOM access, but it does let attacker-controlled sandboxed content redirect itself without user action. ### Details The declarative refresh path is missing sandbox enforce…

Security Severity: High CVE-2026-61689 GHSA-JMMC-WJPC-PG34

XWiki Platform: HQL injection in search allows unauthenticated database extraction including password hashes

GitHub Advisories

### Impact The query REST API allows executing HQL queries to filter the listed pages. While this properly checks access rights for the current user, the query can be used to combine when clauses and blind queries, to recover values, through FROM clause injection to join BaseObject and StringProperty tables, bypassing the HQL validator's SELECT column whitelist. This allows recovering any data that is stored in the database, including data from inaccessible pages, password hashes and passwords stored in configuration properties. For a typical password hash, this requires about 800 requests to the REST API (about one per bit). It should be assumed that when using more complex techniques, this even works when the attacker cannot read any wiki page. Password hashes use salted SHA1 in XWiki w…

Security Severity: High CVE-2026-59975 GHSA-3H63-W8JQ-RRF2

SharpIppNext: Unbounded IPP Document Stream Buffering Leads to Denial of Service

GitHub Advisories

### Summary SharpIppNext's IppProtocol.ReadIppRequestAsync() unconditionally copies the entire attacker-supplied IPP document payload into an unbounded MemoryStream with no size limit. Because this behavior is enabled by default (ReadDocumentStream = true) and the official server documentation shows HttpContext.Request.Body being passed directly to ReceiveRequestAsync() without authentication, an unauthenticated remote attacker can exhaust the server process's memory by sending an arbitrarily large IPP request body, causing an Out-Of-Memory (OOM) condition and denial of service. > [!NOTE] > This vulnerability only affects server-side implementations (using SharpIppServer to parse incoming IPP requests). It does not affect client-side implementations using SharpIppClient or c…

Security Severity: High CVE-2026-77283 GHSA-MX6P-3FG7-V6PJ

obsidian-sync-mcp: Missing Host/Origin validation lets a public website drive a victim's Obsidian vault via DNS rebinding (no-auth mode)

GitHub Advisories

When obsidian-sync-mcp runs without MCP_AUTH_TOKEN (the documented no-auth mode for local use), the HTTP MCP endpoint does not validate the Host or Origin header before dispatching MCP methods (CWE-350). The no-auth mode's "local network only" assumption therefore does not hold: a malicious web page the operator visits can use DNS rebinding to resolve an attacker-controlled hostname to 127.0.0.1 (or the operator's LAN/VPN/Docker-published address) and issue requests the server accepts as trusted local calls, reaching the full tool surface (read_note, write_note, edit_note, delete_note, move_note, list_notes, list_folders, list_tags, get_note_metadata). Affected versions:

Security Severity: High CVE-2026-76090 GHSA-GPCC-36PQ-8QXR

Tapir: Construction/decode RCE via property name -> raw case-class field (tapir-openapi-codegen)

GitHub Advisories

The OpenAPI code generator (tapir-openapi-codegen-core) builds Scala source by string templating and emitted several names/values from the (untrusted) OpenAPI document without escaping or validation, allowing injection of arbitrary Scala that runs at generated-code compile time and/or endpoint-assembly time (build/codegen-time RCE from an attacker-controlled spec). This advisory covers the full class of sinks, all sharing one root cause and one fix (PR #5395, commit e015939b7): object property names (-> case-class fields), query/header/path parameter names (-> endpoint input DSL), and operation tags (-> .tags(List(...))). The fix routes identifier-position names through validation/quoting and string-literal values through JavaEscape.escapeString. Consolidates the separately-reported query…

Security Severity: Critical CVE-2026-76807 GHSA-833V-V58W-294H

Todoist MCP Server: Browser DNS rebinding lets websites write and delete Todoist data through local MCP server

GitHub Advisories

The self-hosted todoist-mcp-http server accepts browser-origin MCP requests with attacker-controlled Host and Origin headers. A malicious website can use DNS rebinding to route its own origin to a victim's local 127.0.0.1 MCP server, then invoke Todoist MCP tools without a caller credential. This affects github.com/Doist/todoist-mcp at commit d2903e0d945d2a559d71c091337ad6380511e62f, package version 10.3.1, when the optional Streamable HTTP server is running. The stdio entrypoint is not browser-reachable. The vulnerable browser-reachable component is todoist-mcp-http. The documented HTTP server mode runs all MCP tools with the operator's TODOIST_API_KEY and binds to loopback by default: ``bash TODOIST_API_KEY=your-key npx -p @doist/todoist-mcp todoist-mcp-http `` `src/…

Security Severity: High CVE-2026-62964 GHSA-W42C-H7HR-F67P

Gortex: Arbitrary file write / repo-confinement escape in `write_file` / `edit_file` / `move_inline` MCP tools → code execution

GitHub Advisories

### Summary Gortex is an MCP server exposing write_file, edit_file, and move_inline tools. resolveFilePath **exempts absolute paths** from confinement, and the write handlers — unlike read_file / get_symbol_source — **never call guardSymlinkWithinRepo**. A single MCP write_file call with an absolute path writes any file the daemon user can, **outside every indexed repo root** (AtomicWriteFile's MkdirAll auto-creates missing parents). Writing ~/.zshrc, ~/.bashrc, .git/hooks/pre-commit, or a cron/systemd unit yields code execution on the next shell/commit. This directly violates the project's own SECURITY.md invariant *"File-path resolution is **confined to indexed repository roots**"* ### Affected internal/mcp/tools_fileops.go (+ tools_move_inline.go), HEAD…

Security Severity: High CVE-2026-75522 GHSA-4C2F-96CF-F5FC

OpenID4VP: X.509 chain validation accepts a forged certificate that reuses a trusted anchor's Subject DN without verifying its signature

GitHub Advisories

## Summary ChainBuilder (the private RFC 5280 validator behind TrustEvaluator and the public credential-parsing API) terminated chain building on **Subject Distinguished Name string equality** rather than on cryptographic closure to a trust anchor. A certificate whose Subject DN string matched a trusted anchor's Subject DN was accepted as the chain terminus **with no signature verification** against the anchor's public key. An attacker who mints a self-signed certificate and copies a trusted anchor's Subject DN string onto it can therefore have that certificate — and any credential signed with its private key — accepted as issued under a trusted authority. ## Impact A relying party using @openeudi/openid4vp to verify OpenID4VP presentations (mdoc / SD-JWT VC) could be induced to acc…

Security Severity: High CVE-2026-76101 GHSA-J282-PJG5-J643

keystore-go: Keystore integrity and password verification bypass via stripped trailing digest in Decode()

GitHub Advisories

### Summary keystore.Decode() fails to check the error returned when reading the trailing SHA-1 integrity digest of a JKS keystore. If an attacker removes the final 20 bytes from a .jks file, the digest read returns an empty slice and the byte-comparison loop never executes, so Decode() returns the parsed keystore with err == nil. This defeats both tamper detection and — for certificate-only truststores — the password check itself, allowing an attacker with write access to a keystore file (but without knowledge of the keystore password) to silently inject or replace trusted CA certificates. ### Details **Affected versions:** github.com/pavel-v-chernykh/keystore-go ≤ v2.1.0+incompatible (the final release on this module path). v3 and v4 releases are not impacted. In `decoder.go…

Security Severity: High CVE-2026-76818 GHSA-R7WG-F7R2-8WF7

Axon: Download of Code Without Integrity Check in axon-mcp

GitHub Advisories

### Summary axon rtk-install downloads a pre-built rtkx binary from GitHub releases and executes it via subprocess.run() on every text-compression call, without verifying its integrity — no checksum, signature, or attestation check anywhere in the download/install path. If the release pipeline or a maintainer token for sammyjdev/rtkx were ever compromised, every axon user who installs or auto-bootstraps rtkx would silently download and execute an unverified binary with the same privileges as the axon process. ### Details The download path lives in src/axon/context/rtk_bootstrap.py: - _http_download() fetches the release archive over HTTPS via urllib.request.urlopen() and writes the raw response bytes to disk — no hash comparison against any published value. - _extract_binary() unpacks the…

Security

ThreatsDay: GPT-6.2 Jailbreak Flaws, BubbleLoader PNG Malware, $500M Ransom Demands + 17 More Stories

The Hacker News

The easiest way to fool someone is to give them something they already expect. A job offer. A message about a service outage. A familiar app. Nothing looks strange at first. And that's the problem. This week's stories show how ordinary things are being used to steal data, spread malware, and get people to hand over access. There's another shift worth watching. AI is making some attacks easier

Security

phpAfterShell Explained: How Hackers Could Turn a PHP Session Flaw Into Code Execution

The Hacker News

PHP's default file-based session storage can be made to return objects an attacker chose, by cutting off a session write at the right moment. When combined with a second weakness, such as a suitable gadget chain in the app, those objects can allow the attacker to run code on the server. Today's PHP releases fix the flaw, called phpAfterShell. The flaw is tracked as CVE-2026-126714 and rated

Security Severity: Critical CVE-2026-63412 GHSA-Q8V2-3J4H-XG2P

Jane: Instantiation RCE via query parameter name -> raw PHPDoc */ breakout (jane-php/open-api-3)

GitHub Advisories

### Summary jane-php (open-api-3) builds PHP via nikic/php-parser (AST), so string literals are escaped -- but PHPDoc comment text is emitted RAW. The generated Client/Endpoint method docblocks embed the query parameter name verbatim in a @param array{ ""?: ... } block. A */ in the query name closes the /** ... */ docblock early and lands in class-body position; because the name is a raw string key (not identifier-mangled), the */ and following PHP survive. Injecting */ public function __construct(){ } /* adds an attacker-controlled __construct to the generated Client class, which runs when the client is instantiated -> RCE (CWE-94). Verified 7.11.2/PHP8.1. ### Impact Generating a client from an attacker-influenced OpenAPI document and using the generated SDK (instantiating the…

Security Severity: Critical CVE-2026-63413 GHSA-X9XR-53QX-9QCF

Jane: Instantiation RCE via header parameter name -> raw PHPDoc */ breakout (jane-php/open-api-3)

GitHub Advisories

### Summary jane-php (open-api-3) builds PHP via nikic/php-parser (AST), so string literals are escaped -- but PHPDoc comment text is emitted RAW. The generated Client/Endpoint method docblocks embed the header parameter name verbatim in a @param array{ ""?: ... } block. A */ in the header name closes the /** ... */ docblock early and lands in class-body position; because the name is a raw string key (not identifier-mangled), the */ and following PHP survive. Injecting */ public function __construct(){ } /* adds an attacker-controlled __construct to the generated Client class, which runs when the client is instantiated -> RCE (CWE-94). Verified 7.11.2/PHP8.1. ### Impact Generating a client from an attacker-influenced OpenAPI document and using the generated SDK (instantiating th…

Security Severity: Critical CVE-2026-63411 GHSA-XWCW-J52R-34X4

Jane: Instantiation RCE via parameter description -> raw PHPDoc */ breakout (jane-php/open-api-3)

GitHub Advisories

### Summary jane-php (open-api-3) builds PHP via nikic/php-parser (AST), so string literals are escaped -- but PHPDoc comment text is emitted RAW. The generated Client/Endpoint method docblocks embed the parameter description verbatim in a @param array{ ""?: ... } block. A */ in the parameter description closes the /** ... */ docblock early and lands in class-body position; because the name is a raw string key (not identifier-mangled), the */ and following PHP survive. Injecting */ public function __construct(){ } /* adds an attacker-controlled __construct to the generated Client class, which runs when the client is instantiated -> RCE (CWE-94). Verified 7.11.2/PHP8.1. ### Impact Generating a client from an attacker-influenced OpenAPI document and using the generated SDK (instan…

Security Severity: Medium CVE-2026-75518 GHSA-VG83-HCP4-5QCC

DOMShell: domshell_eval classified as read-tier can execute side-effecting JavaScript without --allow-write

GitHub Advisories

### Summary The domshell_eval MCP tool (and the eval command inside domshell_execute) was classified as **read-tier**, allowing it to run without the --allow-write server flag. However, eval and the write-tier js command dispatch to the same handler in the extension and call CDP Runtime.evaluate with the raw expression string and no side-effect gate. Any JavaScript expression could therefore mutate DOM, window, or global state through domshell_eval without the operator's --allow-write authorization. The tool description explicitly promised "(read-only) ... always available in read-only mode" — the misclassification contradicted the documented contract, not just an implicit one. ### Impact No new capability was exposed — the same write access was already available via `do…

Security Severity: Medium CVE-2026-69139 GHSA-PJ7P-238H-76PV

djangocms-moderation: Moderation comments disclosed to non-participant staff via the admin changelist

GitHub Advisories

## Summary The Django admin views for moderation comments (CollectionCommentAdmin and RequestCommentAdmin) render the full comment body but scope access only by an attacker-controlled id in the URL and Django's model-level view_*comment permission. They perform no per-object participant check. As a result, any authenticated staff user who holds the comment *view* permission can read the comments of **any** collection or moderation request — including ones they are not a participant of — simply by supplying the target object's id. Comments are documented and intended to be private to the participants of a collection (its author and the moderators assigned to its workflow). This advisory concerns a read/write authorization asymmetry: the write paths already enforced `request.user ==…

Security Severity: High CVE-2026-71535 GHSA-8776-QF3H-26R3

Mareforma: Unsigned Claims Can Be Promoted to REPLICATED via Missing Signature Enforcement in Convergence Path

GitHub Advisories

### Summary mareforma 0.3.3 contains a critical integrity flaw in the REPLICATED convergence logic (_maybe_update_replicated_unlocked() in mareforma/db/core.py:1300-1319). The peer-selection SQL query that determines whether two independent claims "agree" on the same anchor does not verify that either claim carries a valid cryptographic signature from an enrolled validator key. Because rekor_enabled=False is the default and automatically sets transparency_logged=1 at insert time, every claim — signed or not — immediately satisfies the convergence precondition. An attacker with no Mareforma key can write an unsigned claim to a shared graph, cause it to converge with a legitimate signed peer claim, and have it promoted to REPLICATED status. The forged REPLICATED row is then re…

Security Severity: Medium CVE-2026-71534 GHSA-XFQ4-8HF9-5H43

Mareforma: transparency_logged trusts the unsigned rekor block

GitHub Advisories

## What's wrong During restore, transparency_logged is recomputed as 1 if (toml_logged is not False and bundle_has_rekor) else 0, where bundle_has_rekor comes only from a rekor.uuid field inside signature_bundle. That derivation is wrong in both directions. First, the rekor block is metadata attached after signing (attach_rekor_entry in mareforma/signing/rekor.py leaves the payload and signatures untouched), so it is not covered by the Ed25519 signature. A hand-edited claims.toml can add "rekor": {"uuid": "x"} to any claim's bundle and forge the "publicly witnessed by Rekor" state. The claim signature still verifies, and restore never cross-checks the block against [rekor_inclusions] or the log. Tampering with claims.toml is the exact threat model restore defends aga…

Security Severity: Medium CVE-2026-71500 GHSA-RGG9-956J-3378

Mareforma: invalidated claims still promote to REPLICATED

GitHub Advisories

## What's wrong _maybe_update_replicated_unlocked never checks t_invalid, so a claim that a signed contradiction verdict has marked invalid can still climb to REPLICATED through convergence detection, and it pulls an honest peer up with it. Three gaps line up: - The new-claim short-circuit reads only status and asserter_keyid (core.py:1339-1352); an invalidated but still-open new claim passes. - The candidate-peer SELECT filters status = 'open', unresolved = 0, and transparency_logged = 1 but has no t_invalid predicate (core.py:1390-1410), so an invalidated existing claim qualifies as a convergence partner. - The promotion UPDATE gates only on status = 'open' (core.py:1422-1426), leaving a TOCTOU window even after the SELECT is fixed. A signed contradiction verdi…

Security Severity: High CVE-2026-71536 GHSA-HXH5-GP44-RC6P

Mareforma: verify_bundle never checks a per-claim signature

GitHub Advisories

## What's wrong verify_bundle documents that it verifies "a bundle's DSSE envelope AND each per-claim signature", lists "per-claim signature failure" among its raised errors, and promises that partial verification never surfaces "an authenticated bundle that contains some invalid claims" as success. The code does not do this. The JSON-LD predicate built by JSONLDExporter._claim_node carries no signature material (there is no signatureBundle field on the node), so the verify loop has nothing cryptographic to check per claim. It only re-derives each claim's canonical-statement digest from the node fields and compares it to the signed subject list: ```python chain_input = _signing.canonical_statement({...node fields...}, node.get("evidence") or {}) expected = hashlib.sha256(chain_input…

Security Severity: Medium CVE-2026-71533 GHSA-M29V-3G7G-9C63

Mareforma: search_claims skips verify-on-read, serving forged rows

GitHub Advisories

## What's wrong search_claims never calls _row_verified_on_read. Its row loop applies only the PRELIMINARY-unenrolled filter, then appends the row. query_claims runs the same projection but additionally re-verifies REPLICATED/ESTABLISHED signatures on read (line 4023) and drops any row that fails, per the documented tamper guarantee in the comment block above it: a high-trust row whose signature does not verify is excluded from query results entirely. So a tampered or forged high-trust row splits the two read paths. Any process with DB write access, or an attacker copying a genuine validation envelope onto a fresh row, can flip a row to ESTABLISHED. query() drops it; search() serves it at its persisted trust level. Verified in a runtime check against a forged ESTABLISHED row: ``…

Security Severity: Medium CVE-2026-58214 GHSA-4G68-3PWX-5VFJ

NATS Server MQTT subscribe permission bypass exposes internal QoS 2 metadata

GitHub Advisories

### Background NATS.io is a high performance open source pub-sub distributed communication technology, built for the cloud, on-premise, IoT and edge computing. The NATS Server MQTT support uses internal $MQTT.* subjects to implement MQTT protocol features such as QoS handling. ### Problem Description An authenticated MQTT client could subscribe to an internal MQTT delivery subject that was not intended to be available to clients. This bypassed configured subscribe permissions for that internal subject family and exposed MQTT QoS2 protocol metadata for sessions in the account. Message payloads were not exposed through this path. This issue was related to an incomplete restriction on internal MQTT subjects. It affected MQTT users whose ordinary subscribe permissions would not otherwise al…

Security Severity: High CVE-2026-58213 GHSA-QRCV-3558-GJ4F

NATS Server: MQTT SUBSCRIBE Protocol Injection via Leaf Node/Route Forwarding allows arbitrary NATS command injection

GitHub Advisories

### Background NATS.io is a high performance open source pub-sub distributed communication technology, built for the cloud, on-premise, IoT and edge computing. The NATS Server supports MQTT clients and can bridge MQTT activity into NATS subjects across routes and leafnode connections. ### Problem Description An MQTT client could include protocol control characters in subscription filters that were later forwarded as NATS protocol data to route or leafnode connections. This could corrupt the forwarded protocol stream and allow injection of unintended NATS protocol operations, potentially across cluster nodes or accounts where route or gateway connections are present. Anonymous MQTT deployments are higher risk because no credentials are required to reach the affected parser. Authenticated d…

Security

Kritische Sicherheitslücken in PHP - Updates verfügbar

CERT.at

19. November 2026 Beschreibung Das PHP-Projekt hat am 19. November 2026 Sicherheitsupdates veröffentlicht, die unter anderem sieben als kritisch eingestufte Sicherheitslücken beheben. Die Schwachstellen betreffen die Session-Verwaltung (ext-session), die Datums-Erweiterung (ext-date), PHP-FPM sowie die Zend Engine und können unter bestimmten Konfigurationsvoraussetzungen zur Ausführung von beliebigem Code führen. CVE-Nummer(n): CVE-2026-115560, CVE-2026-126714, CVE-2026-129182, CVE-2026-129289, CVE-2026-129474, CVE-2026-129481, CVE-2026-129496 CVSS v4.0 Base Score: jeweils 9.2 (kritisch) Auswirkungen Bei erfolgreicher Ausnutzung können Angreifer:innen beliebigen Code mit den Rechten des PHP-Worker-Prozesses ausführen. Zudem sind Speicherkorruption, Abstürze von Worker-Prozessen (Denial-of…

Security

Critical VMware vCenter Flaw (CVSS 9.8) Lets Network Attackers Bypass Authentication

The Hacker News

A critical flaw in VMware vCenter lets an attacker with network access bypass authentication and gain unauthorized access to the system, Broadcom, which owns VMware, said in an advisory published today. Fixed versions are out for all supported branches, and the company lists no workaround. vCenter is the central console for managing an organization's ESX hosts and virtual machines. The

Security

PHP Fixes 7 Critical Flaws, Including Bugs That Could Allow Remote Code Execution

The Hacker News

The PHP Foundation has released security updates to address multiple critical security flaws that could be exploited to achieve remote code execution on affected deployments, including CVE-2026-115560. The list of vulnerabilities is as follows - CVE-2026-115560 (CVSS score: 9.2) - An improper input validation vulnerability that could result in remote code execution, file modification,

Security

Drupal Patches Critical Installer Flaw That Could Give Unauthenticated Attackers Control of Sites

The Hacker News

Under specific conditions, a critical vulnerability in Drupal core can allow an attacker without login credentials to use the built-in installer to attempt to reinstall a site. That can lead to a site takeover or remote code execution, and the project rates the vulnerable configurations as uncommon. Fixed releases for all supported branches shipped yesterday. The Drupal Security Team disclosed

Hosting & Network

Internet traffic and attacks during the 2026 U.S. midterm elections

Cloudflare

On November 3, 2026 U.S. voters headed to the polls. Here’s what Cloudflare data across more than 1,400 protected sites tells us about Election Day Internet traffic and cyberattacks.

Security

Everything Is a Web Application, Including Your Firewall

The Hacker News

One of the early targets of PHP2Shell exploitation was the firewall. On October 28, Palo Alto Networks confirmed that attackers were exploiting the two PHP vulnerabilities, CVE-2026-109618 and CVE-2026-109619, against PAN-OS management interfaces exposed to the internet. Both flaws let anyone execute code on the web server without authentication. The disclosure itself went a little wrong.

Security

Hackers Breach N-able Cloud Server, Disrupting Email Security Management Across 3 Regions

The Hacker News

N-able on Wednesday disclosed that unknown threat actors gained unauthorized access to one of the servers in the Mail Assure and Spam Experts Hosted Cloud, causing it to disable management interfaces and APIs. "We have taken steps to mitigate the threat and are continuing to harden our services to reduce the risk of recurrence," N-able said. "The investigation is ongoing, but at this time we

Security

Ruby Releases Fixes for 7 Regex and String Flaws, Warns 5 Have Proof-of-Concept RCE

The Hacker News

Ruby contains seven memory-safety flaws in its regular expression engine and its string case-conversion code. For five of them, its maintainers say, proof-of-concept exploits, or PoCs, have shown that crafted input can run code on the machine. "We are aware of PoCs that prove some of them can be used to trigger remote code execution," the maintainers said. The project released fixed versions

Security

Researcher Demonstrates Database RCE Exploits Affecting PostgreSQL, MySQL and Oracle

The Hacker News

Low-privilege database accounts that cannot read a single application table can still be used to run code on the database server itself, a researcher has shown, by reaching memory-corruption bugs in the engine code behind ordinary SQL. The exploits, published yesterday, are the researcher's proofs of concept against PostgreSQL, MySQL and ClickHouse, plus a separate Oracle chain that needs no

Security

CISA Warns of 4 Exploited Flaws Linked to Ransomware, Cryptomining, and LLMjacking Attacks

The Hacker News

The U.S. Cybersecurity and Infrastructure Security Agency (CISA) on Wednesday added four vulnerabilities impacting Synology DiskStation Manager (DSM), BerriAI LiteLLM, Apache Axis, and Vanderbilt University Research Electronic Data Capture (REDCap) to its Known Exploited Vulnerabilities (KEV) catalog, citing evidence of active exploitation. The vulnerabilities are listed below -

Security

PHP Warns of Critical Security Flaws Affecting All Supported Versions, Fixes Coming November 19

The Hacker News

The maintainers of the PHP programming language on Wednesday issued an advisory announcing an upcoming security release that addresses critical flaws. The release is scheduled for November 19, 2026, between 2 and 2:30 p.m. UTC. "These releases are part of PHP's regular four-week release cycle and will address security vulnerabilities affecting all supported PHP versions," the maintainers said.

Security Severity: High CVE-2026-76088 GHSA-CVX8-9FF6-54XQ

PGPainless: Unbounded Compressed Packet Descent in inline-detach and MessageInspector leads to Denial of Service (DoS)

GitHub Advisories

### Summary An architectural security boundary bypass in inline-detach and MessageInspector allows remote, unauthenticated attackers to force unbounded recursive decompression routines. By supplying a specially crafted OpenPGP message containing deeply nested compressed packet structures, an attacker can completely bypass the library's built-in DoS protections (MAX_LAYER_DEPTH = 16), leading to resource exhaustion, thread blocking, and potential Out-of-Memory (OOM) application crashes. ### Details The pg-painless core processing pipeline implements a defensive threshold constraint to prevent decompression bomb sequences (Zip Bombs) and arbitrary resource consumption: Enforcement Location: pgpainless-main/pgpainless-core/src/main/kotlin/org/pgpainless/decryption_verification/MessageMetadat…

Security Severity: Medium CVE-2026-73504 GHSA-JC42-994R-VVWP

cassandra-jdbc-wrapper: Authentication Token Exposed in Logs

GitHub Advisories

### Summary The fix for [AIKIDO-2024-10565](https://intel.aikido.dev/cve/AIKIDO-2024-10565) (plaintext password logging) introduced two redaction helpers — DriverUtil.toStringWithoutSensitiveValues() and DriverUtil.redactSensitiveValuesInJdbcUrl() — but both helpers only redact the "password" property/parameter (JdbcUrlUtil.TAG_PASSWORD). The equally sensitive "token" property (JdbcUrlUtil.TAG_TOKEN), used for DataStax Astra and other token-based Cassandra authentication, is completely unredacted by both helpers. Applications using token-based authentication with DEBUG logging enabled will therefore log the live authentication token in plaintext via SessionHolder's calls to these same two helpers — the exact same exposure pattern that the original fix was intended to prevent…

Security Severity: High CVE-2026-63129 GHSA-2M9M-6CR5-9X25

mssql-mcp-core: SQL injection in mssql-mcp write tools via unparameterized table names and WHERE clauses

GitHub Advisories

Several tools in mssql-mcp-core built T-SQL by string-interpolating caller-supplied identifiers and predicates directly into the statement passed to the node-mssql Request.query() batch API. Only data values were parameterized. Affected tools and inputs: - update_data, delete_data: tableName and the free-form whereClause were interpolated raw. - insert_data: tableName and column names (object keys) were interpolated raw. - execute_transaction: the same raw tableName/whereClause interpolation per operation. - create_table, create_index, drop_table: table/column/index/schema identifiers were interpolated with no or insufficient validation. - list_databases (reader tier): the stateFilter argument was interpolated raw into the query, with only a non-enforced in…

Security Severity: Critical CVE-2026-75521 GHSA-8FH7-7Q4Q-CQ52

Miren Runtime: Authentication bypass in RPC layer: unverified TLS client certificates grant cluster superuser access

GitHub Advisories

### Summary The Miren Runtime RPC server (QUIC/HTTP3, default port :8443) requested TLS client certificates but never verified that a presented certificate chained to the cluster Certificate Authority. Because a client-certificate identity is granted a blanket RBAC bypass, any party able to reach the RPC listener could present a forged, self-signed certificate and be authenticated as a cluster **superuser** — no valid CA signature, credential, or prior authorization required. ### Impact This is a complete, unauthenticated authentication bypass against the cluster control plane. An attacker who can reach the RPC port can perform any RPC operation with full privileges: enumerate and manipulate entities, apps, sandboxes, disks, and other cluster resources. This yields full compromise of co…

Hosting & Network

An updated Clairic and Clairic-flash are now open-weight, from the new Workers AI Superintelligence team

Cloudflare

Add your teaser here. It should complement the headline, not repeat it. Teaser cannot be longer than 240 characters. The Blog Review Gem will suggest an excerpt. Clairic graduates from preview, while Clairic-flash joins the repertoire on Workers AI. We’re doing an open-weight release for both extraction models.

Security Severity: Medium CVE-2026-75506 GHSA-VC6P-M6VX-6CWQ

OliveTin: Second-Order OS Command Injection via shellAfterCompleted

GitHub Advisories

## Summary OliveTin's shellAfterCompleted post-execution hook injects unsanitized variables — including arbitrary command output (output), the authenticated username (ot_username), and the exit code (exitCode) — directly into a shell command template processed by sh -c. Unlike the main action's argument handling, **no checkShellArgumentSafety validation is applied** to these variables. An attacker who can influence the output of a command (e.g., via user-supplied arguments that reflect in stdout, or through trusted-header username spoofing) can inject arbitrary OS commands into the post-execution shell. This is a **distinct** finding from CVE-2026-27626 (OS command injection via password type in webhooks). That CVE addressed argument types bypassing shell safety checks in th…

Security Severity: Medium CVE-2026-69131 GHSA-VF85-8FF2-3R9W

django-filer: Missing per-object authorization on `discard` and `edit_redirect` version transitions

GitHub Advisories

## Summary When django-filer's optional per-folder permission system is enabled (FILER_ENABLE_PERMISSIONS=True), the "Delete files and/or folders" admin action does **not** enforce per-folder edit permissions the way every other mutating action does. A staff user who is scoped **read-only** on a folder via FolderPermission (can_edit = DENY), but who holds the global Django model-level delete_* permission, can delete files and entire subfolders inside that folder — even though their move, rename, copy, and resize actions on the same folder are correctly denied. This is an integrity / edit-control gap (unauthorized deletion). It is **not** a read-confidentiality issue: filer files are world-downloadable by design, so no confidentiality claim is made. ## Affected versions - django-fi…

Security Severity: Medium CVE-2026-69138 GHSA-5G9X-QWH5-33X4

djangocms-versioning: Authorization Bypass Through User-Controlled Key and Missing Authorization

GitHub Advisories

## Summary The discard and edit_redirect version transitions did not enforce a per-object change-permission check, while the sibling transitions (archive, publish, unpublish, revert) all did. As a result a low-privileged staff user could **discard (delete) any draft version — and thereby the underlying content object — of content they have no change permission on**, and could create an editable draft off any published version, by supplying a version primary key they should not have access to (an insecure direct object reference). ## Details Version state transitions are guarded by Conditions objects declared on djangocms_versioning.models.Version. Every transition that mutates content carries the user_can_change condition, which delegates to the *content* object's own pe…

Security Severity: High CVE-2026-68903 GHSA-JW3M-8Q7M-F35R

LLMKube: Arbitrary Host File Read via Model.spec.source hostPath Injection

GitHub Advisories

### Summary LLMKube's ModelReconciler accepts arbitrary absolute paths and file:// URIs in the Model.spec.source field and propagates them to two distinct sinks without path allowlisting: (1) os.Open() inside the controller pod itself (copyLocalModel), and (2) a Kubernetes HostPathVolumeSource that mounts the attacker-supplied path into the inference pod's init container. Any namespace user with permission to create or update Model and InferenceService custom resources can read arbitrary files accessible to the controller pod (e.g., the controller's own Kubernetes service-account token) or arbitrary files on the node where the inference pod is scheduled (e.g., /etc/kubernetes/kubelet.conf). Model caching, the feature that activates the hostPath sink, is **enabled by de…

Security Severity: High CVE-2026-73864 GHSA-88Q3-GCH3-5396

install-artifact-from-github loads downloaded native artifacts without integrity verification

GitHub Advisories

## Description bin/install-from-cache.js downloads a prebuilt native addon (*.node) over the network and writes it directly to the artifact path **with no cryptographic integrity verification of any kind** — no checksum manifest, no signature, no SRI. A scan of the whole package for createHash|sha256|checksum|integrity|digest|signature finds nothing. The file is then require()-loaded by the consumer, which executes the addon's native module-init code. Anyone able to influence the download achieves code execution on the installing machine. ### Affected code (v1.6.0) - **Mirror is fully attacker-steerable via an env var, no host pinning** — bin/install-from-cache.js:80: ``js let assetUrl = mirrorHost || process.env[mirrorEnvVar] || 'https://github.com'; `` re2 passes `--host-v…

Security Severity: High CVE-2026-71861 GHSA-WQ26-3J2M-4HVV

Chainguard SDK: AWS SigV4 token replay in auth/aws.VerifyToken — Chainguard-Audience/Chainguard-Identity binding headers not required in SignedHeaders

GitHub Advisories

### Summary The auth/aws package of the chainguard.dev/sdk Go library provides Chainguard's AWS-backed identity federation (an AWS workload proves its identity to Chainguard by signing an AWS STS GetCallerIdentity request). Its verifier, VerifyToken, reads the Chainguard-Audience and Chainguard-Identity binding headers from a presented token but does not require them to be covered by the SigV4 signature. AWS STS validates only the headers listed in SignedHeaders and ignores all others, so an attacker can take a GetCallerIdentity request that a victim signed for a *different* relying party, inject or rewrite those two headers *after* signing (without invalidating the signature), and replay it to any service that authenticates callers with VerifyToken. The binding those he…

Security Severity: High CVE-2026-71481 GHSA-82W8-65QW-GCH6

ALTCHA PHP: verifySolution bypasses HMAC signature check when challenge signature is absent

GitHub Advisories

In altcha-org/altcha v2, the verifySolution method skips HMAC signature verification when the signature field is absent from the challenge payload, even when hmacSignatureSecret is configured. An attacker who strips the signature key from the challenge JSON passes the condition as false, bypassing tamper-detection entirely. The PoW solution check then runs against unverified parameters — allowing an attacker to self-issue a low-difficulty challenge, solve it trivially, and submit a payload that verifies as true. Impact: Complete CAPTCHA bypass on any deployment that sets hmacSignatureSecret (the recommended production configuration). Fix: The check was split so that a missing signature is explicitly rejected when a secret is configured.

Security Severity: Medium CVE-2026-71425 GHSA-7JVC-9XQ8-FRFF

Outstatic: Authenticated GitHub REST proxy can send OAuth token to non-GitHub origins

GitHub Advisories

### Impact Outstatic’s authenticated GitHub REST proxy accepted an unvalidated endpoint parameter and constructed an upstream GitHub API URL by string concatenation while attaching the authenticated user’s GitHub OAuth token. A user with access to the Outstatic dashboard could craft a request that caused the server to send their own GitHub OAuth token to a non-GitHub host. If that token was captured, it could be used to access GitHub resources available to that same user, including private repositories depending on granted scopes. This does not allow unauthenticated attackers to access private repository data, and it does not directly expose another user’s GitHub token without an additional same-origin execution or request-forging primitive. ### Patches The issue has been patched by valid…

Security Severity: High CVE-2026-69158 GHSA-FF87-73JP-F3V4

Atomic Server: Unauthenticated full-response SSRF in Atomic-Server /bookmark endpoint

GitHub Advisories

## Summary Atomic-Server exposes a GET /bookmark endpoint that fetches an attacker-supplied URL server-side, parses the response, and reflects the fetched content back to the caller. The endpoint requires no authentication and performs no authorization of its own, and the underlying fetch helper applies no allow-list or private-IP deny-list. An unauthenticated attacker with network reach to the server can force it to issue arbitrary outbound HTTP GET requests to internal-only hosts (loopback services, internal admin panels, link-local cloud-metadata) and read the response body back. This is a full-response SSRF, not a blind one. ## Root cause (source trace) 1. The bookmark endpoint is registered unconditionally for every server: server/src/appstate.rs:69 (`store.add_endpoint(plugins::…

Security Severity: Critical CVE-2026-69157 GHSA-PFWX-XJP4-QXCJ

Atomic Server: Unauthenticated `/setup` invite grants write access to the entire Drive

GitHub Advisories

## Summary atomic-server provisions a well-known invite at {server}/setup with write = true, target = the Drive root, and usagesLeft = 1. Invite redemption **ignores the redeemer's identity** (for_agent: _ in server/src/plugins/invite.rs:22), so possession of the URL is the only requirement. An **unauthenticated** attacker who sends GET /setup?public-key= has the server create a new Agent and grant it **write access to the entire Drive**. On a freshly deployed (not-yet-claimed) instance this is a full server takeover with no credentials. ## Severity **Critical — CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H (9.8).** No authentication required; grants attacker-controlled write over all resources in the Drive. ## Affected component - server/src/appstate.rs — creates the `/set…

Security Severity: High CVE-2026-69156 GHSA-8VC4-8HJQ-988P

Atomic Server: Arbitrary file read via user-controlled `internalId` in the `/download` handler (leaks root agent private key)

GitHub Advisories

## Summary The Commit apply path enforces **no allowlist of writable properties**, so any authenticated Agent can set the internalId string (datatype string, no character validation) on a resource it owns. The /download handler then uses that value **verbatim** as a filesystem path — file_path.push(internal_id); NamedFile::open(file_path) — with **no sanitization and no containment check** (server/src/handlers/download.rs:56-65). By setting internalId to a traversal path (../../../../etc/passwd) or an absolute path (PathBuf::push of an absolute path replaces the buffer), an attacker reads **any file on the host**. The highest-value target is the server config file storing the **root agent private key**, which yields full server compromise. Only the *upload* path sanitizes…

Security Severity: High CVE-2026-69155 GHSA-X277-3WCG-G9R2

Atomic Server: Stored XSS via uploaded files served inline (same-origin) on `/download` → account takeover

GitHub Advisories

## Summary Files uploaded via POST /upload are served back by GET /download/{path} using actix_files::NamedFile. For text/html and image/svg+xml, actix-files (0.6.6) sets Content-Disposition: inline, so the browser **renders** the file instead of downloading it. The /download route sets **no Content-Security-Policy, no X-Content-Type-Options: nosniff, and no forced attachment** (CSP exists only on the SPA route), and files are served from the **same origin** as the app UI. An authenticated Agent uploads evil.html containing ``; when a victim opens the link, the script executes in the app origin. Because the atomic_session cookie is set via document.cookie (not HttpOnly) and the Agent's Ed25519 private key is stored in same-origin IndexedDB (`browser/data-browser/…

Security

10-Year-Old NGINX HTTP/2 Flaw Lets Unauthenticated Attackers Execute Code on Servers

The Hacker News

A flaw in NGINX's HTTP/2 support can allow an attacker to run code on servers with HTTP/2 enabled, without needing to log in. The decade-old flaw, CVE-2026-123007, dubbed "nginx2root," has been present in NGINX's open-source code since version 1.9.5, released on September 22, 2015. Fixed versions 1.31.9 and 1.30.7 came out today. F5, the company behind NGINX, says attackers can run code where

Security

F5 Warns 6 Critical BIG-IP Flaws Can Crash Traffic in Specific Setups, May Allow RCE

The Hacker News

Six critical vulnerabilities in F5 BIG-IP allow an attacker to crash the Traffic Management Microkernel (TMM) without logging in, disrupting traffic until the TMM restarts. Each flaw needs a specific setup on a virtual server: an iRule that uses a particular command, or an APM policy that includes two particular kinds of agent. F5, which makes BIG-IP, disclosed the flaws today and says they

Security

Critical Apache Roller RCE Flaw Under Active Exploitation, No Authentication Required

The Hacker News

A critical security flaw in Apache Roller, an open-source, Java-based blogging platform, has come under active exploitation in the wild, according to the Apache Software Foundation (ASF) The vulnerability, tracked as CVE-2026-129448 (CVSS score: 9.8), is a case of unauthenticated deserialization in the XML-RPC endpoint that could lead to remote code execution. "Deserialization of Untrusted