CVSS spiegato: leggere e calcolare una stringa vettore

CVSS è il sistema di punteggio dietro la maggior parte dei punteggi di vulnerabilità pubblicati. Vedrai un numero tra 0.0 e 10.0, una parola di gravità come "Critical" e una lunga stringa che sembra un numero di serie. Questo articolo spiega che cosa significa ogni parte, come leggere la stringa campo per campo e come controllare da solo un punteggio pubblicato.

#Che cos'è CVSS

CVSS sta per Common Vulnerability Scoring System. Lo mantiene FIRST, il Forum of Incident Response and Security Teams. La versione corrente è la 4.0, pubblicata alla fine del 2023. La versione 3.1 compare ancora nella maggior parte dei vecchi bollettini di sicurezza e nel database NVD, quindi devi saperle leggere entrambe.

CVSS dà a una falla un punteggio da 0.0 a 10.0. Il punteggio viene dalle proprietà della falla: quanto è difficile raggiungerla, che cosa deve avere prima chi attacca e quanti danni può fare se qualcuno la usa. La maggior parte degli strumenti traduce il numero in una classe di gravità:

Le classi sono le stesse in v3.1 e v4.0. La matematica dietro il numero è diversa.

#Perché conta

I team hanno bisogno di una parola condivisa per la gravità. Un vendor scrive un bollettino di sicurezza, uno scanner segnala un asset, un manager chiede quale patch va applicata per prima, e tutti dovrebbero intendere la stessa cosa con "high". CVSS dà loro una scala comune. La stringa vettore registra anche il ragionamento, così chi legge può controllare se il punteggio si adatta al proprio sistema.

Il punteggio ha dei limiti, e la maggior parte degli errori nasce dall'ignorarli. La sezione su gravità e probabilità tratta il principale.

#I quattro gruppi di metriche

CVSS v4.0 organizza le metriche in quattro gruppi. Per produrre un punteggio serve solo il gruppo Base.

#Base

Le metriche Base descrivono la falla così com'è nel software vulnerabile, senza sapere niente della tua rete. I bollettini di sicurezza le pubblicano quasi sempre. In v4.0 coprono:

• Sfruttabilità: vettore d'attacco (AV), complessità d'attacco (AC), requisiti d'attacco (AT), privilegi richiesti (PR) e interazione utente (UI).
• Impatto sul sistema vulnerabile: riservatezza (VC), integrità (VI) e disponibilità (VA).
• Impatto sui sistemi successivi: riservatezza (SC), integrità (SI) e disponibilità (SA). Descrivono il danno ad altri sistemi che chi attacca può raggiungere dopo che il primo è caduto.

#Threat

Le metriche Threat cambiano nel tempo. La metrica Threat di v4.0 è E, per exploit maturity. Può valere A (attacked, cioè ci sono prove di sfruttamento), P (esiste un proof of concept), U (unreported) o X (not defined, il valore predefinito). Un punteggio con E impostata può differire dal punteggio base, e si sposta quando cambia il quadro delle minacce.

#Environmental

Le metriche Environmental descrivono il tuo deployment. Le metriche di requisito (CR, IR e AR per riservatezza, integrità e disponibilità) dicono quanto conta per te ciascuna proprietà. Le metriche base modificate ti permettono di sovrascrivere un valore base quando la tua configurazione lo cambia. Una falla su una pagina di login esposta su internet e la stessa falla in una VM di laboratorio senza alcuna rotta di rete possono avere lo stesso punteggio base e meritare comunque priorità diverse nel tuo ambiente.

#Supplemental

Le metriche Supplemental aggiungono contesto, come impatto sulla safety, automatizzabilità, sforzo di recupero o urgenza. Non cambiano il punteggio. Aiutano un team a ordinare il lavoro.

La versione 3.1 usa i gruppi Base, Temporal ed Environmental. Non ha un gruppo Supplemental, e le sue metriche Temporal (exploit code maturity, remediation level e report confidence) sono diverse dalla singola metrica E di v4.0.

#Come leggere una stringa vettore

La stringa vettore è la forma compatta delle metriche. Comincia con la versione, poi elenca le metriche come Name:Value, separate da barre. Ogni valore è una sola lettera. Quando conosci le lettere, puoi leggere qualsiasi stringa senza tabella.

#Un esempio v4.0

CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Decodificala campo per campo:

In parole povere: qualcuno in rete può sfruttare la falla senza fare login, senza una configurazione particolare e senza che una vittima faccia niente. L'attacco dà il pieno controllo su riservatezza, integrità e disponibilità del componente vulnerabile, e niente oltre quello. Il calcolatore di FIRST restituisce per questo vettore un punteggio base di 9.3 (Critical). Il laboratorio più avanti mostra come controllarlo.

#Un esempio v3.1

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H

I campi di v3.1 sono simili, con tre differenze. Non c'è il campo AT. I campi di impatto sono C, I e A, senza distinzione tra sistema vulnerabile e sistemi successivi. E compare invece S (scope):

Il campo S spiega gran parte del divario tra un 9.8 e un 10.0 che vedrai più avanti in questo articolo.

#In che cosa v4.0 differisce da v3.1

Le modifiche sono strutturali, quindi leggere un punteggio di una versione come se venisse dall'altra porta a errori.

• Lo scope non c'è più. v3.1 chiedeva se l'impatto attraversava un confine di sicurezza. v4.0 divide l'impatto tra sistema vulnerabile e sistemi successivi, quindi alla stessa domanda rispondono campi diretti.
• Sono stati aggiunti i requisiti d'attacco. AT descrive le condizioni che chi attacca deve soddisfare e che non sono privilegi, come una particolare configurazione o una race window.
• L'interazione utente ha più valori. v4.0 distingue l'interazione passiva (una vittima si limita a visualizzare o renderizzare qualcosa) da quella attiva (una vittima deve cliccare o agire).
• Il gruppo Threat è più semplice. Una sola metrica, E, sostituisce le tre metriche Temporal di v3.1.
• Le metriche Supplemental sono nuove. Portano contesto senza cambiare il punteggio.
• Il punteggio viene da una tabella, oltre che da un calcolo. v3.1 usa una breve formula aritmetica che puoi seguire su una pagina. v4.0 riporta le metriche base su una tabella di lookup e interpola al suo interno, come descrive la specifica. Per v4.0 usa il calcolatore ufficiale o una libreria testata, non un foglio di calcolo scritto da te.

I bollettini di sicurezza continuano a mescolare le versioni. Alcuni pubblicano sia un punteggio v3.1 sia uno v4.0 per la stessa falla, e i due numeri possono differire. Controlla il prefisso prima di confrontare due numeri.

#La gravità non è la probabilità

Questo è il punto che conta di più, e quello che la gente salta. CVSS misura quanto è grave una falla se viene sfruttata. Non ti dice se qualcuno la sfrutterà.

Una falla con un punteggio base Critical può restare per anni senza che nessuno la sfrutti. Una falla Medium può essere sotto attacco attivo questa settimana. CVSS non lo vede. Il gruppo Threat può portare qualche informazione sullo sfruttamento (E impostata ad A, per esempio), ma qualcuno deve comunque impostarla e tenerla aggiornata. Alla domanda sulla probabilità rispondono altre fonti:

• EPSS stima la probabilità che una falla venga sfruttata nei prossimi 30 giorni, sulla base di dati osservati.
• Il catalogo CISA Known Exploited Vulnerabilities elenca le falle per cui esistono prove di sfruttamento reale.

Se devi decidere che cosa correggere per primo, leggi insieme gravità, probabilità ed esposizione. Un punteggio CVSS alto su un sistema che nessuno può raggiungere di solito è meno urgente di un punteggio medio su una pagina di login pubblica con sfruttamento segnalato.

Per le basi su che cos'è una vulnerabilità e su come ottiene un identificatore, leggi che cos'è una vulnerabilità e che cos'è un identificatore CVE.

#Pratica: decodifica un vettore pubblicato e ricalcolalo

Ti servono un terminale e un browser. Il laboratorio usa solo dati pubblici. Tocca l'API pubblica di NVD e il sito di FIRST, e nient'altro.

#Passo 1: preleva il vettore da NVD

L'API di NVD restituisce i punteggi che NVD ha per un CVE. Per CVE-2021-44228, la falla Log4Shell in Apache Log4j, esegui:

curl -s 'https://services.nvd.nist.gov/rest/json/cves/2.0?cveId=CVE-2021-44228' | jq -r '.vulnerabilities[0].cve.metrics | .. | .vectorString? // empty'

Il filtro percorre l'intero oggetto metrics e stampa ogni vectorString che trova. Sulla macchina su cui è stato verificato questo articolo, jq non era installato. Lo stesso percorso è stato fatto con Node 24. Usa questa alternativa se non hai jq:

curl -s 'https://services.nvd.nist.gov/rest/json/cves/2.0?cveId=CVE-2021-44228' -o nvd_44228.json
node -e "const j=JSON.parse(require('fs').readFileSync('nvd_44228.json','utf8'));const out=[];(function walk(n){if(n&&typeof n==='object'){for(const[k,v]of Object.entries(n)){if(k==='vectorString')out.push(v);else walk(v);}}})(j.vulnerabilities[0].cve.metrics);console.log(out.join('\n'));"

Output osservato l'8 novembre 2026:

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
AV:N/AC:M/Au:N/C:C/I:C/A:C

Le prime due righe sono il vettore v3.1 del record di NVD e di un secondo record che NVD elenca. La terza riga è un vettore CVSS v2.0, una scala più vecchia. Per questo laboratorio ignorala. NVD può aggiornare un record, quindi il tuo output può essere diverso da questo.

#Passo 2: decodificalo su carta

Prendi la prima riga e compila una tabella come quelle qui sopra. Scrivi ogni campo e il suo significato prima di aprire un calcolatore. Ti aiutano due domande:

1. Che cosa deve già avere chi attacca? PR:N e UI:N dicono che non serve niente.
2. Quale proprietà va persa? C, I e A sono tutte H, cioè perdita totale di ciascuna.

Il campo che merita una seconda occhiata è S:C. Significa che l'exploit arriva oltre il componente che contiene la falla. Per questo il vettore ottiene un punteggio più alto dello stesso vettore con S:U.

#Passo 3: inseriscilo nel calcolatore

Apri il calcolatore per la versione della tua stringa. Per v3.1, usa https://www.first.org/cvss/calculator/3.1. Per v4.0, usa https://www.first.org/cvss/calculator/4.0. Puoi incollare il vettore dopo il # nell'URL per precompilare il modulo.

Per l'esempio v4.0 visto prima, apri questo link:

https://www.first.org/cvss/calculator/4.0#CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Il calcolatore dovrebbe restituire per questo vettore un punteggio base di 9.3 (Critical). Non l'ho eseguito in un browser mentre scrivevo, quindi considera 9.3 il valore da confermare. Se non torna, confronta ogni lettera del modulo con la tua tabella decodificata.

Per il vettore v3.1 di NVD, apri il calcolatore v3.1 e imposta ogni valore come nella tua tabella. Il punteggio atteso è 10.0. Se il modulo resta vuoto dopo il caricamento della pagina, seleziona i valori a mano, che è già di per sé una verifica utile.

#Passo 4: ricalcola v3.1 con uno script

Per v3.1 la formula base è abbastanza corta da stare in poche righe. Questo script segue la specifica v3.1. Serve a verificare di aver capito e non è fatto per la produzione. Salvalo come cvss31.js:

// CVSS v3.1 base score, following the FIRST v3.1 specification.
function roundup(x) {
  const i = Math.round(x * 100000);
  return i % 10000 === 0 ? i / 100000 : (Math.floor(i / 10000) + 1) / 10;
}
function base(vec) {
  const m = Object.fromEntries(vec.split('/').slice(1).map(p => p.split(':')));
  const S = m.S === 'C';
  const AV = { N: 0.85, A: 0.62, L: 0.55, P: 0.2 }[m.AV];
  const AC = { L: 0.77, H: 0.44 }[m.AC];
  const PR = { N: 0.85, L: S ? 0.68 : 0.62, H: S ? 0.5 : 0.27 }[m.PR];
  const UI = { N: 0.85, R: 0.62 }[m.UI];
  const cia = { H: 0.56, L: 0.22, N: 0 };
  const iss = 1 - (1 - cia[m.C]) * (1 - cia[m.I]) * (1 - cia[m.A]);
  const imp = S ? 7.52 * (iss - 0.029) - 3.25 * Math.pow(iss - 0.02, 15) : 6.42 * iss;
  const expl = 8.22 * AV * AC * PR * UI;
  if (imp <= 0) return 0;
  return S ? roundup(Math.min(1.08 * (imp + expl), 10)) : roundup(Math.min(imp + expl, 10));
}
for (const v of process.argv.slice(2)) console.log(v, '->', base(v).toFixed(1));

Eseguilo sul vettore di NVD e sullo stesso vettore con lo scope impostato a unchanged:

node cvss31.js "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H" "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H"

Output osservato l'8 novembre 2026:

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H -> 10.0
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H -> 9.8

La prima riga corrisponde al punteggio NVD di 10.0. La seconda dà il 9.8 che molti ricordano per questa falla. L'unica modifica è S:U. Quando vedi un punteggio, leggi il suo vettore prima di fidarti del numero.

#Che cosa cercare

Se la tua tabella decodificata, il calcolatore e lo script concordano, sai leggere una stringa CVSS. Se non concordano, trova il campo che differisce. Le cause abituali sono una lettera sbagliata (AV:L significa local, non low), una confusione tra C, I e A, o il confronto di un punteggio v3.1 con uno v4.0 come se venissero dalla stessa scala.

#Errori comuni

• Trattare il punteggio come rischio. Un 10.0 che nessuno può raggiungere è un problema diverso da un 10.0 sul tuo server esposto su internet. Aggiungi i dati su esposizione e sfruttamento.
• Confrontare punteggi tra versioni. I numeri di v3.1 e v4.0 vengono da calcoli diversi. Confronta solo cose omogenee.
• Fermarsi al numero in evidenza. Il vettore dice perché il punteggio è quello. Leggilo.
• Fidarsi di un punteggio senza vettore. Un numero da solo non si può controllare. Preleva il vettore da NVD o dal vendor.
• Modificare un punteggio a mano. Se cambi una lettera, ricalcola. Un numero digitato che non corrisponde al suo vettore è un errore da segnalare.
• Dare per scontato che il valore predefinito descriva il tuo ambiente. Il punteggio base non presume niente sulla tua configurazione. Per questo esistono le metriche Environmental.

#Per andare oltre

Leggi prima le definizioni delle metriche base nella specifica. Sono brevi, e le risposte stanno nella formulazione esatta di ogni valore. Poi decodifica su carta cinque o sei vettori pubblicati prima di controllare ciascuno nel calcolatore. Scegline alcuni con S:C o AT:P e guarda come si sposta il punteggio.

Poi passa allo sfruttamento: che cosa stima EPSS e che cosa registra il catalogo KEV. Quei due rispondono alla domanda che CVSS lascia aperta, cioè se qualcuno stia attaccando questa falla adesso.

#Fonti

• FIRST, CVSS v4.0 Specification Document: https://www.first.org/cvss/v4.0/specification-document
• FIRST, CVSS v3.1 Specification Document: https://www.first.org/cvss/v3.1/specification-document
• FIRST, CVSS v4.0 Calculator: https://www.first.org/cvss/calculator/4.0
• NIST, NVD CVSS information: https://nvd.nist.gov/vuln-metrics/cvss
• NIST, NVD CVE API 2.0 (usata nel laboratorio): https://services.nvd.nist.gov/rest/json/cves/2.0