>>FIRST MISSION//LOGS//openssl//one-openssl-bug-three-scores-six-points-apart.MD
[ + ] TARGET_LOCKED200 OK
NOV 21, 2026timer 3 MIN READSYS_TAG: openssl STATUS: VERIFIED_WORKING

One OpenSSL Bug, Three Scores, Six Points Apart

CVE-2026-121481 carries 9.8 from CISA, 3.7 from Red Hat and Low from OpenSSL itself, and the fix is still an unmerged pull request. The patch that survived review aborts your process rather than returning an error, which changes what you are actually deploying.

ENGINE: KERNEL // STABLE
BASE_ARCH: x86_64
HOST: VASTORIGINS.COM
GPG: OKSIG_ID: 0x4EB27DB0

Base64 encoding is one of those functions I stopped thinking about years ago, which is exactly why this one deserves an hour. On 18 November a heap buffer overflow in OpenSSL’s EVP_EncodeBlock() was published as CVE-2026-121481, and within a day it had three official severity numbers, a critical label, and no patch to install.

📊 Three Numbers, One Bug

OpenSSL is the CNA here, meaning it assigned the CVE itself. It filed the bug as CWE-190, integer overflow or wraparound, and rated it Low under its own security policy. That is the vendor’s judgment on its own code.

On 19 November, CISA’s ADP enrichment attached a CVSS 3.1 base score of 9.8, critical, on the vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, and filed the same flaw under CWE-122, heap-based buffer overflow. Red Hat then published a third number, 3.7, on CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L, noting it had been “Lowered from prior Important” because OpenSSL rates the flaw Low with no known attack path.

Three assessments of one function, 6.1 points apart on a ten-point scale. The two CWEs are not even describing the same thing: 190 is the arithmetic, 122 is the memory error the arithmetic causes. And NVD has not adjudicated any of it. Its record reads “Awaiting Analysis,” and the GitHub Advisory Database entry, GHSA-83xj-7xh4-4p7x, is still marked “unreviewed.”

The 9.8 is not a lie, but it is not a measurement of this bug either. Look at the vector: low complexity, no privileges, no user interaction, high impact across confidentiality, integrity and availability. That is the score you get when every impact field is high and nothing downgrades for reachability. It answers “if this were reachable, how bad would it be,” not “is this reachable.” Red Hat’s 3.7 answers the second question, and it is the one I would plan against.

🔍 What the Math Actually Does

The signature is int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int dlen);. There is no parameter for the size of the output buffer t. The function returns the number of bytes it wrote, as an int.

That means the library cannot check whether the caller’s buffer is big enough. It never receives that information. The man page tells the caller to size the output at four bytes for every three bytes of input, plus a NUL terminator, so the security boundary lives in the caller’s arithmetic, not in the encoder.

Base64 expands by roughly a third. If the caller computes that expansion in a signed 32-bit int, the multiplication wraps once the input passes (INT_MAX / 4) * 3, which is 1,610,612,733 bytes, or about 1.5 GiB. Above that line the caller allocates a small buffer while believing it allocated a large one, and the encoder writes the full expanded output into it.

The detail I keep coming back to is that the guard already existed in that file. EVP_EncodeUpdate(), the streaming sibling, contains if (total > INT_MAX) { *outl = 0; return 0; } with the comment “Too much output data!” The one-shot EVP_EncodeBlock() has no equivalent check. Someone thought about this overflow in the incremental path and did not in the single call path.

🧨 The Fix Kills the Process

The patch is pull request 33652, opened on 10 November by Nicky Mouha, before the CVE existed. How it got from there to here is more instructive than the overflow.

The first version returned -1 on invalid inputs: null pointers, negative lengths, lengths whose encoded output would overflow. Tomas Mraz objected, and his reasoning is the kind of thing that only comes from maintaining an API for decades. Third-party callers routinely cast that int return straight to size_t without checking it. Cast -1 and you get SIZE_MAX, the largest possible unsigned value. You would have replaced an overflow in OpenSSL with a worse one in code OpenSSL does not own. Return 0 instead, he asked.

Mouha pointed out that 0 is already a success in both directions. EVP_EncodeBlock() returns 0 for a zero-length input, and EVP_DecodeBlock() returns 0 for input that is only padding. A “0 means error” convention would make two existing success paths ambiguous. Bob Beck argued the reverse, that a failure returning a value defined as success is precisely what the project’s STYLE.md forbids. Meanwhile Norbert went looking for internal callers that ignore the return entirely and found PEM_SignFinal() and NETSCAPE_SPKI_b64_encode().

What survived all of that is an assertion:

OPENSSL_assert(dlen >= 0);
OPENSSL_assert(dlen <= (INT_MAX / 4) * 3);

No new error path, no new return value, no ABI change. The process dies instead. Bob Beck, reviewing a redundant NULL check, put it plainly: “it will eat the NULL and crash. let it.”

I think that is the right call for a library this old and this widely linked, because the alternative was betting on every caller on earth to start checking a return value they have ignored since the 1990s. But be precise about what lands in your dependency tree. An application that passes a negative or oversized length to that function will terminate after this patch. If your service reads a length field off the network and hands it to a single base64 encode, your failure mode changes from “possibly memory corruption” to “certainly a dead process,” and then a supervisor restart.

It is also not settled. A maintainer requested changes on 20 November and wants 0 returned rather than an abort. Backports need separate pull requests. Issue 33812 tracks the fix that actually matters, moving validation into the internal functions where they can report failure to internal callers without touching the public contract.

🎯 Whether Anyone Can Reach It

The CVE record is direct: TLS, QUIC and CMS never encode buffers of that size, an attacker would need a buffer of about two gigabytes in hand first, and the command line tools “cannot practically” be driven there.

Mouha’s pull request says something narrower and more interesting. He documents triggering it through openssl s_client -proxy_pass, supplying an enormous proxy password from an environment variable via the env: prefix, because no shell will accept a multi-gigabyte argument. Paired with the GOST engine, which accepts oversized passwords without truncating them, the client base64-encodes the credential and walks into the overflow.

Both statements come from OpenSSL and neither has been withdrawn. So the primitive is real, the path through the shipped CLI tools is demonstrated, and the impact assessment rests on the argument that nobody has a reason to do this. I would call reachability open rather than closed. For context, EPSS puts exploitation at 0.14 percent, the CVE is not in KEV, and CISA’s own SSVC decision records exploitation as “none.”

🛠️ What This Means For Your Build

The affected range is narrower than a scanner will suggest: 4.0.0 to 4.0.3, and 4.1.0. The 3.5 LTS line, which a lot of production runs, is not in it.

The versions named as fixed do not exist yet. I pulled the download page: the current releases are 4.1.0 from 23 October, 4.0.3 from 29 September, and 3.5.9 from 29 September. There is no 4.1.1 and no 4.0.4. The newest advisory on the site is dated 17 November, the day before this CVE, and covers a different set of bugs; it states that releases containing its fixes are scheduled for 1 December 2026. I also grepped the vulnerabilities index for this CVE and found nothing. There is no OpenSSL advisory for it at all, which is why the PR body says the advisory is still pending.

Two trackers worth reading yourself. Red Hat rates it 3.7 and says only the 4.0 and 4.1 lines are affected upstream. Ubuntu has openssl as “Needs evaluation” on every release it ships, and marks nodejs on 22.04 jammy as “Vulnerable” with a note that the build embeds OpenSSL 1.1.1m. 1.1.1 is outside the range the CNA named. So a scanner will happily report jammy nodejs as exposed to a bug its bundled library predates by a major version. That is the failure mode here: not that the score is too high, but that it propagates to things that are not affected while the actual 4.x builds sit unassessed.

Concretely: grep your tree for EVP_EncodeBlock, check whether any caller casts its return to size_t without testing it, cap the input length before the call, and rewrite any buffer sizing done in int math. That last one is worth doing on every version, patched or not, because it is the part no vendor can fix for you.

🧠 Final Thoughts

Three teams scored one function 6.1 points apart because only one of them was scoring reachability, and the two extremes had no way to score anything else. A CNA that publishes a primitive before an advisory leaves a vacuum, and worst-case arithmetic fills it. The number is not the bug.

Patch when 4.1.1 and 4.0.4 land on 1 December, and read the release notes for the assertion change before you do. Then spend the hour on your own call sites, because that is where the buffer size is decided.

Thanks for reading.

[ SIGNATURE VERIFIED // GPG 0x4EB27DB0 // PROVENANCE SECURE ]
➔ RETURN TO LOGS