Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify app SSR path with unescaped hono/jsx child
-
DeliveryCraft input containing HTML/script payload
-
ExploitSubmit value that reaches vulnerable render path
-
ExecutionServer emits payload as raw markup
-
ImpactVictim loads page, script executes in origin
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the target application to use hono/jsx server-side rendering in one of four specific ways: a plain string as a child or fallback of Suspense, a string child of ErrorBoundary alongside an asynchronous sibling, the single child of a Context.Provider, or the root value passed to renderToString() or renderToReadableStream() from hono/jsx/dom/server. In addition, attacker-controlled data must flow directly into that string during SSR, and a victim must load the rendered output (UI:P). These narrow, app-specific coding patterns are the primary limiting factor - a Hono app that does not use these exact patterns with untrusted input is not exploitable. No authentication is required of the attacker (PR:N). Fixed in hono 4.13.7. |
| Impact | This is a genuinely low-priority XSS despite the network attack vector. The vendor CVSS 4.0 base score is 2.3 (Low), and the vector reflects why: AC:H and AT:P (attack requirement present) capture that exploitation is not a general property of the framework but is confined to four narrow hono/jsx server-side-rendering code paths - a plain string used as a Suspense child/fallback, an ErrorBoundary string child alongside an async sibling, the single child of a Context.Provider, or the root value passed to renderToString()/renderToReadableStream() from hono/jsx/dom/server. The application must both use one of those specific patterns AND route attacker-controlled data directly into it. UI:P/UI:R further requires a victim to render/view the malicious output. No EPSS score, no CISA KEV listing, and no public POC were provided, so exploitation status is 'no public exploit identified at time of analysis.' Impact is limited (VC:L/VI:L, i.e. client-side script execution under the app origin), not a server compromise. Bottom line: a real defense-in-depth bug worth patching by upgrading to hono 4.13.7, but not an urgent, widely-exploitable issue - the signals are internally consistent (low CVSS, no exploitation intelligence, narrow preconditions) with no conflicts to flag. |
| Exploit ScenarioDerived | A developer builds a Hono app that server-side renders a JSX component where user-supplied data (e.g. a username or query parameter) is passed as the direct string child of a Suspense fallback or as the root value to renderToString(). An attacker submits a value like '<script>...</script>'; because these paths treat the stringified input as already-escaped markup, the script is emitted verbatim and executes in the victim's browser under the application's origin. No public exploit code was identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 19, 2026
Cross-site scripting in Hono before 4.13.7 allows unauthenticated remote attackers to inject arbitrary HTML and execute script in a victim's browser under the application's origin when the application uses hono/jsx server-side rendering in one of four specific patterns involving plain strings: as a child or fallback of Suspense, as a string child of ErrorBoundary alongside an asynchronous sibling, as the single child of Context.Provider, or as the root value passed to renderToString() or renderToReadableStream() from hono/jsx/dom/server. Exploitation requires attacker-controlled data to flow directly into those strings during SSR and a victim to load the rendered output, making this a low-priority XSS despite the network attack vector and no authentication requirement. No public exploit code has been identified at time of analysis, and the issue is fixed in Hono 4.13.7.
RemediationAI
Upgrade to hono 4.13.7 or later; this is the vendor-released patch that fixes the unescaped-string rendering paths in hono/jsx. The fix is documented in the GitHub security advisory GHSA-hxh3-vqpv-xpqv at https://github.com/honojs/hono/security/advisories/GHSA-hxh3-vqpv-xpqv. If an immediate upgrade is not possible, audit the application for the four vulnerable patterns and avoid passing attacker-controlled strings directly into Suspense (as a child or fallback), ErrorBoundary (as a string child with an async sibling), Context.Provider (as the single child), or as the root value to renderToString()/renderToReadableStream() from hono/jsx/dom/server; instead, wrap such strings in a component that explicitly HTML-escapes them or use a safe rendering approach. Trade-offs: manual escaping may break intended HTML output if not applied carefully, and code audits are error-prone; these mitigating measures are temporary until the upgrade can be applied. No vendor-released workaround other than upgrading is specified in the advisory.
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 vulnerability is a CWE-79 (Improper Neutralization of Input During Web Page Generation, i.e., cross-site scripting) in the hono/jsx server-side rendering runtime. Hono is a lightweight web framework, and hono/jsx provides JSX rendering on the server. Normally, JSX escapes dynamic values when rendering, but four specific code paths bypass this escaping: when a plain string is passed as a child or fallback of Suspense, as a string child of ErrorBoundary with an asynchronous sibling, as the single child of Context.Provider, or as the root value to renderToString() or renderToReadableStream() from hono/jsx/dom/server. In these cases, the runtime stringifies the input and treats the result as already-escaped markup, so an attacker who controls the string during SSR can inject HTML and script. The affected product is identified by CPE cpe:2.3:a:honojs:hono:*:*:*:*:*:*:*:* (all versions before 4.13.7). Tags associated with this CVE are XSS, Hono, and Honojs. The assessed CVSS:3.1 vector is AV:N/AC:H/PR:N/UI:R/S:C/C:L/I:L/A:N, indicating a network-borne, high-complexity attack that requires victim interaction and results in limited confidentiality and integrity impact with scope change (the script executes in the context of the application's origin).
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:H/AT:P/PR:N/UI:P/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N
AC:H because exploitation depends on the app using specific vulnerable hono/jsx SSR paths with attacker data; PR:N as no auth is needed; UI:R and S:C reflect browser-executed XSS with limited impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
hono before 4.13.7 fails to HTML-escape plain strings rendered by hono/jsx as a child or fallback of Suspense, as a string child of ErrorBoundary alongside an asynchronous sibling, as the single child of a Context.Provider, or as the root value passed to renderToString() or renderToReadableStream() from hono/jsx/dom/server. These paths stringify their input and treat the result as already-escaped markup, so an attacker who controls such a string during server-side rendering can inject arbitrary HTML and execute script under the application's origin.
Blast Radius
ecosystem impact- 137 npm packages depend on hono (76 direct, 61 indirect)
Ecosystem-wide dependent count for version 4.13.7.
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
Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.
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-83586
GHSA-6623-4q32-82v8
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB