Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify Hono app serving static files behind prefix auth
-
DeliveryCraft double percent-encoded request path
-
ExploitRouter matches encoded form, skipping prefix middleware
-
ExecutionPath decoded and resolved to protected static file
-
ImpactRetrieve file without authentication
Vulnerability Assessment
| Weakness |
CWE
|
| Exploitation Conditions | Exploitation requires an application that serves files via Hono's serveStatic AND relies on prefix-mounted middleware (such as authentication/authorization) to gate access to those files; the bypass works because a malformed/double percent-encoded path is matched by the router in encoded form, so the prefix middleware does not run before the decoded path reaches the static handler. No credentials, user interaction, or non-default framework settings are needed against such deployments (AV:N/AC:L/PR:N/UI:N). Limiting factors: the issue only matters when (a) serveStatic is actually used, (b) access control is implemented as prefix middleware rather than inside the static handler or at a reverse proxy, and (c) the static files behind that prefix are sensitive; deployments without prefix-based protection of static content are not meaningfully exposed. Affected versions are Hono 4.12.4 up to (not including) 4.13.11. |
| Impact | This is a moderate-severity authentication-bypass issue whose signals are largely consistent. The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) describes a network-reachable, low-complexity, unauthenticated attack with no user interaction, which matches the description of sending malformed percent-encoded paths. The 6.9 score is tempered by limited impact: only VC:L (low confidentiality) with no integrity or availability effect, reflecting that the flaw exposes static files behind prefix middleware rather than granting code execution or data tampering. No EPSS score, CISA KEV listing, or public POC was provided in the input, so exploitation probability cannot be quantified; per precision rules this is 'no public exploit identified at time of analysis.' The real-world priority depends heavily on deployment: it is only dangerous where serveStatic is placed behind prefix-mounted authentication/authorization middleware AND those static assets are sensitive. For deployments that do not use prefix middleware to gate static files, impact is minimal. Net: a legitimate but not emergency-grade issue - patch in normal cycles unless you specifically rely on prefix middleware to protect static content. Note the apparent anomaly that CWE-174 (Double Decoding) is the root cause while the effect is classed as Authentication Bypass; both are consistent here (double decoding is the mechanism that defeats the auth prefix match). |
| Exploit ScenarioDerived | An application uses Hono's serveStatic to serve files behind an authentication middleware mounted on a path prefix. An unauthenticated attacker sends an HTTP request with a double/malformed percent-encoded path that the router matches in its still-encoded form, so the prefix-mounted auth middleware never fires, and the decoded path then resolves to a protected static file. No public exploit code was identified at time of analysis, but the attack is low-complexity and requires no credentials. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 13, 2026
Authentication bypass in Hono 4.12.4 up to (but not including) 4.13.11 lets unauthenticated remote attackers read static files that are supposed to be gated by prefix-mounted middleware: a malformed, double percent-encoded path is matched by the router in its encoded form, so middleware mounted on the decoded prefix never runs while serveStatic still resolves and serves the underlying file. The impact is limited to confidentiality of the exposed static content (assessed CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N - no integrity or availability effect), and only deployments that both use serveStatic and rely on prefix-based middleware for access control are meaningfully exposed. No public exploit identified at time of analysis, and the vendor-released fix is Hono 4.13.11.
RemediationAI
Vendor-released patch: upgrade Hono to 4.13.11 or later, which is the first version that closes the double-decoding path mismatch between router matching and serveStatic resolution; the advisory at https://github.com/honojs/hono/security/advisories/GHSA-5r4p-p66f-jhc7 should be consulted for the maintainers' guidance. If upgrading cannot be done immediately, the most effective compensating control is to stop treating prefix-mounted middleware as the access-control boundary for static assets: terminate authentication and authorization for those paths at a reverse proxy or ingress (for example nginx auth_request or an API gateway policy) so the decision is made on the normalized request before it ever reaches Hono - the trade-off is added infrastructure complexity and a second place to maintain policy. Alternatively, enable authentication/authorization logic inside the static handler or in global (non-prefix) middleware that normalizes and single-decodes the path before routing, accepting the cost of a code change and careful path canonicalization to avoid breaking legitimate clients. A more brittle mitigation is to reject or normalize requests whose paths contain encoded separators or repeated percent-encoding at the edge; this blocks the exploitation primitive but risks breaking legitimate clients and third-party integrations that legitimately use encoded paths, so it should be applied only as a stopgap and monitored for false positives. Because the bypass requires no credentials, user interaction, or non-default settings, exposed deployments should also review logs for requests containing double-encoded path segments against protected prefixes, and confirm that no sensitive static files (configuration, backups, source maps, or data exports) are reachable through serveStatic prefixes while the upgrade is pending.
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
The root cause class is CWE-174 (Double Decoding of the Same Data) combined with an encoding mismatch between Hono's router matching phase and its static file handling. Hono routes requests using the path as it appears on the wire; middleware registered with a prefix mount (for example app.use('/protected/*', authMiddleware)) is therefore evaluated against the still-encoded path and does not match a request that carries extra percent-encoding, such as an encoded value that only resolves to a path beneath the protected prefix after a second decoding pass. The serveStatic handler then performs its own decoding before resolving the file on disk, so the request reaches the static file without the prefix middleware ever having executed. This is a middleware-ordering/tokenization defect rather than a memory-safety issue: the router's view of the path and the static handler's view of the path diverge, and the authorization decision is made on the wrong representation. It applies to the npm 'hono' package (CPE cpe:2.3:a:honojs:hono:*:*:*:*:*:*:*:*) in versions from 4.12.4 through 4.13.10, and is not contingent on any non-default framework setting - the required preconditions are architectural, not configuration-gated: the application must serve files via serveStatic and must place its access control in prefix middleware rather than inside the static handler or in front of the app at a reverse proxy.
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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
Remote, low-complexity, unauthenticated path manipulation (AV:N/AC:L/PR:N/UI:N) yielding only unauthorized read of static files, so C:L and I/A:N.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
Hono from 4.12.4 before 4.13.11 contains a middleware bypass vulnerability in serveStatic that allows unauthenticated attackers to skip prefix middleware by exploiting double path decoding. Attackers can send malformed percent-encoded paths that the router matches in encoded form, reaching static files without authentication checks running.
Blast Radius
ecosystem impact- 10 npm packages depend on hono (10 direct, 0 indirect)
Ecosystem-wide dependent count for version 4.12.4.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
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
Path prefix stripping in Hono's app.mount() API exposes mounted sub-applications to incorrect routing due to a raw-vs-de
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
EUVD-2026-98659
GHSA-3g9q-qwv8-cxpf
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB