Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify paid endpoint served via CDN
-
DeliveryWait for a paying client to populate cache
-
ExploitRequest same URL unauthenticated
-
ExecutionReceive cached paid 200 + Payment-Receipt
-
ImpactObtain paid content and receipt without paying
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V3 - Web Frontend Security Cache-Control for sensitive pages
|
| Exploitation Conditions | Exploitation requires all of the following, none of which are the library's default: (1) a mounting application that sets its own Cache-Control on the MPP-gated paid resource with a shareable directive (e.g. public, max-age=3600), overriding the library's Cache-Control: private via Plug.Conn.put_resp_header/3; and (2) a shared HTTP cache - a CDN or reverse proxy - in the response path that will store and replay the paid 200 along with its Payment-Receipt header. A related weaker condition needs no cache: because no register_before_send/2 callback strips it, a downstream non-2xx response still carries a Payment-Receipt, issuing a receipt for a response that delivered no resource. Limiting factors: the library's own default (Cache-Control: private on success, no-store on 402) is safe, so the vulnerable state only exists when the protected application misconfigures caching; without a shared cache the primary leak does not occur. |
| Impact | This is a genuine but modest-severity flaw whose real-world risk is tightly bounded by preconditions. The vendor CVSS 4.0 vector (6.3, AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:N/VA:N/SC:L) already signals limited impact: only low confidentiality to the vulnerable system and to a subsequent system (the shared cache), with no integrity or availability effect. Critically, the vector carries AT:P (attack requirements present), which correctly captures that exploitation is not universal against defaults - it depends on a mounting application overriding the library's Cache-Control: private with a cacheable directive AND a CDN/reverse proxy being present in the response path. No EPSS score, KEV listing, or public POC was provided; per the precision rules this is 'no public exploit identified at time of analysis.' There is no SSVC decision data supplied. Note a nuance: the CVSS marks AC:L, but the description makes clear a specific application-side misconfiguration is required, so real-world attack complexity is higher than AC:L implies - the network vector is low-complexity to send, but the vulnerable state must first be created by the deploying app. Net: a real correctness/logic weakness worth patching, not an urgent widely-exploitable priority. |
| Exploit ScenarioDerived | A developer mounts MPP.Plug to gate a premium API endpoint, and the endpoint's own controller (or an upstream layer) sets Cache-Control: public, max-age=3600 on the paid 200 response, silently overwriting the library's private directive. A CDN or reverse proxy in front of the app then stores that paid response together with its Payment-Receipt header and serves it verbatim to subsequent clients who never paid. No public exploit code is identified; the 'attack' is simply an unpaid client requesting the same cached URL. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 16, 2026
ZenHive mpp (MPP.Plug payment middleware for Elixir/Phoenix) versions 0.1.0 through 0.16.1 can allow a shared HTTP cache - a CDN or reverse proxy - to store a paid 200 response together with its Payment-Receipt header and replay both to clients that never paid, because the library's own Cache-Control: private is silently replaced when the mounting application sets its own cache directive on the same connection. An unauthenticated remote client that reaches such a cache can therefore obtain paid content and a valid receipt for free, and a related weaker case has a downstream non-2xx response still carrying a Payment-Receipt for a resource that was never delivered (CWE-524). The real-world risk is tightly bounded: the library's default behavior (private on success, no-store on 402) is safe, so the leak requires an application-level caching misconfiguration plus a shared cache in the response path, and no public exploit code was identified at time of analysis.
RemediationAI
Vendor-released patch: 0.16.2 - upgrade the mpp dependency to 0.16.2 or later, as indicated by the affected range ('from 0.1.0 before 0.16.2') and the advisory at https://github.com/ZenHive/mpp/security/advisories/GHSA-82qh-vrvm-gqvc, whose fixes are captured in upstream commits https://github.com/ZenHive/mpp/commit/2fd91a5ecbd0b0ad2a4ac202b79659e8126dbc0b (patch) and https://github.com/ZenHive/mpp/commit/2d4d1d94aae7790ae0623063961adbeef171fa71. If upgrading immediately is not possible, apply compensating controls at the application and edge layers: (1) remove any application-set Cache-Control directive on MPP-gated paid routes, or at minimum stop emitting shareable directives such as public/max-age there - the side effect is increased origin load and lower cache hit rates for those routes, which is preferable to leaking paid content; (2) explicitly strip or overwrite the Payment-Receipt header (and re-assert Cache-Control: private) in a custom register_before_send/2 callback or a terminal plug placed after MPP.Plug in every paid pipeline, so receipts are never attached to cached or non-2xx responses - this duplicates logic the library should own and must be audited whenever routes change; (3) configure the CDN or reverse proxy to bypass caching entirely for MPP-gated paths (cache-bypass rules, Vary: Authorization/Payment handling, or surrogate-key purging) - this sacrifices edge caching performance for those endpoints but closes the primary leak; (4) ensure no Payment-Receipt header is emitted on error responses, e.g. by scrubbing it on non-2xx status codes. Note that the library's default configuration (Cache-Control: private on success, no-store on 402) is already safe, so any mitigation should be verified by asserting the final response headers rather than assuming application code preserves them.
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
MPP.Plug is a mountable Plug middleware implementing the MPP 402 payment handshake in Elixir: on init/1 it validates options into an MPP.Plug.Config struct (secret_key, realm, method, charge/request, expires_in, opaque), and on call/2 it either returns 402 with a WWW-Authenticate challenge, or, for a valid credential, passes the request through after setting receipt data in conn.assigns[:mpp_receipt] and adding a Payment-Receipt response header. The defect is CWE-524 (Use of Cache Containing Sensitive Information): the library sets payment-receipt and cache-control: private on the connection before invoking the wrapped application, and registers no register_before_send/2 callback to re-assert those headers at response time. Because Plug.Conn.put_resp_header/3 replaces an existing header rather than appending it, any application code that writes its own Cache-Control (for example "public, max-age=3600") on the paid resource overwrites the library's private directive, so the guarantee the library advertises is defeatable by the very application it is protecting. The same missing before-send hook means a non-2xx downstream response keeps the Payment-Receipt header, effectively issuing a receipt for a response that delivered no resource. The affected component is the plug.ex implementation added in the Task 8 'Plug middleware' work on Phase 1 of the project's roadmap, so all releases from 0.1.0 up to (but not including) 0.16.2 carry the flawed ordering. Per the assessed vector (AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:N/A:N), exploitation is unauthenticated and network-reachable but has high attack complexity and limited confidentiality impact in a changed security scope - no integrity or availability impact - which matches the requirement for a specific, non-default deployment configuration rather than a straightforward remote exploit.
Know when Mpp 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
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:N/VA:N/SC:L/SI:N/SA:N
Network-reachable but AC:H because a specific app-side Cache-Control override plus a shared cache must both be present; S:C as a separate cache component is affected; only low confidentiality, no integrity/availability.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Use of Cache Containing Sensitive Information in ZenHive mpp allows a shared HTTP cache to store a paid response and serve it to clients that never paid.
MPP.Plug.verify_credential in lib/mpp/plug.ex sets payment-receipt and cache-control: private on the connection before the wrapped application runs, and registers no register_before_send/2 callback. Plug.Conn.put_resp_header/3 replaces an existing header, so a mounting application that sets its own cache-control on the paid resource (for example public, max-age=3600) silently overrides the private the library relies on, and a CDN or reverse proxy can then store the paid 200 together with its Payment-Receipt and serve both to unpaid clients. The library-level guarantee is therefore defeatable by the application it protects. For the same reason a downstream non-2xx response still carried Payment-Receipt, issuing a receipt for a response that delivered no resource.
This issue affects mpp: from 0.1.0 before 0.16.2.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Missing validation of the EIP-7702 aa_authorization_list field in ZenHive mpp's Tempo payment sponsorship module allows
Gas-cost inflation and unauthorized access key provisioning in ZenHive mpp (versions 0.2.0 through 0.15.x) allows any un
Replay of settled EVM blockchain transaction hashes against ZenHive mpp versions 0.3.0-0.6.2 allows unauthenticated remo
Concurrent sponsored-payment flooding in ZenHive mpp (versions 0.2.0 through 0.12.0) allows an unauthenticated remote cl
Economic resource exhaustion in the ZenHive mpp Elixir library (versions 0.2.0 through 0.5.x) lets an unauthenticated re
Fee-payer wallet draining in ZenHive mpp (Elixir) 0.2.0-0.5.x lets an unauthenticated remote client empty the sponsor's
Capture-replay authentication bypass in ZenHive mpp versions 0.6.1-0.6.3 allows unauthenticated network attackers to cla
Wallet-draining denial of service in ZenHive mpp (Elixir library) versions 0.2.0 through 0.5.x affects deployments confi
Replay of a captured Tempo subscription credential in ZenHive mpp 0.14.0 through 0.16.1 lets an attacker who already hol
ZenHive mpp versions 0.14.0 through 0.16.1 fail to charge clients that hold an open payment channel, allowing an authent
Duplicate-submission gate bypass in the Tempo payment method of ZenHive mpp (versions 0.2.0 through 0.16.1) lets an unau
Payment-replay protection in ZenHive mpp's Tempo hash-credential path is defeated by a TOCTOU race condition, allowing a
EUVD-2026-80254
GHSA-4h6w-pvrh-g28p
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB