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 Severity: Medium CVE-2026-129237 GHSA-VX32-XF7G-9GHR From dashboard

qbee-agent: Docker Compose build context Zip Slip writes outside context directory

GitHub Advisories

## Summary qbee-agent contains a Zip Slip vulnerability in app/utils/tar.go. The tar extractor checks whether an entry remains inside the destination directory with: ``go strings.HasPrefix(targetPath, destdirClean) `` This does not enforce a path separator boundary. If the destination directory is /tmp/.../context, a tar entry such as ../context-outside/payload.txt cleans to /tmp/.../context-outside/payload.txt and still passes the prefix check. qbee-agent then creates the outside directory and writes the payload outside the intended extraction root. The issue is reachable through the Docker Compose build context path when UseContext is enabled. ## Details Code references below were verified against qbee-io/qbee-agent commit: - 1d8bdbb7422adb4ca563d3114cbe2817d6ba3581 Af…

Security Severity: High CVE-2026-91115 GHSA-C94F-87XG-65WF

Silverstripe Framework: RCE via i18nTextCollectorTask writer parameter

GitHub Advisories

### Impact The writer option of the i18nTextCollectorTask dev task was passed to the injector without validation. A crafted dev task URL could create arbitrary objects with attacker-controlled constructor arguments and run code on the server. Because the dev task did not ask for confirmation, an administrator could be tricked into running it by following a link. On a site in dev mode, no login was needed. CMS 5 is not affected. ### Reported by Jack Wallace

Security Severity: Medium CVE-2026-91113 GHSA-4QV2-G5VP-WJJW

Silverstripe Framework: User-controlled ClassName allows unauthorized record type change

GitHub Advisories

### Impact A user who can edit a record through a GridField detail form could change the record to an unrelated class, without the permission checks for that class. ### Reported by Lachlan Davidson, Carapace

Security Severity: Medium CVE-2026-91112 GHSA-RG72-5958-C65M

Silverstripe Framework: CMS_ACCESS_SecurityAdmin privilege escalation

GitHub Advisories

### Impact A user with access to the Security section (CMS_ACCESS_SecurityAdmin) but without the ADMIN permission could edit a group that grants ADMIN through a role or a parent group, and use it to escalate their own privileges. ### Reported by Lachlan Davidson, Carapace

Security Severity: Medium CVE-2026-88989 GHSA-3QH3-54QG-GPQ3

Silverstripe Framework: Auth bypass GridFieldDetailForm

GitHub Advisories

### Impact A CMS user who can edit records through a GridField detail form could create new records without the permission to create them, by sending a save request directly. ### Reported by HDWSec - https://hdwsec.fr

Security Severity: Medium CVE-2026-88988 GHSA-XWG4-8HQH-79JQ

Silverstripe Framework: XSS via SVG data URI

GitHub Advisories

### Impact The HTML sanitiser did not remove SVG data URIs. A CMS author could store content that runs JavaScript in the browser of another user who views it. ### Reported by HDWSec - https://hdwsec.fr

Security Severity: Medium CVE-2026-88987 GHSA-QQRG-8JPM-8MPH

Silverstripe Framework: XSS via XHTML data URI

GitHub Advisories

### Impact The HTML sanitiser did not remove XHTML and XML data URIs. A CMS author could store content that runs JavaScript in the browser of another user who views it. ### Reported by Jack Wallace from Bastion Security

Security Severity: Medium CVE-2026-129239 GHSA-7H45-Q5JX-7R87

Directus: Share update allows reassigning user_created and role

GitHub Advisories

### Summary A non-admin user who can update their own shares can reassign a share's creator (user_created), role, item, and collection fields after the share is created. The update is authorized against the row as it existed before the change, and the resulting row is never revalidated, so these fields can be set to values the user would not be permitted to assign when creating a share. By reassigning both user_created and role to an administrator the share's effective permissions get elevated. This is a server-side authorization gap in the share update path. It does not by itself produce an administrator token. It re-opens a previously patched privilege-escalation surface on the effective permissions of a share. ### Prerequisites - An authenticated non-admin account that hold…

Security Severity: Medium CVE-2026-129301 GHSA-8CGQ-X343-P74C

mail-parser: One hostile attachment aborts `write_attachments()` and silently drops the rest of the batch

GitHub Advisories

### Impact write_attachments() called _safe_attachment_filename() and write_sample() inside its loop with no guard, so a single crafted attachment raised out of the whole save. Every attachment **after** the malicious one was silently never written, with no error surfaced to a caller that catches only MailParserError. That is an evasion primitive as much as an availability bug: a sender puts one poisoned part first and the real payload second, and the payload never reaches the extraction directory that a downstream scanner or sandbox reads — while it still reaches the recipient's mail client intact. The tool's output diverges from the bytes actually in the message, which is the same failure mode as the filename-sanitizing bypass in [GHSA-fr3h-cpq2-9496](https://github.com/SpamScop…

Security Severity: Medium CVE-2026-129300 GHSA-XHRQ-2MQV-Q8WX

mail-parser: Uncaught `OverflowError` / `OSError` on an out-of-range `Received` date

GitHub Advisories

### Impact A Received header whose trailing date carries an out-of-range year, or a timezone offset large enough to push the timestamp past the int64 epoch range, raises an exception that is **outside the MailParser* hierarchy**. A caller that catches only mail-parser exceptions does not catch it, and the parse of the entire message is aborted — the same class of issue as [GHSA-24mq-4vc6-2prf](https://github.com/SpamScope/mail-parser/security/advisories/GHSA-24mq-4vc6-2prf), which this survives (it is not a duplicate; 24mq is fixed in 4.6.2 and this reproduces on 4.6.2). All entry points are affected: parse_from_string(), parse_from_bytes(), parse_from_file(), parse_from_file_obj() and the mail-parser CLI. The header is fully attacker-controlled and a single line is enough,…

Security Severity: Medium CVE-2026-129235 GHSA-GJ7R-P794-HHQ5

Kubeshark: MCP `download_file` writes fetched bytes to an unvalidated destination path

GitHub Advisories

**Ecosystem / package:** Go — github.com/kubeshark/kubeshark (the kubeshark CLI, kubeshark mcp subcommand) **Affected component:** cmd/mcpRunner.go, MCP tool download_file **Affected versions:** >= v53.1.0, < v53.4.0 (the flaw shipped with the tool's first release; v53.3.0 was the last affected release) **Patched version:** v53.4.0 **Credit:** novice-22 (Urim), via private coordinated disclosure. ## Summary The download_file MCP tool fetches a caller-supplied path from the Kubeshark Hub API and writes the response body to a caller-supplied dest on the local filesystem with no validation of dest. An attacker who can influence the MCP tool arguments — e.g. via indirect prompt injection against an AI agent driving kubeshark mcp — can write attacker-controlled bytes…

Security Severity: High CVE-2026-129236 GHSA-8VF2-HXG5-CRQH

Kubeshark: MCP `start_kubeshark` argument injection via `pod_regex` → image redirect → cluster takeover

GitHub Advisories

**Ecosystem / package:** Go — github.com/kubeshark/kubeshark (the kubeshark CLI, kubeshark mcp subcommand) **Affected component:** cmd/mcpRunner.go, MCP tool start_kubeshark **Affected versions:** >= v53.1.0, < v53.4.0 (the flaw shipped with the MCP command's first release; v53.3.0 was the last affected release) **Patched version:** v53.4.0 **Credit:** novice-22 (Urim), via private coordinated disclosure. ## Summary The start_kubeshark MCP tool builds a kubeshark tap command by appending the caller-supplied pod_regex as a bare positional argument, with no -- end-of-options separator. Because tap is a cobra command, a pod_regex that begins with -/--set= is parsed as a **flag**, not as the pod regex. An attacker who can influence the tool arguments (e.g. indi…

Security Severity: Medium CVE-2026-129299 GHSA-24MQ-4VC6-2PRF

mail-parser: Uncaught exceptions and silent header loss in mail-parser on attacker-controlled input

GitHub Advisories

### Impact Two effects, sharing the root cause of Advisory 1 — header names chosen by the sender were resolved through Python attribute lookup and rewritten before lookup. **Uncaught exceptions.** A crafted message raises an exception that is *outside* the MailParser* hierarchy, so a caller catching only mail-parser exceptions does not catch it and the worker dies. *Header named after a method* (CWE-248, reported by @iam-niranjan). Python resolves real class attributes before __getattr__, so a header named after a method put a bound method object into the parsed mail dict. A 12-byte email is sufficient. Nine colliding names were confirmed: Parse, Message, Write_Attachments, From_File, From_File_Obj, From_File_Msg, From_String, From_Bytes, Get_Server_Ipaddress. Also r…

Security Severity: High CVE-2026-129297 GHSA-72PX-J8GH-P79X

mail-parser: Sender IP address spoofing in get_server_ipaddress()

GitHub Advisories

### Patches Fixed in **4.6.2**. Upgrade with pip install --upgrade mail-parser. Candidate addresses are now selected by position, not by appearance — a bracketed address the sender wrote is byte-identical to one the MTA wrote, so no amount of pattern matching can tell them apart: - the first token of the from clause is the HELO name, whatever its shape, and is never a candidate; - an explicit HELO marker inside a comment group is sender text and is excluded; - a candidate must sit inside a ( / [ group; - IPv4 and IPv6 matches are merged positionally, never family-first; - the walk stops at the first trusted hop naming no address, rather than continuing into sender-written headers. The IPv6 pattern was corrected to skip the IPv6: tag and to prefer the longest valid form. **Behavi…

Security Severity: High CVE-2026-129295 GHSA-R7W7-VPQ8-C5VV

mail-parser is vulnerable to polynomial ReDoS in email header parsing

GitHub Advisories

### Summary Two regular expressions used while parsing email headers backtrack polynomially on attacker-controlled input. Parsing a single small, well-formed email can consume minutes to hours of CPU, denying service to any process that parses untrusted mail. Both are reachable from an ordinary parse_from_string(), parse_from_bytes() or parse_from_file() call — no special API, option, or malformed structure is required by the victim. ### Details **1. Address-header fallback regex (src/mailparser/utils.py)** get_addresses() falls back to _ADDR_FALLBACK_RE whenever email.utils.getaddresses(strict=True) yields no usable address. The alternative ([^ overlaps a lazy quantifier with an adjacent \s* — a space matches both. Driven by finditer, which retries at every offset and…

Security Severity: Medium CVE-2026-129296 GHSA-FR3H-CPQ2-9496

mail-parser: Path Traversal vulnerability in attachment extraction

GitHub Advisories

A path traversal vulnerability was identified in mail-parser when extracting email attachments using the write_attachments() and write_sample() APIs. A specially crafted email containing malicious attachment filenames (for example, using directory traversal sequences such as "../" or absolute filesystem paths) could cause files to be written outside the intended output directory. Depending on how the library was used and the permissions of the executing process, this could result in arbitrary file overwrite. The vulnerability affects mail-parser versions 3.8.0 through 4.5.0. The issue has been addressed by introducing comprehensive filename sanitization and path validation before any file is written to disk. The fix includes: - Sanitization of attachment filenames before writing. - Valida…

Security Severity: High CVE-2026-86046 GHSA-259W-WMQG-FP76

termux-sync: Arbitrary file write during restore via attacker-controlled manifest source path

GitHub Advisories

termux-sync restore trusts fields inside an untrusted backup manifest and uses them as the extraction destination without validation. During restore, each archive entry is handled as: src_dir = Path(info.get("source", ...)).parent extract_archive(archive, src_dir, ...) extract_archive opens the archive and runs tarfile.extract for every member with no path jail and no filter: with tarfile.open(archive_path, "r:*") as tf: for member in tf.getmembers(): tf.extract(member, dest_path, set_attrs=True) There is no check that manifest "source" stays under an expected restore root, that tar members stay inside dest_path, or that backup_name used in temporary paths cannot contain ".." or separators. Impact: A victim who restores a malicious backup (local, shared, or from a compromised GitHub/Googl…

Security Severity: High CVE-2026-68934 GHSA-JQ3Q-62JC-FQQ9

code-review-mcp-server: Command injection via unsanitized folderPath/baseBranch parameters

GitHub Advisories

### Impact code-review-mcp-server exposes MCP tools (getLocalGitDiff, codeReview, createPR, getPRTemplate) that accept folderPath and baseBranch string parameters. These caller-controlled values were interpolated directly into shell command strings executed via child_process.execSync(), which runs commands through /bin/sh. A crafted value such as baseBranch = "main; #" (or a $(...) command substitution, or a folderPath that breaks out of the surrounding quotes) results in **arbitrary command execution** on the host running the MCP server. ### Patches Fixed in **1.5.3**. Every execSync() call was replaced with execFileSync() using argument arrays, so inputs are passed directly to git / gh without going through a shell, eliminating the injection at its root.…

Security Severity: High CVE-2026-63182 GHSA-W553-PWX6-3MG9

lightsaml allows Signature wrapping bypass

GitHub Advisories

### Summary LightSaml 5.0.0 (latest release; also confirmed on 4.6.1) validates an inbound samlp:Response by collecting its direct-child saml:Assertion elements and validating each one's ds:Signature via robrichards/xmlseclibs. The two layers disagree on which element a signature actually covers: LightSaml reads claims from the assertion node it collected, while xmlseclibs resolves the signed Reference URI="#id" with a document-wide //*[@Id] XPath that returns the first ID-bearing element anywhere in the document. An attacker who has captured one genuine signed assertion can exploit this to surface attacker-authored, unsigned claims. ### Details Response::deserialize collects assertions with manyElementsFromXml, whose relative XPath saml:Assertion matches only direct child…

Security Severity: Medium CVE-2026-119790 GHSA-MFR8-8QWW-V76H

Next.js: Information disclosure across root params when a 'use cache' function is called through unstable_cache()

GitHub Advisories

Next.js applications with 'use cache' can disclose cached data across root params when the same 'use cache' function is called both directly during rendering and through unstable_cache(), and that function reads a root param. Root params are route parameters of the root layout, and applications commonly use them to scope data, for example per locale. During a cold process start, a cross-request deduplication race allowed an unstable_cache() call to join the in-flight fill of a concurrent direct call and receive its result, bypassing the root param check that would normally reject it. unstable_cache() then stored that result under a cache key without root params, so subsequent requests for other root param values received the same entry until it is revalidated or evicted. Cached…

Security Severity: High CVE-2026-128134 GHSA-7MXV-7H3Q-9324

NLTK dot2img runs Graphviz 'dot' without the trusted-exec chokepoint, enabling local code execution via a writable PATH element

GitHub Advisories

## Summary nltk.parse.dependencygraph.dot2img invokes the Graphviz dot executable without the trusted-execution guarantees that NLTK applies to its other native-tool wrappers. The function resolves dot by bare name and then runs the resolved absolute path with a raw subprocess.run, omitting the ownership/writability check and the loader-environment scrub that nltk.pathsec.spawn_trusted provides. On a POSIX host, a local, unprivileged actor who can write to any group/world-writable directory that appears on the victim's PATH can plant a trojan dot; when the victim later renders a DependencyGraph (for example in a Jupyter notebook, which auto-invokes _repr_svg_) or calls dot2img directly, the planted binary executes as the victim. The advisory GHSA-6hwm-xvph-95vm (CVE-20…

Security Severity: Low CVE-2026-128076 GHSA-HF59-9XWC-2G4P

Nuxt: Colliding island props can share one `/__nuxt_island` path (incomplete fix for CVE-2026-46342)

GitHub Advisories

### Summary The fix for CVE-2026-46342 (GHSA-g8wj-3cr3-6w7v) binds each /__nuxt_island/_.json path to its props by hashing the (name, props, context, source) tuple. That hash was computed over ohash's serialization, which does not escape quotes inside strings or delimiters inside keys, so two different prop objects can produce the same hash. A request with crafted props can therefore pass validation for another island's path and render different content at that path. ### Impact For example, these two prop objects serialize identically and share one island path: ``js { html: '', note: '' } { html: '\',note:\'' } `` This reopens the scenarios described in GHSA-g8wj-3cr3-6w7v: - **nuxt generate / prerendering.** Nuxt caches prerendered island responses by path. If the crawler reach…

Security Severity: Medium CVE-2026-128075 GHSA-96X6-FVHX-49HG

Nuxt exposes the message and data of unhandled errors thrown during server rendering

GitHub Advisories

### Summary When a page, plugin or route middleware throws an error that is not an HTTP error, Nuxt wraps it with createError before rendering the error page. The wrapped error was treated as one the app raised deliberately, so in production its message and data were sent to the client in the error page payload (__NUXT_DATA__) and in JSON error responses. For a failed $fetch, that is the URL that was requested (including its query string) and the body of the upstream error response. ### Impact An application is affected if server-rendered code lets an error with sensitive details reach the error page, for example: ``vue const route = useRoute() // the upstream error body, and the token in the URL, reach the client if this request fails await $fetch(http://users.internal/users/…

Security Severity: Medium CVE-2026-128074 GHSA-R9JC-W898-3FV6

Nuxt payload URL generation has quadratic cost for repeated slashes in the request path

GitHub Advisories

### Summary Nuxt strips trailing slashes from the request path with a regular expression whose cost grows quadratically with the length of a run of consecutive slashes. A single unauthenticated request with a long run of slashes can occupy the server's event loop for a noticeable time, delaying every other request handled by the same process. ### Impact When a page is rendered with payload extraction (any route covered by an isr, swr or cache route rule), Nuxt builds the _payload.json URL from the raw request path. A path such as /blog/a followed by 16,000 slashes and x, which fits within Node's default header size limit, takes roughly 0.1 to 0.4 seconds of synchronous CPU time per request, depending on hardware. Concurrent requests to the same process wait for it to finish, s…

Security Severity: Low CVE-2026-128072 GHSA-X2WV-5868-P7V2

@nuxt/webpack-builder and @nuxt/rspack-builder dev server serves built source to DNS rebinding pages

GitHub Advisories

### Summary When using the webpack or rspack builder, the dev server serves built client chunks to any request whose Host header matches its Origin/Referer, or that carries Sec-Fetch-Site: same-origin. After a DNS rebinding attack both headers name the attacker's hostname, so a malicious page opened while nuxt dev is running can read /_nuxt/*.js and exfiltrate the app's source. This bypasses the same-origin check added for [GHSA-4gf7-ff8x-hq99](https://github.com/nuxt/nuxt/security/advisories/GHSA-4gf7-ff8x-hq99), [GHSA-6m52-m754-pw2g](https://github.com/nuxt/nuxt/security/advisories/GHSA-6m52-m754-pw2g) and [GHSA-x6qj-4h56-5rj5](https://github.com/nuxt/nuxt/security/advisories/GHSA-x6qj-4h56-5rj5). ### Impact A developer runs nuxt dev with builder: 'webpack' or `builder:…

Security Severity: Medium CVE-2026-128071 GHSA-F3X9-2CHM-73C8

Nuxt: Incomplete fix for GHSA-6gq8-jgmh-3ffp: an encoded slash (`%2F`) in the request path bypasses route rules on catch-all page routes

GitHub Advisories

### Summary Nuxt matches route rules against the request path with encoded slashes (%2F) left encoded, while the page router decodes them into route params. A request that spells a slash as %2F can therefore render a page through a catch-all route without the route rules configured for the path it resolves to. The fix for [GHSA-6gq8-jgmh-3ffp](https://github.com/nuxt/nuxt/security/advisories/GHSA-6gq8-jgmh-3ffp) deliberately left reserved escapes such as %2F encoded, so it did not cover this form. ### Impact An unauthenticated attacker can bypass route rules that protect paths served by a catch-all page route, or by a custom route whose param can span several segments. ```ts export default defineNuxtConfig({ routeRules: { '/docs/internal/**': { appMiddleware: 'auth', headers: { 'X-F…

Security Severity: High CVE-2026-128118 GHSA-M9J8-JCMV-HP69

SvelteKit: Build-time server-only module import guard could fail, resulting in server secrets being statically replaced in client bundle

GitHub Advisories

Under certain circumstances, server-only imports, which typically cannot be included in the client bundle, could make their way into it, potentially exposing secrets. This could only occur when those server-only imports were made through src/params.js.

Security Severity: High CVE-2026-128120 GHSA-3R8G-JCQQ-3P5J

SvelteKit: DoS while parsing form data from a remote functions `form`

GitHub Advisories

This only affects applications using the experimental remote functions flag and utilizing the form, query, or command remote functions. A specially-crafted request could block the event loop for extended periods of time during parsing.

Security Severity: High CVE-2026-128124 GHSA-JM3W-GW2P-XJFJ

AIOHTTP: Event loop stall in add_domain() wildcard matching

GitHub Advisories

### Summary Application.add_domain() compiled each * in a host mask to [^:]*. With two or more wildcards in a mask, matching a long Host header that does not match the mask took polynomial time on the event loop. ### Impact An attacker could stall a server that registers a domain mask with more than one wildcard by sending requests with a long Host header. ### Workaround Use at most one * in a domain mask. --- Patch: https://github.com/aio-libs/aiohttp/commit/c6ac0e44c3c573ff9616f4a6a532992538b31e43

Security Severity: Medium CVE-2026-128125 GHSA-5PV8-VVHC-H7JV

AIOHTTP: Unbounded cookie storage in client CookieJar

GitHub Advisories

### Summary Set-Cookie parsing created additional cookies from unrecognised name=value attributes, and CookieJar had no limit on the number of cookies stored or sent. A server could make the client store a very large number of cookies and generate very large Cookie headers. ### Impact A malicious server could cause excessive memory and CPU use in a client, repeated on every redirect, and cause later requests to the same domain to build an excessively large Cookie header. --- Patch: https://github.com/aio-libs/aiohttp/commit/6963ee0befec1502b6bb7b4db6c72d044c08f4fa

Security Severity: High CVE-2026-128126 GHSA-XGW8-8CCX-RMQH

AIOHTTP: Too many URL-encoded form fields block the event loop

GitHub Advisories

### Summary Request.post() had no limit on the number of fields in a URL-encoded form body. Inserting a large number of repeated keys into a MultiDict took quadratic time on the event loop. ### Impact An attacker could block the event loop with a form POST within the default client_max_size to any handler that calls Request.post(). --- Patch: https://github.com/aio-libs/aiohttp/commit/615fec3d4f088f30d2ee72cad760152e92aa1c53

Security Severity: High CVE-2026-128127 GHSA-24C4-3P7V-29CM

AIOHTTP: Base64 multipart parts bypass client_max_size

GitHub Advisories

### Summary When reading a multipart part with Content-Transfer-Encoding: base64, BodyPartReader.read_chunk() kept reading until the chunk length was a multiple of 4, with no byte limit. A part with a short Content-Length, or a long run of whitespace, could cause the entire remaining body to be read into memory within a single call before any size check, or spin on the event loop. ### Impact An attacker could bypass client_max_size to cause excessive memory use, or block the event loop, with a specially crafted multipart request to any handler that reads multipart data. --- Patch: https://github.com/aio-libs/aiohttp/commit/a555ab698e08e9baea7386d5b4c0761cb8956fdd

Security Severity: High CVE-2026-128128 GHSA-3RP8-RXJ8-MVJW

AIOHTTP: WebSocket max_msg_size bypass via integer overflow

GitHub Advisories

### Summary The max_msg_size check in the WebSocket reader added the declared frame length to the size of the partial message already buffered. In the C extension this addition is 64-bit arithmetic, so a declared length close to 2**63 overflowed and the check passed. ### Impact An attacker could bypass max_msg_size and cause unbounded memory use by streaming an oversized WebSocket message after a small non-final fragment. ### Workaround If unable to upgrade, the Python reader is unaffected and can be used with AIOHTTP_NO_EXTENSIONS=1. --- Patch: https://github.com/aio-libs/aiohttp/commit/8cfbe9abe5e11b84006a10f9bdf82bf607671dab

Security Severity: High CVE-2026-128129 GHSA-PW86-H8FM-J323

AIOHTTP: Unbounded buffering of data received during an upgrade request

GitHub Advisories

### Summary While a request flagged as an upgrade (e.g. a WebSocket handshake) was being handled, all further data received on the connection was buffered with no size limit or flow control until the handler completed. ### Impact An attacker could cause unbounded memory use by streaming data behind an upgrade request to any handler that does not immediately accept or reject the upgrade. --- Patch: https://github.com/aio-libs/aiohttp/commit/3d850ee9b92573c7e913821cbcb96005beb3f4df

Security Severity: High CVE-2026-128130 GHSA-28QF-CPWQ-VMC2

AIOHTTP: Pure-Python parser request replay and buffer growth behind a declined upgrade

GitHub Advisories

### Summary When the pipelined request queue was full, the pure-Python parser stored the unparsed remainder internally and also returned it to the caller. After a handler declined an upgrade request, the buffered data was re-fed, so the buffer grew with each handled request and already-handled requests were dispatched to the application again. ### Impact If users are using the Python parser (AIOHTTP_NO_EXTENSIONS, or not a standard wheel installed), an attacker could cause excessive memory use and cause pipelined requests to be processed more than once. ### Workaround Switch to the default C parser. --- Patch: https://github.com/aio-libs/aiohttp/commit/47babd8c23ca79e2bae6cc8dcb5752b61e369fc7

Security Severity: High CVE-2026-128131 GHSA-H4CC-HM5H-FMM9

AIOHTTP: Concatenated compressed streams cause excessive CPU use

GitHub Advisories

### Summary When decompressing a payload made up of many concatenated compressed members (gzip, deflate or zstd), each member was decoded by passing the entire remaining input to a new decompressor, resulting in quadratic CPU time. Empty members produce no output, so client_max_size and output backpressure did not limit the work. ### Impact An attacker could block the event loop of a server with a specially crafted compressed request body or WebSocket message. A malicious server could do the same to a client. --- Patch: https://github.com/aio-libs/aiohttp/commit/d925a80539ffd227da1d93ab4a5bff123cc777db

Security Severity: High CVE-2026-128132 GHSA-5RMC-48H2-HVCM

AIOHTTP: WebSocket receive queue limits bypassed by small or compressed messages

GitHub Advisories

### Summary The WebSocket reader continued parsing frames already received after the receive queue had paused the transport, and empty messages were not counted towards the queue size. With permessage-deflate, a single read of compressed frames could add many megabytes of decompressed messages to the queue. ### Impact An attacker could cause excessive memory use in a WebSocket server, or a malicious server against a client, by sending many small or compressed messages faster than the application consumes them. --- Patch: https://github.com/aio-libs/aiohttp/commit/0ae507423f681161efa77d20052b4054397c7fb6

Security Severity: Medium CVE-2026-128119 GHSA-6CF5-GC4Q-FM3X

SvelteKit: Private `query.batch` functions could collide, producing unexpected parameter / function combinations

GitHub Advisories

Under certain circumstances, private (non-exported) query.batch functions could end up sharing a batch, resulting in the arguments from one function being passed to another. This only affects apps using the experimental remote functions flag and non-exported query.batch functions.

Security Severity: Medium CVE-2026-128116 GHSA-RQP5-R3WG-VG35

SvelteKit: Protocol-relative module import during server-side route resolution allows cross-origin script execution

GitHub Advisories

If an attacker could, using some form of social engineering or other exploit, get a user to use client-side navigation to navigate to a specially-crafted link, the attacker could cause code from another domain to be imported and run on the user's machine. This only affected apps with router.resolution: 'server'.

Security Severity: Medium CVE-2026-126302 GHSA-XMFG-F9CM-W86Q

NLTK: Symlink escape in chat80.sql_query bypasses the pathsec data-root sandbox to read out-of-root SQLite databases

GitHub Advisories

## Summary nltk.sem.chat80.sql_query() opens a SQLite database by handing the result of nltk.data.find(dbname) straight to sqlite3.connect() without the path-containment check that the NLTK data sandbox (nltk.pathsec) is meant to enforce. nltk.data.find() applies only lexical checks to the resource name and returns a FileSystemPathPointer whose path is normalized with os.path.abspath but never resolved for symlinks. As a result, an in-root symbolic link that points at a SQLite file outside every registered NLTK data root is followed by SQLite, and the caller receives query results from the out-of-sandbox database. An attacker who can place a file inside a directory the application trusts as an NLTK data root can read SQLite databases that the pathsec sandbox is supposed to k…

Security Severity: Medium CVE-2026-126296 GHSA-59F9-GQG8-MQPJ

NLTK: Path Traversal in save_maxent_params / load_maxent_params Allow Arbitrary File READ/WRITE

GitHub Advisories

### Summary Path traversal in NLTK's save_maxent_params() and load_maxent_params() allows arbitrary file write and arbitrary file read outside the directories permitted by NLTK's pathsec security mechanism. This vulnerability was previously reported through Huntr, accepted by the NLTK project, and assigned CVE-2026-15367. A $750 bounty was paid through Huntr (i didnt get the fix bounty). Huntr subsequently shut down its OSS vulnerability program, so I am submitting this report through GitHub to continue the existing disclosure process and preserve the original CVE assignment and researcher credit. ### Details The affected functions are: - nltk.classify.maxent.load_maxent_params() - nltk.classify.maxent.save_maxent_params() Both functions construct filesystem paths from the caller-controll…

Security

Google Finds Hackers Using AI Agents to Build and Run Exploits From Software Patches

The Hacker News

Google on Monday revealed that adversarial use of artificial intelligence (AI) by threat actors has gone beyond manual prompting to deploying autonomous multi-agent offensive frameworks like ARTEX, CAIRN, CyberStrikeAI, and PentAGI to execute multi-stage intrusions at greater operational velocity. In tandem, threat actors are leveraging the power and capabilities of large language models (LLMs)

Security

⚡ Weekly Recap: N-able 0-Days, Windows 0-Days, Chrome 0-Days, Fridge 0-Days, and More Bad Days

The Hacker News

A default password opened doors it never should have. A trusted update delivered malware. Even a security feature became a way to break in. Different stories, same problem: the things meant to protect us aren't always doing their job. Meanwhile, AI is making bug hunting faster, old flaws are still paying off, and attackers keep finding easy ways in. Some attacks take real skill. Others barely

Security

Six Unpatched Danfoss Refrigeration Controller Flaws Could Allow Remote Takeover Without Login

The Hacker News

Six flaws in Danfoss AK-SM800A refrigeration controllers could let a remote attacker take over a controller without logging in, Dutch security consultancy Midnight Blue said earlier this week. No patch is available, and the researchers say the newest firmware, version 5.4.0, does not fix the flaws. Government cybersecurity agencies in Belgium, Ireland and Germany told operators this week to

Security

Retadup Worm Resurfaces 7 Years After Takedown to Spread CoffeeLoader Malware

The Hacker News

Cybersecurity researchers have disclosed details of a new variant of CoffeeLoader, a malware designed to deliver additional payloads to infected machines. "On launch, the NSIS-based installer executable dropped a file named '7z.dll' into a temporary directory and ran it through rundll32.exe," Kaspersky said in an analysis published today. "The '7z.dll' file was a patched version of the

Security

SANSAR Linux Cryptomining Malware Uses Modified NVIDIA Library to Hide GPU Activity

The Hacker News

A financially motivated threat activity cluster tracked as REF3364 has been attributed to a Linux-focused cryptocurrency mining operation that tampers with the readings used to detect high GPU workloads. Central to the intrusion is a toolkit called SANSAR, a Rust-based orchestrator that receives commands over the TOR anonymity network to manage CPU and GPU miners. The activity was observed in

Security

Amazon Uncovers AI Agent Campaign Targeting LiteLLM, Dify, and Other Apps for API Keys

The Hacker News

Attackers' AI agents have been hunting for weak spots in internet-exposed AI apps such as LiteLLM, One API, and Dify to steal the AI provider keys stored inside, according to the agents' own records. The records, which Amazon's threat intelligence team captured with decoy servers, describe stolen keys being used to run the AI models that powered the search for more keys. The team said this

Security

BO Team Exploits Log4Shell in VMware vCenter, Compromises Russian Firm's Code-Signing Server

The Hacker News

An investigation into suspicious activity within a Russian software developer's network has uncovered a months-long compromise of its development infrastructure and a software code-signing server. The activity, documented by Kaspersky's ICS CERT team after it was contacted by the affected developer in June 2025, has been attributed to a threat actor named BO Team (aka Black Owl, Hoody Hyena,

Security

Italy Fines Meta €805 Million Over Facebook's Android Gallery Access Without Explicit Consent

The Hacker News

Meta was fined €805 million in Italy yesterday over a Facebook for Android feature that suggests photos and videos from users' phone galleries for them to post. The Garante, Italy's data protection authority, found that the feature was enabled by default and that the app accessed Italian users' photos, videos, and related metadata without their explicit consent. The company has 60 days to

Security

Stolen Fireworks AI Key Led to Cursor Data Breach and Trojanized Claude Code Extension

The Hacker News

The compromise of Anthropic's official Claude Code extension on Cursor's extension marketplace was the result of the theft of an access key that was exposed in the wake of a breach targeting Fireworks AI. "An attacker obtained an access key we had issued to Fireworks," Cursor said in a Friday update. "The key was exposed by Fireworks, and the attacker used it to copy data from a read-only

Security

Attackers Exploit UnrealIRCd Flaw That Enables Server-Level Command Injection

The Hacker News

The U.S. Cybersecurity and Infrastructure Security Agency (CISA) on Friday added a high-severity security flaw impacting UnrealIRCd, an open-source Internet Relay Chat (IRC) server, to its Known Exploited Vulnerabilities (KEV) catalog, following reports of active exploitation. The vulnerability, tracked as CVE-2026-114713 (CVSS score: 8.6), is a case of improper neutralization of delimiters

Security Severity: High CVE-2026-126299 GHSA-89P3-FCCH-88PH

NLTK: Quadratic-time CPU denial of service in CCG lexicon parser (fromstring) on wide bracket bodies and operator chains

GitHub Advisories

## Summary The public CCG lexicon parser nltk.ccg.lexicon.fromstring parses caller-influenced lexicon text with two pure-Python loops whose cost is quadratic in the input width. A service that parses an untrusted CCG lexicon string can be driven into tens of seconds of single-threaded CPU by a few-megabyte input, starving the request worker. No authentication or user interaction is required. ## Root Cause matchBrackets consumes a bracket body one character at a time with inside = inside + rest[0]; rest = rest[1:]. The rest = rest[1:] tail re-slice copies the entire remaining string on every iteration, so a flat bracket body costs O(n^2). augParseCategory drives a while rest != "": operator loop that re-copies the regular-expression match tail (rest = app[3]) once per operato…

Security Severity: High CVE-2026-126298 GHSA-R53H-RW34-8H97

NLTK: Quadratic-time CPU denial of service in Tree.chomsky_normal_form right-factor binarization via list.pop(0)

GitHub Advisories

## Summary Tree.chomsky_normal_form() binarizes a parse tree and defaults to right factoring. For a node with N children the right-factor branch repeatedly removes the first element of a working list with list.pop(0), which shifts all remaining elements each time, so binarizing one wide node costs O(N^2). An application that converts an attacker-supplied treebank tree to Chomsky Normal Form can be forced into tens of seconds of single-threaded CPU by one wide flat tree. No authentication or user interaction is required. ## Root Cause In the default right-factor branch the transform executes curNode[0:] = [nodeCopy.pop(0), newNode] inside a loop over the N children of a node. list.pop(0) is O(len) because it shifts every remaining element down by one; performed N-2 times over a shr…

Security Severity: High CVE-2026-126297 GHSA-V8F3-6PHW-6MH9

NLTK: Quadratic-time CPU denial of service in ConllCorpusReader SRL instance builder via nested span rescan

GitHub Advisories

## Summary ConllCorpusReader.srl_instances() builds semantic-role-labeling instances from a CoNLL corpus block. For a sentence block with P predicates and P span columns, the instance builder rescans every span column (and every span within it) once per predicate while searching for each predicate's head, giving O(P^2 * R) work. A single well-formed block that places the head span in the last column forces the full scan on every predicate, so an application that reads an attacker-supplied CoNLL SRL corpus can be driven into tens of seconds of single-threaded CPU. No authentication or user interaction is required. ## Root Cause _get_srl_instances iterates over the P predicates of a block; for each predicate it scans every span list and every span within it, using an inner break that…

Security Severity: Medium CVE-2026-126295 GHSA-FG9W-WFP5-J933

NLTK: BllipParser passes caller-supplied model paths to the bllipparser C extension with no pathsec check, enabling arbitrary read

GitHub Advisories

## Summary BllipParser in nltk/parse/bllip.py hands caller-supplied filesystem paths to the native bllipparser C extension without routing them through NLTK's pathsec validation. The constructor parameters parser_model, reranker_features, and reranker_weights, and the alternative from_unified_model_dir() entry point, flow directly to the C extension's load_parser_model() and load_reranker_model() calls, which open and read the given path at the OS level. Any application that passes an attacker-influenced path to this API reads a file of the attacker's choosing from anywhere on the filesystem, outside the NLTK data roots that every other NLTK tool wrapper confines access to. ## Root Cause As of NLTK 3.10.0, SECURITY.md documents a centralized I/O security module (`nlt…

Security Severity: High CVE-2026-62297 GHSA-QFX6-Q44V-9QQW

ag-psd can exhaust memory when parsing crafted PSD dimensions

GitHub Advisories

### Summary readPsd() commits the image/layer buffers from the declared header geometry (width x height x channels x depth, and per-layer rectangles) before validating those values against the actual data. A tiny crafted PSD declaring huge geometry forces a multi-gigabyte allocation. ### Impact On ag-psd 30.2.0, Node 24, a 52-byte PSD makes readPsd(buf) commit ~3.17 GB (measured peak RSS) in ~0.45 s before throwing a catchable RangeError ("Offset is outside the bounds of the DataView") — about 61,000,000x amplification. Because the buffer is committed before validation, the allocation OOM-kills the process before the error on essentially any host (uncatchable), and concurrent requests exhaust memory. Any service reading untrusted PSDs with ag-psd is exposed to a remote DoS. This is distin…

Security Severity: Low CVE-2026-62683 GHSA-PP88-JHWJ-5QH5

File Browser: Trailing-slash directory deletion leaves public shares active for recreated paths

GitHub Advisories

## Summary File Browser v2.63.15 can leave a public directory share behind when the shared directory is deleted through a path with a trailing slash. The share cleanup path calls DeleteWithPathPrefix(file.Path, userID), but the Bolt backend performs the database prefix query with the unnormalized argument before trimming the slash for boundary checks. For a stored share at /a, deleting /a/ queries for paths prefixed by /a/, so the exact /a share is never loaded and never deleted. If a directory with the same path is later recreated, the stale public share becomes active again and exposes the new directory contents through the old public URL. ## Impact An authenticated user with share, download, and delete permissions can create a valid public share, delete the shared path with a…

Security Severity: Medium GHSA-GPWC-27CW-RH9R

NLTK: Quadratic CPU exhaustion in LegalitySyllableTokenizer.tokenize via unguarded onset reversal loop

GitHub Advisories

## Summary LegalitySyllableTokenizer.tokenize in the NLTK tokenizer package contains an unguarded O(n^2) processing loop. When the method is called on a single token that consists of a long run of vowels (for example "a" * n), it consumes CPU time proportional to the square of the token length. An attacker who can supply an untrusted token to this public tokenizer API can force a single request to saturate one CPU core for a prolonged period, degrading availability of any service that syllabifies attacker-controlled text. No authentication, special configuration, or user interaction is required. ## Root Cause The method walks the token in reverse and, on every iteration after the first vowel is seen, evaluates the membership test char_lower + current_onset[::-1] in self.legal_onsets…

Security Severity: Medium CVE-2026-126301 GHSA-GPWC-27CW-RH9R

NLTK: Quadratic CPU exhaustion in LegalitySyllableTokenizer.tokenize via unguarded onset reversal loop

GitHub Advisories

## Summary LegalitySyllableTokenizer.tokenize in the NLTK tokenizer package contains an unguarded O(n^2) processing loop. When the method is called on a single token that consists of a long run of vowels (for example "a" * n), it consumes CPU time proportional to the square of the token length. An attacker who can supply an untrusted token to this public tokenizer API can force a single request to saturate one CPU core for a prolonged period, degrading availability of any service that syllabifies attacker-controlled text. No authentication, special configuration, or user interaction is required. ## Root Cause The method walks the token in reverse and, on every iteration after the first vowel is seen, evaluates the membership test char_lower + current_onset[::-1] in self.legal_onsets…

Security Severity: Medium CVE-2026-126300 GHSA-FFR9-MGRR-WCVR

NLTK: Quadratic CPU exhaustion in TreebankWordTokenizer.span_tokenize via list.pop(0) in quote-restore loop

GitHub Advisories

## Summary TreebankWordTokenizer.span_tokenize in the NLTK tokenizer package contains an unguarded O(n^2) processing loop in its quote-restoration step. When the method is invoked on text containing a long run of double-quote characters (for example '"' * n), it performs a list.pop(0) operation once per quote token, and because list.pop(0) is O(length), the total cost grows with the square of the input length. An attacker who can supply untrusted text to this public span-tokenization API can force a single request to saturate one CPU core for a prolonged period, degrading availability. No authentication, special configuration, or user interaction is required. ## Root Cause Inside span_tokenize, when the input contains double or repeated quotes, the code builds matched, a list…

Security Severity: High CVE-2026-126303 GHSA-8FX7-8JR8-84RV

NLTK: Unbounded CPU consumption in SteppingRecursiveDescentParser.parse() with ambiguous or self-embedding grammars

GitHub Advisories

## Summary nltk.parse.recursivedescent.SteppingRecursiveDescentParser.parse() performs an unbounded top-down search over ambiguous or self-embedding context-free grammars with no wall-clock or step limit. An actor who can influence the grammar and supply a short input to a caller that uses this parser can force a single parse() call to pin a CPU core indefinitely, producing a denial of service. The related base class RecursiveDescentParser gained a max_time wall-clock deadline, but the stepping subclass drives its own step loop and never arms or consults that deadline, and its constructor does not accept a max_time parameter, so the guard cannot be enabled on this path. ## Root Cause RecursiveDescentParser bounds its recursive search inside _parse: it arms a wall-clock deadl…

Security Severity: High CVE-2026-126304 GHSA-QG35-44QX-7VRR

NLTK: Symlink escape in YCOECorpusReader lets a psd/pos directory symlink read files outside the corpus root within the data sandbox

GitHub Advisories

## Summary YCOECorpusReader builds two nested corpus sub-readers whose roots are derived from self.root.join("psd") and self.root.join("pos") (nltk/corpus/reader/ycoe.py). Because FileSystemPathPointer.join() (nltk/data.py) performs a purely lexical containment check and never resolves symlinks, and because CorpusReader.__init__ (nltk/corpus/reader/api.py) validates a sub-reader root only against the global NLTK data sandbox and not against the enclosing corpus root, a directory symlink named psd or pos planted inside a YCOE corpus lets the reader anchor its nested sub-readers outside the YCOE corpus root. An attacker who controls the contents of a YCOE corpus loaded under pathsec.ENFORCE=True can make parsed_sents(), tagged_words(), and related methods return file con…

Security Severity: Medium CVE-2026-128117 GHSA-MW6W-2FMV-PVW3

SvelteKit: adapter-node crashes with an unhandled URIError when `reroute` rewrites malformed pathnames

GitHub Advisories

When reroute turned an invalid percent-encoded path into a valid path, it could potentially trigger a comparison that would crash the server.

Security Severity: Medium CVE-2026-128121 GHSA-JF9X-2FG2-HX4W

SvelteKit: Prerendered paths are interpreted as regular expressions in Vercel route config generated by @sveltejs/adapter-vercel and @sveltejs/adapter-static

GitHub Advisories

If an attacker could influence a link that was crawled during the prerender phase, that link could later be interpreted as a regex in the Vercel routing configuration.

Security Severity: Medium CVE-2026-128122 GHSA-5WG4-Q3WW-283H

SvelteKit: Prerendered redirect paths can inject arbitrary rules into the `_redirects` file generated by `@sveltejs/adapter-cloudflare`

GitHub Advisories

If an attacker can influence the links crawled during prerendering, they can influence the redirects entries that are added to the Cloudflare platform redirects generated during the adapt phase of the build.

Security Severity: Medium CVE-2026-128123 GHSA-RQW3-X7HX-MM3P

SvelteKit: `@sveltejs/adapter-node` crashes when proxying certain requests via `fetch`

GitHub Advisories

In affected versions, @sveltejs/adapter-node can attempt to add a header to an immutable request in a context that causes the server to crash, denying service to any other requests routed to that server.

Security Severity: Low CVE-2026-126347 GHSA-5CJW-F85J-CV6R

Tornado: Open redirect via triple-slash redirect paths

GitHub Advisories

### Summary Due to differences in the way browsers and Python's urllib parse urls, browsers treat a string starting with three or more slashes as a protocol-level redirect, while urllib does not. This means that the 6.6.0 fix for the RedirectHandler open redirect (CVE-2026-116578, commit cc75ab0e) is incomplete. Tornado 6.6.1 improves the open-redirect detection to handle this case correctly, as well as fixing a regression in the 6.6.0 implementation.

Hosting & Network

Kitesurf is now open source

Cloudflare

Kitesurf, our experimental browser engine for AI agents, is now open source. Inspect the code, run it locally, or deploy your own instance on Cloudflare Workers.

Security Severity: High CVE-2026-128089 GHSA-VVF4-9X63-8XVV

dnspython has excessive memory and CPU use

GitHub Advisories

### Summary A maliciously crafted zone file could use a WKS record to consume excessive memory and CPU, possibly causing the process to exit due to memory exhaustion. ### Details The from_text() parser does not check that a WKS record service number is between 0 and 65535 inclusive. It then uses this number to resize the bitmap to accommodate a bit with that offset. This can cause extremely large memory allocations, and also extends the array very inefficiently, wasting CPU. ### Proof of concept This demonstrates the failure to limit the service number, though with a value that does not cause excessive memory or CPU consumption. `` rd = dns.rdata.from_text("IN", "WKS", "10.0.0.1 udp 65536") `` ### Impact If dnspython is used to read zonefile format where the attacker can control the t…

Security Severity: Medium CVE-2026-128077 GHSA-R99W-JH2X-3MG9

Nuxt: Incomplete fix for GHSA-9v7c-q64q-vv33: a leading `//` in the request path bypasses `server/middleware` path checks and server route rules on page routes

GitHub Advisories

### Summary Since 4.6.0, Nuxt parses a request path that starts with // as a URL with a host before rendering a page, so //x/admin renders the page at /admin. Nitro's routing, Nitro's route rules and server/middleware see the path as //x/admin, so server-side checks keyed on /admin do not apply. The fix for [GHSA-9v7c-q64q-vv33](https://github.com/nuxt/nuxt/security/advisories/GHSA-9v7c-q64q-vv33) in 4.6.3 covered dot segments but not this form. ### Impact An unauthenticated attacker can bypass server-side controls that match on the request path of a page route. A route-scoped server handler is skipped: ``ts // nuxt.config.ts export default defineNuxtConfig({ serverHandlers: [{ route: '/admin', middleware: true, handler: '~~/server/admin-guard.ts' }], }) `` ```ts // serv…

Security Severity: Medium CVE-2026-128080 GHSA-3V2P-HM54-8QCQ

OpenTelemetry JavaScript: Insertion of Sensitive Information into Log File and Exposure of Sensitive Information to an Unauthorized Actor in @opentelemetry/instrumentation-http

GitHub Advisories

### Summary @opentelemetry/instrumentation-http redacts sensitive URL query parameters on **outgoing (client) spans** but not on **incoming (server) spans**. The server-span path writes the raw query string verbatim into the url.query attribute, so credentials embedded in inbound request URLs — AWS presigned-URL signatures, Azure SAS tokens (sig), GCS signed-URL signatures — are exported in plaintext to the configured tracing backend. Configuring the redactedQueryParams option **does not change this**, as this applies only to outgoing (client) spans. ### Impact **Information disclosure / credential leakage** (CWE-200; CWE-532, insertion of sensitive information into telemetry data). **Who is impacted:** any Node.js service instrumented with @opentelemetry/instrumentation-http —…

Hosting & Network

Adapting to AI penetration testing orchestrators: The Modern Security Model

Cloudflare

AI-orchestrated penetration testing platforms like ARTEX have become increasingly powerful tools enabling effective attacks on exposed infrastructure. Here we share Cloudflare’s observations and recommended countermeasures.

Security Severity: High CVE-2026-128082 GHSA-6VHM-J9H7-F9GH

AutoMapper: Uncontrolled Recursion with Constructor Parameters

GitHub Advisories

### Summary MaxDepth, whether set explicitly or applied by default (64) to self-referential type maps, was not enforced when the recursion goes through constructor parameters. Mapping a deeply nested source to a destination built through its constructor, such as a positional record, recurses without bound and throws a StackOverflowException. That exception can't be caught and terminates the process. This bypasses the mitigation for CVE-2026-32933. ### Details The type depth used by MaxDepth was incremented only after the destination object was created. Constructor parameters, including child objects of the same type, are mapped while the destination is created, so each level recursed before its parent was counted, and the depth check never tripped. Affected: - destination types ma…

Security Severity: Low CVE-2026-128087 GHSA-9264-JVGF-6W2F

russh kex_done: Shared-secret callback runs before server host-key verification

GitHub Advisories

### Summary A malicious SSH server whose host key is rejected can still cause russh's client::Handler::kex_done() callback to execute with the raw key-exchange shared secret. Applications using the callback for its documented protocol-bridging purpose may derive keys, initialize a secondary data channel, or perform another externally visible action before russh calls check_server_key() and rejects the server. ### Details During the initial key exchange, russh calls kex_done() immediately after the server proves possession of the presented host key, but before the application decides whether that key belongs to the intended server: ```rust let shared_secret = newkeys.kex.shared_secret_bytes(); handler .kex_done(shared_secret, &newkeys.names, session) .await?; // Initial KEX only chec…

Security Severity: Low CVE-2026-128088 GHSA-736F-C93Q-9FWX

russh try_sign: asynchronous confirmation can sign after agent lock

GitHub Advisories

### Summary In russh 0.65.0, a sign request for a confirmation-constrained key can retain and use the private key after another connection locks the agent. try_sign() snapshots an Arc before awaiting Agent::confirm() and does not revalidate the shared lock state after the await. An agent-forwarding peer can therefore obtain a signature while the agent is locked and every new request is being rejected. ### Details The agent's lock and key stores are shared by all connections. respond() reads the lock state once, then dispatches a sign request: ```rust let is_locked = { // ... read the shared lock ... }; // ... Some((&13, mut r)) if !is_locked && agentref.confirm_request(MessageType::Sign).await => { let agent = self.agent.take().ok_or(Error::AgentFailure)?; let (agent, signed) =…

Security Severity: Medium CVE-2026-128086 GHSA-RRFC-GJM9-CGRJ

OpenTelemetry-Go: Eager W3C baggage-property materialization causes bounded memory-allocation amplification

GitHub Advisories

## Summary OpenTelemetry Go eagerly materializes W3C baggage metadata into property objects during parsing. Slice growth, serialization, and copying into the internal representation cause **bounded but disproportionate memory-allocation amplification** for a valid, densely populated header. In v1.46.0 and v1.47.0-rc.1, the 8,192-byte raw-input limit is checked before member parsing; this is not unlimited allocation or a bypass of that limit. A valid 8,191-byte value containing one member and 4,094 properties causes approximately 778 KB of cumulative allocation per parse. A corrected measurement with forced garbage collection before and after parsing retains approximately 164 KB per result while it remains live. These are different metrics: approximately 95 times the input in allocation tr…

Security Severity: Medium CVE-2026-128085 GHSA-Q7GW-24FR-5P69

opentelemetry-go: AttributeValueLengthLimit is fully bypassed by attribute values composed of valid U+FFFD runes

GitHub Advisories

## Summary The AttributeValueLengthLimit span/log-record limit can be bypassed entirely with attribute values that consist of valid U+FFFD (REPLACEMENT CHARACTER) runes. The counting-based truncation introduced by the fix for GHSA-p9f8-wvj8-2fg8 (commit e016a78c9, first released in v1.33.0) has an "optimistic" fast path that skips every U+FFFD without counting it and without falling back to the correct slow path. A value of 1000 U+FFFD runes (3000 bytes) is stored verbatim even with a limit of 5 characters (15 bytes). The same defect affects the attribute truncation paths in go.opentelemetry.io/otel/sdk/trace (sdk/internal/attrnorm), go.opentelemetry.io/otel/sdk/log (sdk/log/internal/attrnorm), and the auto-instrumentation tracer in go.opentelemetry.io/otel/trace (`trace/aut…

Security Severity: Medium CVE-2026-128084 GHSA-4FQR-96Q8-XRFX

sqlite3-ruby: Possible SQL query truncation when a string is 4 GiB or larger

GitHub Advisories

### Summary sqlite3-ruby cast Ruby string lengths (long) to int before passing them to SQLite. On 64-bit platforms, a string of 4 GiB (2^32 bytes) or larger had its length wrap, so SQLite saw only the first length mod 2^32 bytes. An attacker who controls the length of a SQL string could truncate the query, for example dropping a trailing WHERE clause. The affected paths are: - the SQL passed to Database#prepare, #execute, and related methods - String and Blob values passed to Statement#bind_param and related methods - String and Blob values returned from SQL functions and aggregates defined in Ruby (Database#create_function, #create_aggregate, and related methods) sqlite3 v2.10.2 raises RangeError when any of these strings is longer than INT_MAX bytes. ### Severity T…

Security Severity: Low CVE-2026-128083 GHSA-63HM-G96R-2M2Q

Laravel: Task Output Injection - Concurrency Process

GitHub Advisories

### Summary If a concurrency task prints user-controlled text, an attacker can forge the framework's internal result message and achieve remote code execution in certain conditions ### Pre-reqs Insecure code and insecure handling of user provided input (devs trust user-provided input) : 1. App has a route that reaches Concurrency::run() (Not by default, it requires app code) 2. The task writes user-controlled data to stdout (echo/print/dd of input, hand-built JSON via string concat, passthrough of tool output), and the user-controlled bytes can be made to start the child's stdout and form a complete JSON document followed by \x1f\x8b (Not by default, requires the specific coding pattern in the app code) ### Patches * 13.40.0 * 12.71.0

Security Severity: High CVE-2026-128081 GHSA-GPWP-5797-MJFF

AutoMapper: Denial of Service via uncontrolled recursion that bypasses MaxDepth

GitHub Advisories

### Summary The default and explicit MaxDepth limits added for CVE-2026-32933 don't apply to several mapping paths. Mapping a deeply nested source through any of them recurses without bound and throws a StackOverflowException, which can't be caught and terminates the process. ### Affected paths - **Polymorphic maps:** derived type maps (Include / IncludeBase) didn't inherit the base map's MaxDepth, and the default limit for self-referential maps was only applied to the base map. A chain of derived objects was mapped without a limit, even with MaxDepth set on the base map. - **Runtime-typed members:** members typed as object or an interface aren't seen by self-reference detection, so the default limit isn't applied. - **Dictionary and dynamic sources:** mapping a nested `Dict…

Security Severity: Low CVE-2026-126361 GHSA-MH32-JXCR-MH9F

Astro: XSS via attribute injection in dynamic tag names

GitHub Advisories

## Summary When a dynamic tag (const Tag = ...; ) resolves to a string, Astro renders it as a raw HTML element name. The name was filtered to remove characters that could inject attributes, but the filter did not handle /. Because HTML parsers treat / inside a tag as an attribute separator, a tag name such as img/src/onerror=alert(1) was rendered as an `` element with an onerror attribute. The JSX renderer used for MDX did not filter string tag names at all. For example: ``astro --- const Tag = Astro.url.searchParams.get('as') ?? 'div'; --- hello `` rendered ?as=img/src/onerror=alert(1) as live HTML. ## Impact Reflected or stored cross-site scripting, but only in applications that use untrusted input (such as a request parameter or an uncontrolled CMS field) as all or part o…

Security Severity: Medium CVE-2026-126364 GHSA-R3H5-4585-7X3W

Astro: Image endpoint in @astrojs/node can read files from a case-variant sibling of the output directory on case-sensitive filesystems

GitHub Advisories

## Summary The /_image endpoint used by the @astrojs/node adapter checks that a requested local image is inside the build output directory before reading it from disk. That check compared paths case-insensitively. On case-sensitive filesystems (such as Linux), a directory whose path differs from the output directory only by letter case is a different directory, but it passed the check. For example, with the client output directory at /srv/app/dist/client/, a request such as: ``text /_image?href=/../../DIST/client/secret.png&w=32&f=png `` resolved to /srv/app/DIST/client/secret.png and was served, even though that file is outside the output directory. ## Impact An unauthenticated attacker can read image files from outside the output directory, but only when all of the following a…

Security Severity: Medium CVE-2026-128070 GHSA-MJRQ-CFFV-Q4QC

Nuxt dev server serves files from a parent directory with a stray lockfile or workspace file

GitHub Advisories

### Summary Nuxt can pick a parent directory that does not declare a workspace as its default workspaceDir: the farthest directory with a lockfile when the project is not inside a git repository, or the farthest directory with a pnpm-workspace.yaml or deno.json file, even one that only holds settings. The Vite dev server allows /_nuxt/@fs/ requests for any file under workspaceDir. A stray lockfile or settings file in a parent directory, such as the home directory, therefore lets anyone who can reach the dev server read files in that directory and everything below it. ### Impact This affects the development server only; production builds are not affected. All of the following have to hold: - A parent directory contains either: - a lockfile (package-lock.json, pnpm-lock.yaml,…

Security Severity: Medium CVE-2026-128069 GHSA-H7WH-Q2QR-458C

rails-html-sanitizer: Possible XSS via shared scrubber state in concurrent calls

GitHub Advisories

## Summary Rails::HTML::SafeListSanitizer (both the HTML4 and HTML5 variants) shares one Rails::HTML::PermitScrubber across every sanitize call on the same instance, assigning its tags and attributes on each call without synchronization. Two concurrent sanitize calls with different tags: or attributes: options can interleave, so one call is scrubbed with the other call's allowlist. - Versions affected: < 1.7.2 - Not affected: none - Fixed versions: 1.7.2 ## Impact Action View memoizes a single SafeListSanitizer per helper module and uses it for every sanitize call in the process, so in a multi-threaded server (for example Puma) all requests share the same PermitScrubber. If any code path calls sanitize with a more permissive allowlist, an attacker who can trigg…

Security Severity: Medium CVE-2026-128079 GHSA-JV6M-48W5-5RPR

envd: Host file disclosure through requirements path traversal and TOCTOU

GitHub Advisories

### Summary envd’s install.python_packages(requirements=...) could read files outside the build context on the host. Content interpreted as dependency entries could appear in build logs and build-step metadata. Commit f576c92, released in v1.3.5, added path containment validation but left a time-of-check/time-of-use (TOCTOU) race between symlink resolution and opening the requirements file. Commit 9d575b3 addresses this race by opening requirements files through a directory-rooted filesystem handle. ### Details envd reads requirements files on the host to determine whether their contents can be embedded directly into a pip installation build step. The vulnerable host-side requirements read was introduced in v0.3.38. Version v1.3.5 added containment checks for static path escapes but rem…

Security Severity: Medium CVE-2026-128068 GHSA-CPGF-5MJF-73P7

rails-html-sanitizer: Possible regular expression denial of service with certain configurations

GitHub Advisories

## Summary Rails::HTML::PermitScrubber restricts the href and xlink:href attributes of SVG reference elements to local references. That check matched the attribute value against /^\s*[^#\s].*/m. In Ruby ^ anchors to every line start and \s matches newlines, so an all-whitespace value made the engine rescan the value from each of its line starts, taking time quadratic in its length. - Versions affected: >= 1.0.3, < 1.7.2 - Not affected: < 1.0.3 - Fixed versions: 1.7.2 Only Ruby 3.1 and earlier are affected. Ruby 3.2 added linear-time regexp matching, which makes the pattern linear. ## Impact An attacker who supplies HTML to be sanitized can consume CPU out of proportion to the input size, by sending an SVG reference element whose href or xlink:href is a long run of wh…

Security

PostgreSQL Patches 52 Flaws, Including 22-Year-Old Bug Enabling Authenticated RCE

The Hacker News

A type confusion flaw in PostgreSQL lets a database user who can create objects run code on the server. Updates released yesterday fix it, along with 51 other security flaws. Full protection from this flaw also requires rebuilding any C-language extensions installed on the server. The flaw, tracked as CVE-2026-6460, has a CVSS score of 8.8. Any code run this way has the rights of the operating

Security Severity: Medium CVE-2026-126360 GHSA-MF5V-W3W3-F6CG

OpenTelemetry Python API: Denial of service through quadratic-time traceparent parsing

GitHub Advisories

## Summary TraceContextTextMapPropagator.extract() in opentelemetry-api is vulnerable to regular expression denial of service (ReDoS) when processing a specially crafted traceparent value. A malformed value containing a trace-context prefix followed by a long whitespace sequence and an embedded newline triggers quadratic-time regex backtracking. Applications that extract trace context from untrusted carriers accepting such strings can experience excessive CPU consumption and request-processing delays. When extraction runs on an asynchronous server’s event-loop thread, a single malicious message can delay unrelated requests handled by that event loop. ## Exposure conditions Exploitation requires attacker-controlled input to reach the affected propagator through a carrier that preserv…

Security Severity: High CVE-2026-126191 GHSA-6655-6QJP-JX7X

Soup Sieve: Exponential ReDoS in selector compilation via \9-run in CSS_ESCAPES/IDENTIFIER

GitHub Advisories

### Summary The IDENTIFIER/CSS_ESCAPES regex (css_parser.py:119-124) exhibits exponential backtracking on a run of ambiguous digit-escapes (\9) in an attribute-name or tag position of an otherwise well-formed selector. It fires at compile time (before the SELECTOR_LIMIT guard) via the public soupsieve.compile() and BeautifulSoup .select(). ### PoC (verified on soupsieve 2.9.2) import soupsieve as sv sv.compile('[a' + '\\9'*26 + '=x]') # ~57 bytes -> ~10s; ~16x time per +4 chars ### Novelty Distinct from the patched GHSA-836r-... (VALUE regex) and GHSA-2wc2-... (comma-list) advisories, which are fixed in 2.9.2; this is a different regex/vector. ### Reachability CSS selectors are usually developer-controlled, so exposure requires an application that compiles UNTRUSTED selector strings…

Security Severity: Medium CVE-2026-126193 GHSA-7G44-G9RC-X53W

Soup Sieve: Uncontrolled recursion in CSS parser lets nested pseudo-class selectors exhaust the Python call stack

GitHub Advisories

## Summary The Soup Sieve CSS selector parser recurses once per level of nested pseudo-class selector (:is(), :not(), :where(), :has()) without any limit on nesting depth. An unauthenticated attacker who can supply a CSS selector string to soupsieve.compile(), soupsieve.select(), or Beautiful Soup's soup.select() / soup.select_one() can force the parser to exceed Python's recursion limit with a small crafted input (about 1.6 KB, roughly 330 nesting levels), raising an uncontrolled RecursionError. Because this exception is not part of the parser's documented error contract, applications that catch only ValueError or SelectorSyntaxError see an unexpected failure of the request or task that parsed the selector. ## Root Cause The parser dispatches each opening pseudo-cla…

Security

New Mior and Skyfall Attacks Let Rogue Cloud Hosts Steal Secrets From AMD SEV-SNP VMs

The Hacker News

Two attacks made public this week allow a malicious host to read data inside AMD SEV-SNP-protected virtual machines (VMs), which are built to keep the server's operator out. One of them, Mior, can also modify a VM's memory and fake the signed report confirming which software it runs. Both need control of the server's hypervisor, and Mior also needs control of the server's BIOS. Researchers

Security

FBI Says North Korean Hackers Stole Over $400 Million in Crypto Using Deepfake Video Calls

The Hacker News

The U.S. Federal Bureau of Investigation (FBI) has established that threat actors tied to the Democratic People's Republic of Korea (DPRK aka North Korea) have stolen more than $400 million worth of cryptocurrency as part of a social engineering scheme codenamed FaceStealer in the last 18 months. As part of a coordinated set of actions announced by the U.S. government, the cloud-based

Hosting & Network

Introducing Spend Management: Spending limits and alerts for Cloudflare

Cloudflare

Spend Management adds opt-in spending caps for Cloudflare Workers and Durable Objects, and more products soon. Here is how we built the metering pipeline that turns usage into runtime decisions.

Security

Trezor Confirms Hidden Implants in CryptoBilis-Sold Wallets That Can Steal Recovery Phrases

The Hacker News

Three Trezor Safe 5 wallets bought from the reseller CryptoBilis contain an implant, an extra circuit board that can copy their recovery phrases, hardware wallet maker Trezor said yesterday. The implant reads the phrase from the wallet's screen and sends it over the mobile network to a server controlled by the attackers. The company examined one of the wallets in its lab, identified the other

Security Severity: High GHSA-7R4R-6PPG-7FF8

Duplicate Advisory: Symlink escape in YCOECorpusReader lets a psd/pos directory symlink read files outside the corpus root within the data sandbox

GitHub Advisories

## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-qg35-44qx-7vrr. This link is maintained to preserve external references. ## Original Description NLTK from 3.10.0 before 3.10.4 contains a symlink escape vulnerability in YCOECorpusReader that allows attackers to read files outside the corpus root by planting psd or pos directory symlinks. Attackers controlling a YCOE corpus can make parsed_sents() and tagged_words() return file content from other corpora or temporary files within the NLTK data sandbox.

Security Severity: High GHSA-4HVG-FV5C-9936

Duplicate Advisory: Unbounded CPU consumption in NLTK SteppingRecursiveDescentParser.parse() with ambiguous or self-embedding grammars

GitHub Advisories

## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-8fx7-8jr8-84rv. This link is maintained to preserve external references. ## Original Description NLTK before 3.10.4 contains an uncontrolled resource consumption vulnerability in SteppingRecursiveDescentParser.parse() that lacks any max_time deadline or step limit. Attackers influencing the grammar can supply an ambiguous self-embedding grammar and short token input to force unbounded top-down search, pinning CPU cores and exhausting worker pools.

Security Severity: Medium GHSA-RG32-VGF9-927C

Duplicate Advisory: Quadratic CPU exhaustion in TreebankWordTokenizer.span_tokenize via list.pop(0) in quote-restore loop

GitHub Advisories

## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-ffr9-mgrr-wcvr. This link is maintained to preserve external references. ## Original Description NLTK from 3.2.5 before 3.10.4 contains an algorithmic complexity vulnerability in TreebankWordTokenizer.span_tokenize that allows remote attackers to cause quadratic CPU consumption through repeated list.pop(0) calls. Attackers can submit long runs of double-quote characters to services span-tokenizing untrusted text, exhausting a CPU core and degrading availability.

Security Severity: Medium GHSA-W2J9-QH3J-4H63

Duplicate Advisory: Symlink escape in chat80.sql_query bypasses the pathsec data-root sandbox to read out-of-root SQLite databases

GitHub Advisories

## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-xmfg-f9cm-w86q. This link is maintained to preserve external references. ## Original Description NLTK from 3.9.4 before 3.10.4 contains a symlink following vulnerability in nltk.sem.chat80.sql_query() that bypasses the pathsec data-root sandbox containment check. Attackers who can write into a trusted NLTK data root can plant a symbolic link to read SQLite databases outside the sandbox.

Security Severity: Medium GHSA-X4P7-2MV3-X7PX

Duplicate Advisory: Quadratic CPU exhaustion in LegalitySyllableTokenizer.tokenize via unguarded onset reversal loop

GitHub Advisories

## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-gpwc-27cw-rh9r. This link is maintained to preserve external references. ## Original Description NLTK from 3.6 before 3.10.4 contains an algorithmic complexity vulnerability in LegalitySyllableTokenizer.tokenize that allows remote attackers to exhaust CPU by supplying long all-vowel tokens. Attackers can submit a token such as a long run of vowels, causing the unguarded onset reversal loop to perform quadratic work and deny service to syllabification components.

Security Severity: High GHSA-JH6R-H4RX-2J3W

Duplicate Advisory: Quadratic-time CPU denial of service in NLTK CCG lexicon parser (fromstring) on wide bracket bodies and operator chains

GitHub Advisories

## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-89p3-fcch-88ph. This link is maintained to preserve external references. ## Original Description NLTK before 3.10.4 contains a denial of service vulnerability in the CCG lexicon parser fromstring that allows remote attackers to exhaust CPU by supplying wide inputs. Attackers can submit lexicon text with long flat bracket bodies or operator chains, triggering quadratic string re-slicing in matchBrackets and augParseCategory that blocks worker threads.

Security Severity: High GHSA-F7J6-HF97-9V99

Duplicate Advisory: BllipParser passes caller-supplied model paths to the bllipparser C extension with no pathsec check, enabling arbitrary read

GitHub Advisories

## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-fg9w-wfp5-j933. This link is maintained to preserve external references. ## Original Description NLTK from 3.10.0 before 3.10.4 contains an arbitrary file read vulnerability in BllipParser that allows attackers to open files outside NLTK data roots by supplying unvalidated model paths. Attackers controlling parser_model, reranker_features, reranker_weights, or from_unified_model_dir() input can make the bllipparser C extension read sensitive files or block on FIFOs and devices.

Security Severity: High GHSA-6665-2VJ3-H76R

Duplicate Advisory: Quadratic-time CPU denial of service in Tree.chomsky_normal_form right-factor binarization via list.pop(0)

GitHub Advisories

## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-r53h-rw34-8h97. This link is maintained to preserve external references. ## Original Description NLTK before 3.10.4 contains a denial of service vulnerability in Tree.chomsky_normal_form that allows remote attackers to exhaust CPU through quadratic-time right-factor binarization using list.pop(0). Attackers can supply a wide flat treebank tree parsed by Tree.fromstring to force tens of seconds of single-threaded CPU consumption, blocking the processing thread.

Security Severity: High GHSA-QVHX-RVGC-JHWF

Duplicate Advisory: Quadratic-time CPU denial of service in ConllCorpusReader SRL instance builder via nested span rescan

GitHub Advisories

## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-v8f3-6phw-6mh9. This link is maintained to preserve external references. ## Original Description NLTK before 3.10.4 contains a quadratic-time denial of service vulnerability in ConllCorpusReader._get_srl_instances that allows remote attackers to exhaust CPU through nested span rescans. Attackers can supply a crafted CoNLL SRL corpus with many predicates and span columns, placing the head span last, to pin a core for minutes.

Security Severity: Medium GHSA-G5WX-957H-F4WJ

Duplicate Advisory: Path Traversal in save_maxent_params / load_maxent_params Allow Arbitrary File READ/WRITE

GitHub Advisories

## Duplicate Advisory This advisory has been withdrawn because it is a duplicate of GHSA-59f9-gqg8-mqpj. This link is maintained to preserve external references. ## Original Description NLTK before 3.10.4 contains a path traversal vulnerability in save_maxent_params() and load_maxent_params() that bypasses the pathsec filesystem restriction mechanism. Attackers who control the tab_dir argument can read or overwrite model parameter files outside permitted data roots, because the functions call Python's built-in open() directly.

Security

When an AI Agent Goes Wrong, Can You Stop It?

The Hacker News

Suppose an AI agent is asked to sort support tickets and look up account details. A ticket contains instructions that lead the agent to export records to an unfamiliar destination. The agent can make the request because its identity has access to the records and its connected tools allow the action. That kind of scenario raises a response question: what does “stop the agent” actually mean? A

Security

SilentAir Hijacks Asian Telecom Networks to Intercept SMS 2FA Codes and Spy on Taiwanese Users

The Hacker News

A newly identified spying group used hacked equipment inside Asian mobile operators to intercept the calls and texts of selected people, mostly in Taiwan. Enea, a telecom and cybersecurity software company based in Stockholm, found the group's attack sources in at least six Asian countries and named it SilentAir this week. It assessed with high confidence that SilentAir is a state-level actor,

Security

Operation Endgame Takes Down Gootloader, CastleRAT and StealC Servers, Seizes 6.4M Stolen Logins

The Hacker News

An international police operation took down servers behind Gootloader, CastleRAT and StealC this week. Criminals used the three malware tools to gain access to computers, steal passwords, and launch ransomware attacks. Police also seized about 6.4 million stolen logins belonging to more than 40,000 victims, according to Germany's Federal Criminal Police Office (BKA). Gootloader is a loader:

Security

Hackers Exploit PHP2Shell Flaws in Check Point Gateways to Deploy TSGA Backdoor and Wipe ESXi Files

The Hacker News

An unknown threat actor has been observed targeting unpatched Check Point Security Gateways to obtain initial access via the PHP2Shell vulnerabilities and then a previously reported local privilege escalation flaw in Gaia OS to deploy a backdoor called TSGA. The activity, detailed by Check Point, began on October 30, 2026, and targeted Israeli organizations, with a broader follow-up wave

Security

Hackers Exploit N-central Flaws to Infect 21 Servers, Including 19 Running Hotfix 2

The Hacker News

N-able on Thursday said it's taking additional precautions in the wake of public disclosure of a new set of flaws tracked as 4EverAble2Shell and Agent2Shell. "We are restricting certain N-central features and integrations," the company said in a Thursday update. "These measures may affect some functionality, but we believe taking additional precautions while remediation is completed is the

Security Severity: Critical CVE-2026-100397 GHSA-X585-4VV8-2MH2

Rucio: Unauthenticated administrator impersonation through SSH challenge tokens

GitHub Advisories

## Summary SSH challenge tokens are mistakenly accepted as valid credentials during the authentication token validation process. While an SSH challenge token is intended as a short-lived nonce for use in a subsequent SSH key exchange, the function to validate authentication tokens does not differentiate between these and actual authentication tokens. Because challenge tokens are generated based on an account name provided via headers without requiring prior authentication, an unauthenticated attacker can request a valid "challenge" token for any account (including administrative ones) and use it to authenticate against other API endpoints. ## Proof of Concept The vulnerability exists because SSH challenge tokens are stored in the same database table as regular authentication tokens and `v…

Security Severity: High CVE-2026-126190 GHSA-MMHR-3C5M-F64F

Soup Sieve: Polynomial-time denial of service in the descendant combinator

GitHub Advisories

## Summary Matching a selector that uses the descendant combinator (a b) takes time that grows polynomially with how deeply the document is nested, and each extra descendant combinator in the selector raises the degree by one. A selector with k descendant combinators takes O(n^(k+1)) time on a chain of n nested elements. An attacker who controls the HTML or XML that an application passes to Soup Sieve (directly, or through Beautiful Soup's select(), select_one(), css.select(), etc.) can send a very small, deeply nested document that keeps a CPU busy for seconds to minutes against an ordinary selector such as section div div. ## Details To match a b, Soup Sieve checks each element against b and then walks up through its ancestors looking for one that matches a. When t…

Security Severity: Medium CVE-2026-126192 GHSA-4J63-6C4X-WFG4

Soup Sieve: General sibling combinator inside :has() matches untrusted HTML in quadratic time

GitHub Advisories

## Summary Matching a selector that puts a general-sibling combinator inside :has(), such as div:has(a ~ b), against untrusted HTML runs in O(n²) time in the number of sibling elements. A single small document with a few thousand siblings ties the process up for a minute of CPU, so an application that runs a fixed selector of this shape over HTML it doesn't control can be stalled by one request. :has is powerful, but much in the same way poor regular expressions can be crafted to cause catastrophic backtracking with greedy capturing, has can be used to create non-ideal scenarios that can cause large portions of the tree to be evaluated for one or many elements if not used thoughtfully. This behavior is not exclusive to Soup Sieve, but browsers make note of these potential performanc…

Security Severity: Critical CVE-2026-122006 GHSA-F3W6-W445-FWH9

Active Storage: Possible arbitrary file write and read in image analysis

GitHub Advisories

### Impact A Rails application that processes attachments with ImageMagick may allow an unauthenticated attacker to write arbitrary files on the server and, when attachments are stored with the Disk service, to read arbitrary files readable by the application process. Those files typically include secret_key_base and credentials for external systems, which may in turn allow escalation to remote code execution or lateral movement to those systems. ### Details ImageMagick selects a coder from the content of the file it is given, and some coders act on files named inside the image rather than on the image itself. Active Storage constrained none of ImageMagick's coders, and the ImageMagick analyzer runs when a file is attached, so an attacker who can upload a crafted file may be able to inv…

Security Severity: Medium CVE-2026-126072 GHSA-RWVH-FW6R-PWVP

Action Pack: Possible DoS vulnerability in Action Controller Live streaming

GitHub Advisories

### Impact ActionController::Live::Buffer#close pushes its end-of-stream marker onto the response's bounded queue while it holds the buffer's monitor. When the client has stopped reading and the queue is full, the push blocks, and Buffer#abort, which runs when the client disconnects or a write times out, waits indefinitely for the same monitor. Each such response could permanently hold a web server thread and its ActionController::Live thread, possibly resulting in a DoS vulnerability through thread exhaustion. Applications that stream responses with ActionController::Live, including send_stream, are affected. Applications that serve large files through Active Storage proxy mode are exposed to unauthenticated clients. ### Releases The fixed releases are available at the normal l…

Security Severity: Medium CVE-2026-126077 GHSA-X6MJ-8JX9-QHQV

Action Pack: Possible sensitive session information leak in Active Storage proxy mode

GitHub Advisories

### Impact When ActionDispatch::Cookies reads a signed or encrypted cookie that was written under a rotated secret (config.action_dispatch.cookies_rotations) or in the format that a :hybrid cookie serializer migrates from, it writes the cookie back to the response in the current format, and that write ignores request.session_options[:skip]. ActiveStorage::DisableSession relies on that option to keep the session cookie off the public, immutable responses of the Active Storage proxy controllers, but those controllers still load the session, so a request carrying an old-format session cookie could receive the rewritten session cookie in Set-Cookie on a cacheable response. A shared cache that stores such a response together with its Set-Cookie header could then serve one user's…

Security Severity: Medium CVE-2026-126078 GHSA-V6RJ-XM57-3P59

Action View: Possible XSS vulnerability in highlight helper

GitHub Advisories

### Impact ActionView::Helpers::TextHelper#highlight substitutes each matched phrase into the :highlighter string without escaping it and returns the result marked HTML-safe. Because sanitizing leaves quote characters in text unescaped, a match substituted into a quoted attribute value of the highlighter, such as the `` form shown in the method's documentation, could end the attribute value and add attributes to the element, possibly leading to XSS. Applications are affected when they pass a :highlighter that places a placeholder inside an attribute value and highlight text or phrases that a user controls. The default \1 highlighter and the block form are not affected. ### Details The fixed releases HTML-escape each group substituted into the :highlighter string, so quotes in a…

Security Severity: Medium CVE-2026-126070 GHSA-RQ8Q-P985-FJQ7

Action View: Possible XSS vulnerability in strip_tags

GitHub Advisories

### Impact strip_tags in Action View returns its sanitized output marked html_safe, but the underlying sanitizer encodes only &, ``, leaving " and ' unencoded. Because ERB does not escape a string marked html_safe, untrusted input passed through strip_tags and rendered inside a quoted HTML attribute value could close the attribute and add new attributes, possibly leading to XSS. Applications that render strip_tags output from untrusted input inside an HTML attribute, for example in a title attribute or a `` tag, are affected. Output rendered as element content is not affected. ### Details strip_tags now encodes " and ' in its output, as well as &, ``, without double-encoding existing entities. Applications that use strip_tags output outside HTML, such as in a t…

Security Severity: Medium CVE-2026-126079 GHSA-2P2F-4RQ4-GJWC

Action View: Possible XSS vulnerability in text helpers

GitHub Advisories

### Impact With the HTML5 sanitizer (Rails::HTML5::Sanitizer, the default vendor on CRuby for applications using load_defaults 7.1 or later), Nokogiri before 1.19.5 serializes `` unescaped inside attribute values. The Action View text helpers highlight and simple_format sanitize their input and then process the resulting HTML as a string: highlight splits it on tag boundaries to insert matches, and simple_format splits it into paragraphs on blank lines. An unescaped > or a blank line inside an attribute value could cause markup in that value, which the sanitizer left inert, to be emitted as live elements in the helper's html_safe output, possibly leading to XSS. Applications that use the HTML5 sanitizer and pass untrusted text to highlight, or to simple_format with `ht…

Security Severity: Medium CVE-2026-126084 GHSA-3W93-6HMW-WHH4

Active Storage: Unsigned Content-Type in GCS direct uploads with cache_control

GitHub Advisories

### Impact When a GCS service is configured with the cache_control option, ActiveStorage::Service::GCSService#url_for_direct_upload signs direct-upload URLs with V4, and the V4 signature covers only the Cache-Control and Host headers. A direct-upload client can therefore send a Content-Type of its choosing, and can omit the declared Content-MD5, without invalidating the URL. GCS stores the supplied content type as object metadata, which takes precedence over the response-content-type that Active Storage sets on download URLs, so an uploaded object could be served as inline HTML under the application's bucket path on storage.googleapis.com. Script in such an object runs on the storage origin rather than the application's, but could register a Service Worker scoped to the bu…

Security Severity: High CVE-2026-126081 GHSA-WM3X-V3QW-4JH3

Action Pack: Possible Strong Parameters Bypass in Parameters#each_key

GitHub Advisories

### Impact ActionController::Parameters#each_key delegates to the internal ActiveSupport::HashWithIndifferentAccess that holds the request parameters, so when called with a block it returns that hash instead of the Parameters instance. The hash does not respond to permitted?, so Active Model mass assignment (new, assign_attributes, update) accepts it without raising ActiveModel::ForbiddenAttributesError. An application that passes the return value of each_key to mass assignment could allow a remote, unauthenticated attacker to set attributes that the application does not permit, such as an authorization flag. This is an incomplete fix of [CVE-2020-8164](https://github.com/advisories/GHSA-8727-m6gj-mc37), which made each, each_pair and each_value return the `Paramet…

Security Severity: Medium CVE-2026-128066 GHSA-WQGW-9XFH-QF2G

Pillow: Memory DoS in TIFF and EXIF IFD parsing via overlapping tag data

GitHub Advisories

`` ============================================================================ ANT-2026-D7STJUWL [medium] CWE-770 dos Memory DoS in TIFF and EXIF IFD parsing via overlapping tag data Location: src/PIL/TiffImagePlugin.py:927 in ImageFileDirectory_v2.load() Commit: a707c6b21c313880d0771e54965d142dd42358b6 ============================================================================ `` A small, crafted image file can make Pillow use thousands of times its own size in memory while the file is only being opened, which lets anyone who can submit an image crash or stall the process handling it. A 144 KB TIFF makes Image.open() return normally while holding 1.6 GiB of memory. The largest such standard TIFF, about 786 KB, asks for roughly 48 GiB, which in practice gets the worker killed by the…

Security Severity: High CVE-2026-128067 GHSA-XCVG-W56Q-R89M

Pillow: Heap buffer overflow saving TIFF with libtiff when tags override image size

GitHub Advisories

`` ============================================================================ ANT-2026-CS7N494P [high] CWE-787 memory-safety Heap buffer overflow saving TIFF with libtiff when tags override image size Location: src/libImaging/TiffDecode.c:1035 in ImagingLibTiffEncode() Commit: a707c6b21c313880d0771e54965d142dd42358b6 ============================================================================ `` When Pillow saves an image as a compressed TIFF, size information taken from the image's metadata can make the encoder read past the end of a heap buffer. Someone who uploads an image can use this to get the server process's memory, including pointers, copied into the saved file, or to crash the process. When the metadata also enables TIFF "Predictor=2" compression, the encoder writes past the…

Security Severity: Medium CVE-2026-126355 GHSA-46WX-V44X-9HH2

Hono: `csrf()` does not check requests sent by hyperlink auditing (`text/ping`)

GitHub Advisories

### Summary csrf() validates a request only when its Content-Type is one of the three types an HTML form can send. Chromium's hyperlink auditing (``) sends a cross-origin POST with the user's cookies and the content type text/ping, which is not in that list. The middleware does not look at Origin or Sec-Fetch-Site for such a request, so it is passed to the handler. ### Details The middleware skips the origin check when the content type is not one that a form submission produces. The assumption was that any other content type requires a CORS preflight and therefore cannot be sent cross-origin with credentials. Hyperlink auditing is an exception: Chrome and Edge send the ping as a credentialed POST without a preflight, with a fixed body and Content-Type: text/ping. A page on ano…

Security Severity: Medium CVE-2026-126356 GHSA-4H7H-RV7C-7M2V

Hono: `validator('form')` skips validation for `multipart/form-data` requests with extra parameters

GitHub Advisories

### Summary validator('form') only recognizes a multipart/form-data Content-Type that carries nothing but a single boundary parameter. A request with another legal parameter, such as charset, or with extra whitespace after the ; is not recognized as a form. The validation callback then receives an empty object, while c.req.parseBody() still parses the body as a form. ### Details The check that decides whether a request body is a form was written as a strict pattern over the whole Content-Type value. Any parameter list that does not look exactly like ; boundary=... fails the check. When it fails, the middleware does not read the body and passes an empty object to the validation callback. If the callback accepts an empty object, the request proceeds to the handler, which c…

Security Severity: Medium CVE-2026-126357 GHSA-4M76-XFJ5-7975

Hono: `mount()` and `app.mount()` can forward a path that bypasses middleware scoped inside the mount prefix

GitHub Advisories

### Summary mount() and app.mount() remove the mount prefix from the request path and forward the rest to the mounted application. Two mistakes in that step let a crafted request reach a route of the mounted application that the outer application protects with path-scoped middleware, such as an authentication check on /app/admin/*. The outer application routes on the original path, so the middleware does not run. ### Details 1. **Dynamic prefix** (all affected versions): for a mount such as /api/:tenant/*, the prefix was removed by the length of the route pattern, not of the matched prefix. A request with a longer or shorter first segment is cut in the middle, so /api/a/xxxxx/admin/secret reaches the mounted application as /admin/secret. 2. **Re-normalization** (since 4.12.21)…

Security Severity: Medium CVE-2026-126358 GHSA-H7MG-CQ63-VHPQ

Hono: RegExpRouter skips wildcard middleware for some route sets and for paths with an encoded line terminator

GitHub Advisories

### Summary RegExpRouter, which the default SmartRouter selects for most applications, skipped wildcard middleware in three cases, so a route handler ran without the middleware registered for it: 1. Middleware whose parameter is written with the explicit default pattern, such as /api/:tenant{[^/]+}/admin/*, was not applied to a route written as /api/:tenant/admin/:id. (since 4.13.0) 2. Middleware on /admin/* was not applied to a route registered on /admin* for paths under /admin/. (since 4.1.4) 3. For a path with an encoded line terminator (%0A, %0D, %E2%80%A8, %E2%80%A9), no wildcard pattern matched, so the request reached the not-found handler without any wildcard middleware. (since 4.4.0) TrieRouter, LinearRouter and PatternRouter apply the middleware in all three c…