Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify PSL H2 server endpoint
-
DeliveryOpen HTTP/2 stream
-
ExploitSend HEADERS with crafted content-length
-
ExecutionSend mismatched DATA frame total
-
PersistBypass size limit or truncate body
-
ImpactApplication acts on smuggled or partial request
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 that the target application directly instantiates Psl\H2\ServerConnection from PSL 6.1.0, 6.1.1, or 6.2.0 to terminate untrusted HTTP/2 client traffic - applications that consume only the documented high-level PSL HTTP APIs are not reachable. No authentication or user interaction is needed (PR:N/UI:N), the attacker only needs the ability to open an HTTP/2 stream to the server, and the application must trust the declared content-length when processing the body (otherwise the smuggling is benign). Realistic risk is bounded by how unusual this low-level integration pattern is in production deployments. |
| Impact | The CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N (7.5 High) accurately reflects a network-reachable, unauthenticated integrity-only smuggling primitive - confidentiality and availability are not directly affected, but downstream integrity impact can be severe depending on what the application trusts. There is no EPSS score, no KEV listing, and no POC referenced; the release notes explicitly state discovery was internal and pre-public, so this should be treated as a real but not actively exploited issue. The most important caveat is the narrow reachability condition: only deployments that build directly on Psl\H2\ServerConnection to terminate untrusted HTTP/2 traffic are exposed, which is likely a small subset of PSL users, so prioritization should be driven by an inventory check rather than raw CVSS. |
| Exploit ScenarioDerived | A remote attacker opens an HTTP/2 stream against a PSL-backed server, sends a HEADERS frame declaring content-length: 100, then sends DATA frames totaling either 200 bytes (smuggling 100 extra bytes past size limits or into a co-tenant request boundary) or only 50 bytes followed by END_STREAM (forcing the application to act on a truncated body it believes is complete). The attacker can use this to bypass application-level size caps, poison logs/queues that key on content-length, or induce inconsistent state in handlers that trust the declared length. No public exploit identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 17, 2026
HTTP/2 request smuggling in PHP Standard Library (PSL) versions 6.1.0, 6.1.1, and 6.2.0 lets remote unauthenticated clients desynchronize stream boundaries in Psl\H2\ServerConnection by sending DATA frame totals that disagree with the declared content-length header. Only applications that consume the low-level H2 server connection directly to accept untrusted traffic are exposed; high-level PSL APIs are unaffected. No public exploit identified at time of analysis, and the maintainers state the issue was found during internal review prior to public exploitation.
RemediationAI
Vendor-released patches are available: upgrade to PSL 6.1.2 (https://github.com/php-standard-library/php-standard-library/releases/tag/6.1.2) on the 6.1.x branch or 6.2.1 (https://github.com/php-standard-library/php-standard-library/releases/tag/6.2.1) on the 6.2.x branch, e.g. composer require php-standard-library/psl:^6.1.2. These versions parse and validate content-length on server-side HEADERS receive, track cumulative DATA frame payload length per stream, and throw Psl\H2\Exception\StreamException on mismatch or overflow. If patching is delayed, compensating controls are to front Psl\H2\ServerConnection with a hardened HTTP/2 terminator such as nginx or Envoy that enforces RFC 9113 framing (trade-off: extra hop and TLS termination move) or refactor consumers off the low-level ServerConnection onto the documented high-level PSL APIs, which are not affected.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 6 packages in composer, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
PSL is a PHP standard-library-style toolkit; the affected component, Psl\H2\ServerConnection, implements the server side of HTTP/2 framing as defined by RFC 9113. RFC 9113 §8.1.1 and §8.1.2.6 require that when a HEADERS frame declares a content-length, the cumulative payload of subsequent DATA frames on that stream must equal that value. The vulnerable code parsed the header but never reconciled it against the running byte count of DATA frames, classifying this as CWE-444 (Inconsistent Interpretation of HTTP Requests / Request Smuggling). The CPEs cpe:2.3:a:php-standard-library:php-standard-library:* and the dedicated cpe:2.3:a:php-standard-library:php-standard-library/h2:* confirm the H2 subcomponent as the locus of the flaw.
Know when Php Standard Library gets its next vulnerability
- 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:N/I:H/A:N
HTTP/2 server is network-reachable with low complexity and no auth or interaction; impact is integrity-only via smuggling/truncation, with no direct confidentiality or availability loss.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
PHP Standard Library (PSL) is set of APIs covering async, collections, networking, I/O, cryptography, terminal UI, etc. In versions 6.1.0, 6.1.1 and 6.2.0, the Psl\H2\ServerConnection does not validate that the total bytes received in DATA frames match the content-length header declared in the HEADERS frame, allowing request smuggling. This is in violation of RFC 9113 §8.1.1. A malicious client is able to send more DATA bytes than declared, smuggling additional content past application-level size limits and send fewer DATA bytes than declared and close the stream early, causing applications that trust the declared length to behave incorrectly. The vulnerability is only reachable for consumers using Psl\H2\ServerConnection directly to accept untrusted client traffic. Consumers of documented high-level PSL APIs are not affected. This issue has been fixed in versions 6.1.2 and 6.2.1.
Executive ViewAI
HTTP/2 request smuggling in PHP Standard Library (PSL) versions 6.1.0, 6.1.1, and 6.2.0 allows remote unauthenticated attackers to desynchronize request streams through DATA frame manipulation, potentially enabling cache poisoning or request smuggling attacks. Impact is limited to organizations directly using PSL's low-level H2ServerConnection; applications built on standard PSL APIs remain unaffected.
No vendor-released patch identified at time of analysis. Interim mitigations: (1) Disable HTTP/2 if not critical to operations; (2) Enforce strict application-layer validation of DATA frame totals against content-length headers; (3) Restrict H2 endpoint access via network controls, authentication, or API gateway policies; (4) Configure alerting for anomalous stream state transitions.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-37798
GHSA-pw9p-jvrm-f7rm
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB