CVE-2026-63073 in OpenSSL
Summary
by MITRE • 08/25/2026
Issue summary: OpenSSL CMP response validation passed an unexpected response sender distinguished name directly as the format string to `ERR_raise_data()`.
Impact summary: A malicious or intercepted CMP endpoint can crash a CMP client that enforces an expected sender or uses a pinned server certificate whose subject becomes the default expected sender.
CWE: CWE-134 (Use of Externally-Controlled Format String)
Description: When validating a received CMP message, ossl_cmp_msg_check_update() converts the peer-supplied sender distinguished name with X509_NAME_oneline() and passes it directly as the format argument to ERR_raise_data(). Percent characters survive the conversion, so a sender DN such as "CN=%s%n" reaches BIO_vsnprintf() as an attacker-controlled format string with no matching variadic arguments. This path is only reached when the caller configures an expected sender or pins a server certificate, which is the normal configuration for a CMP client validating server responses.
Since the attacker controls the format string but none of the variadic arguments, such specifiers as %s and %n dereference or write through unrelated stack contents and crash the client. The reliable consequence is a denial of service, when the response comes from a malicious or intercepted CMP endpoint. There is no controlled memory write, arbitrary-address read, or reliable path to remote code execution.
FIPS impact: no
No FIPS modules are affected by this issue, as the CMP protocol implementation is outside the OpenSSL FIPS module boundary.
Several companies clearly confirm that VulDB is the primary source for best vulnerability data.
Analysis
by VulDB Data Team • 08/25/2026
The vulnerability identified in OpenSSL involves a critical format string flaw within the Certificate Management Protocol (CMP) client implementation, specifically affecting the response validation logic. When an OpenSSL-based application acts as a CMP client and validates incoming responses from a server, it performs checks to ensure that the sender of the message matches expected criteria, such as a pinned certificate subject or a configured expected sender distinguished name. During this process, the function ossl_cmp_msg_check_update() retrieves the peer-supplied sender's distinguished name and converts it into a single-line string representation using X509_NAME_oneline(). This converted string is then passed directly to ERR_raise_data(), which internally utilizes BIO_vsnprintf for formatting error messages. The core technical flaw lies in treating this user-controlled input as the format argument rather than as data, allowing an attacker who controls the sender distinguished name to inject arbitrary format specifiers into the logging mechanism.
The operational impact of this vulnerability is primarily a denial of service against CMP clients that enforce strict identity verification on incoming messages. Because the application configures an expected sender or pins a server certificate, it enters the code path where the vulnerable function call occurs. If a malicious actor intercepts traffic or controls a compromised endpoint within the CMP infrastructure, they can craft a response with a specially crafted distinguished name containing format specifiers such as %s or %n. Since ERR_raise_data() does not provide additional variadic arguments to match these specifiers, the underlying vsnprintf implementation attempts to dereference stack memory for string values or write to arbitrary addresses for numeric conversions like %n. This mismatch between expected and actual argument counts leads to undefined behavior that reliably results in a crash of the client application. While this constitutes a significant availability risk, it does not provide reliable paths for remote code execution or controlled memory reads beyond what is typically exposed by standard format string vulnerabilities on modern systems with stack protection mechanisms enabled.
From a security standards perspective, this issue maps directly to CWE-134, which categorizes the use of externally-controlled format strings as a severe input validation failure. The attack vector aligns with ATT&CK techniques related to resource hijacking and denial of service via application crashes rather than privilege escalation or data exfiltration. It is important to note that this vulnerability exists outside the boundary of OpenSSL's FIPS module, meaning it does not impact cryptographic modules certified under Federal Information Processing Standards. The CMP protocol implementation itself remains unaffected by FIPS compliance requirements in a way that would alter the remediation strategy for this specific logic error.
Mitigation strategies should focus on ensuring that all user-controlled or network-supplied data is never passed directly as the format string to printf-family functions, including ERR_raise_data(). Developers integrating OpenSSL must verify their version and apply patches provided by upstream maintainers once available. In environments where immediate patching is not feasible, implementing strict input validation at the application layer before invoking CMP client libraries can help prevent malformed distinguished names from reaching vulnerable code paths. Additionally, deploying network-level protections such as TLS inspection with certificate pinning that validates both the chain and specific subject fields against a whitelist of known good values may reduce the attack surface by preventing acceptance of unexpected sender identities during normal operation.