CVE-2026-41898: Rust-openssl Buffer Overflow Vulnerability

CVE-2026-41898 Overview

CVE-2026-41898 is a buffer over-read vulnerability affecting rust-openssl, which provides OpenSSL bindings for the Rust programming language. The vulnerability exists in the FFI (Foreign Function Interface) trampolines behind several SSL context builder callback functions, where user closure return values were passed directly to OpenSSL without proper validation against the buffer boundaries.

Critical Impact
This vulnerability can lead to buffer overflows and other unintended consequences when the user closure returns a length value that exceeds the actual buffer size, potentially allowing attackers to read beyond buffer boundaries in network-facing TLS applications.

Affected Products

rust-openssl versions 0.9.24 through 0.10.77
Applications using SslContextBuilder::set_psk_client_callback
Applications using set_psk_server_callback, set_cookie_generate_cb, or set_stateless_cookie_generate_cb

Discovery Timeline

2026-04-24 - CVE CVE-2026-41898 published to NVD
2026-04-28 - Last updated in NVD database

Technical Details for CVE-2026-41898

Vulnerability Analysis

The vulnerability resides in the FFI trampoline implementation within rust-openssl's callback handling mechanism. The affected functions—SslContextBuilder::set_psk_client_callback, set_psk_server_callback, set_cookie_generate_cb, and set_stateless_cookie_generate_cb—failed to validate the usize return value from user-provided closures before passing it to the underlying OpenSSL library.

When a user closure returns a length value that exceeds the size of the &mut [u8] buffer provided to it, OpenSSL would trust this value and potentially read beyond the allocated buffer boundaries. This represents a classic buffer over-read condition (CWE-126) where memory beyond the intended buffer can be accessed.

Root Cause

The root cause is insufficient bounds checking in the FFI trampoline code. The original implementation directly cast and forwarded the closure's returned usize value to OpenSSL without comparing it against the actual capacity of the mutable byte slice (psk_sl) that was handed to the closure. This trust of user-supplied length values violates fundamental memory safety principles.

Attack Vector

An attacker could potentially exploit this vulnerability through network-based attacks targeting applications that use the affected PSK (Pre-Shared Key) or cookie callback functionality in TLS connections. The network attack vector requires no user interaction and no prior privileges, though some preparation is needed to successfully exploit the vulnerability. Successful exploitation could lead to information disclosure by reading sensitive data from memory locations beyond the intended buffer.

rust

// Security patch demonstrating the fix in openssl/src/ssl/callbacks.rs
// Source: https://github.com/rust-openssl/rust-openssl/commit/1d109020d98fff2fb2e45c39a373af3dff99b24c

         let identity_sl = util::from_raw_parts_mut(identity as *mut u8, max_identity_len as usize);
         #[allow(clippy::unnecessary_cast)]
         let psk_sl = util::from_raw_parts_mut(psk as *mut u8, max_psk_len as usize);
+        let psk_cap = psk_sl.len();
         match (*callback)(ssl, hint, identity_sl, psk_sl) {
-            Ok(psk_len) => psk_len as u32,
+            Ok(psk_len) if psk_len <= psk_cap => psk_len as u32,
+            Ok(_) => 0,
             Err(e) => {
                 e.put();
                 0

The patch adds explicit bounds checking by storing the buffer capacity in psk_cap and validating that the returned psk_len does not exceed this capacity before passing it to OpenSSL. If the returned length is invalid, the function safely returns 0 instead.

Detection Methods for CVE-2026-41898

Indicators of Compromise

Unexpected application crashes or memory corruption errors in Rust applications using OpenSSL bindings
Anomalous TLS handshake failures, particularly those involving PSK authentication
Memory access violations or segmentation faults in production environments running affected rust-openssl versions
Unusual network traffic patterns during TLS session establishment

Detection Strategies

Audit Cargo.toml and Cargo.lock files for rust-openssl dependencies between versions 0.9.24 and 0.10.77
Use cargo audit to scan for known vulnerabilities in Rust dependencies
Monitor application logs for OpenSSL-related errors or callback failures
Implement runtime monitoring for memory safety violations in Rust applications

Monitoring Recommendations

Deploy SentinelOne Singularity to detect and respond to memory corruption exploitation attempts
Enable detailed logging for TLS handshake operations in affected applications
Set up alerts for applications using the affected callback functions experiencing unexpected terminations
Monitor network traffic for unusual PSK authentication patterns or cookie handling anomalies

How to Mitigate CVE-2026-41898

Immediate Actions Required

Upgrade rust-openssl to version 0.10.78 or later immediately
Review application code for usage of set_psk_client_callback, set_psk_server_callback, set_cookie_generate_cb, or set_stateless_cookie_generate_cb
Ensure all closure implementations return length values within the bounds of the provided buffer
Run cargo update to pull in the patched version if using semantic versioning constraints

Patch Information

The vulnerability has been fixed in rust-openssl version 0.10.78. The patch is available through the following resources:

Workarounds

If immediate upgrade is not possible, manually validate that callback closures never return a length exceeding the buffer size
Consider temporarily disabling PSK authentication if not strictly required
Implement additional application-level bounds checking before returning from affected callbacks
Monitor applications closely for any signs of exploitation while preparing for the upgrade

bash

# Update rust-openssl to the patched version
cargo update -p openssl

# Verify the installed version
cargo tree -p openssl | grep openssl

# Run security audit to check for vulnerabilities
cargo audit