Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted HTTP request with percent-encoded multi-byte characters in path prefix
-
DeliveryTrigger raw-vs-decoded boundary mismatch in app.mount() prefix stripping
-
ExploitSub-application receives incorrect shifted path
-
ExecutionUnintended route matched within mounted sub-application
-
ImpactSensitive information disclosed to unauthenticated attacker
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 the target application to use Hono's app.mount() API to mount at least one sub-application at a path prefix. The attacker must send a URL containing percent-encoded multi-byte UTF-8 characters within the mount prefix segment to trigger the byte-boundary misalignment. The CVSS vector AV:N/AC:L/PR:N/UI:N confirms no authentication, no elevated privileges, and no user interaction are required - this is exploitable against any network-accessible Hono instance using app.mount() running a version prior to 4.12.21. Exploitation is limited in practice to applications where the mounted sub-application exposes sensitive routes or data without its own independent authentication layer; if sub-applications enforce authentication internally, the path misrouting may reach an endpoint but still be blocked by auth checks. Non-default configurations are not required - app.mount() is a core, commonly used API. |
| Impact | The CVSS 3.1 score of 5.3 (Medium) with vector AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N indicates a network-accessible, low-complexity, fully unauthenticated attack with limited but real confidentiality impact and no integrity or availability consequences. The zero-authentication, zero-user-interaction requirement is the most significant risk amplifier - any network-reachable Hono application using app.mount() is theoretically exposed without requiring an account or session. The 'Request Smuggling' tag elevates concern beyond simple misconfiguration, as it signals an actively exploitable parser-level inconsistency. EPSS data was not provided in the source intelligence, so a quantitative exploitation probability cannot be stated. This is not listed in CISA KEV, and no public POC has been identified, suggesting opportunistic mass exploitation is not yet occurring. Real-world impact is deployment-dependent: applications that rely solely on app.mount() path prefixes for security boundaries (e.g., admin panels mounted at /admin without independent auth middleware) face higher practical risk than those with defense-in-depth authentication at the sub-application level. This is not a 'high-CVSS-but-low-real-risk' case - the CVSS score is moderate and the risk profile aligns with it. Priority should be determined by whether path-prefix routing in the application carries any security significance. |
| Exploit ScenarioDerived | An attacker identifies a Hono application that mounts a sensitive sub-application (e.g., an admin API) at a path prefix such as /admin, where access control depends on the path prefix not being reachable from other routes. The attacker crafts an HTTP request with a URL containing percent-encoded multi-byte characters within the prefix segment - for example, encoding a character that spans two bytes as %XX%XX - causing the prefix-stripping logic to remove fewer or more characters than intended. The sub-application receives a shifted path, potentially matching an unintended route and returning data or functionality that should not be accessible from the public-facing application path. No public POC has been identified, but the attack requires only a crafted HTTP GET request with no authentication or user interaction. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 28, 2026
Path prefix stripping in Hono's app.mount() API exposes mounted sub-applications to incorrect routing due to a raw-vs-decoded URL path inconsistency, potentially allowing unauthenticated remote attackers to reach unintended endpoints and disclose protected information. All Hono versions prior to 4.12.21 are affected across every supported JavaScript runtime. No public exploit or CISA KEV listing exists at time of analysis; however, the CVSS vector AV:N/AC:L/PR:N/UI:N and the 'Information Disclosure / Request Smuggling' classification make this a meaningful priority for any deployment that relies on mount-prefix path logic for access segregation.
RemediationAI
Upgrade Hono to version 4.12.21 or later, which resolves the inconsistency between raw-pathname prefix stripping and percent-decoded route matching in app.mount(). This is a vendor-released patch confirmed at version 4.12.21 per the GitHub Security Advisory GHSA-2gcr-mfcq-wcc3 at https://github.com/honojs/hono/security/advisories/GHSA-2gcr-mfcq-wcc3. If immediate upgrade is blocked, a compensating control is to enforce URL path canonicalization at the reverse proxy or WAF layer - specifically, percent-decode and then re-encode all incoming paths to a canonical form before they reach the Hono process, which eliminates the raw/decoded discrepancy. Note that this may break applications intentionally handling raw percent-encoded paths. A second mitigation is to remove reliance on app.mount() path prefixes as a security boundary entirely: add explicit authentication or authorization middleware inside each mounted sub-application so that even if a path is misrouted, the sub-app independently enforces access control. This approach is the more architecturally sound long-term posture regardless of patch status.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Hono is a lightweight, multi-runtime web framework for JavaScript (Cloudflare Workers, Deno, Bun, Node.js, and others). The vulnerability is rooted in CWE-444 - Inconsistent Interpretation of HTTP Requests - a class of flaw where different layers of the same stack parse the same input differently, enabling attackers to exploit the gap. Specifically, app.mount() strips the mount prefix from an incoming request path using the raw (percent-encoded) URL pathname, but the subsequent route matching step operates against the percent-decoded version of that path. When a URL contains percent-encoded multi-byte characters (e.g., multi-byte UTF-8 sequences represented as %XX%XX), the byte-length difference between the encoded and decoded forms causes the prefix to be stripped at the wrong character boundary. The sub-application consequently receives a malformed or shifted path that does not correspond to any route the developer intended to expose, potentially bypassing path-prefix-based access controls. The affected CPE is cpe:2.3:a:honojs:hono:*:*:*:*:*:*:*:*, covering all Hono versions prior to 4.12.21.
Know when Hono 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:L/I:N/A:N
Primary rating from Vendor (GitHub_M) · only source for this CVE.
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
Hono is a Web application framework that provides support for any JavaScript runtime. Prior to 4.12.21, app.mount() strips the mount prefix from the incoming request path using the raw URL pathname, while route matching is performed against the percent-decoded path. This inconsistency causes the prefix to be stripped at the wrong position when the path contains percent-encoded multi-byte characters, resulting in the mounted sub-application receiving an incorrect path. This vulnerability is fixed in 4.12.21.
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.
Improper authorization in Hono's JWT Auth Middleware (hono/jwt in the npm package 'hono', versions 1.1.0 through 4.10.1)
The adapter @hono/node-server allows you to run your Hono application on Node.js. Rated high severity (CVSS 7.5), this v
Hono, a web framework, prior to version 4.6.5 is vulnerable to bypass of cross-site request forgery (CSRF) middleware by
Quadratic-complexity denial of service in Hono's `languageDetector` middleware (versions 4.12.0-4.12.33) allows unauthen
Hono is a Web application framework that provides support for any JavaScript runtime. Rated medium severity (CVSS 5.3),
@hono/node-server is an adapter that allows users to run Hono applications on Node.js. Rated medium severity (CVSS 5.3),
Hono is a Web application framework that provides support for any JavaScript runtime. Rated medium severity (CVSS 5.0),
Cross-user HTML disclosure in Hono's server-side rendering affects all applications using hono/jsx with memo()-wrapped c
Hono is a web framework written in TypeScript. Rated medium severity (CVSS 4.3), this vulnerability is remotely exploita
Hono is a Web application framework that provides support for any JavaScript runtime. [CVSS 8.2 HIGH]
Hono versions before 4.11.4 allow JWT algorithm confusion attacks through improper algorithm validation in the JWK/JWKS
Hono before version 4.11.4 contains a JWT algorithm confusion vulnerability in its JWK/JWKS verification middleware that
EUVD-2026-32924
GHSA-2gcr-mfcq-wcc3
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB