Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure curl GnuTLS client to malicious WebSocket server
-
ExploitManipulate TLS flow control to block a send
-
Executiongnutls_record_send() over-reports bytes sent
-
ImpactCurl reads past send buffer, leaks adjacent process memory to attacker
Vulnerability Assessment
| Exploitation Conditions | Exploitation requires that curl be built against the GnuTLS TLS backend (not OpenSSL or other backends) AND with WebSocket support enabled, and that the curl client connect to an attacker-controlled WebSocket server. The specific trigger is a blocked TLS send that causes GnuTLS's gnutls_record_send() to return a byte count greater than the amount it was asked to send; only then does curl read past its send buffer. Limiting factors: the attacker must control or impersonate the WebSocket server the client connects to (client-initiated outbound connection), WebSocket support in curl is experimental and off by default in many builds, and the OpenSSL-backed builds that dominate most deployments are not affected - substantially narrowing the realistically exploitable population despite curl's near-universal presence. |
| Impact | No CVSS vector, EPSS score, KEV listing, or POC is provided in the input, so quantitative exploitation signals are entirely absent and cannot be cross-referenced - this limits confidence in any automated prioritization. Based on the technical description alone, this is a client-side out-of-bounds read (CWE-125) in curl's GnuTLS backend, triggered only when curl connects to a malicious WebSocket server and GnuTLS's gnutls_record_send() over-reports bytes sent after a blocked send. The real-world risk is moderate-to-low: the victim must be the curl client reaching out to attacker-controlled infrastructure, the specific GnuTLS 'bytes sent > bytes given' edge case must occur (a blocked send), and WebSocket support in curl is experimental and infrequently enabled. The primary consequence is disclosure of adjacent process memory being transmitted to the attacker's server (and a possible crash), not remote code execution. Exploitation status: no public exploit identified at time of analysis. This looks like a genuine but niche memory-safety defect worth patching promptly where the vulnerable configuration exists, rather than a mass-exploitation emergency; the absence of EPSS/KEV data should be treated as missing information, not as evidence of safety. |
| Exploit ScenarioDerived | An attacker stands up a malicious WebSocket (wss://) server and lures or redirects a curl client - built against GnuTLS with WebSocket support - into connecting to it. By manipulating TLS flow control to induce a blocked send, the attacker causes gnutls_record_send() to report more bytes written than were supplied, making curl read past its send buffer and transmit adjacent process memory back to the server, leaking potentially sensitive data or crashing the client. No public exploit code is identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
An out-of-bounds read in curl when built with the GnuTLS TLS backend and WebSocket support allows a malicious WebSocket server to cause the client to send memory beyond its send buffer, potentially disclosing limited process memory (C:L) and causing a low availability impact (A:L). This unauthenticated attack (PR:N) requires user interaction (UI:R) because the victim must connect to an attacker-controlled WebSocket server; affected builds are those using GnuTLS rather than OpenSSL and with WebSocket support enabled, which is experimental and off by default in many distributions. No public exploit code or CISA KEV listing was identified at time of analysis, and no CVSS, EPSS, or POC data was provided, so quantitative exploitation signals are absent; a vendor patch is available per the Ubuntu security notice USN-8927-1.
RemediationAI
Apply the vendor patch referenced in Ubuntu security notice USN-8927-1 (https://ubuntu.com/security/notices/USN-8927-1); the advisory lists the exact fixed curl versions for affected Ubuntu releases. If immediate patching is not possible, mitigate by rebuilding curl with the OpenSSL TLS backend rather than GnuTLS, or by disabling WebSocket support at compile time-both options require a rebuild and may break functionality that depends on WebSocket or GnuTLS. Avoid connecting to untrusted WebSocket servers as a temporary risk reduction, though this is not a complete fix. Patch status: Patch available per vendor advisory.
Affected ProductsAI
curl builds that use the GnuTLS TLS backend and have WebSocket support enabled are affected. The input data does not provide specific version ranges or CPE identifiers; the vendor advisory for Ubuntu is USN-8927-1 (https://ubuntu.com/security/notices/USN-8927-1), which lists the fixed versions for Ubuntu packages. Note that curl is nearly ubiquitous, but the combination of GnuTLS and WebSocket support is not the default in many deployments-OpenSSL-backed builds and those without WebSocket support are not affected.
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
The vulnerability resides in curl's WebSocket implementation when it is linked against GnuTLS, a TLS library. When a TLS send would block, gnutls_record_send() can return a byte count that exceeds the number of bytes curl handed to it-a GnuTLS quirk after a blocked send. curl trusts that return value and subsequently performs an out-of-bounds read from its send buffer, transmitting adjacent memory to the WebSocket peer. The root cause is an out-of-bounds read (CWE-125 class, though no CWE was supplied). Exploitation requires the curl client to initiate a WebSocket connection to a server controlled or impersonated by the attacker, and the client must be built with GnuTLS and WebSocket support. OpenSSL-backed builds are not affected, and WebSocket support is experimental and disabled by default in some builds, narrowing the vulnerable population.
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
Network-reachable but victim must connect to a malicious server (UI:R) and a race-like blocked-send condition must occur (AC:H); leaks process memory to attacker (C:L) with possible crash (A:L).
DescriptionCVE.org
When curl is built with GnuTLS, a malicious WebSocket server can make curl send memory past its send buffer. This is due to an out of bounds read following when gnutls_record_send() returns a number of bytes sent greater than the number of bytes it was given to send. GnuTLS does that after a blocked send.
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
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
CVE.org
GitHub PoC
Exploit-DB