Skip to main content

Python h2 Library CVE-2026-71554

| EUVDEUVD-2026-54177 MEDIUM
HTTP Request/Response Smuggling (CWE-444)
2026-08-06 https://github.com/python-hyper/h2 GHSA-6hr6-w5qg-qmwg
5.3
CVSS 3.1 · Vendor: https://github.com/python-hyper/h2
View

Attack ChainAIDerived

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

  1. Access
    Send HTTP/2 request with two Host headers
  2. Delivery
    h2 ≤4.4.0 accepts malformed header block
  3. Exploit
    Both Host headers forwarded to consuming application
  4. Execution
    Consumer rewrites request as HTTP/1.1
  5. Persist
    Downstream origin receives ambiguous dual-Host request
  6. Impact
    Inconsistent Host interpretation exploited for cache poisoning or access control bypass

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

Exploitation requires two conditions to be simultaneously present. First, the target application must use h2 version 4.4.0 or earlier as its HTTP/2 parsing layer - any deployment running h2 ≥4.4.1 is patched. Second, the application or an intermediary component must downgrade the parsed HTTP/2 request to HTTP/1.1 before forwarding it to an upstream or origin server, which is a common pattern in reverse proxies, API gateways, and load balancers. The CVSS vector (AV:N/AC:L/PR:N/UI:N) confirms that no authentication and no special attacker-side configuration is required to send the crafted HTTP/2 request. The limiting factor is architectural: deployments where h2 terminates HTTP/2 without any subsequent HTTP/1.1 forwarding are not exposed to the smuggling consequence, even though the library still silently accepts the malformed header block.

Impact

The NVD CVSS 5.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L) rates this as moderate, but the I:N assignment is worth scrutinising: request smuggling is fundamentally an integrity-class attack (cache poisoning, security control bypass, routing manipulation), and the A:L rating in the official vector is atypical for this vulnerability class. Real-world risk is highly deployment-dependent - the smuggling impact only materialises where h2 feeds into an HTTP/1.1 backend or proxy that interprets Host headers; deployments where h2 is a terminating endpoint with no downstream HTTP/1.1 forwarding are not exposed to the smuggling consequence, though the library still silently accepts the malformed input. No EPSS data was provided, so exploitation probability cannot be quantified. Not in CISA KEV and no public exploit code identified at time of analysis, suggesting no widespread weaponisation at the time of disclosure. Patch is available and straightforward to apply, making this a low-urgency-but-clear-action item for teams running h2-powered HTTP/2-to-HTTP/1.1 gateway architectures.

Exploit ScenarioDerived

A remote, unauthenticated attacker sends a crafted HTTP/2 request to an h2-powered reverse proxy, embedding two Host header fields in a single HPACK header block. The h2 library accepts both and forwards them to a backend that rewrites the request as HTTP/1.1; the resulting request carries two Host lines, which the origin server or caching layer interprets inconsistently with the proxy, allowing the attacker to poison a shared cache entry or bypass a Host-based access control rule. No public exploit code has been identified at time of analysis, but the technique is well-documented in HTTP smuggling literature.

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

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

Alert me

AnalysisAIv1 – Aug 06, 2026

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.

RemediationAI

Upgrade the pip/h2 package to version 4.4.1 or later; this version raises a ProtocolError and rejects any HTTP/2 header block containing multiple Host headers before the data reaches application code (patch commit 292a40829feefda98c8509dcdbbb4a57af9bd6a6, advisory GHSA-6hr6-w5qg-qmwg). Where an immediate upgrade is not possible, consuming application code should explicitly validate that each inbound request exposes exactly one Host header and reject or terminate requests that carry duplicates - however, the vendor notes that h2 provides best-effort sanity checks and the calling code bears final responsibility, so application-layer workarounds are fragile and should not substitute for upgrading. Teams should audit any reverse proxy or gateway components built on h2 that perform HTTP/2-to-HTTP/1.1 downgrading, as those are the deployments where the smuggling primitive can be realised; architectures that terminate HTTP/2 without any HTTP/1.1 downstream forwarding have reduced but non-zero exposure.

Affected VersionsENISA

h2 < 4.4.1

Affected Packages

pypi h2 fix: 4.4.1

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in pypi

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

h2 is the canonical Python implementation of the HTTP/2 protocol, distributed as pip/h2 under the python-hyper organization. HTTP/2 transmits headers as HPACK-compressed binary blocks rather than plaintext; the h2 library is responsible for parsing these blocks and surfacing them to calling application code. CWE-444 (Inconsistent Interpretation of HTTP Requests) describes the root cause: h2 ≤4.4.0 did not enforce the HTTP/2 specification requirement that a header block contain at most one Host header, and forwarded all duplicates downstream. The vulnerability mirrors a prior duplicate content-length issue in the same library. The patch (commit 292a40829feefda98c8509dcdbbb4a57af9bd6a6) adds a ProtocolError in _validate_host_authority_header within src/h2/utilities.py that rejects header blocks containing more than one Host value before they reach consumer code. The affected CPE is pkg:pip/h2.

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/python-hyper/h2) PRIMARY 5.3 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
vuln.today AI 5.3 MEDIUM

Network-accessible with no auth; integrity impact (routing/cache manipulation) better represents smuggling than availability; no confidentiality or availability impact from the primitive itself.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N
SUSE MEDIUM
Red Hat 5.3 MEDIUM

Primary rating from Vendor (https://github.com/python-hyper/h2).

CVSS VectorVendor: https://github.com/python-hyper/h2

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

DescriptionCVE.org

Impact

h2 <=4.4.0 accepts request header blocks containing more than one Host header, and forwards every Host header to the consuming application. Where the consumer downgrades HTTP/2 to HTTP/1.1, the resulting request carries two Host header lines, which is a request smuggling primitive (CWE-444).

Patches

Patched and fixed in v4.4.1

Workarounds

Users of the h2 library are advised to check and follow HTTP semantics best practices in their application code. h2 provides best effort sanity checks, but ultimately the calling code is responsible to ensure proper and safe usage of HTTP/2 as provided by h2, hyperframe, and hpack.

References

Similar to the previously disclosed and fixed duplicate content-length issue.

Threat Intelligence Overview

EPSS Score
0.3%
Top 75% exploitable
Prevalence
Medium
widely used Python HTTP/2 library, not universally deployed
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Data Quality
8 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub VulDB

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 Yes
EPSS 0.3%
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
None
System Exposure· derived
Open
Automatable
Yes
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

46
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
PoC: +20
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.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Performance Computing 15 SP7 Affected
SUSE Linux Enterprise Module for Python 3 15 SP7 Affected
SUSE Linux Enterprise Module for Server Applications 15 SP7 Affected
SUSE Linux Enterprise Server 15 SP7 Affected

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