@fastify/http-proxy versions before 11.6.10 contain a path traversal vulnerability (CWE-22) due to improper handling of semicolon path parameters in destination URLs. This allows crafted requests to bypass directory restrictions and access resources outside the intended proxy subtree, affecting both HTTP and WebSocket proxy paths. The issue is fixed in version 11.6.10.
@fastify/reply-from versions before 12.8.4 contain a path traversal vulnerability in the buildURL function. The function's check for parent-directory segments fails to detect segments with semicolon path parameters, allowing bypass of traversal protections. This can lead to unauthorized access to internal paths such as admin or internal API endpoints on certain backend servers that strip semicolon parameters before resolving paths. The issue is fixed in version 12.8.4.
Eclipse Ditto versions 2.0.0 through 3.8.14 and 3.9.0 through 3.9.8 contain an authorization flaw in the handling of JSON merge patch commands. The authorization check fails to verify permissions for fields deleted or set to empty objects by the patch, allowing authenticated users with WRITE permission on any part of a Thing to delete or overwrite attributes, features, or definitions beyond their granted permissions.
In Eclipse Dataspace Components (EDC) – Connector (`org.eclipse.edc:decentralized-claims-*`, `org.eclipse.edc:jwt-verifiable-credentials`, `org.eclipse.edc:ldp-verifiable-credentials`) there's a credential verification bypass in Decentralized Claims Protocol (DCP) presentation handling: a participant can present credentials appearing to be issued by any trusted issuer without holding them.
@fastify/middie versions up to 9.3.6 have a vulnerability where duplicate slashes in middleware mount paths are not normalized, causing middleware such as authentication or rate limiting to be bypassed when the ignoreDuplicateSlashes router option is enabled. This allows requests to reach protected handlers without proper middleware enforcement. The issue is fixed in version 9.3.7.
mail-parser is a tool that parses emails by enhancing the Python standard library and extracting message details into a comprehensive object. From 4.6.0 until 4.6.3, write_attachments() calls _safe_attachment_filename() and write_sample() without isolating failures for individual attacker-controlled MIME parts. An RFC 2231 filename containing a NUL, a basename exceeding NAME_MAX, or an undecodable base64 payload can raise ValueError, OSError, or binascii.Error and abort the entire save loop. Later attachments remain unwritten; when a caller catches only MailParserError, the failure is not surfaced through the expected library-exception path. If a downstream scanner or sandbox reads only the extraction directory, a payload after the crafted part can be missed even though it remains in the delivered message, and the aborted batch also causes availability loss. This issue is fixed in version 4.6.3.
mail-parser is a tool that parses emails by enhancing the Python standard library and extracting message details into a comprehensive object. Prior to 4.6.2, multiple message-processing behaviors can raise exceptions or silently lose content. Headers colliding with methods such as Parse, Message, and Write_Attachments can place bound method objects into parsed output and raise TypeError when a caller requests JSON serialization such as mail_json. When byte input is parsed through parse_from_bytes(), an 8-bit header value returned as email.header.Header can likewise raise TypeError when an X_raw accessor passes the value to json.dumps; both exceptions are outside the MailParserError hierarchy. Separately, rewritten names such as Subject_json and X_Spam_Flag can be substituted or disappear from mail, headers, and JSON output while has_defects remains false, and a headerless message can be treated as falsy before parser state is initialized, causing body and attachment properties to return empty values without an error signal. These behaviors can abort message processing or hide malicious indicators from downstream scanners. This issue is fixed in version 4.6.2.
Interpretation Conflict, resulting in (Incorrect Authorization) vulnerability in Apache APISIX.
An unauthenticated client can reach upstream paths protected
by a route-level auth plugin when a route without auth exists on the
same upstream and the upstream does not collapse encoded dot segments.
This issue affects Apache APISIX: from 0.9 through 3.19.0.
Users are recommended to upgrade to version 3.20.0, which fixes the issue.
Interpretation Conflict, leading to Incorrect Authorization vulnerability in Apache APISIX.
With match_uri_encoded_slash enabled and skip_mtls_uri_regex
configured, a client without a certificate can reach an upstream
behind a route that requires one, limited to request paths that decode
to an exempted URI. This issue affects Apache APISIX: from 3.18.0 through 3.19.0.
Users are recommended to upgrade to version 3.20.0, which fixes the issue.
Nuxt is an open-source web development framework for Vue.js. From 4.6.0 until 4.6.4, Nuxt parses a request path beginning with // as a URL host before rendering a page, while Nitro server/middleware and routeRules continue to evaluate the original path. An unauthenticated request such as //x/admin can therefore resolve to the /admin page without route-scoped serverHandlers, server/middleware path checks, redirects, or security headers configured for /admin. API handlers in server/api and server/routes, appMiddleware, page middleware are unaffected. This issue is fixed in version 4.6.4.
Nuxt is an open-source web development framework for Vue.js. Nuxt from 3.0.0 until 4.6.4, @nuxt/nitro-server from 3.20.0 until 4.6.4, and @nuxt/vite-server from 4.6.0 until 4.6.4, routeRules matching leaves an encoded slash (%2F) in the request path while a catch-all page such as app/pages/[...slug].vue or a custom multi-segment page route decodes it into a route parameter. The getRouteRules result is therefore incomplete, and an unauthenticated request can render the page without the redirect, headers, proxy, SSR, noScripts, appMiddleware, or appLayout rules configured for the decoded path. Protected content is resolved only when the page interprets the decoded parameter accordingly: a custom multi-segment parameter can contain the decoded path, while a repeatable catch-all must join the slash-containing array element; route.path remains encoded and does not resolve that resource. Static pages, single-segment parameters, server/api handlers, and server/routes handlers are not affected because they do not have the same encoded-path mismatch. This issue is fixed in version 4.6.4.
In Eclipse BaSyx Go Components versions up to and including 1.1.3, ABAC-enabled deployments match `ROUTE` access rules against the fully decoded request path, while the router routes on the raw, still encoded path. An encoded slash (`%2F`) inside a path value is a segment separator for the access check but part of the value for the router, so a request can match a narrow `ROUTE` rule while the handler returns a different, larger resource.
An authenticated caller whose rules grant READ only on parts of a resource can therefore read the whole resource. In the DPP API, a rule such as `/v1/dpps/*/elements/*`, meant to grant only passport elements, also grants the complete passport whose identifier contains `/elements/`. In the Submodel Repository, AAS Repository and AAS Environment, a rule such as `/submodels/*/submodel-elements/*/attachment`, meant to grant only file attachments, also grants the complete element whose stored idShort contains `%2F`.
The issue is fixed in Eclipse BaSyx Go Components v1.1.4.
Authorization Bypass Through User-Controlled Key vulnerability in elixir-grpc grpc_server and grpc allows an attacker to make a handler act on a resource other than the one named in the URL of an HTTP-transcoded route, via a request with a gRPC Content-Type.
Only the transcoding clause of GRPC.Server.do_handle_request/4 (grpc_server/lib/grpc/server.ex, and lib/grpc/server.ex before the package split) applies the route's path bindings to the request message. The Cowboy handler picks that clause from the request Content-Type, not from the route. A request to a transcoded URL with application/grpc or application/grpc-web is decoded from the body alone, so every path-bound field takes its value from the body. A gateway, proxy rule or WAF that authorizes on the URL path sees one resource while the handler receives another.
This issue affects grpc: from 0.8.0 before 1.0.0; grpc_server: from 1.0.0 before 1.1.0.
Addressable is an alternative implementation to the URI implementation that is part of Ruby's standard library. From 2.2.5 until 2.9.1, Addressable::URI.normalize_path can resolve a path containing leading parent segments and later parent segments to a different path than an RFC 3986 resolver. URI#normalize, URI#join, URI#==, and URI#=== inherit the result. An application that authorizes the Addressable-normalized path but sends the original URI to another resolver can allow access outside the intended path allowlist. Applications that use the same normalized value for authorization and the request, or reject parent segments, are unaffected. This issue is fixed in version 2.9.1.
@hono/node-server allows running the Hono application on Node.js. Prior to 1.19.18 and from 2.0.0 until 2.1.6, the server passes a raw request-target containing a backslash in its path to the WHATWG URL parser, which treats the backslash as a path separator and resolves dot segments. A reverse proxy, load balancer, or web application firewall that preserves the backslash and applies path-based rules to the original request can therefore permit a request that the application normalizes to a blocked route. This lets an unauthenticated client reach route content that the upstream component was intended to deny, while Hono application access controls are unaffected because they operate on the normalized path. This issue is fixed in versions 1.19.18 and 2.1.6.
A vulnerability in the Rails Action Pack framework prior to versions 8.1.4.1 and 8.0.5.2 allows cache poisoning due to improper handling of the Vary header in HTTP responses. Specifically, responses to requests without an Accept header or to XHR requests may omit the Vary header that indicates which request headers influenced the response format. This can cause shared caches that honor the Vary header to serve incorrect content representations to clients, such as serving HTML instead of JSON. The issue affects applications that render negotiated responses from public actions behind shared caches like Thruster or Rack::Cache. The vulnerability is fixed in Rails versions 8.1.4.1 and 8.0.5.2.
CVE-2026-120813 is a vulnerability in MongoDB Server's client-side field-level encryption (CSFLE) schema processing. It allows encryption metadata to be silently dropped during schema parsing, which can cause sensitive data to be stored in plaintext. Exploitation requires delivering a specially crafted schema to the user's CSFLE client, such as via a man-in-the-middle or untrusted server. This bypasses confidentiality protections for encrypted data.
CVE-2026-125108 is a vulnerability in the Rack Ruby web server interface where the multipart parser can skip a leading empty or quoted boundary parameter in a multipart Content-Type header. This allows the parser to accept a boundary that intermediaries would not, potentially bypassing proxy or web application firewall inspection. The issue affects versions prior to 2.2.25, 3.1.23, and 3.2.8 and is fixed in those versions.
CVE-2026-118517 is a vulnerability in the Symfony HtmlSanitizer component's UrlSanitizer that causes it to parse URLs differently from browsers. This discrepancy allows bypassing host allow-list checks for URLs without a well-formed authority, leading to untrusted hosts being referenced in sanitized output. The issue affects Symfony versions 6.1.x prior to 6.4.50, 7.x prior to 7.4.23, and 8.x prior to 8.1.11. The default configuration is not affected.
ModSecurity versions from 3.0.0 up to but not including 3.0.17 have a multipart parser discrepancy where the RFC 2231 filename* parameter precedence is not applied. This causes a conflict between the filename used by ModSecurity and the backend application, potentially allowing bypass of WAF inspection when the backend uses the encoded filename* value. The issue is fixed in version 3.0.17.