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:
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:
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.
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%.
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:
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.
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
- CVSS measures how bad a bug could be, not how likely it is to hurt you. FIRST says so itself.
- The number is a summary. Read the vector string behind it.
- The vendor, CISA, NVD, GitHub and your distro can all give the same bug different scores. Check whose score you’re looking at.
- Don’t compare a CVSS 3.1 score with a 4.0 score.
- Only about 6% of CVEs get exploited. EPSS predicts which ones much better than CVSS does, and KEV tells you which ones already are.
- What you run decides the rest: the version, the hardware, and whether the bug is reachable.
- Sort by exploitation and reachability first. Use CVSS to break ties.