Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend malformed percent-encoded request
-
ExploitEvade upstream routing middleware match
-
ExecutionTrigger second decode in serveStatic
-
ImpactDisclose protected static file
Vulnerability Assessment
| Weakness |
CWE
|
| Exploitation Conditions | Exploitation requires a specific, non-default deployment: the application must (1) run Hono serveStatic in an affected version (4.12.4 through 4.13.10), and (2) protect a static sub-prefix with upstream routing/authorization middleware (e.g. app.use('/static/admin/*', authMiddleware) in front of serveStatic on '/static/*'). The attacker then supplies an attacker-controlled malformed percent-encoded path (such as '/static/%%36%31dmin/secret.txt') that survives the first routing-layer interpretation but resolves to the protected path during serveStatic's second filesystem-lookup decode. Limiting factors that reduce real-world risk: the flaw yields only disclosure of files already inside the configured static root (no path traversal outside it, no write/integrity/availability impact); applications that do not place access-control middleware on a sub-prefix of the static root are unaffected; and it is a read-only confidentiality issue, not code execution. |
| Impact | This is a moderate, conditional information-disclosure flaw rather than a critical issue. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N = 5.3) indicates remote, unauthenticated, low-complexity reachability, but impact is deliberately limited: Confidentiality is Low with no Integrity or Availability effect, and the advisory explicitly states the bug does NOT allow traversal outside the configured static root - only disclosure of a single static file that upstream middleware was meant to protect. The 'network/unauthenticated/low-complexity' signals must be read against a hard precondition: the target application must both use Hono serveStatic AND protect a static sub-prefix with upstream routing middleware, so the real-world exploitable population is a subset of Hono deployments, not all of them. No EPSS score and no CISA KEV entry were provided in the input, so exploitation probability cannot be quantified; exploitation status is 'no public exploit identified at time of analysis.' However, the public fix commit (8b05c774) ships regression tests containing the exact working bypass payload (e.g. '/static/%%36%31dmin/secret.txt' double-decoding to 'admin'), so a working exploit primitive is effectively public even though no standalone weaponized tool is cited. Net: a legitimate patch-management priority for teams running the affected Hono versions behind prefix-based access control, but not an emergency mass-exploitation scenario given the Low confidentiality-only impact and configuration dependency. |
| Exploit ScenarioDerived | An application serves static files via Hono serveStatic and guards a sensitive sub-prefix (e.g. '/static/admin/*') with upstream authentication/authorization middleware. A remote unauthenticated attacker requests a malformed percent-encoded path such as '/static/%%36%31dmin/secret.txt', which the routing layer does not recognize as the protected '/static/admin/...' route, so it passes through to serveStatic, which decodes a second time and reads the protected file. The exact bypass payload is publicly demonstrated in the fix commit's regression tests, making reproduction straightforward. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Static-file disclosure in Hono's serveStatic middleware (versions 4.12.4 through 4.13.10) lets remote attackers read files that routing-level access controls were meant to protect, by requesting a malformed percent-encoded path such as '/static/%%36%31dmin/secret.txt' that only normalizes to the protected path during serveStatic's second decode. Affected deployments are those that guard a sub-prefix of the static root with upstream middleware (for example app.use('/static/admin/*', auth) in front of serveStatic('/static/*')); attackers gain read-only access to files already inside the configured static root, with no traversal outside it and no write or availability impact, giving CVSS 3.1 5.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N) with authentication requirements not applicable per the PR:N vector. No public exploit code or CISA KEV entry was identified at time of analysis; exploitation requires the specific non-default middleware-on-sub-prefix layout, so real-world risk is a moderate, conditional information-disclosure issue rather than a critical one.
RemediationAI
Vendor-released patch: upgrade Hono to 4.13.11 or later (advisory GHSA-5r4p-p66f-jhc7, fix commit 8b05c774ef1555c70f5ba5e2991b7e77cc3635cc); the release makes serveStatic reject any routed path containing a percent sign unless the new allowPercentInPath option is explicitly enabled, closing the second-decode mismatch. If an immediate upgrade is not possible, add a guard middleware ahead of serveStatic that rejects requests whose raw path contains '%' or whose decodeURIComponent(path) differs from the path the authorization middleware evaluated - the trade-off is that legitimately percent-encoded filenames (spaces, non-ASCII characters such as '/static/%E7%82%8E.txt') will start returning 404 until the guard is removed after upgrading. Alternatively, stop relying on path-prefix middleware for static authorization: move protected files out of the serveStatic root entirely, or gate them behind an explicit authenticated handler rather than a prefix rule, at the cost of extra application code. Note that opting into allowPercentInPath: true on a patched release restores the vulnerable decode behavior unless the authorization middleware is normalized to the same post-decode path, so leave it at its default unless encoded filenames are required and the front-end checks have been aligned.
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 small, runtime-agnostic JavaScript/TypeScript web framework that runs on Node.js, Deno, Bun, and edge runtimes such as Cloudflare Workers; serveStatic is its built-in middleware for serving files from a configured directory root. The root cause maps to CWE-174 (double decoding of encoded input): Hono's router and upstream authorization middleware interpret c.req.path after the first URL decode, while serveStatic applies an additional decodeURIComponent pass to derive the filesystem lookup path. A payload like '%%36%31dmin' survives the routing layer as an opaque token that does not match the protected '/static/admin/*' pattern, but re-decodes to '%61dmin' → 'admin' during serveStatic's lookup, so the file is served from within the protected prefix without the authorization hook ever firing. The upstream fix (commit 8b05c774ef1555c70f5ba5e2991b7e77cc3635cc) changes serveStatic to throw when the routed path contains a '%' character unless the new allowPercentInPath option is explicitly set to true (default false), and adds regression tests confirming that '/static/%%36%31dmin/secret.txt' now returns 404 instead of leaking the protected file. The flaw is confined to the configured static root - no path traversal, symlink escape, or code execution is involved - and only matters where authorization or routing middleware sits on a sub-prefix of that root.
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
Remote unauthenticated request with a crafted encoding (AV:N/AC:L/PR:N/UI:N); impact is disclosure of one in-root protected file only, so C:L and I:N/A:N.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
Hono is a Web application framework that provides support for any JavaScript runtime. From 4.12.4 until 4.13.11, serveStatic can interpret a malformed percent-encoded path differently from upstream routing middleware and bypass protection for a static prefix. The root cause is serveStatic decodes a routed request path a second time before filesystem lookup. The attack mechanism is malformed percent encoding survives the first routing interpretation and becomes a protected path only during the later static-file decode. The affected component is serveStatic. The trigger conditions are an application protects a static prefix with upstream middleware and serveStatic receives an attacker-controlled malformed percent-encoded path. The impact is unauthorized disclosure of a static file that upstream middleware was intended to protect. The issue does not permit traversal outside the configured static root. This issue is fixed in version 4.13.11.
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-104537
GHSA-5r4p-p66f-jhc7
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB