CVE-2026-29085: Hono Framework SSE XSS Vulnerability

CVE-2026-29085 Overview

CVE-2026-29085 is an injection vulnerability in Hono, a lightweight Web application framework that provides support for any JavaScript runtime. Prior to version 4.12.4, the streamSSE() function in the Streaming Helper module failed to properly validate the event, id, and retry fields for carriage return (\r) or newline (\n) characters. Since the Server-Sent Events (SSE) protocol uses line breaks as field delimiters, this vulnerability allows attackers to inject additional SSE fields within the same event frame when untrusted input is passed into these fields.

Critical Impact
Attackers can manipulate SSE streams by injecting malicious event data, potentially leading to client-side data manipulation, event spoofing, or unauthorized command execution in SSE-consuming applications.

Affected Products

Hono Web Framework versions prior to 4.12.4
Applications using the streamSSE() Streaming Helper function with untrusted input
Any JavaScript runtime environment running vulnerable Hono versions (Node.js, Deno, Bun, Cloudflare Workers, etc.)

Discovery Timeline

2026-03-04 - CVE CVE-2026-29085 published to NVD
2026-03-05 - Last updated in NVD database

Technical Details for CVE-2026-29085

Vulnerability Analysis

This vulnerability is classified under CWE-74 (Improper Neutralization of Special Elements in Output Used by a Downstream Component), commonly known as injection. The root issue stems from insufficient input validation in the SSE streaming functionality of the Hono framework.

The SSE protocol defines a simple text-based format where fields are delimited by newline characters. Each event consists of fields like event:, data:, id:, and retry:, separated by line breaks. When the streamSSE() function accepts user-controlled input for these fields without sanitizing newline characters, an attacker can terminate the current field prematurely and inject arbitrary additional fields.

This attack pattern is particularly dangerous in real-time applications that rely on SSE for pushing updates to clients, as injected events could manipulate application state, trigger unintended client-side behavior, or spoof legitimate server events.

Root Cause

The streamSSE() function in Hono's Streaming Helper module did not implement proper input validation for the event, id, and retry parameters. Specifically, the function failed to sanitize or reject carriage return (\r) and newline (\n) characters before incorporating these values into the SSE stream output. This oversight allows attackers to break out of the intended field context and inject additional SSE protocol elements.

Attack Vector

The attack requires network access and involves sending malicious input that gets processed by the streamSSE() function. An attacker can craft input containing newline characters followed by additional SSE fields. When this input is used in the event, id, or retry parameters, the injected content becomes part of the SSE stream sent to connected clients.

For example, if an application passes user input directly to the event field, an attacker could inject a value like legitimate\ndata: malicious payload which would result in the SSE stream containing an injected data field with attacker-controlled content. This can lead to event spoofing where clients receive fabricated events that appear to originate from the legitimate server.

For detailed technical analysis and proof-of-concept information, refer to the GitHub Security Advisory.

Detection Methods for CVE-2026-29085

Indicators of Compromise

Unusual SSE event patterns in application logs containing unexpected newline sequences
Client-side errors or unexpected behavior in applications consuming SSE streams
Multiple SSE fields appearing where single fields were expected in network traffic analysis
User input containing \r or \n characters being processed by SSE endpoints

Detection Strategies

Review application code for instances where user-controlled input is passed to streamSSE() function parameters
Implement web application firewall (WAF) rules to detect and block requests containing newline characters in SSE-related parameters
Monitor SSE endpoint traffic for anomalous patterns indicating injection attempts
Conduct static code analysis to identify vulnerable code paths in Hono-based applications

Monitoring Recommendations

Enable detailed logging for all SSE endpoint interactions including input parameter values
Set up alerts for SSE streams containing unexpected field delimiters or malformed event structures
Monitor for client-side error reports that may indicate successful injection attacks
Implement network traffic analysis to detect SSE protocol anomalies

How to Mitigate CVE-2026-29085

Immediate Actions Required

Upgrade Hono to version 4.12.4 or later immediately
Audit all application code for usage of the streamSSE() function with untrusted input
Implement input validation to strip or reject newline characters before passing data to SSE functions
Consider temporarily disabling affected SSE endpoints until patches can be applied

Patch Information

The vulnerability has been addressed in Hono version 4.12.4. The fix implements proper validation and sanitization of the event, id, and retry fields to prevent injection of carriage return and newline characters.

The patch can be reviewed at the GitHub Commit. For complete security details, consult the GitHub Security Advisory.

Workarounds

Implement input sanitization to remove or escape \r and \n characters before passing data to streamSSE()
Use an allowlist approach for SSE field values, rejecting any input containing control characters
Deploy a reverse proxy or WAF rule to filter requests containing newline characters in relevant parameters
Avoid using user-controlled input directly in SSE event, id, or retry fields

bash

# Upgrade Hono to patched version
npm update hono@4.12.4

# Or using yarn
yarn upgrade hono@4.12.4

# Verify installed version
npm list hono