CVE-2026-1965
Plain English Summary
AI-powered analysis for quick understanding
This vulnerability allows an attacker to potentially access sensitive information by reusing an existing connection that was authenticated with different user credentials, leading to unauthorized actions. This can happen if an application makes multiple requests to the same server using Negotiate authentication, where the first request is authenticated with one user's credentials and the second request mistakenly uses that same connection, thinking it's authenticated with a different user's credentials.
Technical Description
libcurl can in some circumstances reuse the wrong connection when asked to do an Negotiate-authenticated HTTP or HTTPS request. libcurl features a pool of recent connections so that subsequent requests can reuse an existing connection to avoid overhead. When reusing a connection a range of criterion must first be met. Due to a logical error in the code, a request that was issued by an application could wrongfully reuse an existing connection to the same server that was authenticated using different credentials. One underlying reason being that Negotiate sometimes authenticates *connections* and not *requests*, contrary to how HTTP is designed to work. An application that allows Negotiate authentication to a server (that responds wanting Negotiate) with `user1:password1` and then does another operation to the same server also using Negotiate but with `user2:password2` (while the previous connection is still alive) - the second request wrongly reused the same connection and since it then sees that the Negotiate negotiation is already made, it just sends the request over that connection thinking it uses the user2 credentials when it is in fact still using the connection authenticated for user1... The set of authentication methods to use is set with `CURLOPT_HTTPAUTH`. Applications can disable libcurl's reuse of connections and thus mitigate this problem, by using one of the following libcurl options to alter how connections are or are not reused: `CURLOPT_FRESH_CONNECT`, `CURLOPT_MAXCONNECTS` and `CURLMOPT_MAX_HOST_CONNECTIONS` (if using the curl_multi API).
CVSS Vector Analysis
Vector String
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:NExploit Resources
Search for proof-of-concept code and exploit modules
Official References
Quick Information
Published
Mar 11, 2026
28 days ago
Last Modified
Mar 12, 2026
26 days ago
Vendor
haxx
Product
curl
Related Vulnerabilities
This vulnerability allows an attacker to potentially execute arbitrary code on a system using curl when making a second SMB request to the same host, due to the software mistakenly using memory that has already been freed. To exploit this, the attacker must be able to send multiple SMB requests to the same server, which could happen in certain network configurations.
This vulnerability allows an attacker to potentially gain access to sensitive information by reusing an existing HTTP proxy connection, even if the new request uses different login credentials. This issue occurs when the curl tool fails to establish a separate connection for requests that require different authentication, which could lead to unauthorized data exposure if an attacker can control the proxy or its traffic.
This vulnerability allows an attacker to potentially capture an OAuth2 bearer token when a user is redirected from one website to another, exposing sensitive information. This can happen if the second website has credentials stored in the user's .netrc file, which curl mistakenly sends along with the token.
This vulnerability allows an attacker to potentially send incorrect data during an HTTP POST request if the same connection handle was previously used for a PUT request, which could lead to unexpected application behavior. It mainly affects applications that reuse connection handles without properly resetting them, making it important for developers to be cautious when switching between different types of requests.
An attacker can exploit a vulnerability in curl to send malicious commands during TELNET communication, potentially allowing them to execute arbitrary code on the system. This can happen if an application using curl accepts user input without properly checking it, making it particularly risky for applications that rely on user-provided data.