Skip to main content

swift-nio-http2 EUVDEUVD-2026-39533

| CVE-2026-28898 MEDIUM
HTTP Request/Response Smuggling (CWE-444)
2026-06-12 https://github.com/apple/swift-nio-http2 GHSA-4px2-pw77-vc85
5.3
CVSS 3.1 · Vendor: https://github.com/apple/swift-nio-http2
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Send HTTP/2 request with CRLF bytes in :path pseudo-header
  2. Delivery
    Codec skips control character validation
  3. Exploit
    Bytes written verbatim into HTTP/1.1 output
  4. Execution
    Backend HTTP/1.1 parser interprets CRLF as structural delimiters
  5. Persist
    Injected header or smuggled request processed by backend
  6. Impact
    Bypass 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

swift-nio-http2 0 <1.44.1

Affected Packages

euvd swift_nio_http2 fix: 1.44.1

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

Vendor (https://github.com/apple/swift-nio-http2) PRIMARY 5.3 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
vuln.today AI 9.3 CRITICAL

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:H/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:H/VA:N/SC:L/SI:H/SA:N

Primary rating from Vendor (https://github.com/apple/swift-nio-http2).

CVSS VectorVendor: https://github.com/apple/swift-nio-http2

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
Low
Integrity
None
Availability
None

Lifecycle Timeline

2
Patch available
Jun 25, 2026 - 21:03 EUVD
CVSS changed
Jun 25, 2026 - 20:22 NVD
5.3 (MEDIUM)

DescriptionCVE.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

EPSS Score
0.1%
Top 83% exploitable
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact· derived
Medium

Priority Score

26
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy