Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend HTTP/2 request with CRLF bytes in :path pseudo-header
-
DeliveryCodec skips control character validation
-
ExploitBytes written verbatim into HTTP/1.1 output
-
ExecutionBackend HTTP/1.1 parser interprets CRLF as structural delimiters
-
PersistInjected header or smuggled request processed by backend
-
ImpactBypass proxy security controls or access restricted backend resources
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service HTTP request consistency
|
| Exploitation Conditions | Two concrete conditions must both be met: first, the server must run swift-nio-http2 at a version earlier than 1.44.1 with either HTTP2FramePayloadToHTTP1ServerCodec or HTTP2ToHTTP1ServerCodec active in the request pipeline; second, the server must operate in a reverse-proxy or protocol-bridging mode where HTTP/2 requests are translated to HTTP/1.1 and forwarded to a backend - this is the explicit deployment pattern identified in the advisory. No authentication is required (PR:N per independent CVSS assessment); the attacking client only needs the ability to reach the HTTP/2 listener and send a request containing control characters in a pseudo-header value. Exploitation is limited by the following: a swift-nio-http2 server that terminates HTTP/2 as a final endpoint without any HTTP/1.1 backend forwarding is not exploitable; the attack requires the HPACK layer to pass the malformed pseudo-header without prior rejection (pre-1.44.1 behavior does not validate these values); and backend exploitation impact depends on whether the backend HTTP/1.1 server shares connection state across requests. |
| Impact | The CVSS vector supplied in the source data (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:N) is a placeholder with zero impact scores and must not be used for prioritization decisions - it does not reflect any real severity assessment of this vulnerability. An independent assessment assigns high integrity impact with scope change because successful exploitation allows injected requests to reach a backend system outside the proxy's trust boundary. Real-world risk is strongly topology-dependent: deployments where swift-nio-http2 terminates HTTP/2 as a final endpoint without backend forwarding are not exploitable, while any reverse-proxy or API gateway pattern translating HTTP/2 to HTTP/1.1 backends is directly exposed. EPSS data is absent from available intelligence, so statistical exploitation probability cannot be quantified. The vulnerability is not in CISA KEV and no POC code is referenced in the advisory. However, the technique is well-documented in the HTTP request smuggling literature, the affected library family has had two prior CRLF injection fixes, and no authentication is required - these factors combine to make exploitation plausible by a motivated attacker in a targeted engagement against a known deployment. The Vapor framework is explicitly named as a directly affected consumer. |
| Exploit ScenarioDerived | An attacker sends an HTTP/2 request to a swift-nio-http2 reverse-proxy with a crafted :path value such as /api/data X-Forwarded-For: 127.0.0.1 POST /admin HTTP/1.1 Host: backend - which is syntactically valid in HTTP/2's binary framing layer and passes through without error. When the codec translates this to HTTP/1.1 and forwards it to the backend, the embedded CRLF bytes become structural delimiters, causing the backend parser to interpret the payload as containing an injected header and a second smuggled POST request to the /admin endpoint. This could allow the attacker to bypass proxy-enforced authentication headers, poison shared backend connection state, or reach restricted backend endpoints not intended to be exposed via the proxy. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 12, 2026
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.
RemediationAI
Upgrade swift-nio-http2 to version 1.44.1 as recommended by the vendor - the CPE package data specifies 1.44.1 as the fixed version, though the advisory text references 1.44.0 as the version introducing the fix; consult the upstream advisory at https://github.com/apple/swift-nio-http2/security/advisories/GHSA-4px2-pw77-vc85 to confirm the canonical release. The fix adds validation of all pseudo-header values (:path, :authority, :scheme, :method, :status) at both the HPACK header validation layer and the HTTP/2-to-HTTP/1.1 translation layer, rejecting connections that carry CR, LF, or NUL bytes with a connection error. If an immediate upgrade is not feasible, a compensating control is to deploy a validating HTTP/2 termination proxy such as Envoy or nginx (with strict header validation enabled) in front of the swift-nio-http2 endpoint to reject requests containing control characters in pseudo-header values; this introduces an additional hop and a dependency on the proxy's own validation correctness. Swift server deployments not performing HTTP/2-to-HTTP/1.1 forwarding are not exploitable but should upgrade regardless to eliminate the vulnerability class.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The affected package is pkg:swift/github.com_apple_swift-nio-http2, Apple's Swift implementation of HTTP/2 built on the SwiftNIO non-blocking I/O event loop. The two vulnerable codecs, HTTP2FramePayloadToHTTP1ServerCodec and HTTP2ToHTTP1ServerCodec, handle the translation layer between HTTP/2 binary frames and HTTP/1.1 text-based messages used by downstream backends. The root cause is CWE-444 (Inconsistent Interpretation of HTTP Requests - HTTP Request Smuggling): HTTP/2 uses HPACK binary encoding and binary framing where CRLF bytes carry no structural meaning at the framing layer, so they are treated as opaque data. However, when the codec writes these bytes verbatim into HTTP/1.1 header fields or the request line, CR and LF become structural delimiters that the backend HTTP/1.1 parser interprets as header terminators or line boundaries, creating the smuggling primitive. The five affected pseudo-headers are :path, :authority, :scheme, :method, and :status. Prior advisories GHSA-7fj7-39wj-c64f (HTTP/1.1 header value CRLF injection) and GHSA-cq87-8r7h-962v (method, path, and version CRLF injection) addressed adjacent attack surfaces in swift-nio but left pseudo-header translation unguarded.
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
Network-exploitable with no auth; scope changes because CRLF injection lets smuggled requests reach and affect the HTTP/1.1 backend beyond the proxy boundary.
Primary rating from Vendor (https://github.com/apple/swift-nio-http2).
CVSS VectorVendor: https://github.com/apple/swift-nio-http2
Lifecycle Timeline
2DescriptionCVE.org
swift-nio-http2's HTTP/2-to-HTTP/1.1 codec (HTTP2FramePayloadToHTTP1ServerCodec / HTTP2ToHTTP1ServerCodec) did not validate pseudo-header values for control characters before placing them into the translated HTTP/1.1 message. A remote attacker could send an HTTP/2 request containing CR (\r), LF (\n), or NUL (\0) bytes in pseudo-header values such as :path, and when the server translated this to HTTP/1.1 - for example in a reverse-proxy configuration - the resulting output could contain injected headers or entirely smuggled requests.
This is an HTTP/2-to-HTTP/1.1 request smuggling vulnerability. HTTP/2's binary framing means that CRLF bytes are never parsed as line terminators at the HTTP/2 layer, so they pass through transparently to the HTTP/1.1 output. Any swift-nio-http2 server that translates HTTP/2 requests to HTTP/1.1 and forwards them to a backend is affected. Server-side Swift frameworks such as Vapor that use this codec in a reverse-proxy pattern are directly affected.
This vulnerability is related to https://github.com/advisories/GHSA-7fj7-39wj-c64f in swift-nio, which addressed CRLF injection in HTTP/1.1 header values but did not cover pseudo-header values in the HTTP/2 layer.
This vulnerability is also related to https://github.com/advisories/GHSA-cq87-8r7h-962v in swift-nio, which addressed CRLF injection in HTTP/1.1 version, method and path.
swift-nio-http2 1.44.0 adds validation of all pseudo-header values (:path, :authority, :scheme, :method, and :status) at both the HPACK header validation layer and the HTTP/2-to-HTTP/1.1 translation layer. Requests or responses containing CR, LF, or NUL bytes in any pseudo-header value are now rejected with a connection error.
SwiftNIO recommends all adopters upgrade to 1.44.0 as soon as possible.
SwiftNIO thanks @kuranikaran for filing this issue and the support in fixing it.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
EUVD-2026-39533
GHSA-4px2-pw77-vc85
NVD
CVE.org
EPSS
VulDB
Exploit-DB