OpenSSL just disclosed a bug scored 9.8 out of 10. CVE-2026-121481 sits in EVP_EncodeBlock(), and to trigger it you have to Base64-encode about 1.6 GB in a single call. Nobody has shown a way to reach it remotely, and EPSS gives it a 0.3% chance of being exploited in the next month.

The same week, Java4Shell went public in OpenJDK. Put 64 A characters and an = in an HTTP auth header and on newer Intel and AMD servers you can crash the JVM, and in default setups of Jenkins, Jira and Keycloak, run code without logging in. Oracle scored it 8.1.

The gigabyte bug got the higher score. That’s not a mistake in either score. CVSS just answers a different question from the one most of us ask it, which is “how worried should I be?”

What CVSS actually measures

CVSS is run by FIRST, and their own user guide says it plainly: the score “is designed to measure the severity of a vulnerability and should not be used alone to assess risk.” The CVSS 4.0 guide says the same thing again.

Severity and risk sound alike, but they’re different questions. Severity asks how bad it gets if someone exploits the bug. Risk asks whether anyone will, whether they can reach the bug in your setup, and what they get if they do. The bug can’t know any of that about you, so the base score doesn’t either.

CVSS does have extra fields for that context. Version 4.0 calls them Threat and Environmental, and they’re meant to adjust the score. I’ve almost never seen anyone fill them in. The number in your scanner, on the advisory and in the HN title is nearly always the base score on its own.

That base score then gets a label from a fixed table in the spec: Low below 4, Medium up to 6.9, High up to 8.9, and Critical from 9 to 10. That’s where “patch every Critical within 15 days” policies come from, and it’s why those policies spend so much time on the wrong bugs.

Read the vector, not the number

Every score is calculated from a vector string, and the vector is the part worth reading. Here’s the one behind a 9.8:

Attack vectorComplexityPrivilegesUser actionScopeConf.IntegrityAvail.9.8 Criticalthe worst caseAV:NAC:LPR:NUI:NS:UC:HI:HA:H8.1 HighJava4ShellAV:NAC:HPR:NUI:NS:UC:HI:HA:Hnetworklownonenoneunchangedhighhighhighhigh: needs heap grooming,a memory leak and an AVX-512 CPU
Figure 1. A CVSS 3.1 vector, metric by metric. One letter separates the 9.8 worst case from Java4Shell’s 8.1.

Left to right, it says the attack works over the network, needs nothing special, needs no account and no click from a user, and fully breaks confidentiality, integrity and availability. That’s about as bad as CVSS 3.1 gets, which is why you see 9.8 so often.

Java4Shell’s vector from Oracle is AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H. It’s the same string with one letter changed: attack complexity is High instead of Low. That one letter takes it from 9.8 down to 8.1. I can see why Oracle did it. Going from a crash to running code needs heap grooming and a separate memory leak to get past ASLR, and the buggy code only runs on x86-64 CPUs with AVX-512 VBMI. CVSS 3.1 has no field for “only on some CPUs”, so it ends up in attack complexity.

CVSS 4.0 fixed that by adding a field called Attack Requirements for conditions on the target that the attacker can’t control. That’s part of why Calif scored the same bug 9.2 under 4.0. The two versions weigh things differently, so don’t compare a 3.1 score with a 4.0 score as if they were the same scale.

One bug, four scores

The OpenSSL bug shows what happens when different people score the same bug. Look it up on CIRCL’s vulnerability lookup and you get four answers:

LOWMEDIUMHIGHCRITICAL047910GitHub advisoryAC:L · C/I/A high9.8CISA VulnrichmentAC:H · availability high5.9Red HatAC:H · availability low3.7OpenSSL (the CNA)qualitative rating onlyLow · no numberSame patch, same code. EPSS: 0.3% chance of exploitation in the next 30 days.
Figure 2. Four ratings for OpenSSL CVE-2026-121481, as aggregated by CIRCL on November 20. The disagreement is almost entirely about attack complexity and impact.

GitHub’s advisory took the worst case: network attack, low complexity, full compromise, 9.8. CISA’s entry said complexity is high and only availability is at risk, which comes out at 5.9. Red Hat agreed on complexity but called the availability impact low, which gives 3.7. OpenSSL, the people who wrote the code, just called it Low and didn’t give a number. They all looked at the same patch.

This happens all the time. This year the Commerce Department’s Inspector General reviewed the National Vulnerability Database, and its own specialists rescored a random sample of CVEs using NIST’s method. They matched NVD’s score on 8 out of 69, about 12%, according to reporting on the findings. I don’t read that as NVD being bad at its job. It shows how much of a score is one person’s judgment.

Some scores are pessimistic on purpose, too. curl’s Daniel Stenberg fought a 9.8 on CVE-2020-19909, an overflow in a retry delay setting that he called “a silly bug” with no security impact. NVD told him that when it doesn’t have much information, its policy is to “represent the worst-case scenario.” It later proposed 3.3.

Where your number comes from

So before you trust a score, it’s worth knowing who wrote it. There are more possible authors than most people expect.

Vendor (CNA)writes the recordCVE recordcve.orgCISA ADPadds enrichmentNVDskips if CNA scoredGitHub advisoryown scoreDistro advisoryRed Hat, UbuntuYour scannershows one numberevery box can holda different scorerarely says whose
Figure 3. Where a CVSS score can come from. The number in your dashboard is one of these, and it rarely says which.

The CVE record itself is published by a CNA, a CVE Numbering Authority, which is usually the vendor. Oracle scored Java4Shell, and OpenSSL rated its own bug. Vendors know their code best, but they also have every reason to score their own bugs low. CISA adds its own data to CVE records through its ADP program. NVD used to rescore almost everything, but in April NIST said it can’t keep up with a 263% rise in CVEs since 2020. It now skips its own score when the vendor already gave one, and it has stopped working through most of its older backlog. Then GitHub’s advisory database and Linux distros like Red Hat and Ubuntu publish their own scores for the packages they ship, often based on how they build them.

Your scanner picks one of those, sometimes just the highest, and doesn’t tell you which. So before you argue about a number, check whose number it is.

What predicts exploitation

What most of us really want from CVSS is something it was never built to tell us: will this bug actually get exploited? Most won’t. Cyentia and FIRST looked at exploitation in the wild and saw activity against only about 6% of published CVEs. They also found CVSS is a weak predictor of which 6%. If you patch the same number of bugs either way, sorting by CVSS catches 37% of the ones that get exploited. Sorting by EPSS catches 93%.

0%25%50%75%100%CVEs exploited in the wildof all published CVEs~6%Prioritize by CVSSexploited CVEs caught37%Prioritize by EPSSsame effort93%
Figure 4. Most CVEs are never exploited, and CVSS is a weak guide to which ones will be. Data from Cyentia and FIRST; “equal effort” means patching the same number of vulnerabilities.

That’s why I check two other things before I look at the CVSS score.

The first is EPSS, FIRST’s model of how likely a CVE is to be exploited in the next 30 days. It’s recalculated every day for every CVE, and it gives you a probability and a percentile. FIRST suggests reading the probability first. Keep in mind that the numbers run low: 10% sounds small, but it puts a CVE around the 88th percentile, because almost every CVE sits near zero. EPSS also learns from what it sees happening, so it’s slow on brand-new bugs. Three days after disclosure, Java4Shell was at about 0.9%, around the 61st percentile, while people were already scanning for it.

The second is CISA’s Known Exploited Vulnerabilities catalog, or KEV. It’s a list of CVEs that are confirmed to be exploited, and it had 1,484 entries at the end of 2025. If you run something on that list, stop reading and patch it. The catch is that KEV only lists what has already been confirmed. As I write this, Java4Shell isn’t on it, even though GreyNoise has seen exploitation attempts and at least one vendor says it has a working exploit.

I use all three together. CVSS tells me how bad it could be, EPSS how likely it is, and KEV whether it’s already happening.

What you run decides the rest

None of those numbers know anything about your servers, and that’s usually where the real answer is.

For Java4Shell, I’d ask three things. Do we run an affected JDK? Are our servers on CPUs with AVX-512 VBMI, meaning Intel Ice Lake or newer, or AMD Zen 4 or newer? ARM64 machines, including AWS Graviton, use a different code path and aren’t affected. And does any of our services decode Base64 from untrusted input before login? Keycloak and Jenkins do, which is how Calif ran code on them without an account. If all three answers are yes, it’s an emergency, whatever the score says. If you’re all on Graviton, it’s a routine JDK update.

For the OpenSSL bug, the questions knock most people out fast. Are you on OpenSSL 4.0.0 to 4.0.3 or 4.1.0? The 3.x line isn’t listed. Does anything you run encode gigabyte-sized buffers with EVP_EncodeBlock(), or let someone else set the proxy password your OpenSSL client sends? For almost everyone, no. Patch it in your normal update cycle once the fix ships. OpenSSL has releases scheduled for December 1, though the fix was still in review this week.

You could plug those answers into CVSS’s Environmental fields and get a new score. I find it quicker to ask the questions and write the answers down.

A simple way to triage

CISA’s SSVC (Stakeholder-Specific Vulnerability Categorization) works this way. Instead of a score, it walks you through a few questions: is it being exploited, how bad is the impact, can the attack be automated, how much of your stuff runs it, and does it affect public safety. You end up with an action instead of a number: Track, Track*, Attend or Act. Act means fix it now and get leadership involved.

You don’t need CISA’s exact tree. Here’s the version I’d use on a normal engineering team:

Q1Do you run anaffected version?Q2Is the codereachable fromuntrusted input?Q3Exploited,in KEV, or apublic exploit?Q4Pre-auth andautomatable, orEPSS high?Tracknormal cycle,order by CVSSnoNot affectedclose itnoTracknormal updateyesActpatch nowyesAttendthis weekDown arrows show the answer that exits; the arrow to the right is the other answer.
Figure 5. A triage flow for a typical engineering team, loosely based on CISA’s SSVC decision tree. The CVSS score only orders the last queue.

Run this week’s two bugs through it and you get the opposite of what the scores said. Java4Shell, the 8.1, is an Act if you run Keycloak or Jenkins on recent Intel or AMD servers: people are already trying it, it works before login, it’s easy to automate, and attackers can reach it. The OpenSSL bug, the 9.8, is a Track for nearly everyone: nobody is exploiting it, there’s no remote path, and almost no system ever feeds it that much data.

CVSSAffected?Reachable?Exploited?Pre-auth?ActionOpenSSLCVE-2026-1214819.84.0–4.1only~1.6 GB inone callnonoTrackJava4ShellCVE-2026-1149388.1OpenJDK17.0.6+auth headers,AVX-512 CPUsattemptsseenyesActThe higher score goes to the bug you can usually leave for the normal cycle.
Figure 6. This week’s two Base64 bugs, run through the triage flow. For the Java4Shell row, the answers assume you run Keycloak or Jenkins on recent Intel or AMD hardware.

I’m not saying ignore CVSS. It tells you the worst case if everything else goes wrong, and it’s a fine tiebreaker between two bugs that look the same otherwise. It just shouldn’t be the first column you sort by.

The short version