CVSS explicado: como ler e calcular uma vector string

O CVSS é o sistema de pontuação por trás da maioria das notas publicadas de vulnerabilidades. Você vai ver um número entre 0.0 e 10.0, uma palavra de severidade como "Critical" e uma string longa que parece um número de série. Este artigo explica o que cada parte significa, como ler a string campo a campo e como conferir uma nota publicada por conta própria.

#O que é o CVSS

CVSS é a sigla de Common Vulnerability Scoring System. Quem mantém o padrão é a FIRST, o Forum of Incident Response and Security Teams. A versão atual é a 4.0, publicada no fim de 2023. A versão 3.1 ainda aparece na maioria dos avisos antigos e no banco da NVD, então você precisa saber ler as duas.

O CVSS dá a uma falha uma nota de 0.0 a 10.0. A nota vem das propriedades da falha: o quão difícil é chegar até ela, o que o atacante precisa ter antes e quanto dano a falha causa se alguém a usar. A maioria das ferramentas converte o número em uma classificação:

As classificações são iguais na v3.1 e na v4.0. A conta por trás do número é diferente.

#Por que isso importa

As equipes precisam de uma linguagem comum para severidade. O fornecedor escreve o aviso, um scanner marca um ativo, o gerente pergunta qual correção vai primeiro, e todos deveriam entender a mesma coisa quando dizem "high". O CVSS oferece essa escala comum. A vector string também registra o raciocínio, então quem lê pode conferir se a nota faz sentido para o seu ambiente.

A nota tem limites, e a maioria dos erros vem de ignorá-los. A seção sobre severidade e probabilidade trata do principal.

#Os quatro grupos de métricas

O CVSS v4.0 organiza as métricas em quatro grupos. Só o grupo base é necessário para gerar uma nota.

#Base

As métricas base descrevem a falha como ela existe no software vulnerável, sem saber nada da sua rede. Os avisos quase sempre publicam essas métricas. Na v4.0 elas cobrem:

• Exploração: vetor de ataque (AV), complexidade do ataque (AC), requisitos de ataque (AT), privilégios necessários (PR) e interação do usuário (UI).
• Impacto no sistema vulnerável: confidencialidade (VC), integridade (VI) e disponibilidade (VA).
• Impacto em sistemas subsequentes: confidencialidade (SC), integridade (SI) e disponibilidade (SA). Descrevem o dano a outros sistemas que o atacante alcança depois de tomar o primeiro.

#Ameaça

As métricas de ameaça mudam com o tempo. A métrica de ameaça da v4.0 é a E, de exploit maturity (maturidade do exploit). Ela pode ser A (atacada, ou seja, há evidência de exploração), P (existe prova de conceito), U (não reportada) ou X (não definida, que é o padrão). Uma nota com E preenchido pode ser diferente da nota base, e ela muda quando o cenário de ameaça muda.

#Ambiental

As métricas ambientais descrevem o seu próprio ambiente. As métricas de requisito (CR, IR e AR, para confidencialidade, integridade e disponibilidade) dizem o quanto cada propriedade importa para você. As métricas base modificadas permitem substituir um valor base quando a sua configuração muda esse valor. Uma falha numa página de login exposta na internet e a mesma falha numa VM de laboratório sem rota para a rede podem ter a mesma nota base e ainda merecer prioridades diferentes no seu ambiente.

#Suplementar

As métricas suplementares acrescentam contexto, como impacto na segurança física, possibilidade de automação, esforço de recuperação ou urgência. Elas não alteram a nota. Servem para a equipe ordenar o trabalho.

A versão 3.1 usa os grupos Base, Temporal e Ambiental. Ela não tem grupo suplementar, e as métricas temporais (maturidade do código de exploração, nível de remediação e confiança do relatório) são diferentes da métrica E única da v4.0.

#Como ler uma vector string

A vector string é a forma compacta das métricas. Ela começa com a versão e depois lista cada métrica como Nome:Valor, separadas por barras. Cada valor é uma única letra. Quando você conhece as letras, consegue ler qualquer string sem consultar uma tabela.

#Um exemplo da 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

Decodifique campo a campo:

Em palavras simples: alguém na rede pode explorar isso sem fazer login, sem uma configuração especial e sem que a vítima precise fazer nada. O ataque dá controle total sobre a confidencialidade, a integridade e a disponibilidade do componente vulnerável, e nada além dele. A calculadora da FIRST devolve nota base 9.3 (Critical) para esse vetor. O laboratório abaixo mostra como conferir.

#Um exemplo da v3.1

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

Os campos da v3.1 são parecidos, com três diferenças. Não existe o campo AT. Os campos de impacto são C, I e A, sem divisão entre sistema vulnerável e sistemas subsequentes. E aparece o S (escopo):

O campo S explica a maior parte da diferença entre 9.8 e 10.0 que aparece mais adiante neste artigo.

#Como a v4.0 difere da v3.1

As mudanças são estruturais, então ler a nota de uma versão como se fosse da outra gera erros.

• O escopo sumiu. A v3.1 perguntava se o impacto atravessava uma fronteira de segurança. A v4.0 separa o impacto entre o sistema vulnerável e os sistemas subsequentes, então a mesma pergunta é respondida com campos diretos.
• Foram acrescentados os requisitos de ataque. O AT registra condições que o atacante precisa cumprir e que não são privilégios, como uma configuração específica ou uma janela de corrida.
• A interação do usuário tem mais valores. A v4.0 separa a interação passiva (a vítima apenas visualiza ou renderiza algo) da ativa (a vítima precisa clicar ou agir).
• O grupo de ameaça ficou mais simples. Uma métrica, E, substitui as três métricas temporais da v3.1.
• As métricas suplementares são novas. Elas trazem contexto sem alterar a nota.
• A nota é consultada numa tabela, não só calculada. A v3.1 usa uma fórmula aritmética curta que você consegue seguir numa página. A v4.0 associa as métricas base a uma tabela de consulta e interpola dentro dela, como descreve a especificação. Para a v4.0, use a calculadora oficial ou uma biblioteca testada, e não uma planilha feita por você.

Os avisos ainda misturam versões. Alguns publicam a nota da v3.1 e a da v4.0 para a mesma falha, e os dois números podem ser diferentes. Confira o prefixo antes de comparar dois números.

#Severidade não é probabilidade

Este é o ponto mais importante, e o que mais gente pula. O CVSS mede quão grave uma falha é se ela for explorada. Ele não diz se alguém vai explorá-la.

Uma falha com nota base Critical pode ficar sem exploração por anos. Uma falha Medium pode estar sob ataque ativo nesta semana. O CVSS não enxerga isso. O grupo de ameaça pode carregar alguma informação de exploração (E com valor A, por exemplo), mas alguém ainda precisa preenchê-lo e mantê-lo atualizado. Outras fontes respondem à pergunta de probabilidade:

• O EPSS estima a probabilidade de uma falha ser explorada nos próximos 30 dias, com base em dados observados.
• O catálogo Known Exploited Vulnerabilities, da CISA, lista falhas com evidência de exploração em campo.

Se você precisa decidir o que corrigir primeiro, leia severidade, probabilidade e exposição juntas. Uma nota alta do CVSS num sistema que ninguém consegue alcançar costuma ser menos urgente do que uma nota média numa página de login pública com exploração relatada.

Para o básico sobre o que é uma vulnerabilidade e como ela recebe um identificador, leia o que é uma vulnerabilidade e o que é um identificador CVE.

#Mão na massa: decodificar um vetor publicado e recalcular

Você precisa de um terminal e de um navegador. O laboratório usa apenas dados públicos. Ele acessa a API pública da NVD e o site da FIRST, e mais nada.

#Passo 1: buscar o vetor na NVD

A API da NVD devolve as notas que a NVD guarda para um CVE. Para o CVE-2021-44228, a falha Log4Shell do Apache Log4j, rode:

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

O filtro percorre todo o objeto metrics e imprime cada vectorString que encontra. Na máquina onde este artigo foi conferido, o jq não estava instalado. A mesma varredura foi feita com o Node 24. Use este caminho alternativo se não tiver o 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'));"

Saída observada em 8 de novembro 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

As duas primeiras linhas são o vetor v3.1 do próprio registro da NVD e de um segundo registro que a NVD lista. A terceira linha é um vetor CVSS v2.0, uma escala mais antiga. Ignore-a neste laboratório. A NVD pode atualizar o registro, então sua saída pode ser diferente desta.

#Passo 2: decodificar no papel

Pegue a primeira linha e preencha uma tabela como as acima. Anote cada campo e o seu significado antes de abrir a calculadora. Duas perguntas ajudam:

1. O que o atacante já precisa ter? PR:N e UI:N dizem que nada é exigido.
2. Qual propriedade se perde? C, I e A são todas H, o que significa perda total de cada uma.

O campo que merece uma segunda olhada é S:C. Ele significa que a exploração alcança além do componente que contém a falha. Por isso este vetor tem nota maior do que o mesmo vetor com S:U.

#Passo 3: colocar na calculadora

Abra a calculadora da versão que aparece na sua string. Para a v3.1, use https://www.first.org/cvss/calculator/3.1. Para a v4.0, use https://www.first.org/cvss/calculator/4.0. Você pode colar o vetor depois do # na URL para preencher o formulário.

Para o exemplo v4.0 de antes, abra este 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

A calculadora deve devolver nota base 9.3 (Critical) para esse vetor. Não executei isso num navegador ao escrever o texto, então trate o 9.3 como o valor a confirmar. Se não bater, compare cada letra do formulário com a sua tabela decodificada.

Para o vetor v3.1 da NVD, abra a calculadora v3.1 e ajuste cada valor para bater com a sua tabela. A nota esperada é 10.0. Se o formulário continuar vazio depois que a página carregar, selecione os valores manualmente, o que já é uma boa verificação.

#Passo 4: recalcular a v3.1 com um script

Para a v3.1, a fórmula base cabe em poucas linhas. Este script segue a especificação da v3.1. Ele serve para conferir o seu entendimento, não para produção. Salve 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));

Rode no vetor da NVD e no mesmo vetor com o escopo voltando a inalterado:

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"

Saída observada em 8 de novembro 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

A primeira linha bate com a nota 10.0 da NVD. A segunda mostra o 9.8 que muita gente lembra para essa falha. A única mudança é S:U. Quando você vir uma nota, leia o vetor antes de confiar no número.

#O que observar

Se a sua tabela decodificada, a calculadora e o script concordam, você já sabe ler uma string CVSS. Se discordam, encontre o campo que difere. As causas comuns são uma letra errada (AV:L quer dizer local, não baixa), trocar C, I e A, ou comparar uma nota v3.1 com uma v4.0 como se as duas estivessem na mesma escala.

#Erros comuns

• Tratar a nota como risco. Um 10.0 que ninguém alcança é um problema diferente de um 10.0 no seu servidor exposto na internet. Acrescente dados de exposição e de exploração.
• Comparar notas entre versões. Os números da v3.1 e da v4.0 vêm de contas diferentes. Compare coisas da mesma espécie.
• Parar no número principal. O vetor diz por que a nota é aquela. Leia o vetor.
• Confiar numa nota sem o vetor. Um número solto não pode ser conferido. Busque o vetor na NVD ou no fornecedor.
• Editar a nota à mão. Se você muda uma letra, recalcule. Um número digitado que não bate com o vetor é um erro a ser reportado.
• Supor que o padrão descreve o seu ambiente. A nota base não assume nada sobre a sua configuração. As métricas ambientais existem por isso.

#Como ir além

Leia primeiro as definições das métricas base na especificação. São curtas, e a redação exata de cada valor é onde estão as respostas. Depois decodifique cinco ou seis vetores publicados no papel antes de conferir cada um na calculadora. Escolha alguns com S:C ou AT:P e veja como a nota se move.

Depois disso, leia sobre o lado da exploração: o que o EPSS estima e o que o catálogo KEV registra. As duas respondem à pergunta que o CVSS deixa em aberto, que é se alguém está atacando essa falha agora.

#Fontes

• 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, informações do NVD sobre CVSS: https://nvd.nist.gov/vuln-metrics/cvss
• NIST, NVD CVE API 2.0 (usada no laboratório): https://services.nvd.nist.gov/rest/json/cves/2.0