Thesmartshadow

Rack::Static serves a path after `Utils.clean path info` normalization but evaluates `header rules` against a path that is only URL-decoded. This allows an unauthenticated attacker to request a known file using raw or percent-encoded dot segments, resulting in the file being delivered without path-specific security headers, such as `Content-Disposition` or `Content-Security-Policy`. Applications that do not utilize path-specific `header rules` are not affected.

Insufficient policy enforcement in the chrome-devtools-mcp component on Linux allows a local attacker to perform arbitrary read and write operations using a malicious file.

A sandbox escape exists when running on Node.js 26. The issue occurs because `WebAssembly.compileStreaming` and `WebAssembly.instantiateStreaming` can produce a raw host-realm Promise that rejects with a host-realm error object. By controlling `Symbol.species` via `Promise.prototype.finally`, sandbox code can obtain this raw host error, navigate from the host error constructor to the host Function constructor, and recover the host `process` object. This allows the attacker to gain host Node.js capabilities, such as access to host modules like `fs`, within the process running the sandbox. This escape is possible using a default `new VM()` sandbox and does not require NodeVM, require permissions, host object injection, or any unsafe configuration.

An issue exists where the software fails to honor the `createUserDir` isolation during proxy and hook authentication auto-provisioning paths. This allows attackers possessing valid upstream-authenticated credentials to exploit the server root scope assignment to read, modify, delete, and share files belonging to other users.

No detailed information is available regarding the nature of the issue.

In Node.js deployments using the HTTP adapter, a bypass of prototype pollution hardening allows requests to be routed through an attacker-controlled proxy. While the software initially creates a null-prototype object for request configuration to prevent prototype pollution, request interceptors that use immutable patterns—such as `{...config}` or `Object.assign({}, config)`—convert this back into a regular object. Because the software does not re-harden the configuration before dispatch, the Node HTTP adapter reads the `config.proxy` variable through the prototype chain. If an attacker pollutes `Object.prototype.proxy`, they can intercept plaintext HTTP requests to observe `Authorization` headers, Basic auth from `config.auth`, the request method, absolute URL, `Host` header, and the request body, and can also return custom responses. This issue does not affect browser adapters or HTTPS requests under normal TLS validation.

During server-side rendering, the `hono/jsx` module fails to isolate context values on a per-request basis. This allows data from a different in-flight request to be accessed after an `await` operation within an async component. The affected functions include `createContext()`, `useContext()`, `jsxRenderer()`, and `useRequestContext()`.

When verifying detached JWS tokens using the unencoded-payload option (`"b64": false`, RFC 7797), the software performs Base64URL decoding of the compact-serialization payload segment before enforcing detached-payload rules. Because the decoded payload is later discarded and replaced with the caller-provided `detached payload`, the middle segment can be used as a work amplifier. A remote client can provide an arbitrarily large Base64URL payload segment, forcing excessive CPU work and memory allocations regardless of whether the signature is valid. This results in an unauthenticated Denial of Service (DoS) against any endpoint verifying detached JWS.

On Linux, the library is subject to command injection within the `networkInterfaces()` function. This occurs when an active NetworkManager connection profile name contains shell metacharacters. The vulnerable value is retrieved internally from the output of the `nmcli device status` command. While the library sanitizes network interface names, it fails to apply the same sanitization to the parsed `connectionName` variable. This unsanitized variable is subsequently interpolated into three shell command strings executed via `execSync()`, allowing an attacker who can create or rename a NetworkManager connection profile to execute arbitrary shell commands with the privileges of the Node.js process.

jq accepts embedded NUL bytes in import paths at the jq-language level, but subsequently resolves those paths using C string operations during module and data-file lookup. This results in a mismatch between the logical import string validated by policy or audit code and the actual on-disk path that the software opens.

CoreDNS is a DNS server that chains plugins. A denial-of-service issue exists in the DNS-over-HTTPS (DoH) GET path because it lacks early size validation for incoming requests. Specifically, the server accepts oversized values for the `dns` query parameter and performs expensive operations—including URL query parsing, base64 decoding, and DNS message unpacking—before rejecting the request. In contrast, the POST path utilizes `http.MaxBytesReader` to limit reads to 65536 bytes. A remote, unauthenticated attacker can exploit this by sending repeated oversized DoH GET requests to the `/dns-query` endpoint. This forces high CPU usage, large transient memory allocations, and elevated garbage-collection pressure (the process of reclaiming memory used by the application), leading to a denial of service. The vulnerable logic is located in the `requestToMsgGet()` and `base64ToMsg()` functions within `plugin/pkg/doh/doh.go`.

Name of the Vulnerable Software and Affected Versions RustFS versions prior to alpha.90 Description RustFS, a distributed object storage system built in Rust, had a missing authorization check in the multipart copy path (`UploadPartCopy`) before version alpha.90. This allowed a low-privileged user, lacking read access to objects in a victim bucket, to exfiltrate those objects by copying them into a multipart upload they control and then completing the upload. This compromised tenant isolation in multi-user or multi-tenant deployments. Recommendations Update to version alpha.90 or later.

The `xmldom` library contains a flaw where attacker-controlled strings including the CDATA terminator `]]>` can be inserted into a `CDATASection` node. During serialization, the `XMLSerializer` emits the CDATA content without rejecting or safely splitting the terminator. This allows data intended as text to become active XML markup in the serialized output, enabling XML structure injection and potential manipulation of downstream business logic. The issue affects `Document.createCDATASection(data)`, `CharacterData.appendData()`, `CharacterData.replaceData()`, `CharacterData.insertData()`, and direct assignment to `.data` or `.textContent`. Parsing XML containing a CDATA section is not affected. Exploitation can lead to integrity violations of generated XML documents and potential business-logic injection in downstream consumers.

A stack-based buffer overflow exists in the Zen C compiler. This issue is due to a flaw in identifier mangling. By supplying a specially crafted Zen C source file (`.zc`) containing excessively long struct, function, or trait identifiers, an attacker can cause a compiler crash or potentially execute arbitrary code. The vulnerability affects the processing of identifiers within the compiler.

pyLoad, a free and open-source download manager written in Python, is affected by a path traversal issue. This occurs during password verification of specific encrypted 7z archives – those encrypted with non-encrypted headers. The issue allows for arbitrary file deletion outside of the intended extraction directory. The software derives an archive entry name from 7z listing output and incorrectly treats it as a filesystem path without restricting it to the extraction directory.

cpp-httplib is a C++11 single-file header-only cross platform HTTP/HTTPS library. Before version 0.35.0, the library does not enforce the payload size limit configured via `Server::set payload max length()` on decompressed request bodies when using `HandlerWithContentReader` with `Content-Encoding: gzip` or other supported encodings. A small compressed payload can expand beyond the configured limit, potentially leading to a denial of service through CPU or memory exhaustion.

Rack’s `Rack::Directory` component generates HTML directory indexes with clickable links for each file entry. If a file exists with a basename starting with the `javascript:` scheme (for example, `javascript:alert(1)`), the generated index includes an anchor with an `href` attribute set to that scheme. Clicking this link executes JavaScript in the browser. This results in a client-side cross-site scripting (XSS) condition in directory listings generated by `Rack::Directory`. The issue occurs because the file basename is directly inserted into the `href` attribute without validation or normalization. The vulnerable component is `Rack::Directory`.

The `callout` and `fence environment` plugins in the @digitalocean/do-markdownit package perform `.includes` substring matching if `allowedClasses` or `allowedEnvironments` is a string instead of an array.