Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessClient connects to malicious/MitM SSE endpoint
-
DeliveryServer streams unbounded oversized SSE line/event
-
ExploitParser buffers payload without size cap
-
ExecutionClient memory exhausted
-
ImpactDenial of service on client process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Exception handling procedures
|
| Exploitation Conditions | Exploitation requires the AG-UI Kotlin/Java client (HttpAgent / SseEventParser) to consume a Server-Sent Events response from an attacker-controlled or man-in-the-middle-positioned agent endpoint. The client must connect to that endpoint (the trust flows from server to client), and the attacker supplies an oversized SSE wire line or decoded event |
| Impact | This is a memory-exhaustion / unbounded-buffering defect (CWE-755) in the SSE parser (SseParser.kt / SseEventParser) of the AG-UI Kotlin/Java Community SDK. The fix in PR #2657 introduces |
| Exploit ScenarioDerived | An application using the AG-UI Kotlin/Java Community SDK's HttpAgent connects to a remote agent endpoint that is attacker-controlled (or intercepted via MitM). The malicious endpoint returns an SSE response containing an enormous single line or event |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 28, 2026
Unbounded buffering in the Server-Sent Events parser of the AG-UI Community SDK (Kotlin/Java) lets a malicious or man-in-the-middle-positioned agent endpoint drive a client-side memory exhaustion condition, degrading or killing the consuming process. All ag-ui-protocol ag-ui builds up to 2026-09-23 are flagged by CPE, specifically the Kotlin Community SDK SseParser.kt and its Java counterpart SseEventParser, which had no per-line or per-event size caps before the fix. Impact is availability-only (no confidentiality or integrity effect), an upstream fix exists as PR #2657 but was still awaiting acceptance, and no public exploit was identified at time of analysis.
RemediationAI
Adopt the upstream fix in PR https://github.com/ag-ui-protocol/ag-ui/pull/2657 (referenced as the vendor patch) once it is merged and a tagged release is published, then rebuild against that release; because the PR was still awaiting acceptance, verify the released artifact actually contains the SseLimits class before assuming you are fixed - no exact fixed version number is confirmed by the input data. Roll forward by explicitly constructing HttpAgent with a bounded SseLimits (for example 256 KiB per line and 2 MiB per event) instead of relying on pre-patch defaults, since the patched defaults of 1 MiB per line and 8 MiB per event still leave a large allocation window for high-volume streams and there is no lifetime byte budget per stream; the trade-off is that legitimate large agent tool-call payloads can be truncated or errored, so tune caps to observed maximums. On the server side, use the JdkAgentHttpHandler constructor accepting maxRequestBodyBytes and keep the 8 MiB default so oversized requests receive 413 before parsing. Where the SDK cannot be patched, the practical compensating control is to consume SSE only from endpoints you control or that are reached over mutually authenticated TLS, and to front the client with a stream proxy that terminates any connection whose line or event size exceeds a fixed ceiling - accepting that this can break chatty or large-payload agents - while also configuring the underlying JSON Serializer with nesting, token, and string limits so library-level failures surface as SerializationException rather than exhausting memory. Full advisories: https://vuldb.com/vuln/410974 and https://vuldb.com/cve/CVE-2026-101099.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
AG-UI is a protocol for streaming agent events over HTTP using Server-Sent Events; the affected component is the community Kotlin/Java SDK (sdks/community/java/ag-ui) whose client-side parser reads the SSE byte/line stream and decodes each event's data payload into AG-UI events. The root-cause class is CWE-755 (Improper Handling of Exceptional Conditions): an attacker-supplied SSE stream containing an extremely long wire line or a very large multi-field data payload is accumulated without bound, and the resulting exception or memory pressure is not contained, so the parser/consumer fails. The upstream fix introduces an SseLimits abstraction that bounds every wire line and every decoded event payload by UTF-8 byte count (documented defaults 1 MiB per line and 8 MiB per decoded data payload, with newline bytes between multiple data: fields counted toward the event cap), and adds a matching server-side guard in the JDK HTTP adapter that rejects bodies over 8 MiB with 413 Payload Too Large before parsing. The vendor-published CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N, VA:L, E:X, score 5.3) rates this low-severity, availability-only; our independent assessment is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L, i.e., remote, low complexity, availability impact only, and exploitation hinges on the client trusting and consuming a hostile SSE stream.
Know when Kotlin 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:L/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
Remote malicious/MitM SSE server needs no client-side privileges (PR:N) and no user interaction; unbounded buffering yields availability-only impact (A:L), no C/I effect.
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
DescriptionCVE.org
A vulnerability was detected in ag-ui-protocol ag-ui up to 2026-09-23. This affects an unknown part of the file SseParser.kt of the component Kotlin Community SDK. Performing a manipulation results in handling of exceptional conditions. The attack may be initiated 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
JetBrains Kotlin versions before 1.3.30 were resolving artifacts using an http connection during the build process, pote
Versions of the package pubnub before 7.4.0; all versions of the package com.pubnub:pubnub; versions of the package pubn
In JetBrains Kotlin from 1.4-M1 to 1.4-RC (as Kotlin 1.3.7x is not affected by the issue. Rated high severity (CVSS 8.8)
Cookie scoping bypass in the http4k client-side cookie jar (Maven org.http4k:http4k-core) causes cookies stored by Basic
Replay of captured Digest authentication credentials is possible in the http4k http4k-security-digest module (org.http4k
JetBrains IntelliJ IDEA projects created using the Kotlin (JS Client/JVM Server) IDE Template were resolving Gradle arti
JetBrains Ktor framework (created using the Kotlin IDE template) versions before 1.1.0 were resolving artifacts using an
Remote code execution in JetBrains Kotlin before 2.4.20 stems from unsafe deserialization (CWE-502) of build cache metad
In JetBrains Kotlin before 1.6.0, it was not possible to lock dependencies for Multiplatform Gradle Projects. Rated medi
EUVD-2026-88369
GHSA-pcr3-24cw-387c
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB