Skip to main content

AG-UI Rust Client CVE-2026-92362

| EUVDEUVD-2026-80703 MEDIUM
Uncontrolled Resource Consumption (CWE-400)
2026-09-16 VulDB GHSA-469m-pffj-3v74
6.9
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

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

  1. Access
    Victim client connects to attacker/compromised SSE endpoint
  2. Delivery
    Server streams unterminated frame with no delimiter
  3. Exploit
    Client buffers bytes unbounded in sse.rs
  4. Execution
    Memory exhaustion and OOM kill
  5. Impact
    Denial 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 (\n\n) with no upper bound, so an SSE source that never sends a delimiter forces unbounded buffer growth toward memory exhaustion - the PR #2500 fix adds an 8 MiB per-frame cap (SSE_MAX_BUFFER_BYTES). The CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N, VulDB-scored 6.9) reflects easy remote reachability, but the impact triad VC:L/VI:L/VA:L is poorly calibrated: this is a memory-exhaustion DoS with no plausible confidentiality or integrity effect, so VC:L and VI:L are unjustified and the real impact is availability-only against the client that consumes the stream. Crucially, the 'attacker' is the SSE server side - exploitation requires the ag-ui client to connect to an attacker-controlled, compromised, or MITM'd SSE endpoint, which meaningfully limits real-world risk. No EPSS score, no CISA KEV listing, and no public exploit code are present; SSVC exploitation status is effectively 'none.' Net: a legitimate hardening fix in a niche emerging library, low operational urgency.

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.

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

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

Alert me

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

ag-ui 1.0

Affected Packages

euvd ag_ui no fix

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

Vendor (VulDB) PRIMARY 6.9 MEDIUM
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
vuln.today AI 5.3 MEDIUM

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.

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

Primary rating from Vendor (VulDB).

CVSS VectorVendor: VulDB

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

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

EPSS Score
0.5%
Top 58% exploitable
Prevalence
Low
Rust community SDK of emerging niche OSS AI-agent UI protocol
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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.5%
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
Yes
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in Ag Ui

View all
CVE-2026-120233 MEDIUM POC
5.5 Nov 01

Cross-origin information disclosure in the ag-ui TypeScript client: HttpAgent builds the POST run request with the conve

CVE-2026-120237 LOW POC
2.1 Nov 01

Denial of service in the ag-ui TypeScript client SDK (versions up to and including 0.0.58) allows a party that controls

CVE-2026-120235 LOW POC
2.1 Nov 01

Denial of service in the ag-ui TypeScript client SDK (versions up to 0.0.58) where the SSE/protobuf stream parser fails

CVE-2026-120234 LOW POC
2.1 Nov 01

Resource exhaustion in the ag-ui Protocol TypeScript client SDK (versions up to and including 0.0.58) allows a hostile o

CVE-2026-120236 LOW POC
2.1 Nov 01

Improper input validation in the AG-UI protocol SDK transport decoder path affects ag-ui versions up to and including 0.

CVE-2026-101099 MEDIUM
5.3 Sep 28

Unbounded buffering in the Server-Sent Events parser of the AG-UI Community SDK (Kotlin/Java) lets a malicious or man-in

CVE-2026-92361 MEDIUM
5.3 Sep 16

Memory exhaustion in the AG-UI Go community SDK's SSE client allows a remote attacker who controls or can intercept an S

CVE-2026-92360 MEDIUM
5.3 Sep 16

Origin validation errors in the AG-UI TypeScript client SDK (ag-ui 1.0) allow remote, low-privileged attackers who can i

CVE-2026-101101 MEDIUM
5.3 Sep 28

Uncaught exception handling in the A2A middleware of ag-ui-protocol ag-ui (all versions up to 2026-09-07) allows an atta

CVE-2026-101100 MEDIUM
5.3 Sep 28

Incomplete cleanup of per-run state in the ag-ui TypeScript client SDK's FilterToolCallsMiddleware allows disallowed too

CVE-2026-101098 MEDIUM
5.3 Sep 28

Unbounded request-body reads in the ag-ui Java community server SDK (JdkAgentHttpHandler, used by applications that inst

CVE-2026-92363 MEDIUM
5.3 Sep 16

Unbounded memory growth in the ag-ui (AG-UI protocol) C++ community SDK's Server-Sent Events parser lets an attacker who

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