HTTP Request Smuggling

HTTP request smuggling in Twisted's twisted.web server (twisted.web.http.HTTPChannel, versions 26.4.0 and earlier) lets remote attackers fold a hidden Content-Length header into an ordinary header value using a bare carriage return or bare line feed, because the parser rejects NUL bytes but not the other two control characters RFC 9110 section 5.5 requires it to reject. The impact is realized only when Twisted sits behind a front-end proxy or load balancer that treats a bare CR or LF as a line terminator: the front end frames one request, Twisted frames another, and the attacker can slip a request past front-end access controls, poison a shared connection so a later client receives the wrong response, or poison a cache. No authentication (PR:N) and no user interaction (UI:N) are required, but attack complexity is high (AC:H) because of the proxy dependency, no code execution results in any configuration, there is no KEV listing or confirmed active exploitation, and the GitHub advisory includes a PoC request sequence that has not been independently verified as working exploit code.

HTTP request smuggling in Apache Traffic Server (8.0.0 through 8.1.11, 9.0.0 through 9.2.15, 10.0.0 through 10.1.4, and 10.2.0) lets unauthenticated remote attackers send HEAD requests carrying Content-Length or Transfer-Encoding headers to desynchronize HTTP message framing between ATS and an upstream or downstream agent. The scope-changed CVSS 3.1 score of 9.3 (AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:H/A:N) reflects high integrity impact - cache poisoning, request/response queue confusion, and possible access-control bypass - with limited confidentiality exposure; no public exploit code was identified at time of analysis. Vendor-released fixes are available in 9.2.16, 10.1.5, and 10.2.1.

HTTP request smuggling in Apache Traffic Server 8.0.0 through 8.1.11, 9.0.0 through 9.2.15, 10.0.0 through 10.1.4, and 10.2.0 allows attackers behind a front-end proxy that pools and reuses upstream connections to desynchronize responses and smuggle requests past that front end. The trigger is a client POST carrying 'Expect: 100-continue' when the origin responds before the request body is read, causing ATS to parse the unread body as the next request on the shared connection. Standalone ATS deployments, or those not fronted by a connection-reusing proxy, are not exploitable; no public exploit code or active exploitation was identified at time of analysis.

Request smuggling in Apache Traffic Server 8.0.0 through 8.1.11, 9.0.0 through 9.2.15, 10.0.0 through 10.1.4, and 10.2.0 allows remote unauthenticated attackers to have a later request read as leftover body data on a recycled origin connection, enabling access-control bypass, cross-user request disruption, and cache poisoning. The attacker must declare a body via Content-Length or Expect: 100-continue but never fully send it, then win a timing window while ATS returns the origin connection to its shared keep-alive pool. No public exploit has been identified at time of analysis, but the default configuration is affected and exploitation is probabilistic rather than guaranteed.

HTTP request smuggling in Eclipse ThreadX NetX Duo's optional Web add-on allows unauthenticated remote clients to influence request-framing decisions by placing header-like field names in the request body; the embedded HTTP server scans the entire packet for headers instead of stopping at the end of the header section. The CVSS 4.0 score is 6.9, with low integrity and availability impact and no confidentiality impact, and exposure is limited to devices that enable and network-expose the Web add-on. No public exploit code or CISA KEV confirmation is present in the provided data; no public exploit identified at time of analysis.

A request-routing discrepancy in Cloudflare Pingora before 0.9.0 lets an unauthenticated remote attacker send a single HTTP/2 request that the proxy evaluates under one authority while the upstream receives a different Host, so Host-based filters, access controls, or cache keys can be applied to the wrong virtual host. Exploitation is conditional and moderate risk: the deployment must terminate client HTTP/2 in Pingora, make security or caching decisions from the request URI authority, and sit in front of an upstream that routes by Host and serves different content per Host. The outcome is limited-impact confidentiality and integrity exposure on the downstream component (possible cache poisoning or host-based access-control bypass); there is no public exploit code and no confirmed active exploitation at time of analysis, and Cloudflare's own CDN path was unaffected because its internal Pingora services do not accept HTTP/2 from clients.

HTTP request smuggling in aiohttp's pure-Python HTTP parser (versions prior to 3.14.4) can let an unauthenticated remote attacker desynchronize request framing between aiohttp and a front-end proxy when the application runs without the standard compiled llhttp extension - for example with AIOHTTP_NO_EXTENSIONS set or when no compatible wheel is installed. Exploitation additionally requires an intermediary that interprets ambiguous HEAD-with-Content-Length framing differently from the backend, so default installations using the C extension are not vulnerable; no public exploit was identified at the time of analysis, and this is a medium-severity, conditionally exploitable flaw rather than a broadly exploitable one.

Front-end request desynchronization in Progress Telerik Fiddler Classic for Windows (versions prior to v6.0.20262.10021) allows a locally positioned, low-privileged actor to send a single malformed request through the proxy's forwarding component and have it split into two requests delivered to the origin server, returning an extra smuggled response on the reused client connection. Exploitation is constrained: it requires local access to the Fiddler proxy (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:N, base 3.6), depends on the exact condition of a request carrying both Content-Length and Transfer-Encoding headers combined with connection reuse and pipelining behavior, and is limited to shared or multi-user developer environments rather than production edge deployments. No public exploit code has been identified at time of analysis and the flaw is not confirmed actively exploited (not in CISA KEV); the vendor-released fix is v6.0.20262.10021.

HTTP request smuggling in Progress Telerik Fiddler Classic for Windows (versions prior to v6.0.20262.10021) allows a low-privileged local user sharing the same Fiddler proxy instance to desynchronize requests and poison responses delivered to other users. Fiddler forwards conflicting multiple Content-Length headers verbatim to the origin while framing the body using only the first value, and because the server connection is returned to Fiddler's pipe pool after reading only the first response, an unread smuggled response stays buffered on the socket and is served to the next session that reuses it. Exploitation is authenticated (CVSS vector PR:L), local-only (AV:L), and high complexity (AC:H), requiring a non-RFC-9110-compliant keep-alive origin server; no public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor has released a fix.

HTTP request smuggling in libsoup's SoupServer - as shipped in Red Hat Enterprise Linux 6, 7, 8, 9, and 10 - allows remote, unauthenticated attackers to have an attacker-controlled HTTP request processed as an unintended subsequent request on a keep-alive connection. The issue triggers when an HTTP/1.x client sends 'Expect: 100-continue' with a declared body and the SoupServer-based application issues an early final (non-1xx) response before that body is read; SoupServer then neither drains the body bytes nor closes the connection, so the leftover bytes are parsed as the next request. Rated CVSS 3.1 5.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N), the flaw carries limited integrity impact on request handling while leaving confidentiality and availability unaffected, and it is inert unless the specific combination of keep-alive, a declared body, and an early final response is present. No public exploit code and no confirmed active exploitation were identified at time of analysis.

HTTP/1 response smuggling in the Elixir Mint client (0.1.0 through 1.10.x) allows a malicious or attacker-influenced origin server to desynchronize Mint from an upstream intermediary on a pooled keep-alive connection, so that bytes following a crafted response are parsed as the answer to a subsequent request, poisoning that request's response. The root cause is that Mint's message_body/1 selects chunked framing whenever 'chunked' is the FIRST coding in a Transfer-Encoding header (e.g. 'Transfer-Encoding: chunked, gzip') instead of requiring it to be the final coding, and additionally keeps the connection open after an HTTP/1.0 response - final or 1xx - that carries Transfer-Encoding with 'Connection: keep-alive', both contrary to RFC 9112. Exploitation is a reverse-trust scenario: the attacker must control or inject server response framing and the client must reuse an HTTP/1 connection; HTTP/2 and non-pooled connections are unaffected, and no public exploit code or active exploitation was identified at time of analysis. The issue is fixed in Mint 1.11.0.

Host-header routing bypass in http4k (Maven artifact org.http4k:http4k-core) before 6.49.0.0, 5.42.0.0 and 4.51.0.0 lets remote, unauthenticated attackers reach a virtual host they should not be authorized for by supplying a Host header that merely contains a configured vhost name - for example Host: admin.evil.com against a vhost configured as "admin" - because reverseProxy() and reverseProxyRouting() default to a substring (Contains) matcher rather than an exact match. Exploitation is tightly scoped: it requires the functions to be deployed as a public-facing inbound HTTP handler with two or more configured virtual hosts, where that routing is what enforces authorization; the documented outbound-dispatch and test-time fake-backend uses set the Host value from the calling application and are unaffected. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the issue is a genuine but narrow authorization-bypass rather than a high-severity emergency; vendor patches are available in 6.49.0.0 (Community 6.x), 5.42.0.0 and 4.51.0.0 (Enterprise LTS lines).

Unauthenticated remote attackers can desynchronize HTTP/1.1 response parsing in Netty's HttpServerCodec (io.netty:netty-codec-http) versions 4.2.0.Final through 4.2.16.Final and all versions up to and including 4.1.136.Final by pipelining a GET carrying 'Expect: 100-continue' immediately followed by a HEAD request on the same keep-alive connection. Because the codec pairs each outbound response - including the 100 Continue informational response - with a queued inbound method via pollMethod(), the GET's 200 OK is matched to HEAD and its entity body is dropped, while the following 200 OK (intended for HEAD) is emitted with a body; this misattributes content across responses, enabling response splitting and unsafe reuse of the connection. It is a genuine but moderate-priority integrity flaw (vendor CVSS 4.0 score 6.9; independent assessment CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N), with no public exploit identified at time of analysis and vendor-released patches available in 4.2.17.Final and 4.1.137.Final.

Routing and access-control bypass in Netty's HTTP/3 codec (io.netty:netty-codec-http3) versions 4.2.0.Final through 4.2.17.Final allows a remote unauthenticated attacker to send a single HEADERS frame with conflicting :authority and host header values, causing different components in a multi-component request path to make inconsistent decisions. This moderate-severity integrity issue is fixed in 4.2.18.Final; no public exploit code or active exploitation has been identified at time of analysis.

HTTP request desynchronization in Apache Tomcat allows an unauthenticated remote attacker to cause a single request belonging to another user to fail when Tomcat is deployed behind a reverse proxy. The flaw (CWE-444) arises because Tomcat processes the Transfer-Encoding header on HTTP/1.0 requests, and when a fronting proxy interprets that header differently, the two sides disagree about request boundaries on a shared upstream connection. Affected releases are 11.0.0-M1 through 11.0.25, 10.1.0-M1 through 10.1.59, 9.0.47 through 9.0.121, and the end-of-life 8.5.67 through 8.5.100; standalone Tomcat with no fronting proxy is not affected. The assessed impact is availability-only (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L) - no persistence, data exposure, or code execution is described - and no public exploit code was identified at time of analysis.

Unauthenticated attackers can defeat the IP-based administrative login throttling in pH7Software pH7Builder (pH7 Social Dating CMS) through version 18.2.0 by sending a different X-Forwarded-For or Client-IP header with every request, allowing unlimited password-guessing attempts against the admin login. The CMS derives the client address from those attacker-controlled headers without verifying that the request came from a trusted proxy, so the per-IP failed-attempt counter and lockout never trigger. Exploitation requires only network reachability to the admin login endpoint and a standard HTTP client; the flaw is not confirmed actively exploited (not in CISA KEV), EPSS is low at 0.34% (27th percentile), and no public exploit code has been identified at time of analysis, although a third-party blog documents the bypass chain. The CNA-assigned CVSS 9.8 (C:H/I:H/A:H) substantially overstates the direct impact - the vulnerability only removes a brute-force control, so real-world risk hinges on whether valid admin credentials (weak or default passwords, no MFA) can subsequently be guessed.

Chunked-response smuggling in the Elixir Mint HTTP client (0.1.0 through 1.10.0) allows a malicious or compromised HTTP/1 origin to desynchronize an RFC-9112-strict intermediary from Mint on a shared, pooled connection, poisoning the response queue so that later requests reusing that socket receive another request's or attacker-chosen response content. Mint's chunk-size parser accepts trailing junk after the hex size (for example '5ZZZZZ', '5 9', or '0ZZZZ') while strict proxies reject it, so the two disagree on chunk boundaries and on where the message ends. Exploitation is unauthenticated (PR:N) but conditional and non-trivial: it requires a pooled connection to an attacker-influenced origin plus a strict intermediary in the path; impact is limited to confidentiality and integrity of responses on the poisoned connection (VC:L/VI:L), with no availability or code-execution effect, and no public exploit code has been identified at time of analysis. Note that upstream tag metadata for this CVE includes 'RCE'; that label is not supported by the assessed vector or impact and should not be used for prioritization.

HTTP request smuggling in Netty's netty-codec-http component lets unauthenticated remote attackers bypass front-end security controls by sending a crafted HTTP/1.1 chunk-size token containing whitespace after the hexadecimal digits, which Netty parses differently from other HTTP intermediaries. The flaw carries a CVSS 3.1 base score of 6.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:L), meaning no authentication or user interaction is required, but integrity and availability impact is limited; meaningful exploitation generally depends on a multi-tier topology where a proxy, load balancer, or backend parses the chunk-size token inconsistently with Netty. Red Hat ships the affected library across a broad portfolio - including AMQ Broker 7, AMQ Clients, Quarkus, Keycloak and Red Hat Single Sign-On 7, JBoss EAP 7/8, Fuse 7, Data Grid 8, Camel for Spring Boot 4, Camel 4 for Quarkus 3, Apicurio Registry 3 and Debezium 3 - and no public exploit code has been identified at time of analysis, with no confirmed active exploitation (CISA KEV).

HTTP request smuggling in IBM WebSphere Application Server and WebSphere Application Server Liberty - as bundled in IBM CICS TX Advanced per the affected CPE - lets remote attackers desynchronize request framing between a front-end intermediary and the WebSphere back end, enabling request tampering or response poisoning. Exploitation requires the server to sit behind a reverse proxy, load balancer, or CDN that parses Content-Length/Transfer-Encoding framing differently than the back end; no authentication or user interaction is needed (PR:N/UI:N), but attack complexity is high (AC:H) because the attacker must find and reliably trigger a specific parser discrepancy in the real deployed chain, and a directly exposed server with no divergent front-end parser is not smuggle-able. Impact is bounded to low confidentiality and integrity with no availability effect (CVSS 3.1 base 4.8); this is a genuine but modest-severity issue rather than a top priority, and no public exploit was identified at time of analysis.

HTTP request smuggling in IBM WebSphere Application Server 8.5 can allow unauthenticated remote attackers to desynchronize request processing when the server sits behind or in front of an HTTP intermediary with mismatched Content-Length parsing, potentially leading to credential theft, cache poisoning, or request hijacking. The flaw (CWE-444) rates 6.5 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:N) and requires a specific proxy-layer mismatch and concurrent traffic; no public exploit identified at time of analysis. Vendor patch is available and the risk is assessed as moderate and non-urgent.

HTTP request smuggling in IBM WebSphere Application Server Liberty - the runtime bundled with IBM CICS TX Advanced 10.1 - lets remote, unauthenticated attackers desynchronize HTTP message framing between an upstream HTTP parser and the Liberty backend, so a smuggled request can be processed as if it came from the trusted front-end, with low confidentiality and integrity impact on subsequent requests sharing the connection. Exploitation requires a multi-tier topology (reverse proxy, load balancer, or CDN in front of or behind Liberty) where the two parsers disagree on Content-Length/Transfer-Encoding or chunked framing, and is rated high complexity because the specific parsing gap must be discovered and precisely crafted while connection reuse must be achievable; no user interaction is required. Risk is moderate and consistent with the vendor CVSS of 4.8 (Medium); no public exploit identified at time of analysis, and patch is available from the vendor.

HTTP request smuggling (CWE-444) in IBM WebSphere Application Server 8.5, 9.0, and Liberty lets an authenticated, low-privileged remote attacker desynchronize HTTP request framing between WebSphere and an intermediary so that one user's request boundaries are misattributed on a shared connection. The issue only manifests when WebSphere sits behind or in front of a second HTTP parser (reverse proxy, load balancer, or CDN) that disagrees with WebSphere on Content-Length versus Transfer-Encoding chunked handling; a standalone WebSphere instance with no fronting or backend HTTP hop is not affected, and the 4.2 score reflects high attack complexity, partial confidentiality and integrity impact, and no availability or scope change. No public exploit code and no confirmed active exploitation were identified at time of analysis, and a vendor patch is available per IBM's advisory.

This is a real but moderate-priority vulnerability whose severity depends almost entirely on deployment topology rather than the raw 6.5 CVSS score. Netty's HTTP decoder lets split or duplicated Transfer-Encoding header fields slip past its final-chunked validation, so an unauthenticated, remote attacker who can send a raw crafted request to a Netty listener that sits in an HTTP chain with a second HTTP parser (reverse proxy, load balancer, CDN, WAF, or upstream/downstream server) can desynchronize the two parsers and smuggle a request (CWE-444). Impact is confined to low confidentiality and integrity loss (C:L/I:L) with no availability impact, no authentication (PR:N) or user interaction (UI:N) is required, and no public exploit identified at time of analysis.

Web cache poisoning in the Breeze Cache WordPress plugin before 2.5.15 allows unauthenticated remote attackers to append tracking-related query parameters that the plugin still caches responses for but omits from the page-cache key, causing a page rendered in the attacker's own request context to be stored under the clean URL's cache entry and served to every subsequent visitor. Exploitation requires only that page caching be active in its default configuration - no authentication, no user interaction, and no special setup (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N, 6.5) - and publicly available exploit code exists; the issue is not confirmed as actively exploited (not in CISA KEV). Impact is bounded to low confidentiality and integrity effects, exposing one visitor's rendered context to others and altering cached page content until the entry expires or is purged.

Chunked-transfer request smuggling in Sanic allows a remote unauthenticated attacker to plant a hidden second HTTP request inside the trailer-part of a chunked request, which Sanic then parses and routes as a genuine backend request on the same keep-alive connection. Affected versions are all releases before 24.12.1 and the 25.12.0 release (fixed in 24.12.1 and 25.12.1); the defect triggers on default configuration, with CVSS 3.1 scoring 6.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:L) reflecting a request-boundary integrity failure rather than direct data compromise. A verified proof-of-concept is included in the upstream advisory showing a single TCP payload yielding two responses (a 405 for the outer POST and a 200 for a smuggled GET), meaning publicly available exploit code exists; the practical risk is highest when Sanic sits behind a reverse proxy, CDN, or load balancer that disagrees with Sanic on request boundaries.

Request smuggling in http4s Ember affects ember-core (server and client) before 0.23.35 and 1.0.0-M47 because the chunked decoder trims chunk-size tokens and accepts leading '+' or '-' signs instead of requiring hexadecimal digits followed by the mandatory CRLF. When Ember runs behind an intermediary that forwards chunked bodies without re-encoding and parses chunk boundaries differently, an unauthenticated attacker can achieve TE.TE request smuggling that bypasses intermediary controls, poisons shared caches, or hijacks queued requests; the same response-path leniency enables response smuggling when ember-client is used as a gateway in front of a malicious or compromised upstream. No public exploit code or CISA KEV entry is associated with this issue at time of analysis, and no EPSS score was supplied in the source data.

HTTP request smuggling in IBM WebSphere Application Server 8.5 and 9.0 (including the Liberty variant) enables unauthenticated remote attackers to manipulate shared HTTP caches, circumvent web application firewall rules, and inject malicious scripts into responses served to other users. The root cause is improper parsing of the HTTP Transfer-Encoding request header (CWE-444), a class of vulnerability that exploits disagreement between a front-end proxy and the back-end application server over where one HTTP request ends and the next begins. No public exploit code or active exploitation has been identified at time of analysis; a vendor-released patch is available.

HTTP request smuggling in IBM WebSphere Application Server 8.5, 9.0, and Liberty allows remote unauthenticated attackers to poison web caches, bypass web application firewall protections, and conduct cross-site scripting attacks by sending specially crafted Transfer-Encoding headers. The root cause is CWE-444, inconsistent interpretation of HTTP request boundaries between WebSphere and a frontend proxy component. No public exploit or confirmed active exploitation has been identified at time of analysis; a vendor patch is available from IBM.

HTTP request smuggling in Netty 4.1.133-4.1.137.Final and 4.2.13-4.2.17.Final allows unauthenticated remote attackers to poison HTTP request queues and bypass intermediary security controls by submitting crafted Transfer-Encoding headers. The HttpObjectDecoder's final-coding validation was flawed: both split multi-line TE headers and comma-separated values like 'chunked, xchunked' bypassed the 'chunked must be last' check, causing Netty to interpret message framing differently from upstream proxies. Fixed releases 4.1.138.Final and 4.2.18.Final enforce RFC 9112-compliant validation across all TE header fields; no public exploit code or CISA KEV listing has been identified at time of analysis.

HTTP response splitting and downstream desynchronization in undici's retry interceptor allows an attacker-controlled upstream server to cause downstream HTTP/1.1 clients to misinterpret response boundaries. Affected releases are undici before 6.28.1, 7.0.0 through 7.29.0, and 8.0.0 through 8.10.1. When a proxying application relays the malformed response without normalizing framing, excess bytes appended by the retry interceptor can be parsed by a downstream HTTP/1.1 peer as the start of a subsequent response, enabling response injection or session desynchronization attacks.

HTTP request smuggling in pydantic's HTTPX2 Python client library, all versions prior to 2.11.0, arises because Request._prepare() in _models.py appends a Content-Length header even when a caller-supplied Transfer-Encoding header is already present, producing HTTP/1.1 requests with two conflicting framing headers simultaneously. Downstream intermediaries such as reverse proxies or API gateways that resolve the Content-Length vs. Transfer-Encoding ambiguity differently from the upstream server can misparse request boundaries, enabling request smuggling or connection desynchronization affecting co-located sessions. No public exploit code or active exploitation has been identified at time of analysis; a vendor-released patch is available in v2.11.0.

Cache poisoning and stored XSS in Hono (all versions before 4.13.5) stem from the framework's query helpers treating a literal `#?` sequence as a query string, creating a parser discrepancy between the application and every other layer - browsers, reverse proxies, WAFs, access logs, and validation middleware - that correctly ignores fragments. The Cache Middleware compounded this by stripping fragments when building cache keys, so a response shaped by fragment-injected parameters gets stored and served to subsequent users under a key that omits those parameters entirely. No public exploit code has been identified at time of analysis, and exploitation is gated by the requirement that the runtime and intermediary pass raw `#` characters through to the application.

HTTP Request Smuggling in Elasticsearch allows a network attacker to intercept confidential HTTP responses intended for other authenticated users when Elasticsearch is deployed behind certain proxy configurations. The vulnerability (CWE-444, CAPEC-33) arises from inconsistent HTTP request boundary interpretation between the intermediary proxy and Elasticsearch, enabling response queue poisoning that leaks data across user sessions. Vendor-released patches 8.19.20, 9.4.5, and 9.5.1 are available per ESA-2026-141; no public exploit code or CISA KEV listing has been identified at time of analysis.

HTTP request smuggling in Node.js's HTTP client module enables forwarding proxies to desynchronize backend connections when request headers exceed the maxHeadersCount or maxHeaderPairs thresholds. When a Node.js-based proxy rebuilds outbound request headers from the visible IncomingMessage properties and pipes the original body over a reused backend connection, framing-critical headers such as Content-Length are silently omitted from the proxy's outbound request while still governing body delivery internally - causing the backend to misparse the request stream. No public exploit has been identified at time of analysis, and exploitation is constrained to specific proxy architectures, which is reflected in the CVSS 3.7 Low score.

Unauthenticated BLE packet injection in BitChat for iOS v1.5.0 (reported in the CVE as v1.15.0) allows any device within Bluetooth adjacency range to inject crafted MESSAGE packets into the mesh gossip cache, causing denial of service for all mesh participants. The attack exploits a TTL=0 validation bypass in BLEService.swift that accepted packets as anonymous without full sender authentication. A public proof-of-concept is available at a named GitHub repository; no active exploitation has been confirmed by CISA KEV.

HTTP request smuggling in the Perl CPAN module Reverse::Proxy (versions before 0.04) allows unauthenticated remote attackers to inject arbitrary HTTP requests to upstream servers by embedding CRLF sequences in percent-encoded URL paths. The PSGI specification requires servers to percent-decode PATH_INFO before handing it to the application, meaning %0d%0a has already become a literal carriage return and line feed by the time the proxy appends it to the upstream request line - terminating that line early and promoting everything that follows to a second, attacker-controlled request. The injected request is attributed to the proxy by the upstream and can reach internal paths the proxy's own routing never exposes; on pooled keep-alive connections it may be delivered in the context of another client's session. No public exploit code and no CISA KEV listing exist at time of analysis.

HTTP chunked trailer smuggling in libevent before 2.1.13 and 2.2.2-alpha allows unauthenticated remote attackers to inject security-sensitive header fields - such as Authorization or X-Forwarded-For - via chunked transfer encoding trailers that libevent merges directly into its request header store. In deployments fronted by a reverse proxy, the proxy evaluates the original headers while libevent processes the attacker-supplied trailers as authoritative input headers, enabling authorization bypass, proxy-header spoofing, and cache poisoning. No public exploit has been identified at time of analysis; vendor-released patches exist in both stable and alpha release branches.

HTTP request smuggling in actix-http (versions up to and including 3.12.0) allows unauthenticated remote attackers to desynchronize backend request parsing when the service operates behind an HTTP/1.1 intermediary. The parser accepted requests carrying both Content-Length and Transfer-Encoding: chunked headers (the CL.TE variant) and silently selected chunked decoding instead of rejecting the ambiguous framing as required by RFC 7230, enabling an attacker to prepend malicious content to subsequent backend requests. No public exploit code has been identified and this vulnerability is not listed in the CISA KEV catalog at time of analysis.

HTTP request smuggling in System.Net.HttpListener across .NET 8.0, 9.0, and 10.0 enables unauthenticated remote attackers to bypass security features on Linux and macOS deployments. The flaw stems from inconsistent HTTP request interpretation (CWE-444), allowing crafted requests to circumvent authentication or access controls with high confidentiality impact. Exploitation carries high attack complexity (AC:H), no public exploit has been identified at time of analysis, and the vulnerability is not listed in CISA KEV, placing this in a monitored-but-not-emergency posture for most organizations.

HTTP request smuggling in Undertow's ChunkReader component enables unauthenticated remote attackers to inject out-of-sync requests, bypassing upstream security controls such as authentication layers or reverse-proxy ACLs. Affected deployments include JBoss EAP 7, WildFly, Red Hat Enterprise Linux 8/9/10, Red Hat Data Grid 8, Red Hat Fuse 7, Red Hat Single Sign-On 7, and several Apache Camel-based Red Hat products. No confirmed active exploitation or public proof-of-concept has been identified at time of analysis; the CVSS 5.3 Medium score reflects limited direct impact, though real-world risk in proxy-fronted architectures is meaningfully higher than the score alone suggests.

Cache poisoning in CoreBunch/Instatic through version 0.0.14 allows unauthenticated remote attackers to corrupt the shared process-wide render cache by supplying a crafted originating-page URL via the `u` query parameter of the server island endpoint `GET /_instatic/hole/<nodeId>`. Because the cache is keyed solely on `nodeId` without incorporating the `u` value, a single poisoning request causes every subsequent visitor requesting that node to receive attacker-controlled fragment content. No public exploit code has been identified and no CISA KEV listing exists; the product's early-stage, niche deployment footprint limits real-world blast radius, but the unauthenticated network vector and low attack complexity make exploitation straightforward against exposed instances.

Request smuggling primitive in h2 (pip/h2) versions 4.4.0 and below enables network-accessible attackers to craft HTTP/2 header blocks containing duplicate Host headers that the library forwards verbatim to consuming applications. When a consumer downgrades the HTTP/2 request to HTTP/1.1 - a common pattern in reverse proxy and gateway architectures - the resulting HTTP/1.1 request carries two Host header lines, violating RFC 7230 and creating an ambiguity that downstream servers may interpret differently, enabling cache poisoning, security control bypass, or session hijacking. No active exploitation confirmed (not in CISA KEV); no public exploit code identified at time of analysis; fix is available in v4.4.1.

HTTP request smuggling in aiohttp's server-side parser allows unauthenticated remote attackers to inject and misdirect HTTP traffic by exploiting a protocol-switch race in the WebSocket upgrade path. Versions 3.14.1 and earlier prematurely mark the connection as upgraded before the full request body is consumed, causing trailing bytes - potentially an attacker-controlled HTTP request - to be interpreted as WebSocket or pipelined data by the server or any upstream proxy. No public exploit code exists and the vulnerability is not listed in CISA KEV, but CVSS 4.0 AC:H reflects the edge-case nature of the trigger condition.

HTTP request smuggling in cPanel and WP Squared (by WebPros) enables leakage of credentials from other users sharing the same hosting infrastructure. The CVSS 4.0 vector confirms network-reachable exploitation with no authentication required but with passive user interaction and attack-specific prerequisites; critically, the subsequent-system impact is rated High for both confidentiality and integrity (SC:H/SI:H), indicating that successful exploitation crosses trust boundaries to affect other users or backend components beyond the attacker's own session. No public exploit code has been identified at time of analysis and this CVE is not listed in the CISA KEV catalog, but the scope-change impact makes it a meaningful risk in shared hosting environments where cPanel serves multiple tenants.

Response body/Content-Length desynchronization in undici's retry interceptor allows a malicious or faulty upstream server to induce HTTP response smuggling against downstream clients of proxy and gateway applications. Affected versions span undici before 6.28.0, the 7.x line before 7.29.0, and the 8.x line before 8.9.0. An upstream that deliberately returns a partial response with mismatched framing and closes the socket early can cause the retry interceptor to assemble a body of a different length than the attached Content-Length, leading downstream consumers to experience response desynchronization, connection hangs, or data corruption. No public exploit has been identified at time of analysis, and this is not listed in CISA KEV.

HTTP request smuggling exposure in Node.js 26.x arises because the HTTP server failed to reject incoming requests that exceed the configured maximum header count, creating an inconsistent parsing boundary exploitable by adversaries. Rated Low severity (CVSS 3.7) by the Node.js security team and fixed in v26.5.1 released 2026-07-29, the flaw is classified under CWE-444 and is most dangerous in reverse-proxy deployments where header-count enforcement differs between the frontend proxy and the Node.js backend. No public exploit code and no CISA KEV listing have been identified at time of analysis.

HTTP/2-to-HTTP/1 protocol conversion in Apache Traffic Server 10.0.0-10.1.3 forwards origin HTTP/2 trailers to downstream HTTP/1 clients without the required chunked transfer encoding framing, enabling HTTP response smuggling. The CVSS 8.3 Scope:Changed rating reflects that exploitation impacts downstream HTTP/1 clients architecturally separate from ATS itself, with potential for cache poisoning, response injection, and limited information disclosure. No public exploit code has been identified and this CVE is not listed in CISA KEV at time of analysis.

HTTP request smuggling in Apache Traffic Server allows unauthenticated remote attackers to interfere with how the proxy and backend servers interpret HTTP request boundaries, enabling cache poisoning and limited information disclosure. Versions 9.0.0 through 9.2.14 and 10.0.0 through 10.1.3 are confirmed affected per Apache advisory. The Scope Changed (S:C) CVSS metric reflects that exploitation crosses the proxy boundary to impact downstream backend systems. No public exploit code or CISA KEV listing has been identified at time of analysis.

HTTP request smuggling vulnerability in Rouille's proxy implementation allows remote attackers to desynchronize HTTP message boundaries using a CL.TE attack. Affected versions 0.3.3 through 3.6.2. Publicly available exploit code exists, but no active exploitation has been reported.

HTTP request smuggling in tiny-http versions through 0.12.0 allows remote attackers to desynchronize request processing between a front-end proxy and the vulnerable backend. By sending a Transfer-Encoding header with an arbitrary value, the library unconditionally switches to chunked decoding and discards the Content-Length, enabling request smuggling and connection exhaustion. Public exploit code exists, but active exploitation remains unconfirmed.

HTTP request smuggling in Rouille 0.3.3 through 3.6.2 allows remote attackers to bypass access controls by injecting bare line feed characters (0x0A) into header values. The framework forwards these headers verbatim to backends like Go net/http or Python http.server, which interpret the raw LF as a request delimiter, enabling a smuggled request with attacker-chosen method, path, and headers. Publicly available exploit code exists, increasing the risk for deployments using Rouille as a proxy.

HTTP request smuggling in SwiftNIO HTTP/2 allows unauthenticated remote attackers to inject headers or split responses via crafted HTTP/2 HEADERS frames that pass control characters through the HTTP/2-to-HTTP/1.1 codec. The vulnerability, caused by missing CR/LF/NUL/SP validation in regular header values and pseudo-headers, can be exploited when outbound validation is disabled or headers are forwarded without rechecking. Fixed in version 1.45.0; no public exploit identified at time of analysis and EPSS score is 0.14% (low).

HTTP/2-to-HTTP/1.x protocol translation in Netty's `netty-codec-http2` enables request routing bypass and HTTP request smuggling via duplicate `Host` header injection. When a client sends a HEADERS frame containing both the `:authority` pseudo-header and a literal `host` header, `Http2StreamFrameToHttpObjectCodec` and `InboundHttp2ToHttpAdapter` independently translate each into `Host` headers, producing an `HttpRequest` with two attacker-controlled, differing values. Downstream HTTP/1.1 components that prioritize the second header can be manipulated into routing requests to unintended targets. No public exploit has been identified and this CVE is not in the CISA KEV catalog, but patches are vendor-released for both affected release trains.

WebSocket protocol upgrade in Netty's V07/V08 handshakers completes without enforcing RFC 6455-mandatory `Connection: Upgrade` and `Upgrade: websocket` headers, enabling an attacker to silently switch protocols in a way that upstream reverse proxies and load balancers do not recognize as an Upgrade request. This desynchronization between proxy and backend creates a classic HTTP request smuggling vector (CWE-444) that can be exploited to poison shared connections, bypass proxy-enforced access controls, or hijack other users' HTTP sessions. Affected versions are `io.netty:netty-codec-http` prior to 4.1.136.Final and 4.2.0.Final through 4.2.15.Final; no public exploit code or CISA KEV listing has been identified at time of analysis.

Response-queue poisoning in the elixir-mint Mint HTTP/1.1 client library (versions 0.1.0 through before 1.9.3) allows a malicious or attacker-influenced HTTP/1 origin server to desynchronize a strict RFC-compliant intermediary from the Mint client on shared keep-alive pooled connections. The root cause is `Mint.HTTP1.decode_body/5` using Elixir's `Integer.parse/2` for chunked transfer-encoding chunk-size parsing, which accepts RFC-forbidden leading `+` or `-` sign prefixes, causing both parties to disagree on where one HTTP response ends and the next begins. No public exploit has been identified at time of analysis, but a vendor-released patch is available in Mint 1.9.3.

HTTP request smuggling in Eclipse Grizzly before 5.0.2 stems from the framework's inability to correctly parse malformed trailer header lines in chunked HTTP requests, enabling CWE-444 boundary-confusion attacks. Remote unauthenticated attackers who can send crafted chunked requests through a front-end proxy to a GlassFish-backed server can cause the proxy and Grizzly to disagree on request boundaries, smuggling attacker-controlled content as the prefix of a subsequent legitimate user's request. No public exploit code and no CISA KEV listing have been identified at time of analysis, though the CVSS 4.0 AT:P condition signals that specific deployment prerequisites must be met.

HTTP request smuggling in OpenVPN Access Server 2.7.2 through 3.1.0 enables remote unauthenticated attackers to inject or manipulate backend requests when the Access Server is deployed behind a reverse proxy. The server incorrectly accepts bare line-feed (LF-only, without carriage return) characters inside HTTP header values, creating a parsing discrepancy between the front-end proxy and the Access Server backend - the hallmark of CWE-444. No public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog; however, the CVSS 4.0 score of 6.9 with integrity impact on both the vulnerable and subsequent systems indicates meaningful risk in typical enterprise VPN gateway deployments fronted by load balancers or reverse proxies.

HTTP request/response smuggling in nghttpx (the reverse proxy component of nghttp2 through 1.69.0) allows unauthenticated remote attackers to poison shared backend keep-alive connections by crafting an HTTP/1.1 Upgrade request that simultaneously carries a Content-Length header and body. When nghttpx forwards this ambiguous message to a backend and re-adds Connection and Upgrade headers while passing Content-Length verbatim, a backend that resolves the parsing ambiguity in the attacker's favor treats the body as a separate, attacker-controlled HTTP request - enabling cross-client response-queue poisoning. A publicly available proof-of-concept exploit exists; no CISA KEV listing at time of analysis.

HTTP/2-to-HTTP/1.1 request smuggling in swift-nio-http2 (versions prior to 1.44.1) allows unauthenticated remote attackers to inject arbitrary HTTP headers or smuggle entire requests to backend systems in reverse-proxy configurations. The codecs HTTP2FramePayloadToHTTP1ServerCodec and HTTP2ToHTTP1ServerCodec fail to strip CR, LF, or NUL control characters from HTTP/2 pseudo-header values such as :path and :authority before writing them into the HTTP/1.1 output, enabling the binary-safe HTTP/2 layer to act as a covert channel for control characters that become structural delimiters in HTTP/1.1. No public exploit has been identified at time of analysis, but this vulnerability is a direct extension of two prior confirmed CRLF injection flaws in the same library family (GHSA-7fj7-39wj-c64f and GHSA-cq87-8r7h-962v), indicating a recurring pattern that lowers the technical barrier for exploitation.

HTTP request smuggling in Netty's HttpObjectDecoder (netty-codec-http) allows unauthenticated remote attackers to manipulate request-boundary parsing in pipelined or multiplexed deployments by injecting non-CRLF ISO control characters (NUL, SOH, STX, etc.) before the HTTP request-line. Affected are all Netty releases prior to 4.1.135.Final and 4.2.15.Final; both branches have vendor-confirmed patches. No public exploit code has been identified and EPSS is 0.04% (12th percentile), indicating low current exploitation likelihood, though the attack surface expands significantly in architectures fronted by proxies or load balancers that strip or interpret those control bytes differently than Netty does.

HTTP request smuggling in Kong Gateway Enterprise (3.4, 3.10-3.14 series) enables unauthenticated remote attackers to desynchronize the HTTP/1.1 processing pipeline between Kong and its backend services, achieving high confidentiality and integrity impact against downstream systems. The parsing flaw (CWE-444) exploits ambiguous header interpretation to poison backend request queues, allowing cross-user request hijacking or malicious content injection. Proof-of-concept exploit code exists (CVSS 4.0 E:P), and no active exploitation is confirmed in CISA KEV at time of analysis.

Multipart request smuggling in Spring Framework's MVC and WebFlux components exposes applications to HTTP request manipulation via CWE-444. Unauthenticated remote attackers (AV:N/AC:L/PR:N/UI:N per CVSS) can exploit inconsistent multipart boundary parsing to smuggle malformed HTTP requests, achieving low-integrity impact against affected deployments. No public exploit code and no CISA KEV listing have been identified at time of analysis; however, the zero-prerequisite attack profile and broad version coverage across four major Spring branches (5.3.x, 6.1.x, 6.2.x, 7.0.x) make this relevant to any Java shop running Spring MVC or WebFlux with multipart upload handling enabled.

Header injection via parser differential in daphne before 4.2.2 allows unauthenticated remote attackers to smuggle synthetic headers into the ASGI scope received by Django applications during WebSocket handshake processing. The root cause is that Twisted (which daphne uses to parse inbound HTTP) ignores six specific Unicode bytes as line separators, while autobahn (which daphne feeds for WebSocket negotiation) calls Python's str.splitlines() and recognizes them - causing a single header value to be split into multiple injected header lines. No public exploit has been identified at time of analysis, and CVSS scores this at 3.7 (Low) due to high attack complexity, though real-world severity scales with how heavily the downstream application trusts ASGI-scope headers for security decisions.

HTTP/2 request parsing in Vinyl Cache and Varnish Cache enables backend request desync (HTTP request smuggling), exploitable for cache poisoning, authentication bypass, and information disclosure against affected deployments. Vinyl Cache prior to 9.0.1 and Varnish Cache prior to 9.0.3, plus legacy pre-split Varnish Cache branches spanning versions 6.0.14 through 8.0.1, are confirmed affected across three distinct CPE lineages. Exploitation is gated behind an explicitly non-default configuration - HTTP/2 must be enabled via the +http2 feature parameter - which substantially limits exposure; no public exploit code and no CISA KEV listing have been identified at time of analysis.

HTTP response smuggling in the Elixir Mint HTTP client library (versions 0.1.0 through before 1.9.0) allows attacker-controlled upstream servers to desynchronize response framing on shared connections by exploiting a non-RFC-compliant Content-Length parser. Mint's parser accepts sign-prefixed integers such as '+0' or '+123' that RFC 7230 forbids, creating a disagreement with RFC-strict fronting proxies about where one HTTP response body ends and the next begins. When Mint reuses connections via keep-alive, pipelining, or pooling across trust boundaries, this parser mismatch can be weaponized to leak bytes from one requester's response into another's stream. No public exploit code has been identified at time of analysis, and no KEV listing exists; a vendor patch (v1.9.0) is available.

HTTP request smuggling in libsoup allows remote unauthenticated attackers to exploit an unsigned-to-signed integer conversion error in the `soup_body_input_stream_read_chunked()` function via a crafted HTTP request. The vulnerability is confined to specific proxy topologies where libsoup operates either behind or in front of a non-libsoup HTTP intermediary, and successful exploitation can result in authentication bypass, web cache poisoning, or unauthorized access. No public exploit has been identified at time of analysis and this CVE is not listed in CISA KEV, but the integrity and confidentiality impacts warrant urgent attention in any affected mixed-proxy deployment.

Path prefix stripping in Hono's app.mount() API exposes mounted sub-applications to incorrect routing due to a raw-vs-decoded URL path inconsistency, potentially allowing unauthenticated remote attackers to reach unintended endpoints and disclose protected information. All Hono versions prior to 4.12.21 are affected across every supported JavaScript runtime. No public exploit or CISA KEV listing exists at time of analysis; however, the CVSS vector AV:N/AC:L/PR:N/UI:N and the 'Information Disclosure / Request Smuggling' classification make this a meaningful priority for any deployment that relies on mount-prefix path logic for access segregation.

HTTP request smuggling in Netty's chunk size parser allows remote unauthenticated attackers to inject arbitrary HTTP requests by exploiting integer overflow in the hexadecimal chunk size parsing logic. The HttpObjectDecoder.getChunkSize method accumulates the chunk size without proper overflow validation, enabling an attacker to craft a malicious chunk size header that wraps around to a valid size, causing Netty to misinterpret the request boundary and parse injected requests as separate legitimate requests. Publicly available proof-of-concept demonstrates successful parsing of an injected GET request within a chunked POST body, with CVSS score 6.5 (network-accessible, low complexity, no authentication required).

HTTP request smuggling in Starlet through version 0.31 allows remote unauthenticated attackers to bypass header validation by exploiting incorrect precedence of Content-Length over Transfer-Encoding headers. The vulnerability violates RFC 7230 section 3.3.3, which mandates that Transfer-Encoding must take precedence when both headers are present. An attacker positioned between a client and Starlet-based backend can craft malicious requests that are interpreted differently by a front-end reverse proxy and the Starlet server, enabling request smuggling attacks with integrity impact.

HTTP request smuggling in mtrudel bandit before version 1.11.0 allows unauthenticated attackers to bypass edge security controls when the application sits behind a proxy that interprets duplicate Content-Length headers differently. The vulnerability stems from Bandit accepting only the first Content-Length header while proxies may use the last value, causing request framing desynchronization that enables smuggling past WAF rules, path-based ACLs, rate limiting, and audit logging. CVSS 6.3 (AV:N/AC:L/AT:P) indicates network-accessible exploitation with some attack timing complexity; no public exploit code or active KEV listing identified at analysis time, but RFC 9112 non-compliance creates a known attack pattern.

HTTP request smuggling in libsoup's header parsing enables unauthenticated remote attackers to inject malformed requests containing multiple conflicting Content-Length headers, potentially bypassing security controls or poisoning shared connection state in two-tier deployments. The flaw resides in soup_message_headers_append_common() within libsoup/soup-message-headers.c, which blindly appends header values without validating for duplicate or contradictory Content-Length fields - a direct violation of RFC 7230. No active exploitation has been confirmed (not in CISA KEV), EPSS stands at 0.03% (8th percentile), and SSVC rates exploitation as none with partial technical impact, placing this firmly in the low-urgency tier despite its network-accessible attack vector.

HTTP request smuggling in HCL BigFix Service Management (SM) 23 allows unauthenticated remote attackers to bypass front-end security controls, poison caches, or hijack requests when the product is deployed behind a front-end HTTP server or proxy that parses requests differently than the back-end. Exploitation requires this specific desynchronized topology (high complexity per independent assessment), and no public exploit or active exploitation has been identified; EPSS is 0.03% (8th percentile), indicating very low likelihood of exploitation at this time.

Apache Traffic Server versions 9.0.0-9.2.12 and 10.0.0-10.1.1 are vulnerable to HTTP request smuggling through malformed chunked transfer encoding, allowing attackers to bypass security controls and smuggle malicious requests. The vulnerability stems from improper parsing of chunked messages (CWE-444: Inconsistent Interpretation of HTTP Requests) and affects all deployments using these versions as reverse proxies or intermediaries. Apache has released patched versions 9.2.13 and 10.1.2; no public exploit code or active exploitation has been reported at the time of analysis.

IBM Verify Identity Access and Security Verify Access versions 10.0 through 10.0.9.1 and 11.0 through 11.0.2 allow unauthenticated remote attackers to access sensitive information through HTTP request smuggling via inconsistent interpretation of HTTP requests by a reverse proxy. The vulnerability affects both container and non-container deployments and has a CVSS score of 5.3 with confirmed vendor patch availability.

Remote attackers can access sensitive information in IBM Verify Identity Access Container 11.0-11.0.2, IBM Security Verify Access Container 10.0-10.0.9.1, and their non-containerized counterparts through HTTP request smuggling. The vulnerability exploits inconsistent HTTP request interpretation between the application and its reverse proxy, allowing unauthenticated remote access to restricted data with low attack complexity.

HTTP Request Smuggling in cpp-httplib prior to 0.40.0 allows remote attackers to inject arbitrary HTTP requests on HTTP/1.1 keep-alive connections by embedding malicious request data in the body of GET requests that the static file handler does not consume. The unread body bytes remain on the TCP stream and are interpreted as a new request, enabling information disclosure and request manipulation without authentication or user interaction.

An HTTP Request/Response Smuggling vulnerability exists in visualfc liteide due to inconsistent interpretation of HTTP requests in the HTTP parser component (http_parser.C), classified under CWE-444. This affects liteide versions before x38.4, allowing attackers to exploit the qjsonrpc HTTP parser module to smuggle malicious requests. An attacker could leverage this vulnerability to perform request smuggling attacks, potentially leading to cache poisoning, session hijacking, or information disclosure depending on the deployment context and HTTP intermediaries involved.

CVE-2026-29057 is a security vulnerability (CVSS 6.5) that allows request smuggling. Remediation should follow standard vulnerability management procedures. Vendor patch is available.

Cisco Secure Firewall ASA and FTD devices with VPN web services enabled are vulnerable to cross-site request forgery (CSRF) attacks due to insufficient HTTP request validation. An attacker can trick users into visiting a malicious website that sends crafted requests to the affected appliance, potentially allowing injection of malicious content reflected back to the victim's browser. No patch is currently available for this vulnerability.

An inconsistent interpretation of http requests ('http request smuggling') vulnerability in Fortinet FortiOS 7.6.0, FortiOS 7.4.0 through 7.4.9, FortiOS 7.2 all versions, FortiOS 7.0 all versions, FortiOS 6.4.3 through 6.4.16 may allow an unauthenticated attacker to smuggle an unlogged http request through the firewall policies via a specially crafted header [CVSS 5.8 MEDIUM]

HTTP request smuggling in libsoup allows remote attackers to exploit non-compliant chunk header parsing by injecting malformed requests with LF-only line endings instead of proper CRLF formatting. Without requiring authentication, an attacker can cause libsoup to interpret multiple HTTP requests from a single network message, potentially leading to information disclosure. No patch is currently available for this vulnerability.

AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Versions 3.13.2 and below contain parser logic which allows non-ASCII decimals to be present in the Range header. [CVSS 5.3 MEDIUM]

AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Versions 3.13.2 and below of the Python HTTP parser may allow a request smuggling attack with the presence of non-ASCII characters. [CVSS 6.5 MEDIUM]

HTTP request smuggling in libsoup, GNOME's HTTP client/server library, lets remote unauthenticated attackers exploit inconsistent Host header parsing: libsoup accepts multiple Host: headers and processes the last occurrence, while common front-end proxies honor the first. Supplying duplicate Host headers creates a proxy/backend mismatch enabling vhost confusion, request smuggling, cache poisoning, and bypass of host-based access controls. No public exploit is identified at time of analysis and it is not listed in CISA KEV, but Red Hat has shipped fixes across numerous products (15 RHSA errata).

OutSystems Platform Server version 11.18.1.37828 is reported to allow denial of service through HTTP request smuggling (CWE-444) by sending a crafted HTTP request where the Content-Length header value does not match the actual body length, disrupting the server's HTTP parser and causing service unavailability. The impact is limited to availability - no confidentiality or integrity exposure is indicated. Critically, the vendor has publicly stated they are unable to reproduce this vulnerability, and the PoC references point exclusively to personal blogs rather than established security research publications, introducing substantial uncertainty about the finding's validity. No public exploit identified at time of analysis has been confirmed by independent researchers or CISA KEV.

lighttpd1.4.80 incorrectly merged trailer fields into headers after http request parsing. Rated medium severity (CVSS 6.9), this vulnerability is remotely exploitable, no authentication required, low attack complexity. This HTTP Request/Response Smuggling vulnerability could allow attackers to manipulate HTTP request interpretation between frontend and backend servers.

HTTP request smuggling against Google Cloud Vertex AI generative-AI endpoints can cause connection desynchronization between the front-end proxy and the model backend, producing limited confidentiality and availability impact under the assessed vector (CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:N/A:L). The flaw is in Google's managed proxy infrastructure rather than customer-deployed software, so affected parties are users of impacted Vertex AI models served through the vulnerable proxy tier, and Google completed fixes for all such proxies by 2025-09-28. No public exploit code was identified at time of analysis, EPSS is 0.32%, and customers need take no action.

Http4s is a Scala interface for HTTP services. Rated medium severity (CVSS 6.3), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available.

An HTTP Request Smuggling [CWE-444] vulnerability in the Authentication portal of WatchGuard Fireware OS allows a remote attacker to evade request parameter sanitation and perform a reflected. Rated medium severity (CVSS 6.9), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

Netty is an asynchronous event-driven network application framework for development of maintainable high performance protocol servers and clients. Rated low severity (CVSS 2.9), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available.