Skip to main content

Hono JSX renderer CVE-2026-44458

MEDIUM
Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection') (CWE-74)
2026-05-09 https://github.com/honojs/hono GHSA-qp7p-654g-cw7p
4.3
CVSS 3.1 · Vendor: https://github.com/honojs/hono
View

Attack ChainAIDerived

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

  1. Recon
    Attacker submits malicious input via web form
  2. Delivery
    Server receives untrusted input in request
  3. Exploit
    JSX component interpolates input into style object
  4. Install
    JSX renderer serializes style object without CSS escaping
  5. C2
    Malicious CSS declarations injected into rendered HTML
  6. Execute
    Victim browser receives and renders page
  7. Impact
    CSS injection executes (overlay, exfiltration, UI hijacking)

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Input neutralization, injection prevention
Exploitation Conditions

Exploitation requires: (1) server-side JSX rendering of Hono components (SSR mode, not static export or client-only rendering); (2) untrusted user input (from request query parameters, body, database, or other external source) flowing directly into a JSX style object value or property name without sanitization; (3) victim browser rendering and viewing the malicious page (UI interaction required per CVSS). Non-default configuration is NOT required - applications simply using SSR with dynamic styling are at risk. Exploitation is blocked if: style values are hard-coded, input is sanitized before style assignment, or CSP headers are deployed to restrict resource fetching, though the latter does not prevent visual manipulation.

Impact

CVSS 4.3 with AV:N/AC:L/PR:N/UI:R indicates network-accessible, low-complexity exploitation requiring user interaction (UI:R suggests victim must view the rendered page). EPSS and KEV status not provided in input data. The vulnerability requires two confluence factors: (1) server-side JSX rendering enabled and (2) untrusted input flowing into style object keys or values. While CVSS is low-to-moderate and scope is unchanged (S:U), real-world impact is non-negligible for applications using SSR with dynamic styling - phishing overlays and request exfiltration via CSS url() are practical attacks. However, lack of JavaScript execution and HTML attribute breakout significantly limits severity compared to XSS. Attack surface is specific to SSR patterns, not affecting client-only Hono deployments. No exploit complexity noted; a simple semicolon-separated CSS injection suffices. Risk is HIGH for affected applications, MODERATE overall population due to targeted deployment requirement.

Exploit ScenarioDerived

An attacker submits a user profile with a custom theme color field containing the payload red; position: fixed; top: 0; width: 100%; height: 100%; background: rgba(0,0,0,0.8); z-index: 9999; cursor: pointer. When a server renders the victim's profile page with <div style={{ color: userTheme }}>, the injected CSS creates a full-viewport overlay. The attacker then uses the overlay as a phishing layer, displaying a fake login prompt that captures credentials when clicked.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.0% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – May 09, 2026

CSS declaration injection in Hono's JSX server-side renderer allows remote attackers to inject arbitrary CSS declarations via untrusted style object values or property names, enabling visual manipulation, outbound CSS requests to attacker hosts, and UI hijacking. Affects Hono versions before 4.12.18 when rendering JSX server-side with user-controlled style object inputs. No JavaScript execution or HTML breakout possible; impact limited to CSS scope.

RemediationAI

Vendor-released patch: Hono 4.12.18 and later. Upgrade immediately by updating the hono dependency in package.json to ^4.12.18 or later and running npm install or equivalent. For applications unable to upgrade immediately, implement server-side input sanitization: strip or escape CSS-sensitive characters (;, /, *, {, }, :) from user inputs before passing them to JSX style objects, or use a CSS property allowlist that validates style property names against known safe properties only. Additionally, consider using inline style-CSP headers (style-src 'unsafe-inline' removal if feasible) to limit CSS injection scope, though this will break dynamic styling if not carefully implemented. Side effect of sanitization: legitimate user input containing these characters will be truncated or escaped, potentially breaking user-submitted styling intent; test thoroughly before production deployment.

Affected Packages

npm hono fix: 4.12.18

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 JavaScript web framework (pkg:npm/hono) that supports server-side JSX rendering. The vulnerability resides in the JSX renderer's style attribute serialization logic. When a JSX component renders a style object (e.g., <div style={{ color: userInput }}>) server-side, the renderer escapes values for HTML attribute context but fails to escape for CSS context. This creates a mismatch: characters like semicolons (;), comment delimiters (/**/), and quoted strings that are valid CSS declaration boundaries remain unescaped. An attacker injecting ; background: url(attacker.com) into a style value breaks out of the intended property and injects new declarations. Root cause is improper input validation at the CSS parsing layer (CWE-74: Improper Neutralization of Special Elements used in an Output Command).

Know when the next one hits your stack

  • 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 (https://github.com/honojs/hono) PRIMARY 4.3 MEDIUM
AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:N

Primary rating from Vendor (https://github.com/honojs/hono) · only source for this CVE.

CVSS VectorVendor: https://github.com/honojs/hono

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
None
Integrity
Low
Availability
None

DescriptionCVE.org

Summary

The JSX renderer escapes style attribute object values for HTML but not for CSS. Untrusted input in a style object value or property name can therefore inject additional CSS declarations into the rendered style attribute. The impact is limited to CSS and does not allow JavaScript execution or HTML attribute breakout.

Details

style object values are serialized into a CSS declaration list and escaped for HTML attribute context only. Characters that act as CSS declaration boundaries - such as ;, comment markers, quoted strings, and block delimiters - are valid in HTML attribute content and can extend a value beyond its assigned property.

This issue arises when untrusted input is interpolated into a JSX style object and rendered server-side.

Impact

An attacker who can control the value or property name of a style object may inject arbitrary CSS declarations. This may lead to:

  • Visual manipulation of the page, including full-viewport overlays usable for phishing
  • Outbound requests to attacker-controlled hosts via CSS resource references such as url(...)
  • Hijacking of UI affordances through layout, positioning, or visibility changes

This issue affects applications that render JSX on the server with style object values or property names derived from untrusted input.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 31 npm packages depend on hono (28 direct, 3 indirect)

Ecosystem-wide dependent count for version 4.12.18.

Threat Intelligence Overview

EPSS Score
0.0%
Top 88% exploitable
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.0%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Affected Products (CPE)CVE.org

pkg:npm/hono

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