Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessVictim client connects to attacker/compromised SSE endpoint
-
DeliveryServer streams unterminated frame with no delimiter
-
ExploitClient buffers bytes unbounded in sse.rs
-
ExecutionMemory exhaustion and OOM kill
-
ImpactDenial of service on client process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
MITRE ATT&CK
1 technique across 1 tactic: Impact 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 ag-ui Rust client (crates/ag-ui-client) to open an SSE connection to an endpoint the attacker controls, has compromised, or can machine-in-the-middle; the malicious server then withholds the frame delimiter and streams an unterminated frame that grows the client's read buffer without bound. The limiting factor is that this is a client-side parser flaw - a benign, correctly-behaving server does not trigger it, so an attacker must influence the SSE data source the client consumes rather than reach a listening service directly. Impact is confined to memory/availability of the consuming client process; no authentication or user interaction beyond the client's normal act of connecting to its configured endpoint is required. |
| Impact | This is a genuine but low-severity availability issue, not a high-priority emergency. The CWE-400 flaw lives in the Rust community SDK's SSE frame parser (crates/ag-ui-client/src/sse.rs): the read buffer accumulated bytes while waiting for a frame delimiter ( |
| Exploit ScenarioDerived | An ag-ui Rust client is pointed at an agent/SSE endpoint that an attacker controls or has compromised (or is able to MITM). The malicious server responds with an SSE stream that never emits a frame delimiter, streaming an ever-growing single 'frame'; the client's unbounded String buffer grows until the host runs out of memory and the client process is OOM-killed. No public exploit code is identified at time of analysis; the issue is documented via a VulDB report and a pending upstream patch. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 16, 2026
Unbounded memory growth in the AG-UI Rust client's SSE frame parser (crates/ag-ui-client/src/sse.rs, shipped in the ag-ui 1.0 community SDK) lets a malicious, compromised, or machine-in-the-middle SSE server exhaust the memory of the consuming client process by streaming a frame it never terminates with a blank-line delimiter. No public exploit code has been identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV), but the outcome is a denial of service confined to the client process, matching the independently assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L rather than the higher CVSS 4.0 score of 6.9. Exploitation requires the Rust client to open an SSE connection to an endpoint that the attacker controls, has compromised, or can intercept; a correctly behaving server never triggers the flaw, so this is a client-side parsing weakness rather than a remotely reachable listening service.
RemediationAI
The fix is upstream in PR #2500 (https://github.com/ag-ui-protocol/ag-ui/pull/2500), which adds an 8 MiB per-frame cap (SSE_MAX_BUFFER_BYTES) and terminates the stream on overflow; however, the description states the pull request awaits acceptance, so the status is "Upstream fix available (PR/commit); released patched version not independently confirmed" - there is no confirmed tagged release containing the fix. Track PR #2500 and upgrade ag-ui-client to the first published version that includes SSE_MAX_BUFFER_BYTES, or build from the patched commit if you need the fix immediately. Until then, apply compensating controls against the specific attack path: only configure the Rust client to connect to SSE endpoints on an allowlist of trusted hosts, and do not let untrusted input determine the stream URL, since the attacker must control or intercept the SSE source. Enforce strict TLS certificate validation (and pin certificates where practical) to remove the man-in-the-middle path - the trade-off is operational overhead from certificate rotation. Cap the response body or byte stream before it reaches the parser in your own wrapper (for example by limiting total bytes read from the response or applying an idle/overall timeout to the SSE connection), which bounds memory but will truncate legitimately large or long-lived SSE frames. Egress-proxy or sidecar stream-size limits offer the same protection without code changes, at the cost of additional infrastructure and possible false positives on valid large events. Note that none of these workarounds fix the parser itself, and a terminated connection will surface as an AgUiClientError::SseParse or transport error that calling code must handle gracefully.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerable component is the Server-Sent Events (SSE) reader in the Rust community SDK crate ag-ui-client, which consumes an HTTP response body as a stream of reqwest byte chunks and accumulates them in an in-memory String buffer until it can split complete events on a blank-line delimiter (\n\n in the original code). Root cause is CWE-400 (Uncontrolled Resource Consumption): process_raw_sse_events repeatedly split the buffer and returned the trailing remainder, but never bounded the size of that remainder, so a peer that simply omits the frame terminator forces the buffer to grow with every chunk until the client process runs out of memory. The upstream fix in PR #2500 introduces SSE_MAX_BUFFER_BYTES at 8 MiB (deliberately mirroring the Dart SDK's kSseDefaultMaxDataCodeUnits so all community SDKs bound unterminated streams at the same point) and, crucially, checks the cap on each frame before it is parsed rather than only on the leftover remainder - the diff notes that checking only the remainder allows a sender to step over the cap by closing an oversized frame. On overflow the client now clears the buffer and terminates the stream instead of resuming at an arbitrary offset, because the bytes after the abandoned frame are that frame's tail, not a new frame, and treating them as a frame could let a sender have arbitrary content dispatched as an event. The same patch also generalizes delimiter detection to any combination of \r\n, \n, or \r and drops the underlying response stream once terminated.
Know when Ag Ui 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:L/VI:L/VA:L/SC:N/SI:N/SA:N
Remote unterminated SSE stream exhausts client memory (availability-only, single process → A:L); no confidentiality or integrity impact, so VulDB's C:L/I:L are unjustified.
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
DescriptionCVE.org
A vulnerability was detected in ag-ui-protocol ag-ui 1.0. This impacts an unknown function of the file crates/ag-ui-client/src/sse.rs of the component SSE Frame Parser. Performing a manipulation results in resource consumption. The attack is possible to be carried out remotely. The pull request to fix this issue awaits acceptance.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Cross-origin information disclosure in the ag-ui TypeScript client: HttpAgent builds the POST run request with the conve
Denial of service in the ag-ui TypeScript client SDK (versions up to and including 0.0.58) allows a party that controls
Denial of service in the ag-ui TypeScript client SDK (versions up to 0.0.58) where the SSE/protobuf stream parser fails
Resource exhaustion in the ag-ui Protocol TypeScript client SDK (versions up to and including 0.0.58) allows a hostile o
Improper input validation in the AG-UI protocol SDK transport decoder path affects ag-ui versions up to and including 0.
Unbounded buffering in the Server-Sent Events parser of the AG-UI Community SDK (Kotlin/Java) lets a malicious or man-in
Memory exhaustion in the AG-UI Go community SDK's SSE client allows a remote attacker who controls or can intercept an S
Origin validation errors in the AG-UI TypeScript client SDK (ag-ui 1.0) allow remote, low-privileged attackers who can i
Uncaught exception handling in the A2A middleware of ag-ui-protocol ag-ui (all versions up to 2026-09-07) allows an atta
Incomplete cleanup of per-run state in the ag-ui TypeScript client SDK's FilterToolCallsMiddleware allows disallowed too
Unbounded request-body reads in the ag-ui Java community server SDK (JdkAgentHttpHandler, used by applications that inst
Unbounded memory growth in the ag-ui (AG-UI protocol) C++ community SDK's Server-Sent Events parser lets an attacker who
EUVD-2026-80703
GHSA-469m-pffj-3v74
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB