CVE-2026-41677

What it actually does

Affected versions of the Rust openssl crate/rust-openssl from 0.9.0 before 0.10.78 fail to validate the length returned by application-provided *_from_pem_callback password callbacks. If a callback reports a password length larger than the buffer it was given, some OpenSSL versions before OpenSSL 3.x can read past the end of that buffer while processing encrypted PEM material. The primary technical effects are out-of-bounds memory read, possible process crash, and limited unintended exposure of adjacent process memory depending on how the application handles parsing errors, logging, or returned data. OpenSSL 3.x is not affected by the underlying over-read behavior.

Why it matters to the business

Applications that parse encrypted PEM keys, certificates, or similar material using affected rust-openssl callback APIs may become unstable or expose small amounts of sensitive process memory under specific conditions. The issue is high severity but has important exploitation preconditions: the vulnerable callback path must be reachable, the application must use an affected crate version with a susceptible OpenSSL version, and the callback must be able to return an oversized length. The CVE is not in CISA KEV, is not known to be used in ransomware campaigns, has no known public exploit maturity, and its EPSS has remained very low and flat, so remediation should be prioritized for internet-facing services, key-management paths, certificate-processing services, and software supply chains rather than treated as evidence of active mass exploitation.

How an attack unfolds

An attacker first identifies software built with rust-openssl versions 0.9.0 through 0.10.77 that uses *_from_pem_callback APIs to load encrypted PEM content. The attacker then supplies or causes the application to process crafted encrypted PEM data through a code path where the password callback can return a length greater than the provided password buffer. In affected combinations using susceptible OpenSSL versions prior to OpenSSL 3.x, OpenSSL trusts that excessive length and reads beyond the callback buffer. Depending on the surrounding application behavior, this may crash the process, cause abnormal PEM parsing failures, or expose adjacent memory indirectly through logs, responses, diagnostics, or application-specific error handling. Exploitation is not a simple unauthenticated remote attack against every rust-openssl user; it depends on how the consuming application wires the callback, what input an attacker can control, and which OpenSSL runtime is in use.

How to fix it

Upgrade the Rust openssl crate/rust-openssl dependency to version 0.10.78 or later. If the application is pinned through Cargo.lock, regenerate and redeploy with the updated lockfile. Where practical, use OpenSSL 3.x because the advisory states OpenSSL 3.x is not affected by this over-read behavior. Review all uses of *_from_pem_callback APIs and ensure callbacks never return a value greater than the length of the provided buffer. Add defensive checks around any application-level password callback, especially where passwords or PEM material are derived from external input. If immediate upgrade is not possible, reduce exposure by disabling untrusted encrypted-PEM upload/parsing paths, avoiding callback-based PEM parsing for untrusted input, validating callback return lengths before invoking OpenSSL, and isolating PEM-processing workloads with least privilege and crash containment.

How to confirm the fix worked

Confirm dependency remediation with software composition analysis and build artifacts: verify Cargo.lock does not contain package name "openssl" with a version lower than 0.10.78 in the affected range, and confirm rebuilt binaries were deployed. Use `cargo tree -i openssl` or equivalent dependency tooling to identify all paths bringing in the openssl crate. Confirm the runtime OpenSSL version with application diagnostics, package metadata, or `openssl version`; OpenSSL 3.x reduces exposure to the described OpenSSL-side over-read behavior, but the Rust crate should still be upgraded. Review source code for uses of functions or methods matching `*_from_pem_callback` and confirm callbacks bound return values to the supplied buffer length. Functional validation should include parsing encrypted PEM inputs with normal and edge-case passwords under memory-safety tooling such as ASan, Valgrind, or sanitizers in CI to confirm no out-of-bounds reads or crashes occur.

Typical attack path

1. Locate an application or service that accepts attacker-controlled PEM, certificate, or encrypted private-key material.
2. Determine or infer that the application is built with rust-openssl/openssl crate versions from 0.9.0 before 0.10.78 and is using an OpenSSL version where the over-read behavior is present, typically pre-OpenSSL 3.x.
3. Reach a code path that uses a *_from_pem_callback API for password-protected PEM parsing.
4. Cause the application-provided password callback to return a length larger than the destination buffer length, either through malformed input, unusual password-handling behavior, plugin/script integration, or an application bug.
5. Trigger PEM parsing so OpenSSL reads past the callback buffer.
6. Observe resulting denial of service, abnormal parsing behavior, or any application-specific leakage through error messages, logs, or responses.

How to detect it

There are no universal network indicators for exploitation because this is a library-level memory over-read that depends on application-specific PEM parsing behavior. To assess prior exploitation, review logs for services that accept PEM, certificate, private-key, CSR, or encrypted-key uploads and correlate malformed submissions with crashes, restarts, segmentation faults, OpenSSL PEM parsing errors, or unusually verbose error responses. Useful sources include application logs, reverse proxy and API gateway logs for PEM-upload endpoints, systemd/journald logs, container restart events, kernel crash logs, core dumps, EDR process crash telemetry, and memory-safety sanitizer reports. Investigate events involving encrypted PEM parsing followed by process termination, `SIGSEGV`, `SIGABRT`, allocator errors, or OpenSSL PEM routines reporting bad decrypt or password-read failures. For forensics, inspect core dumps and crash traces for rust-openssl/OpenSSL PEM functions and application callback frames. Also search source and telemetry for use of callback-based PEM loading functions so monitoring can focus on the applications where exploitation is plausible.

What your security team should do

• Inventory Rust applications and services that depend on the openssl crate/rust-openssl, prioritizing internet-facing services, certificate/key ingestion services, build systems, secret-management workflows, and products that parse user-supplied PEM data.
• Upgrade affected dependencies to openssl crate/rust-openssl 0.10.78 or later and redeploy all statically linked or vendored builds.
• Identify all uses of *_from_pem_callback APIs and require code review for callback length handling before release.
• Prefer OpenSSL 3.x where compatible, while still applying the rust-openssl fix.
• Add SCA policy gates to block openssl crate versions from 0.9.0 through 0.10.77.
• Monitor for unexplained crashes or abnormal PEM parsing errors in services that process encrypted PEM material, especially after malformed or unusual certificate/key submissions.
• Because EPSS is low, flat, and there is no KEV or known ransomware use, schedule broad remediation through normal vulnerability SLAs, but accelerate remediation for exposed PEM-processing components.