Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessApplication configures libcurl FTP transfer with client certificate
-
ExploitConnection reuse inherits certificate from prior transfer
-
ImpactClient certificate applied to unintended FTP connection
Vulnerability Assessment
| Exploitation Conditions | Requires an application built on libcurl that performs FTP or FTPS transfers with a client certificate configured (e.g. CURLOPT_SSLCERT) and that reuses connections across multiple transfers within the same handle, such that a later FTP connection inherits a client certificate set for an earlier transfer. LIMITING FACTORS: this is not a default-configuration remote exploit - it depends on client certificate use with FTP(S) specifically, connection reuse being active, and the application mixing differently-configured transfers on one handle; the flaw is client-side logic, not server-triggerable, and no attacker-controlled network payload initiates it. Affected via libcurl up to 8.22.0, fixed in 8.23.0 (exact lower bound truncated in provided data). |
| Impact | This is a LOW-severity vulnerability as rated by the curl project, one of twenty-four flaws disclosed alongside curl 8.23.0. No CVSS vector, CWE, EPSS score, KEV listing, or POC is present in the input, so quantitative exploitation signals are entirely absent - the only severity signal is curl's own 'L' (LOW) rating in the advisory table. This is a client-side connection-reuse logic flaw in libcurl: when an FTP connection is reused, it can improperly inherit a client certificate configured for a different transfer, causing a client certificate to be applied to an FTP connection where it was not intended. The real-world risk is low and conditional, not a widespread remote-exploitation priority: it is not attacker-initiated in the classic sense, requires an application to use libcurl FTP(S) with client certificates across reused connections, and has no confirmed active exploitation. Treat this as a hygiene/patch-on-schedule item rather than an emergency, while noting the caveat that curl is ubiquitously deployed so the patch should still be rolled out broadly. KEY MISSING DATA: no CVSS vector means attack vector, complexity, and privilege requirements cannot be confirmed from the input; the affected version range for this specific CVE is truncated in the provided advisory table and could not be fully read. |
| Exploit ScenarioDerived | An application uses a single libcurl handle to perform multiple FTP/FTPS transfers, one of which is configured with a client certificate (CURLOPT_SSLCERT). On a subsequent transfer, libcurl reuses the existing connection and inherits the client certificate from the earlier transfer, applying it to an FTP connection where it was not intended. No public exploit code was identified at time of analysis, and this requires a specific client-side configuration rather than attacker-driven network input. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
FTP and FTPS transfers performed by curl/libcurl through 8.22.0 can reuse a connection that carries a client certificate configured for an earlier, differently-configured transfer, so a later transfer may present the wrong client certificate to a server. It is a client-side connection-reuse logic error, not a server-triggerable flaw: it requires an application built on libcurl that sets CURLOPT_SSLCERT (or equivalent) for FTP(S) and reuses connections across multiple transfers on the same handle, and the assessed vector is CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N. The curl project rates this LOW, and it is one of twenty-four flaws disclosed alongside curl 8.23.0; no public exploit code has been identified and there is no confirmed active exploitation (CISA KEV) at time of analysis. Practical risk is limited to deployments that mix client-certificate and non-client-certificate FTP(S) transfers on shared handles or shared connection caches.
RemediationAI
Primary fix: upgrade to curl/libcurl 8.23.0, which contains the upstream commit referenced in the curl security advisory (https://curl.se/docs/security.html) and described in the oss-security posting (https://seclists.org/oss-sec/2026/q4/154); organizations on a supported LTS branch should take the corresponding Rock-solid curl backport rather than tracking upstream releases directly. If an immediate upgrade is not possible, break the reuse path that triggers the mixup: call CURLOPT_FRESH_CONNECT (or the CURLOPT_FORBID_REUSE equivalent) on FTP(S) transfers that use a client certificate, or isolate client-certificate transfers onto their own easy handle/connection cache instead of sharing one cache (CURLOPT_SHARE) across differently configured transfers - the trade-off is that forcing fresh connections adds a full DNS/TCP/TLS handshake per transfer, increasing latency and overhead on high-volume FTP jobs, while handle isolation increases memory and socket usage. Applications that set a client certificate globally on a handle and never vary it across transfers are not exposed and need only the version upgrade. Ensure any caller-visible credential (the wrong certificate being presented) is rotated or reviewed if affected transfers were already run against third-party endpoints.
Affected ProductsAI
The flaw affects curl and libcurl up to and including version 8.22.0; the first affected version is truncated in the provided vulnerability table, so the exact lower bound could not be confirmed from the supplied data, but the curl security advisory page (https://curl.se/docs/security.html) and the oss-security disclosure (https://seclists.org/oss-sec/2026/q4/154) list it as fixed in curl 8.23.0. The issue applies only when libcurl is used for FTP or FTPS with a client certificate configured and connection reuse enabled, or when the curl command-line tool is used in a way that mixes those configurations; typical HTTPS-only consumers of curl/libcurl are not in scope. Commercial support for this branch is handled through the Rock-solid curl LTS program (https://rock-solid.curl.dev), which backports security fixes to supported curl release lines. No CPE strings were provided in the source data.
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
curl and libcurl maintain a connection cache so that successive transfers on the same easy handle (or a shared cache via CURLOPT_SHARE) can skip DNS, TCP, and TLS setup by reusing an existing connection. For protocol families that carry per-request security context, the reuse decision must also account for that context - here, whether a client certificate (CURLOPT_SSLCERT/CURLOPT_SSLKEY) was configured for the transfer being started. The root-cause class is a session/connection mixup: libcurl's reuse logic did not treat a change in the configured client certificate as a reason to discard or re-key the cached FTP(S) connection, so a cached control connection established under one credential configuration was handed to a later transfer that expected different credentials. Because FTP is stateful and the authentication is applied once at connection establishment, the second transfer inherits the first transfer's client certificate rather than negotiating its own. No CWE was supplied in the provided data, but the flaw maps conceptually to improper reuse of a connection across differing security contexts; the independent assessment confirms it is client-side logic that no attacker-controlled network payload can initiate, which caps both the severity and the realistic attack surface.
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
AC:H because exploitation needs a specific client-cert + connection-reuse configuration and transfer ordering; C:L for unintended client-certificate exposure on a connection, with no integrity or availability impact.
Description PRE-NVD
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
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
CVE.org
GitHub PoC
Exploit-DB