Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend HTTP request with CRLF-embedded cookie name
-
DeliveryApplication passes name to setCookie() without sanitization
-
ExploitHono serializes malformed Set-Cookie header
-
ExecutionRuntime rejects invalid header value
-
PersistApplication throws uncaught runtime error
-
ImpactResponse fails, endpoint becomes unavailable
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization HTTP response header sanitization
|
| Exploitation Conditions | Exploitation requires that the Hono application explicitly passes user-controlled (untrusted) input as the cookie name argument to setCookie(), serialize(), or serializeSigned(). This is not a default framework behavior - it requires an application design decision to use dynamic, user-supplied cookie names rather than static, developer-defined names. Most Hono applications use static cookie names and are not affected in practice. The attack is further limited by runtime behavior: Node.js and Cloudflare Workers both reject malformed header values before transmission, restricting confirmed impact to runtime errors (availability) rather than header injection. Exploitation for header injection or response splitting would require a runtime that does not validate Set-Cookie header values, which was not demonstrated in the vendor's testing. No authentication is required to reach the vulnerable code path if the application exposes an unauthenticated endpoint that uses dynamic cookie names. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L) scores 6.9, reflecting network reachability with no authentication requirement and low availability impact - appropriately calibrated given that confirmed runtime behavior produces errors rather than data exposure. The integrity metrics (VI:N/SI:N) are set to None, consistent with the vendor's finding that header injection could not be reproduced in Node.js or Cloudflare Workers. No EPSS data was provided in the source intelligence. There is no CISA KEV listing and no public exploit code, making this a low-urgency issue despite the network-reachable attack vector. The primary real-world risk is an availability disruption: endpoints that accept untrusted cookie names will throw runtime exceptions and fail to send responses, which could be triggered by a remote unauthenticated attacker if the application exposes such functionality. The theoretical response-splitting risk (which the CWE classification implies) is substantially mitigated by modern runtime protections. The gap between the CVSS classification and confirmed exploitability is notable - defenders should treat this as a correctness/robustness fix rather than an active exploitation risk. |
| Exploit ScenarioDerived | An attacker sends an HTTP request to a Hono-based endpoint that reflects or accepts user input as a cookie name - for example, a session personalization feature that stores a user-supplied preference name as a cookie. By injecting a value containing \r\n (CRLF) characters in the cookie name field, the attacker causes setCookie() to generate a malformed Set-Cookie header. On Node.js or Cloudflare Workers, the runtime rejects the header and the response handler throws an uncaught exception, resulting in a failed response (availability impact). On a hypothetical runtime without strict header validation, the malformed header could produce a secondary injected header in the HTTP response. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 23, 2026
Missing cookie name validation on the write path in Hono's setCookie(), serialize(), and serializeSigned() functions allows user-controlled input containing CRLF control characters to produce malformed Set-Cookie headers. Affected are all Hono npm releases before 4.12.12. In practice, modern runtimes including Node.js and Cloudflare Workers reject the malformed headers before they are transmitted, meaning confirmed impact is availability loss (runtime errors crashing the response) rather than header injection or response splitting - though theoretical risk exists on less-strict runtimes. No active exploitation is confirmed, and no public exploit code has been identified.
RemediationAI
Upgrade the Hono npm package to version 4.12.12 or later; this is the vendor-released patch confirmed by advisory GHSA-26pp-8wgv-hjvm and patch commit https://github.com/honojs/hono/commit/a586cd72e3f6122792e631ecf1817e5cabb803ec. As an immediate compensating control before patching, applications should sanitize or allowlist-validate any user-supplied values before passing them as cookie names to setCookie(), serialize(), or serializeSigned() - specifically rejecting input containing ASCII control characters (values 0x00-0x1F and 0x7F). This validation should occur at the application boundary before invoking Hono's cookie APIs. Note that relying solely on runtime rejection (as occurs in Node.js and Cloudflare Workers) is not a recommended long-term control, as it results in unhandled errors and broken responses rather than graceful handling.
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, TypeScript-first web framework designed for edge and serverless runtimes including Cloudflare Workers, Deno, Bun, and Node.js. The vulnerability is rooted in CWE-113 (Improper Neutralization of CRLF Sequences in HTTP Headers), a class of flaw where unvalidated newline characters allow an attacker to inject additional headers or split HTTP responses. The affected code paths - setCookie(), serialize(), and serializeSigned() - handle cookie serialization and generate Set-Cookie header values. The library validates certain cookie attributes (domain, path) on the write path but omits validation of the cookie name itself, creating an asymmetry between the stricter read/parse path and the permissive write path. When a CRLF sequence (e.g., \r or \n) is embedded in a cookie name, the resulting Set-Cookie header value can contain what appears to be an additional injected header line. The CPE cpe:2.3:a:hono:hono:*:*:*:*:*:*:*:* covers all Hono versions through the vulnerable range.
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:N/VI:N/VA:L/SC:N/SI:N/SA:N
Network-reachable with no auth needed; integrity impact omitted because header injection was not confirmed; availability is Low due to runtime errors.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
Hono before 4.12.12 does not validate cookie names on the write path in the setCookie(), serialize(), and serializeSigned() functions, allowing invalid characters such as control characters (e.g. \r or \n) when an application passes a user-controlled cookie name. This can produce malformed Set-Cookie header values. In modern runtimes such as Node.js and Cloudflare Workers, such invalid header values are rejected and cause a runtime error before the response is sent, so header injection or response splitting could not be reproduced; the issue primarily affects correctness and robustness, resulting in runtime errors (availability) rather than confirmed header injection.
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
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
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-38443
GHSA-55cm-p4ww-685g
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB