CVE-2026-29045: Hono Framework Auth Bypass Vulnerability

CVE-2026-29045 Overview

CVE-2026-29045 is an authorization bypass vulnerability in the Hono Web application framework, which provides support for any JavaScript runtime. Prior to version 4.12.4, a URL decoding inconsistency between the router and serveStatic middleware allowed attackers to bypass route-based middleware protections and access protected static resources without authorization.

The vulnerability stems from a mismatch in how different components decode URL paths: the router uses decodeURI, while serveStatic uses decodeURIComponent. This inconsistency allows paths containing encoded slashes (%2F) to bypass middleware protections while still resolving to the intended filesystem path.

Critical Impact
Attackers can bypass authentication and authorization middleware to access protected static resources, potentially exposing sensitive files and administrative content without proper credentials.

Affected Products

Hono Web Framework versions prior to 4.12.4
Applications using serveStatic with route-based middleware protections (e.g., app.use('/admin/*', ...))
Deployments across any JavaScript runtime environment (Node.js, Deno, Bun, Cloudflare Workers, etc.)

Discovery Timeline

2026-03-04 - CVE-2026-29045 published to NVD
2026-03-05 - Last updated in NVD database

Technical Details for CVE-2026-29045

Vulnerability Analysis

This authorization bypass vulnerability (CWE-177: Improper Handling of URL Encoding) occurs due to inconsistent URL decoding behavior between Hono's router and its serveStatic middleware. When developers configure route-based middleware protections to secure static resources, the framework's internal components process URL-encoded characters differently, creating a security gap that can be exploited to circumvent access controls.

The router component utilizes decodeURI for path decoding, which preserves certain encoded characters that have special meaning in URLs (such as /, ?, #). In contrast, the serveStatic middleware employs decodeURIComponent, which decodes all percent-encoded characters including the forward slash (%2F). This behavioral difference means a request path can pass through the router without matching a protected route pattern, yet still resolve to a protected filesystem path when processed by serveStatic.

The vulnerability is exploitable remotely without authentication, making it particularly dangerous for applications that rely on middleware-based access control for sensitive static resources such as administrative dashboards, configuration files, or confidential documents.

Root Cause

The root cause is the use of two different URL decoding functions (decodeURI vs decodeURIComponent) within the same request processing pipeline. The decodeURI function is designed to decode a complete URI while preserving URI-reserved characters, whereas decodeURIComponent decodes all percent-encoded characters.

When a path like /admin%2Fsecret.html is processed, the router sees it as a single path segment (not matching /admin/*), but serveStatic decodes %2F to /, resolving the path to /admin/secret.html on the filesystem. This allows attackers to craft specially encoded URLs that evade route matching while still accessing protected resources.

Attack Vector

The attack vector is network-based and requires no authentication or user interaction. An attacker can exploit this vulnerability by:

Identifying protected static resources served behind route-based middleware (e.g., /admin/* routes protected by authentication middleware)
Crafting a request with encoded forward slashes (%2F) in the URL path
Sending the request to bypass the middleware protection while still accessing the target resource

For example, if an application protects /admin/* with authentication middleware, an attacker could request /admin%2Fsecret-config.json. The router would not match this against the /admin/* pattern (treating it as a single segment), bypassing the authentication middleware. However, serveStatic would decode the path and serve the file from admin/secret-config.json.

The vulnerability mechanism involves exploiting the encoding mismatch. When a protected path like /admin/secret.html is encoded as /admin%2Fsecret.html, the router's decodeURI function preserves the %2F sequence, causing the path to not match the /admin/* middleware pattern. Subsequently, serveStatic uses decodeURIComponent which converts %2F to /, resolving to the protected filesystem path. For detailed technical information, see the GitHub Security Advisory.

Detection Methods for CVE-2026-29045

Indicators of Compromise

HTTP request logs containing URL-encoded forward slashes (%2F) in paths that target protected directories
Access logs showing requests to sensitive static resources without corresponding authentication events
Unusual patterns of static file access that bypass expected middleware logging
HTTP 200 responses for protected resources to unauthenticated sessions

Detection Strategies

Implement web application firewall (WAF) rules to detect and block requests containing %2F encoding in path segments
Configure server-side logging to capture and alert on URL-encoded path traversal patterns
Deploy runtime application security monitoring to identify middleware bypass attempts
Review access logs for static file requests that lack corresponding authentication middleware execution traces

Monitoring Recommendations

Enable verbose access logging on Hono applications to capture full request URLs including encoded characters
Set up alerting for unusual access patterns to protected static resource directories
Monitor for reconnaissance activity targeting administrative or sensitive static file paths
Implement anomaly detection for requests with atypical URL encoding patterns

How to Mitigate CVE-2026-29045

Immediate Actions Required

Upgrade Hono to version 4.12.4 or later immediately
Audit application routes to identify any serveStatic usage combined with route-based middleware protections
Review access logs for evidence of exploitation attempts using encoded path characters
Consider implementing additional server-level access controls for sensitive static resources as a defense-in-depth measure

Patch Information

The vulnerability has been patched in Hono version 4.12.4. The fix ensures consistent URL decoding behavior between the router and serveStatic middleware, preventing the bypass condition. The patch can be reviewed in the GitHub commit.

To apply the patch, update the Hono dependency in your project:

For npm: npm update hono@4.12.4
For yarn: yarn upgrade hono@4.12.4
For pnpm: pnpm update hono@4.12.4

Workarounds

Implement server-level (nginx, Apache, Cloudflare) URL normalization rules that decode and reject requests with path traversal patterns before they reach the application
Add custom middleware at the application entry point that normalizes URL encoding before route matching occurs
Move sensitive static files behind an API endpoint with explicit authorization checks rather than relying on filesystem-based serveStatic
Use explicit route definitions for sensitive static resources instead of wildcard middleware patterns

bash

# Example nginx configuration to block encoded slashes
location / {
    # Deny requests containing encoded slashes
    if ($request_uri ~* "%2[Ff]") {
        return 400;
    }
    proxy_pass http://your-hono-app;
}