Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify protected route served from cache
-
DeliveryCraft percent-encoded or malformed pathname
-
ExploitBypass middleware authorization matcher
-
ExecutionDecode to cache key of protected route
-
ImpactReceive cached protected content unauthorized
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization URL encoding handling
|
| Exploitation Conditions | Three conditions must all hold: (1) the application sets enableCacheInterception: true in open-next.config.ts (opt-in, non-default); (2) access control is enforced via Next.js middleware matchers rather than in-route checks; and (3) the protected route has a matching entry in the incremental cache. Exploitation is LIMITED by all three being deployment-specific - an app that does not enable cache interception, or that authorizes inside the route handler rather than middleware, or whose protected routes are never cached, is not exploitable. No user interaction or authentication is required once the configuration is present; the attacker only needs to know or guess a protected path and supply an equivalent percent-encoded or malformed encoding. |
| Impact | The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, base 7.5 HIGH) describes a network-reachable, unauthenticated authorization bypass with high confidentiality impact and no integrity or availability effect - consistent with the CWE-177 (improper URL-encoding handling) information-disclosure classification and the 'Information Disclosure' tag. However, the raw 7.5 overstates real-world risk because exploitation is gated on a specific non-default configuration (enableCacheInterception enabled AND middleware used for access control AND an actually-cached protected route), which the base CVSS score does not reflect. No EPSS score was provided in the input, so exploitation probability cannot be quantified. KEV=NO and no public exploit code is referenced - only a vendor advisory, patch commit, and release are cited - so there is no evidence of active exploitation. The strongest contradiction to a 'drop everything' priority is the narrow precondition set versus the CVSS AC:L rating: once the vulnerable configuration exists, crafting the request is trivial, but the configuration itself is uncommon. Net: a credible, patch-worthy confidentiality issue for the specific affected deployments, not a broadly exploitable internet-wide emergency. |
| Exploit ScenarioDerived | An application deployed on OpenNext Cloudflare with enableCacheInterception on, using middleware to gate an /admin route whose protected response has been cached, is targeted by a remote unauthenticated attacker. The attacker requests a percent-encoded path such as /%61dmin/... that fails the middleware authorization matcher but decodes to the cache key of the protected route, so the cached protected content is returned without authorization. No public exploit code is identified at time of analysis, though the fix commit and unit/e2e tests in the references demonstrate the exact bypass payloads. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Unauthenticated attackers can retrieve cached content from protected routes in OpenNext Cloudflare (@opennextjs/cloudflare) versions 0.3.0 through 1.20.2 when three deployment-specific conditions coincide: enableCacheInterception is set to true (an opt-in, non-default setting), access control is implemented with middleware matchers rather than inside route handlers, and the protected route has a matching entry in the incremental cache. Because middleware matching and cache-key lookup handle percent-encoded pathnames inconsistently, a request such as /%61dmin/%ZZ can evade authorization middleware while still resolving to the cache key of a protected route, disclosing cached content with no authentication or user interaction required. Rated CVSS 3.1 base 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N), this is a confidentiality-only authorization bypass; no public exploit code has been identified at time of analysis, and the issue is resolved in @opennextjs/cloudflare 1.20.2.
RemediationAI
Upgrade to @opennextjs/cloudflare 1.20.2, which upgrades the underlying @opennextjs/aws dependency to 4.1.0 and contains the actual routing fixes (commit 38ea40b669be272ddf09a7df7e70c69d0b57404b); installs that pin the older @opennextjs/aws 4.0.2 will remain vulnerable even under a newer Cloudflare wrapper, so confirm the resolved @opennextjs/aws version is at least 4.1.0. Vendor-released patch: @opennextjs/cloudflare 1.20.2 (upstream fix @opennextjs/aws 4.1.0). Details are in the advisory at https://github.com/opennextjs/opennextjs-cloudflare/security/advisories/GHSA-2vc4-c4r6-p6v6 and the release at https://github.com/opennextjs/opennextjs-cloudflare/releases/tag/@opennextjs/cloudflare@1.20.2. If upgrading is not immediately possible, apply compensating controls with their trade-offs: disable enableCacheInterception in open-next.config.ts (effective, but forfeits the performance benefit of serving prerendered/cached responses at the edge); move or duplicate authorization checks inside the route handlers or server components rather than relying solely on middleware matchers (effective, but requires code changes and risks inconsistent policy if only some routes are updated); and exclude protected routes from the incremental cache or purge their cache entries (effective for the specific route, but causes every request to hit origin, increasing latency and load). Note that patching is required for full protection because the mismatch is in framework code, not application logic.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in npm, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is an improper URL-encoding handling issue (CWE-177) that arises in the routing layer OpenNext Cloudflare inherits from its upstream @opennextjs/aws dependency. In hardened Next.js deployments, middleware matchers enforce authorization by regex-matching a normalized pathname, while the incremental-cache interceptor (cacheInterceptor) separately computes a cache key by decoding path segments with decodeURIComponent. Before the fix, if decodeURIComponent threw on a malformed escape such as %ZZ, the interceptor fell back to the partially decoded or original segment and continued cache lookup, whereas middleware matched only against the encoded normalized path and therefore did not evaluate the same route identity. The two subsystems thus derived different pathname identities from the same request: a percent-encoded path like /%61dmin/%ZZ failed the /admin/:path* middleware matcher but decoded - fully or partially - to the cached /admin/[slug] route, causing protected cached content to be served without authorization. The upstream fix in @opennextjs/aws 4.1.0 (PRs #1199/#1200) makes middleware matching also test the fully decoded pathname (preserving the encoded pathname in the request handed to middleware, matching Next.js behavior) and makes path-param decoding atomic - if decoding fails, cache interception returns the event unmodified and never performs a cache lookup on a partially decoded path.
Know when Opennextjs Cloudflare 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:H/I:N/A:N
Remote unauthenticated request with trivial encoding craft (AV:N/AC:L/PR:N/UI:N); only cached protected content is disclosed, so C:H, I:N, A:N, scope unchanged.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
OpenNext Cloudflare is an open Next.js adapter for Cloudflare. From 0.3.0 until 1.20.2, applications that enable enableCacheInterception, rely on middleware for access control, and have a matching cached protected route process encoded pathnames inconsistently between middleware matching and cache lookup. An unauthenticated attacker can use a percent-encoded pathname that does not match authorization middleware but decodes to the cache key of a protected route, causing cached content to be returned without authorization. Malformed encodings can also be partially decoded, allowing cache lookup to continue with a pathname that middleware did not evaluate consistently. This issue is fixed in version 1.20.2.
Technical POC Analysis
Bug class: improper handling of URL encoding (CWE-177, primary per the advisory) combined with incorrect behaviour order - validate before canonicalize (CWE-180, also tagged).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A confidentiality flaw in OpenNext's Cloudflare adapter (@opennextjs/cloudflare 0.3.0 through 1.20.2) can allow anonymous visitors to read cached pages that should sit behind authentication, potentially exposing sensitive application content to anyone who knows how to craft the request. The exposure is limited to deployments that opted into the non-default enableCacheInterception setting and enforce access through middleware matchers rather than inside route handlers, so only a subset of our estate is likely affected, but those that are affected could leak protected data without any credentials. Leadership should care because the issue is an authorization bypass that undermines trust in our access controls and may carry disclosure or compliance obligations if regulated data is cached.
Apply vendor patch.
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.
EUVD-2026-102200
GHSA-2vc4-c4r6-p6v6
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB