Stefan Eissing

When using ambient user credentials, an HTTP request directed to one origin may be dispatched over a connection previously authenticated via Negotiate for a different origin. This behavior results in the intended credentials for the request remaining unused.

When built with wolfSSL, curl may incorrectly validate a pinned public key hash against a key that the TLS peer does not possess. This occurs during the TLS handshake when wolfSSL validates the connection, but curl subsequently re-parses the certificate. A manipulated validity length field can trick curl into extracting and matching a different embedded key, leading to incorrect authorization of the pinned public key.

An `ftp://` transfer configured with `CURLUSESSL NONE` may reuse a pooled FTP control connection previously upgraded with `STARTTLS` and authenticated via a client certificate. Because the subsequent handle does not initiate a new TLS handshake or FTP login, the server continues to authorize the session using the identity of the first handle's certificate.

Enabling `CURLOPT CRLF` allows for command injection during IMAP APPEND operations. When transmitting line-ending expanded data, curl advertises the raw input byte count in the `IMAP APPEND {N}` literal. Because the server only reads $N$ bytes for the payload, any remaining overflow bytes are interpreted and executed as pipelined IMAP commands within the authenticated session.

An issue exists where the connection reuse key does not include the binding when `CURLOPT INTERFACE` (or the `--interface` command line option) is configured with prefixes such as `if!`, `host!`, or `ifhost!`. This allows a subsequent transfer requesting a different source to silently reuse an existing connection, resulting in the traffic originating from the source address of the previous transfer.

The connection cache match function fails to consider the automatic client certificate option. This allows a cached Schannel connection that was already authenticated to be reused for a transfer redirected to a different origin, even if the automatic client certificate option was explicitly disabled for that specific transfer to prevent such an occurrence.

When built with GnuTLS, a malicious WebSocket server can cause curl to send memory beyond its send buffer. This occurs because of an out-of-bounds read that happens when the `gnutls record send()` function returns a number of bytes sent that exceeds the number of bytes it was originally instructed to send, typically following a blocked send.

When using an ambient user during an initial transfer with Negotiate authentication, curl may incorrectly transmit credential details to an unrelated second origin if it is instructed to follow redirects.

An HTTP proxy can trick libcurl into sending the origin's credentials, such as Basic passwords or Negotiate/Kerberos tickets, directly to the proxy. This occurs when the proxy responds to a `CONNECT` tunnel request with a 401 `WWW-Authenticate:` status instead of the expected 407 `Proxy-Authenticate:` status.

A use-after-free memory corruption issue exists during HTTP/2 uploads. The flaw occurs when curl mishandles an HTTP/2 `RST STREAM` response received from a server with the reason `HTTP 1 1 REQUIRED` or `REFUSED STREAM`, leading to a use-after-free of a `struct Curl easy` object. A remote attacker controlling a malicious server can exploit this to cause a client crash or, under highly specific conditions involving precise knowledge of the target's architecture, memory layout, and TLS configuration, achieve remote code execution.

When using the wolfSSL backend with CA caching enabled, a flaw exists where the `CURLOPT SSL CTX FUNCTION` callback can be overridden. If this callback replaces the trust store, libcurl may silently reinstall the cached store after the callback returns. This results in a scenario where a certificate trusted by the cached store is incorrectly accepted, even if it was rejected by the store selected via the callback.

A flaw exists where the software incorrectly reuses an HTTP connection setup for a specific hostname when using Negotiate authentication, specifically when the initial request is made with empty credentials. This behavior can lead to a situation where a request from one user is transmitted over a connection previously authenticated by another user.

A logical error in the connection pooling mechanism allows the software to reuse an incorrect connection for Negotiate-authenticated requests. This occurs even when the requests are configured to use different services, potentially leading to a request being sent over a connection authenticated for a different service on the same server.

An issue exists where libcurl may send request data on a new connection before enforcing certificate verification failure. This occurs when a user first connects to a legitimate HTTP/3 server and subsequently connects to an attacker's impostor machine lacking a valid certificate. The leak of sensitive information can happen if a cached SSL session is used (where `CURLOPT SSL SESSIONID CACHE` is enabled) and early data is active (where the `CURLSSLOPT EARLYDATA` bit is set in `CURLOPT SSL OPTIONS`).

When configured to use a `.netrc` file for credentials while simultaneously specifying a URL containing a username but no password (e.g., `https://user@example.com/`), the software may incorrectly retrieve and use the password of a different user defined in the `.netrc` file for that host, provided no match for the specified user exists.

A flaw exists where a new transfer utilizing STARTTLS to upgrade the connection may incorrectly reuse an existing live connection despite a mismatch in the TLS configuration.

The WebSocket component of the libcurl library contains a resource allocation issue. By default, curl automatically responds to WebSocket PING frames. Because the software lacks an upper bound on memory allocation for unacknowledged frames, a remote attacker acting as a malicious server can exhaust all available memory by flooding the client with rapid, sequential PING messages, resulting in a denial of service.

An issue in the QUIC UDP receive function allows a remote malicious HTTP/3 server to cause a denial of service. The helper function fails to count zero-length UDP datagrams toward the per-call packet budget before discarding them, enabling a connected QUIC peer to stream empty datagrams and indefinitely stall the client.

An issue exists in the certificate authentication procedure where the library maintains a connection pool for reusing connections in subsequent transfers. If a handle initially uses the default native CA trust and is later switched to custom CA material, it may continue to trust the native platform store for subsequent transfers using that handle. This could allow a remote attacker to perform data spoofing or gain unauthorized access to protected information.

A use-after-free issue exists in libcurl involving the HTTP/2 stream-dependency tree management. This occurs when an application configures the tree using `CURLOPT STREAM DEPENDS` or `CURLOPT STREAM DEPENDS E`, calls the `curl easy reset()` function, and then terminates the handle via the `curl easy cleanup()` function. During the final cleanup, the library attempts to access and modify an internal structure that was already freed during the reset operation. This flaw may allow a remote attacker to cause a denial of service.