„Critical, CVSS 9.8.” „CVSS 10.0, no account needed.” Security headlines lead with a number, and many teams decide what to patch first by sorting on it. But what does that number measure, how do you read the string of letters behind it, and when does it mislead you? Here’s a practical guide to CVSS for developers.
What is CVSS?
CVSS (Common Vulnerability Scoring System) is an open standard for rating how severe a software vulnerability is, on a scale from 0.0 to 10.0. It’s maintained by FIRST, the Forum of Incident Response and Security Teams. Vendors, security teams and vulnerability databases use it so that „how bad is this bug?” gets the same kind of answer everywhere.
Two versions are in use today. CVSS 3.1 (2019) is still the one you see most often in advisories and scanners. CVSS 4.0 (November 2023) is the current standard and is slowly taking over. Both use the same severity bands:
| Score | Severity |
|---|---|
| 0.0 | None |
| 0.1 – 3.9 | Low |
| 4.0 – 6.9 | Medium |
| 7.0 – 8.9 | High |
| 9.0 – 10.0 | Critical |
The score is never the whole story. Every CVSS score comes from a vector string: a short code that records the answer to each question the standard asks. If you learn to read the vector, you know why a bug is critical, not just that it is.
How to read a CVSS vector
Here is a CVSS 4.0 vector for a serious bug:
CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:HIt scores 9.5 (Critical). Each XX:Y pair is one metric and its value. The first group describes how an attacker gets in:
| Metric | Value here | What it means |
|---|---|---|
AV Attack Vector | N Network | Can be attacked remotely, over the internet. Other values: Adjacent (same network), Local, Physical. |
AC Attack Complexity | H High | The attacker has to beat a security measure or win a race condition. Not easy, but possible. |
AT Attack Requirements | N None | No special setup on the target is needed. New in 4.0. |
PR Privileges Required | N None | The attacker doesn’t need an account. |
UI User Interaction | N None | Nobody has to click a link or open a file. |
The second group describes what the attacker can do once in, measured as Confidentiality (read data), Integrity (change data) and Availability (take things down):
| Metric | Value here | What it means |
|---|---|---|
VC VI VA | H High | Full impact on the vulnerable system itself: the attacker can read, change or crash everything. |
SC SI SA | H High | Full impact on subsequent systems: the damage spreads to other systems that trust or depend on it. New in 4.0. |
Read as a sentence: anyone on the internet, without an account and without anyone clicking anything, can take full control of this system and of what’s connected to it, although the attack takes some effort. That’s why it’s critical. If attack complexity were Low (AC:L), the same vector would score a full 10.0.
You don’t need to calculate scores by hand. Paste a vector into FIRST’s official calculator or the CVE Tools calculator (opens with this example), and change one value at a time to see what moves the score.
What changed from CVSS 3.1 to 4.0
- Scope is gone. 3.1 had a confusing
S:U/S:C(Unchanged/Changed) flag. 4.0 replaces it with separate impact on the vulnerable system and on subsequent systems. - Attack Requirements (
AT) is new. It separates „the attacker must beat a defence” (complexity) from „the target must be set up in a certain way” (requirements). - User Interaction has three levels: None, Passive (the user just visits a page) and Active (the user must click, install or run something).
- Scores are not comparable across versions. The classic 3.1 „no account, full takeover” vector (
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) is the familiar 9.8. Always check which version a score uses before you compare two bugs.
Base, Threat, Environmental: one bug, three scores
The number in a headline is almost always the Base score. It describes the bug in the worst case, the same for everyone. CVSS 4.0 has more metric groups that adjust it to reality:
- Threat: is anyone actually exploiting it?
E:A(attacks reported),E:P(a public proof of concept exists) orE:U(nothing known). - Environmental: how does it look in your setup? How important is the data on this system, and is the system exposed to the internet or isolated?
- Supplemental: extra information that doesn’t change the score, such as whether the attack can be automated.
Here’s what that does to our example:
| Same bug, different context | Added to the vector | CVSS 4.0 score |
|---|---|---|
| Base score (the headline) | none | 9.5 Critical |
| Attackers are already using it | E:A | 9.5 Critical |
| A public proof of concept exists | E:P | 9.0 Critical |
| No known exploit | E:U | 8.4 High |
| No known exploit, on a system with low-value data | E:U/CR:L/IR:L/AR:L | 6.9 Medium |
Same code, same bug: anywhere from Critical to Medium. The vendor can only publish the Base score, because they don’t know your systems. The rest is your job.
Why CVSS matters
- It’s the common language. CVE records, GitHub security advisories,
npm audit, Dependabot, Trivy, Snyk and most scanners show a CVSS score or a severity based on it. - It drives automation. Rules like „fail the build on High or Critical” or „patch Critical within 7 days” are usually built on CVSS.
- It’s part of compliance. Audits, security questionnaires and customer contracts often set patch deadlines by CVSS severity.
- The vector explains the bug fast.
AV:N/PR:N/UI:Ntells you in a second that this one can be attacked from the internet by anyone, which is often all you need to know to act today.
Where CVSS misleads you
- Severity is not risk. CVSS rates how bad a bug could be. It doesn’t say how likely you are to be attacked. Most vulnerabilities, even critical ones, are never exploited in practice.
- Different sources give different scores. The vendor, the NVD, GitHub and Linux distributions score bugs separately and sometimes disagree a lot, because they assume different configurations. The same CVE can be Critical in one database and Low in another.
- Base scores assume the worst case. A bug in a feature you don’t use, or on a server that isn’t reachable from the internet, still carries its full headline score.
- Not everyone trusts it. In January 2025 the curl project stopped using CVSS altogether, arguing that the scores it was given didn’t match the real impact of its bugs.
What to check besides the score
Two free sources answer the question CVSS doesn’t: is this actually being attacked?
- EPSS (Exploit Prediction Scoring System), also from FIRST, estimates the probability that a CVE will be exploited in the next 30 days. A 9.8 with an EPSS of 0.1% and a 7.5 with an EPSS of 90% call for very different urgency.
- CISA KEV (Known Exploited Vulnerabilities) is a list of CVEs with confirmed attacks in the wild. If a CVE is on it, patch it first, whatever its CVSS score.
A 5-step checklist for your next CVE alert
- Do we run it? Check the affected product and versions against your dependencies, images and servers.
- Read the vector, not just the number.
AV:N+PR:N+UI:Nmeans anyone on the internet can try. Check the CVSS version too. - Is it being exploited? Look it up in CISA KEV and check its EPSS score.
- Is it reachable in our setup? Is the vulnerable feature enabled? Is the system exposed to the internet? What data is on it?
- Decide and record why. Patch now, schedule it or accept the risk, and write the reason down for the next audit.
If your CI pipeline fails builds on CVSS alone, consider adding the KEV list and an EPSS threshold. You’ll block fewer harmless builds and catch the bugs that matter sooner.
Drowning in scanner alerts, or want help setting up a patching process that makes sense for your systems? Talk to the Fireup team.








