Skip to main content

libcurl CVE-2026-10536

| EUVDEUVD-2026-41497 CRITICAL
Use After Free (CWE-416)
Critical
Disputed · 9.8 Vendor
View

Attack ChainAIDerived

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

  1. Access
    App sets CURLOPT_STREAM_DEPENDS on handle
  2. Delivery
    App calls curl_easy_reset() freeing dependency struct
  3. Exploit
    App calls curl_easy_cleanup()
  4. Execution
    Cleanup dereferences dangling pointer
  5. Impact
    Heap memory disclosure or crash

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

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 host application to have configured an HTTP/2 stream-dependency tree via CURLOPT_STREAM_DEPENDS or CURLOPT_STREAM_DEPENDS_E on an easy handle, then to call curl_easy_reset() on that same handle, and finally curl_easy_cleanup() - the use-after-free occurs during that cleanup. The decisive limiting factor is that these are application-controlled libcurl API calls, not attacker-supplied input: an external network attacker cannot force this sequence, so applications that never set the stream-dependency options, or that do not reset-then-cleanup a handle, are unaffected regardless of libcurl version. This application-usage dependency, combined with an Information-Disclosure-class impact and low EPSS, materially limits real-world exploitability despite the AV:N/PR:N CVSS framing.

Impact

The signals conflict sharply and should temper the headline number. The input CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H = 9.8) implies remote unauthenticated full compromise, but the description shows the vulnerability is only triggered by the host application itself invoking a specific sequence - configuring stream dependencies, then curl_easy_reset(), then curl_easy_cleanup(). A network attacker cannot force an application to make those API calls, so the AV:N/PR:N framing overstates real-world exposure; the realistic trigger is application-controlled and the practical impact (per the Information Disclosure tag) is memory disclosure or a crash rather than reliable code execution. This is corroborated by the low EPSS (0.21%, 11th percentile), absence from CISA KEV, and no identified public exploit. This is a genuine memory-safety defect worth patching during normal maintenance, but it is a high-CVSS/low-real-risk case, not an emergency. NOTE: CVSS claims network vector and no privileges, while the description implies the flaw depends on the application's own libcurl usage pattern - verify exploitability against your specific integration before treating it as remotely exploitable.

Exploit ScenarioDerived

An application that enables HTTP/2 stream prioritization sets CURLOPT_STREAM_DEPENDS on an easy handle, reuses the handle by calling curl_easy_reset(), and later tears it down with curl_easy_cleanup(); the cleanup dereferences the already-freed dependency structure, reading or writing dangling heap memory that can leak adjacent data (Information Disclosure) or crash the process. Because the CVSS lists AC:L, no timing race is required, but triggering depends entirely on the application performing this specific API sequence rather than on attacker-supplied network traffic. No public exploit is identified at time of analysis.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv3 – Jul 06, 2026

Use-after-free in libcurl's HTTP/2 stream-dependency handling affects a wide range of curl releases (7.88.0 through 8.20.0) when an application sets CURLOPT_STREAM_DEPENDS or CURLOPT_STREAM_DEPENDS_E, then calls curl_easy_reset() before curl_easy_cleanup(); the reset frees an internal priority structure that cleanup later re-accesses. Despite the NVD 9.8 CVSS rating, the flaw is only reachable through a specific application-controlled API call sequence rather than remote attacker input, and is tagged Information Disclosure. No public exploit identified at time of analysis, EPSS is low (0.21%, 11th percentile), and it is not listed in CISA KEV.

Earlier versions of this analysis (2)
v2 Jul 06, 2026 - 19:32 cvss changed CVSS 9.8

Use-after-free in libcurl (curl versions from 7.88.0 through 8.20.0) is triggered when an application sets an HTTP/2 stream-dependency tree via CURLOPT_STREAM_DEPENDS or CURLOPT_STREAM_DEPENDS_E, then calls curl_easy_reset() followed by curl_easy_cleanup(), causing cleanup to touch an internal structure already freed during the reset. Tagged as Information Disclosure, it can lead to a crash or potential leakage of freed heap memory rather than reliable remote code execution. No public exploit identified at time of analysis; EPSS is low at 0.21% (11th percentile) and it is not in CISA KEV.

v1 Jun 24, 2026 - 18:31

HTTP/2 stream-dependency tree use-after-free in libcurl allows network-reachable attackers to trigger memory corruption when curl processes HTTP/2 stream-dependency tree operations. The flaw resides in libcurl's HTTP/2 implementation (requiring nghttp2 or equivalent backend) and is rated LOW severity by the curl project, indicating limited real-world exploitability likely due to narrow triggering conditions. No active exploitation is confirmed and no public exploit code has been identified at time of analysis. The issue is resolved in curl 8.21.0, released June 24, 2026.

RemediationAI

Upgrade libcurl to the fixed release identified in the vendor advisory at https://curl.se/docs/CVE-2026-10536.html; the input data does not include an exact fixed version, so treat the specific patched build as not independently confirmed and verify it against the advisory and your distribution's security tracker before deploying. As a code-level workaround where you control the application, avoid the vulnerable call ordering: do not call curl_easy_reset() on a handle that has CURLOPT_STREAM_DEPENDS/CURLOPT_STREAM_DEPENDS_E set and then reuse it through cleanup - instead destroy the handle with curl_easy_cleanup() and create a fresh one, or refrain from setting the stream-dependency options at all if your workload does not require HTTP/2 stream prioritization (trade-off: loss of prioritization tuning, negligible for most clients). For deployments that embed libcurl indirectly (language bindings, packaged tools), rebuild or update against the patched shared library. Cross-reference the oss-security disclosure (https://seclists.org/oss-sec/2026/q2/1012) and vendor JSON (https://curl.se/docs/CVE-2026-10536.json) for the exact fixed version.

Affected VersionsENISA

curl 8.18.0 ≤8.18.0
curl 8.10.0 ≤8.10.0
curl 8.1.2 ≤8.1.2
curl 7.88.1 ≤7.88.1
curl 8.9.1 ≤8.9.1
curl 8.13.0 ≤8.13.0
curl 8.6.0 ≤8.6.0
curl 8.17.0 ≤8.17.0
curl 8.15.0 ≤8.15.0
curl 8.0.1 ≤8.0.1
curl 8.14.1 ≤8.14.1
curl 8.5.0 ≤8.5.0
curl 8.2.0 ≤8.2.0
curl 8.11.0 ≤8.11.0
curl 8.14.0 ≤8.14.0
curl 8.19.0 ≤8.19.0
curl 8.12.0 ≤8.12.0
curl 8.4.0 ≤8.4.0
curl 8.0.0 ≤8.0.0
curl 8.1.0 ≤8.1.0
curl 8.2.1 ≤8.2.1
curl 8.9.0 ≤8.9.0
curl 8.11.1 ≤8.11.1
curl 8.10.1 ≤8.10.1
curl 8.3.0 ≤8.3.0
curl 8.12.1 ≤8.12.1
curl 8.7.1 ≤8.7.1
curl 8.16.0 ≤8.16.0
curl 8.20.0 ≤8.20.0
curl 8.7.0 ≤8.7.0
curl 7.88.0 ≤7.88.0
curl 8.8.0 ≤8.8.0
curl 8.1.1 ≤8.1.1

Affected Packages

euvd curl 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 bug lives in libcurl, the transfer library underlying the curl tool and thousands of embedded HTTP clients. It concerns HTTP/2 stream prioritization: RFC 7540 lets a client express a dependency tree among concurrent streams, which libcurl exposes through CURLOPT_STREAM_DEPENDS (dependency) and CURLOPT_STREAM_DEPENDS_E (exclusive dependency). Internally libcurl tracks these relationships in a per-handle structure. The root cause is a classic CWE-416 Use-After-Free (the NVD CWE field is N/A, but the description explicitly states an already-freed internal structure is accessed): curl_easy_reset() releases the stream-dependency state, yet the subsequent curl_easy_cleanup() still attempts to dereference and modify it, operating on dangling memory. The EUVD data (EUVD-2026-41497) enumerates affected releases spanning 7.88.0 up to 8.20.0.

Know when Curl 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

Sources disagree (Medium–Critical)
Vendor (CNA) PRIMARY 9.8 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 3.0 LOW

Trigger requires the application's own libcurl configuration and reset-then-cleanup call sequence, so AV:L/PR:H/AC:H; realistic impact is memory disclosure or crash, giving C:L/A:L and I:N.

3.1 AV:L/AC:H/PR:H/UI:N/S:U/C:L/I:N/A:L
4.0 AV:L/AC:H/AT:N/PR:H/UI:N/VC:L/VI:N/VA:L/SC:N/SI:N/SA:N
SUSE 5.5 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
Red Hat 4.7 MEDIUM

vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.

CVSS VectorVendor

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

1
CVSS changed
Jul 06, 2026 - 19:22 NVD
9.8 (CRITICAL)

Description PRE-NVD

Disclosed via oss-security. NVD scoring and full description are pending.

Executive ViewAI

Why It Matters

A critical memory-safety flaw in libcurl versions 7.88.0 through 8.20.0 affects HTTP/2-enabled applications, potentially exposing sensitive data through information disclosure. Organizations must inventory curl deployment scope and assess HTTP/2 configuration risk; no public exploitation has been documented. With no vendor patch currently available, the immediate risk remains manageable through targeted inventory and interim mitigations.

Business Impact: High
Compensating Controls

Disable HTTP/2 protocol support in libcurl configurations where feasible and application-compatible. Implement network segmentation to isolate affected curl applications from sensitive data systems. Review and restrict use of CURLOPT_STREAM_DEPENDS and CURLOPT_STREAM_DEPENDS_E API options in application code. Subscribe to libcurl security advisories and prepare immediate deployment testing procedures for when patched versions are released.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Ubiquitous
libcurl is embedded in vast numbers of applications, OSes, and devices
Data Quality
6 sources
Confidence: High

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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

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

Attack Technique

Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

More in Curl

View all
CVE-2021-22901 HIGH POC
8.1 Jun 11

curl 7.75.0 through 7.76.1 suffers from a use-after-free vulnerability resulting in already freed memory being used when

CVE-2013-0249 HIGH POC
7.5 Mar 08

Stack-based buffer overflow in the Curl_sasl_create_digest_md5_message function in lib/curl_sasl.c in curl and libcurl 7

CVE-2015-3145 HIGH
7.5 Apr 24

The sanitize_cookie_path function in cURL and libcurl 7.31.0 through 7.41.0 does not properly calculate an index, which

CVE-2022-32206 MEDIUM POC
6.5 Jul 07

curl < 7.84.0 supports "chained" HTTP compression algorithms, meaning that a serverresponse can be compressed multiple t

CVE-2022-32207 CRITICAL POC
9.8 Jul 07

When curl < 7.84.0 saves cookies, alt-svc and hsts data to local files, it makes the operation atomic by finalizing the

CVE-2022-43551 HIGH POC
7.5 Dec 23

A vulnerability exists in curl <7.87.0 HSTS check that could be bypassed to trick it to keep using HTTP. Rated high seve

CVE-2022-32221 CRITICAL POC
9.8 Dec 05

When doing HTTP(S) transfers, libcurl might erroneously use the read callback (`CURLOPT_READFUNCTION`) to ask for data t

CVE-2018-0500 CRITICAL POC
9.8 Jul 11

Curl_smtp_escape_eob in lib/smtp.c in curl 7.54.1 to and including curl 7.60.0 has a heap-based buffer overflow that mig

CVE-2022-32205 MEDIUM POC
4.3 Jul 07

A malicious server can serve excessive amounts of `Set-Cookie:` headers in a HTTP response to curl and curl < 7.84.0 sto

CVE-2025-9086 HIGH POC
7.5 Sep 12

1. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack co

CVE-2023-23914 CRITICAL POC
9.1 Feb 23

A cleartext transmission of sensitive information vulnerability exists in curl <v7.88.0 that could cause HSTS functional

CVE-2023-27534 HIGH POC
8.8 Mar 30

A path traversal vulnerability exists in curl <8.0.0 SFTP implementation causes the tilde (~) character to be wrongly re

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SLES15-SP5-CHOST-BYOS-SAP-CCloud Affected
SLES15-SP6-CHOST-BYOS Affected
SLES15-SP6-CHOST-BYOS-Aliyun Affected
SLES15-SP6-CHOST-BYOS-Azure Affected
SLES15-SP6-CHOST-BYOS-EC2 Affected

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