CVSS explicado: cómo leer y calcular una vector string

CVSS es el sistema de puntuación detrás de la mayoría de las puntuaciones de vulnerabilidades que se publican. Vas a ver un número entre 0.0 y 10.0, una palabra de severidad como "Critical" y una cadena larga que parece un número de serie. Este artículo explica qué significa cada parte, cómo leer la cadena campo por campo y cómo comprobar por tu cuenta una puntuación publicada.

#Qué es CVSS

CVSS son las siglas de Common Vulnerability Scoring System. Lo mantiene FIRST, el Forum of Incident Response and Security Teams. La versión actual es la 4.0, publicada a finales de 2023. La versión 3.1 sigue apareciendo en la mayoría de los avisos antiguos y en la base de datos de la NVD, así que conviene saber leer las dos.

CVSS asigna a una falla una puntuación de 0.0 a 10.0. La puntuación sale de las propiedades de la falla: qué tan difícil es llegar a ella, qué necesita el atacante antes de empezar y cuánto daño puede causar si alguien la usa. La mayoría de las herramientas convierten el número en una calificación:

Las calificaciones son las mismas en la v3.1 y en la v4.0. La cuenta que hay detrás del número sí cambia.

#Por qué importa

Los equipos necesitan una forma común de hablar de la severidad. El proveedor publica un aviso, un escáner marca un activo, un gerente pregunta qué parche va primero, y todos deberían entender lo mismo cuando dicen "high". CVSS ofrece esa escala común. La vector string también registra el razonamiento, así que quien lee puede comprobar si la puntuación encaja con su propio sistema.

La puntuación tiene límites, y la mayoría de los errores vienen de ignorarlos. La sección sobre severidad y probabilidad trata el principal.

#Los cuatro grupos de métricas

CVSS v4.0 organiza sus métricas en cuatro grupos. Solo el grupo base es necesario para obtener una puntuación.

#Base

Las métricas base describen la falla tal como existe en el software vulnerable, sin conocer tu red. Los avisos casi siempre las publican. En la v4.0 cubren:

• Explotabilidad: vector de ataque (AV), complejidad del ataque (AC), requisitos del ataque (AT), privilegios requeridos (PR) e interacción del usuario (UI).
• Impacto en el sistema vulnerable: confidencialidad (VC), integridad (VI) y disponibilidad (VA).
• Impacto en sistemas subsiguientes: confidencialidad (SC), integridad (SI) y disponibilidad (SA). Describen el daño a otros sistemas que el atacante alcanza después de tomar el primero.

#Amenaza

Las métricas de amenaza cambian con el tiempo. La métrica de amenaza de la v4.0 es la E, de exploit maturity (madurez del exploit). Puede ser A (atacada, es decir, hay evidencia de explotación), P (existe una prueba de concepto), U (no reportada) o X (no definida, que es el valor por defecto). Una puntuación con E definida puede diferir de la puntuación base, y cambia cuando cambia el panorama de amenazas.

#Ambiental

Las métricas ambientales describen tu propio despliegue. Las métricas de requisito (CR, IR y AR, para confidencialidad, integridad y disponibilidad) indican cuánto te importa cada propiedad. Las métricas base modificadas te permiten sustituir un valor base cuando tu configuración lo cambia. Una falla en una página de login expuesta a internet y la misma falla en una VM de laboratorio sin ruta a la red pueden compartir la puntuación base y, aun así, merecer prioridades distintas en tu entorno.

#Suplementario

Las métricas suplementarias añaden contexto, como el impacto en la seguridad física, la posibilidad de automatizar, el esfuerzo de recuperación o la urgencia. No cambian la puntuación. Ayudan al equipo a ordenar el trabajo.

La versión 3.1 usa los grupos Base, Temporal y Ambiental. No tiene grupo suplementario, y sus métricas temporales (madurez del código de explotación, nivel de remediación y confianza del informe) son distintas de la métrica E única de la v4.0.

#Cómo leer una vector string

La vector string es la forma compacta de las métricas. Empieza con la versión y luego lista cada métrica como Nombre:Valor, separadas por barras. Cada valor es una sola letra. Cuando conoces las letras, puedes leer cualquier cadena sin una tabla.

#Un ejemplo de 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

Decodifícala campo por campo:

En palabras simples: alguien en la red puede explotar esto sin iniciar sesión, sin una configuración especial y sin que la víctima tenga que hacer nada. El ataque da control total sobre la confidencialidad, la integridad y la disponibilidad del componente vulnerable, y nada más allá de él. La calculadora de FIRST devuelve una puntuación base de 9.3 (Critical) para este vector. El laboratorio de más abajo muestra cómo comprobarlo.

#Un ejemplo de v3.1

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

Los campos de la v3.1 son parecidos, con tres diferencias. No existe el campo AT. Los campos de impacto son C, I y A, sin separar el sistema vulnerable de los sistemas subsiguientes. Y aparece S (alcance) en su lugar:

El campo S explica buena parte de la diferencia entre 9.8 y 10.0 que aparece más adelante en este artículo.

#Cómo cambia la v4.0 respecto de la v3.1

Los cambios son estructurales, así que leer la puntuación de una versión como si viniera de la otra provoca errores.

• El alcance desapareció. La v3.1 preguntaba si el impacto cruzaba un límite de seguridad. La v4.0 separa el impacto entre el sistema vulnerable y los sistemas subsiguientes, así que la misma pregunta se responde con campos directos.
• Se añadieron los requisitos del ataque. AT recoge condiciones que el atacante debe cumplir y que no son privilegios, como una configuración concreta o una ventana de carrera.
• La interacción del usuario tiene más valores. La v4.0 distingue la interacción pasiva (la víctima solo ve o procesa algo) de la activa (la víctima tiene que hacer clic o actuar).
• El grupo de amenaza es más simple. Una métrica, E, sustituye a las tres métricas temporales de la v3.1.
• Las métricas suplementarias son nuevas. Aportan contexto sin cambiar la puntuación.
• La puntuación se consulta en una tabla, no solo se calcula. La v3.1 usa una fórmula aritmética corta que puedes seguir en una página. La v4.0 asocia las métricas base con una tabla de consulta e interpola dentro de ella, como describe su especificación. Para la v4.0, usa la calculadora oficial o una biblioteca probada, no una hoja de cálculo que hayas hecho tú.

Los avisos siguen mezclando versiones. Algunos publican la puntuación de la v3.1 y la de la v4.0 para la misma falla, y los dos números pueden diferir. Revisa el prefijo antes de comparar dos números.

#Severidad no es probabilidad

Este es el punto más importante, y el que más gente se salta. CVSS mide qué tan grave es una falla si se explota. No te dice si alguien la va a explotar.

Una falla con puntuación base Critical puede quedar sin explotar durante años. Una falla Medium puede estar bajo ataque activo esta semana. CVSS no lo ve. El grupo de amenaza puede llevar algo de información de explotación (E con valor A, por ejemplo), pero alguien tiene que definirlo y mantenerlo al día. Otras fuentes responden a la pregunta de probabilidad:

• EPSS estima la probabilidad de que una falla se explote en los próximos 30 días, a partir de datos observados.
• El catálogo Known Exploited Vulnerabilities de CISA enumera fallas con evidencia de explotación en el mundo real.

Si necesitas decidir qué parchear primero, lee severidad, probabilidad y exposición juntas. Una puntuación CVSS alta en un sistema al que nadie puede llegar suele ser menos urgente que una puntuación media en una página de login pública con explotación reportada.

Para los conceptos básicos sobre qué es una vulnerabilidad y cómo recibe un identificador, lee qué es una vulnerabilidad y qué es un identificador CVE.

#Práctica: decodifica un vector publicado y recalcúlalo

Necesitas una terminal y un navegador. El laboratorio usa solo datos públicos. Consulta la API pública de la NVD y el sitio de FIRST, y nada más.

#Paso 1: obtén el vector desde la NVD

La API de la NVD devuelve las puntuaciones que la NVD guarda para un CVE. Para el CVE-2021-44228, la falla Log4Shell de Apache Log4j, ejecuta:

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

El filtro recorre todo el objeto metrics e imprime cada vectorString que encuentra. En la máquina donde se comprobó este artículo, jq no estaba instalado. El mismo recorrido se ejecutó con Node 24. Usa esta alternativa si no tienes 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'));"

Salida observada el 8 de noviembre de 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

Las dos primeras líneas son el vector v3.1 del propio registro de la NVD y de un segundo registro que la NVD también lista. La tercera línea es un vector CVSS v2.0, una escala más antigua. Ignórala en este laboratorio. La NVD puede actualizar el registro, así que tu salida podría ser distinta.

#Paso 2: decodifica en papel

Toma la primera línea y completa una tabla como las de arriba. Anota cada campo y su significado antes de abrir la calculadora. Dos preguntas ayudan:

1. ¿Qué debe tener ya el atacante? PR:N y UI:N dicen que no se requiere nada.
2. ¿Qué propiedad se pierde? C, I y A son todas H, lo que significa pérdida total de cada una.

El campo que merece una segunda mirada es S:C. Significa que la explotación llega más allá del componente que contiene la falla. Por eso este vector puntúa más alto que el mismo vector con S:U.

#Paso 3: introdúcelo en la calculadora

Abre la calculadora de la versión que aparece en tu cadena. Para la v3.1, usa https://www.first.org/cvss/calculator/3.1. Para la v4.0, usa https://www.first.org/cvss/calculator/4.0. Puedes pegar el vector después del # de la URL para rellenar el formulario.

Para el ejemplo de v4.0 de antes, abre este enlace:

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

La calculadora debería devolver una puntuación base de 9.3 (Critical) para este vector. No lo ejecuté en un navegador al escribir el texto, así que toma el 9.3 como el valor que debes confirmar. Si no coincide, compara cada letra del formulario con tu tabla decodificada.

Para el vector v3.1 de la NVD, abre la calculadora v3.1 y ajusta cada valor para que coincida con tu tabla. La puntuación esperada es 10.0. Si el formulario queda vacío después de cargar la página, selecciona los valores a mano, lo que ya es una buena comprobación por sí misma.

#Paso 4: recalcula la v3.1 con un script

Para la v3.1, la fórmula base cabe en unas pocas líneas. Este script sigue la especificación de la v3.1. Sirve para comprobar tu comprensión, no para producción. Guárdalo como 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));

Ejecútalo con el vector de la NVD y con el mismo vector con el alcance vuelto a sin cambio:

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"

Salida observada el 8 de noviembre de 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 primera línea coincide con la puntuación 10.0 de la NVD. La segunda muestra el 9.8 que mucha gente recuerda para esta falla. El único cambio es S:U. Cuando veas una puntuación, lee su vector antes de fiarte del número.

#Qué revisar

Si tu tabla decodificada, la calculadora y el script coinciden, ya sabes leer una cadena CVSS. Si no coinciden, busca el campo que difiere. Las causas habituales son una letra equivocada (AV:L significa local, no baja), confundir C, I y A, o comparar una puntuación v3.1 con una v4.0 como si ambas estuvieran en la misma escala.

#Errores comunes

• Tratar la puntuación como riesgo. Un 10.0 al que nadie puede llegar es un problema distinto de un 10.0 en tu servidor expuesto a internet. Añade datos de exposición y de explotación.
• Comparar puntuaciones entre versiones. Los números de la v3.1 y de la v4.0 salen de cuentas distintas. Compara cosas de la misma clase.
• Quedarse en el número principal. El vector dice por qué la puntuación es la que es. Léelo.
• Confiar en una puntuación sin su vector. Un número suelto no se puede comprobar. Busca el vector en la NVD o en el proveedor.
• Editar la puntuación a mano. Si cambias una letra, recalcula. Un número escrito que no coincide con su vector es un error que hay que reportar.
• Suponer que el valor por defecto describe tu entorno. La puntuación base no asume nada de tu configuración. Para eso existen las métricas ambientales.

#Cómo seguir avanzando

Lee primero las definiciones de las métricas base en la especificación. Son cortas, y la redacción exacta de cada valor es donde están las respuestas. Luego decodifica en papel cinco o seis vectores publicados antes de comprobar cada uno en la calculadora. Elige algunos con S:C o AT:P y observa cómo se mueve la puntuación.

Después, lee sobre el lado de la explotación: qué estima EPSS y qué registra el catálogo KEV. Esas dos fuentes responden a la pregunta que CVSS deja abierta, que es si alguien está atacando esta falla ahora mismo.

#Fuentes

• 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, información de CVSS de la NVD: https://nvd.nist.gov/vuln-metrics/cvss
• NIST, NVD CVE API 2.0 (usada en el laboratorio): https://services.nvd.nist.gov/rest/json/cves/2.0