Skip to main content

Hono CVE-2026-93981

| EUVDEUVD-2026-83586 LOW
Cross-site Scripting (XSS) (CWE-79)
2.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify app SSR path with unescaped hono/jsx child
  2. Delivery
    Craft input containing HTML/script payload
  3. Exploit
    Submit value that reaches vulnerable render path
  4. Execution
    Server emits payload as raw markup
  5. Impact
    Victim 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.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

hono 0 <4.13.7

Affected Packages

npm hono fix: 4.13.7

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

Vendor (VulnCheck) PRIMARY 2.3 LOW
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
vuln.today AI 4.7 MEDIUM

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.

3.1 AV:N/AC:H/PR:N/UI:R/S:C/C:L/I:L/A:N
4.0 AV:N/AC:H/AT:P/PR:N/UI:P/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
High
Attack Requirements
Present
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
Low
Vulnerable system: Availability
None
Subsequent system: Confidentiality
Low
Subsequent system: Integrity
Low
Subsequent system: Availability
None

Lifecycle Timeline

1
Patch available
Sep 19, 2026 - 13:01 EUVD

DescriptionCVE.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.

Threat Intelligence Overview

EPSS Score
0.1%
Top 96% exploitable
Prevalence
Medium
popular lightweight JS web framework, common in edge/serverless deployments
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub

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.

SignalValue
Severity LOW
CISA KEV No
Public POC Yes
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

Priority Score

32
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +12
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.

More in Hono

View all
CVE-2025-62610 HIGH POC
8.1 Oct 22

Improper authorization in Hono's JWT Auth Middleware (hono/jwt in the npm package 'hono', versions 1.1.0 through 4.10.1)

CVE-2024-32652 HIGH POC
7.5 Apr 19

The adapter @hono/node-server allows you to run your Hono application on Node.js. Rated high severity (CVSS 7.5), this v

CVE-2024-48913 MEDIUM POC
5.9 Oct 15

Hono, a web framework, prior to version 4.6.5 is vulnerable to bypass of cross-site request forgery (CSRF) middleware by

CVE-2026-71848 MEDIUM POC
5.3 Aug 07

Quadratic-complexity denial of service in Hono's `languageDetector` middleware (versions 4.12.0-4.12.33) allows unauthen

CVE-2026-47676 MEDIUM POC
5.3 May 28

Path prefix stripping in Hono's app.mount() API exposes mounted sub-applications to incorrect routing due to a raw-vs-de

CVE-2024-32869 MEDIUM POC
5.3 Apr 23

Hono is a Web application framework that provides support for any JavaScript runtime. Rated medium severity (CVSS 5.3),

CVE-2024-23340 MEDIUM POC
5.3 Jan 22

@hono/node-server is an adapter that allows users to run Hono applications on Node.js. Rated medium severity (CVSS 5.3),

CVE-2024-43787 MEDIUM POC
5.0 Aug 22

Hono is a Web application framework that provides support for any JavaScript runtime. Rated medium severity (CVSS 5.0),

CVE-2026-71850 MEDIUM POC
4.8 Aug 07

Cross-user HTML disclosure in Hono's server-side rendering affects all applications using hono/jsx with memo()-wrapped c

CVE-2023-50710 MEDIUM POC
4.3 Dec 14

Hono is a web framework written in TypeScript. Rated medium severity (CVSS 4.3), this vulnerability is remotely exploita

CVE-2026-27700 HIGH
8.2 Feb 25

Hono is a Web application framework that provides support for any JavaScript runtime. [CVSS 8.2 HIGH]

CVE-2026-22818 HIGH
8.2 Jan 13

Hono versions before 4.11.4 allow JWT algorithm confusion attacks through improper algorithm validation in the JWK/JWKS

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy