Skip to main content

curl CVE-2026-107928

LOW
2026-10-14 vendor:ubuntu
View

Attack ChainAIDerived

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

  1. Access
    Lure curl GnuTLS client to malicious WebSocket server
  2. Exploit
    Manipulate TLS flow control to block a send
  3. Execution
    gnutls_record_send() over-reports bytes sent
  4. Impact
    Curl 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.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available

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

Alert me

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

vuln.today AI 4.2 MEDIUM

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).

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

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

Prevalence
High
curl is ubiquitous, but affected GnuTLS build plus experimental WebSocket narrows the footprint
Data Quality
1 sources
Confidence: Low

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 LOW
CISA KEV No
Public POC No
EPSS N/A
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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.

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.

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