Skip to content

GHSA-8j4g-w8fx-2239 CVE-2026-69207

Hono: ReDoS in CORS middleware via Access-Control-Request-Headers

Medium npm
Severity
5.3 / 10
Medium · CVSS 3.1
Exploit chance (EPSS)
0.61%
Chance of exploitation in the next 30 days. Higher than 49.17% of scored vulnerabilities.
Known exploited
No
Not in CISA's catalog
Weakness
CWE-1333 Inefficient Regular Expression Complexity
Fix
4.12.34
Upgrade hono to this version or later

Description

Summary

The built-in CORS middleware (hono/cors) parses the attacker-controlled Access-Control-Request-Headers request header during a preflight (OPTIONS) request using a regular expression whose running time is quadratic in the input length. A single request carrying a long run of whitespace can consume seconds of CPU, and repeated requests can render the service unresponsive. This parsing runs under the default configuration.

Details

On a CORS preflight, when allowHeaders is not configured - the default - the middleware reflects and parses the Access-Control-Request-Headers value. The parser used a whitespace-tolerant regular expression whose backtracking makes the work grow quadratically (O(n²)) with the length of the value when it contains a long whitespace sequence without a delimiter.

Because the header value is bounded only by the deployment's maximum HTTP header size, a single preflight can block request processing for a noticeable amount of time; on runtimes that share one execution thread across requests, this stalls concurrent requests as well. No authentication, special origin, or user interaction is required.

This issue arises for any application using cors() with the default (or an empty) allowHeaders. Applications that set a non-empty allowHeaders do not reach the affected path.

Impact

An unauthenticated attacker can send preflight requests that each consume disproportionate CPU relative to their size, degrading or denying service. This is a denial-of-service issue only; it does not expose or modify data.

Affected versions

npm

PackageVulnerableFixed in
hono
< 4.12.34
4.12.34

How to fix

Move to the fixed version or later with your package manager, update the lockfile, and run your tests. If the package only arrives through another dependency, upgrade that dependency first. If none of its releases pulls a fixed version yet, force the version with your package manager's override.

hono npm → 4.12.34

npm
npm install hono@4.12.34
yarn
yarn add hono@4.12.34
pnpm
pnpm add hono@4.12.34

Severity breakdown

CVSS 3.1 5.3

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L

Attack vector
Network
Attack complexity
Low
Privileges required
None
User interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
Low

Weakness

CWE-1333: Inefficient Regular Expression Complexity

The product uses a regular expression with a worst-case computational complexity that is inefficient and possibly exponential.

How to prevent it
  • Architecture and Design: Use regular expressions that do not support backtracking, e.g. by removing nested quantifiers.
  • System Configuration: Set backtracking limits in the configuration of the regular expression implementation, such as PHP's pcre.backtrack_limit. Also consider limits on execution time for the process.
  • Implementation: Do not use regular expressions with untrusted input. If regular expressions must be used, avoid using backtracking in the expression.
  • Implementation: Limit the length of the input that the regular expression will process.

References

Timeline

  1. Published
  2. Last updated by the source
  3. Latest EPSS score
AdvisorySeverityWhy it's related
GHSA-5r4p-p66f-jhc7
Hono: `serveStatic` decodes the request path a second time, leading to bypass of middleware on static paths
Medium Also affects hono
GHSA-hxh3-vqpv-xpqv
hono/jsx renders plain strings unescaped in boundary components, leading to XSS
Low Also affects hono
GHSA-gqvv-2mrq-wpjv
Hono: Incomplete fix for CVE-2026-39408: `toSSG()` still writes files outside the output directory
Medium Also affects hono
GHSA-g6gw-c38x-mqfc
Hono: Unbounded dot-notation nesting in `parseBody()` can cause memory exhaustion
Medium Also affects hono
GHSA-crvj-82cr-hjcx
Hono: Query parser reads parameters after the URL fragment, causing cache-key and proxy interpretation differentials
Medium Also affects hono
GHSA-f23p-vx2j-j53r
Hono: `memo()` retains SSR output across requests, leading to cross-user data disclosure
Medium Also affects hono
GHSA-79qm-7rj5-m7r9
Hono: Proxy Helper does not remove response headers listed in the `Connection` header
Low Also affects hono
GHSA-54fx-42gc-7vw4
Hono: Algorithmic Complexity DoS in Language Middleware
Medium Also affects hono
Is this in your code?

MergeHarbor checks every repository's dependencies against this database, ranks what matters by exploitability and reachability, routes it to the owning team and opens the fix pull request.

Check your repos with MergeHarbor