Stanislav Fort

A logic flaw in the curl command line tool prevents SSH host verification options from being applied when a connection is established via a redirect. Specifically, if the initial request is HTTPS and the server returns a `Location: sftp://example.com` redirect while using `--location` and `--proto-redir +sftp`, the subsequent SFTP connection ignores the user's requested verification methods. This affects the application of the `--knownhosts`, `--hostpubsha256`, and `--hostpubmd5` options.

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 authenticated HTTPS origin can provide an HSTS `max-age` value that is accepted by the parser but fails during subsequent time serialization. On 64-bit systems, extreme `max-age` values can result in an absolute expiry that exceeds calendar time structure bounds while remaining within standard time integer limits. During the cache saving process, the original HSTS file is truncated before a temporary replacement is written. If serialization fails, the temporary file is deleted, resulting in an empty or partial cache. This data loss occurs silently, and the application exits successfully without indicating an error.

An issue exists during the HSTS cache import process where importing a parent HSTS entry with the `includeSubDomains` flag before a longer-lived child entry causes the child entry to be silently dropped. When the parent entry eventually expires, the valid HSTS policy for the child is lost, which leads the software to issue unencrypted HTTP requests instead of upgrading them to HTTPS.

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.

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.

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.

A remote HTTP server can set a cookie that is accepted and written to a Netscape cookie jar but cannot be reloaded. When curl is subsequently invoked using the same path for the `--cookie` and `--cookie-jar` parameters, the application fails before establishing a connection. During the cleanup procedure, curl replaces the cookie jar with an empty file, which results in the deletion of cookies for unrelated domains.

Setting `CURLOPT AWS SIGV4` to NULL fails to disable SigV4 authentication as expected and documented. Consequently, a subsequent transfer using the same handle continues to send the `Authorization: AWS4-HMAC-SHA256` header to the next specified URL, which leads to the leakage of state information.

When libpsl support is enabled, the software fails to enforce the Public Suffix List boundary check while processing a `Set-Cookie` header. This occurs when the `Domain` attribute explicitly matches an origin host that is a public suffix, such as `co.uk`. Instead of treating it as a strict host-only cookie, the system saves it with a wildcard domain scope (`.co.uk`). This leads to the cookie being incorrectly included in subsequent outbound requests or HTTP redirects to arbitrary sibling subdomains under the same public suffix, such as `attacker.co.uk`.

A heap-use-after-free occurs when using libcurl's multi interface with OpenSSL 3 provider configurations. The issue arises because libcurl attaches an allocated library context to the easy handle's state and passes it to OpenSSL without acquiring an ownership reference. If the easy handle is destroyed prematurely, the context is freed while the active connection retains a dangling pointer, which can be triggered during subsequent I/O or post-handshake operations.

An issue exists where libcurl fails to enforce public key pinning when `CURLOPT PINNEDPUBLICKEY` is used in conjunction with options that disable standard peer verification, specifically `CURLOPT SSL VERIFYPEER = 0` and `CURLOPT SSL VERIFYHOST = 0`. This allows unauthenticated connections to succeed without a presented server certificate, bypassing the pinning check.

A flaw in libcurl causes the software to incorrectly reuse an existing HTTPS connection setup for a specific hostname, even if a different Native CA Store setting (`CURLSSLOPT NATIVE CA`) is used compared to when the connection was originally established. The Native CA Store is a mechanism that allows curl to use the operating system's built-in certificate store to verify the authenticity of SSL/TLS certificates.

A flaw exists where using a horizontal tab (ASCII code 9) instead of a space (ASCII code 32) immediately before the `Secure` attribute in a `Set-Cookie:` header causes the software to store the cookie without the Secure flag. This may result in the cookie being transmitted over plaintext HTTP during subsequent requests to the same host.

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.

The RTSP handler in the `libalias` library rewrites outgoing packets into a fixed-length stack buffer without verifying if the rewritten data fits within the buffer or if the result fits back into the original packet. A remote attacker sending specially crafted RTSP traffic from inside a NAT gateway using `libalias` can trigger a stack buffer overflow. This may lead to remote code execution within the kernel when using `ipfw(4)` NAT, or within the `natd(8)` process, which typically operates with root privileges.

Name of the Vulnerable Software and Affected Versions OpenSSL FIPS Module version 3.6 Description Applications utilizing AES-CFB128 encryption or decryption on systems equipped with AVX-512 and VAES support may experience an out-of-bounds read of up to 15 bytes when handling partial cipher blocks. This can lead to a denial of service if the input buffer is at a memory page boundary and the subsequent page is unmapped. The issue occurs only when processing partial blocks and on x86-64 systems with AVX-512 and VAES instruction support. Recommendations At the moment, there is no information about a newer version that contains a fix for this vulnerability.

The software contains a path traversal issue in the Remote Access Server routing for the authenticated endpoint ''/download''. The `file` query parameter is combined into a filesystem path without proper validation, potentially allowing a network-based attacker to request files outside the intended directory. The impact is limited by Android’s security features, typically restricting access to app-internal and app-specific external storage.

ESF-IDF, the Espressif Internet of Things (IOT) Development Framework, contains a flaw in the `avrc vendor msg()` function within the BlueDroid AVRCP stack. The function validates the allocated buffer size using `AVRC MIN CMD LEN` (20 bytes), but the fixed header data written before the vendor payload exceeds this value, totaling 29 bytes before `p msg->p vendor data` is copied. This discrepancy can lead to an out-of-bounds write when `vendor len` approaches the buffer limit, potentially causing memory corruption, crashes, or undefined behavior. The overflow may be larger when assertions are disabled.