CVE-2026-121481 has a CVSS 3.1 score of 9.8: an input length close to INT_MAX can overflow the output-size calculation in EVP_EncodeBlock() and cause it to write beyond the allocated buffer. The specific risk depends on whether an application can pass it a length that large; simply having OpenSSL installed is not enough.
OpenSSL identifies the flaw as a buffer overflow in its Base64 encoding function. CVE.report's entry attributes the disclosure to OpenSSL and states that no way for an attacker to trigger it has been identified; the case requires the application to pass the function a length close to the limit of a signed integer.
Who should check
CVE.report's entry lists OpenSSL 4.0.0–4.0.4 and 4.1.0–4.1.1 as affected. However, the version alone does not prove exposure: the flaw occurs in EVP_EncodeBlock() when it receives an extremely large input and the encoded-size arithmetic overflows.
The scenario deserves particular attention in applications that call the function directly and calculate or receive the input length from external data. CVE.report notes that OpenSSL's TLS, QUIC, and CMS do not encode buffers of that size; it also says it knows of no practical path through the command-line tools. The decisive point is the code that invokes the API, not generic use of OpenSSL on a machine.
The sources differ in how they present the risk: Tenable shows the critical score of 9.8, while CVE.report lists that score and describes the practical impact as low because no path has been identified and the required size is so large. Tenable also shows a CVSS 2 score of 7.5. The score does not replace analysis of the input path in your application.
Steps to review and reduce the risk
Find calls to EVP_EncodeBlock(). Search your own code and the components you maintain for that function and its wrappers. The proposed fix in the repository also modifies EVP_DecodeBlock() and the base64encode() length calculation in http_client.c, but the flaw described in the CVE entry concerns EVP_EncodeBlock(). Start with the places where the program passes a length to that function.
Trace where each length comes from. For every call, determine whether the size comes from a constant, the actual size of a buffer, or a value that a user can influence. Also check what validation is performed before invoking the function. The relevant condition described by CVE.report is a length close to INT_MAX; do not allow external data to become a length of that magnitude without applying your own limit.
Check the output-buffer calculation. The documentation described in CVE.report expects the caller to allocate 4*((len+2)/3)+1 bytes. Check that the calculation and allocation cannot overflow before calling OpenSSL, and that the resulting size is representable and actually matches the available buffer. The vulnerability itself arises when the encoded-size arithmetic overflows for extreme inputs.
Identify the OpenSSL version in use. Compare the version bundled with or linked by each application against the affected ranges listed by OpenSSL in the CVE record: 4.0.0–4.0.4 and 4.1.0–4.1.1. On systems with dependencies packaged by third parties, also check which library the process actually loads. An affected version is not enough to conclude that the flaw is reachable, but it helps prioritize the code review.
Apply a limit before the call. If a length can approach INT_MAX, reject it before calculating or allocating the output and before invoking EVP_EncodeBlock(). The OpenSSL repository proposes checking for lengths that do not fit in an integer to prevent the overflow. Keep the check in your application, and do not rely on the library to accept inputs outside its preconditions.
Check the status of the upstream fix. The change appears in a GitHub pull request that was still under discussion on November 20, 2026; the initial comment indicated that the advisory was pending. The proposal and its technical decisions changed during review, so do not assume that the patch has been merged or that a particular version contains it. Confirm the status through OpenSSL's official channels before planning an update.
Test the boundaries your program uses. Add tests for the limits your application actually accepts and for rejected inputs, verifying that the function is not called with an invalid length. OpenSSL's pull request mentions new tests and preserving the defined behavior for empty inputs. Do not try to reproduce the case by allocating a buffer close to two gigabytes in production.

Mistakes to avoid
Do not assume that every OpenSSL user is exposed. The technical description requires a direct call with a length close to INT_MAX; CVE.report says that no attacker-controlled path is known and that the application itself must provide a size that large. Prioritize services whose code accepts external lengths and passes them to the function without a limit.
Do not focus only on the 9.8 score. That figure appears in CVSS 3.1, but it does not by itself indicate which application meets the necessary conditions. Nor should you dismiss the issue because the scenario is difficult: if your program handles extreme sizes or accepts unvalidated lengths, review how those values flow through it.
Finally, do not interpret the pull request as a patch that has already been released. The thread records disagreements about how invalid inputs should be handled and shows that the design was still changing; OpenSSL indicated that the advisory was pending. Check the advisory and the fixed version before closing the review.
Sources: GitHub, Tenable, CVE.report