SRI na prática: por que o seu integrity="sha384-…" não bate (o hex do sha384sum não é Base64)

Você coloca um script de CDN com o atributo integrity, abre a página e o console avisa que o recurso foi bloqueado porque o hash não confere. O arquivo é o mesmo, o algoritmo é o mesmo… e mesmo assim não funciona.

Na maioria das vezes o problema não está no arquivo, e sim no formato do hash. Ferramentas como sha384sum mostram o resultado em hexadecimal, mas o Subresource Integrity (SRI) espera esses mesmos bytes em Base64. Neste post vamos ver o formato correto, montar um exemplo do zero e passar pelas armadilhas mais comuns.

O que o navegador espera

Segundo a documentação da MDN sobre Subresource Integrity (consultada em 21/11/2026, https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity):

  • o valor de integrity é uma lista de hashes separados por espaço;
  • cada hash começa com o algoritmo (sha256, sha384 ou sha512), seguido de um hífen e do hash codificado em Base64;
  • se houver hashes de algoritmos diferentes, o navegador usa só os do algoritmo mais forte;
  • para recursos de outra origem, é preciso usar CORS, ou seja, colocar crossorigin="anonymous" na tag e o servidor tem que liberar o acesso. Sem isso, a requisição com integrity falha.

Ou seja, o formato fica assim:

<script src="https://cdn.exemplo.com/ola.js" integrity="sha384-<48 bytes do hash em Base64>" crossorigin="anonymous"></script> 

Hex e Base64: os mesmos 48 bytes, escritos de dois jeitos

Um SHA-384 tem 384 bits, ou seja, 48 bytes. Esses bytes podem ser escritos de duas formas:

  • Hex: 2 caracteres por byte → 48 × 2 = 96 caracteres.
  • Base64: 4 caracteres a cada 3 bytes → 48 ÷ 3 × 4 = 64 caracteres. Como 48 é múltiplo de 3, não sobra = no final.

Então, se o valor depois de sha384- tem 96 caracteres e só usa 0–9 e a–f, você colou o hex. E se tem 128 caracteres, provavelmente você pegou o texto do hex e passou para Base64, que é o erro mais traiçoeiro (falamos dele abaixo).

Exemplo completo (arquivo fictício)

Dados ilustrativos: o arquivo foi criado só para este exemplo.

Arquivo ola.js, salvo em UTF-8 com quebra de linha LF:

console.log("Olá, mundo!"); 

Ele tem 29 bytes: 27 caracteres visíveis, mas o "á" ocupa 2 bytes em UTF-8, e ainda tem o \n final.

1. Hash em hex (o que o sha384sum mostra):

$ sha384sum ola.js 551205d073cff39d26197c1e0aa7e008f2cdcf5aaf37f99b13fe861464888ced7b9308a8fba7521f4b58dd822eb53e15 ola.js 

2. Os mesmos bytes em Base64 (o que o SRI quer):

$ cat ola.js | openssl dgst -sha384 -binary | openssl base64 -A VRIF0HPP850mGXweCqfgCPLNz1qvN/mbE/6GFGSIjO17kwio+6dSH0tY3YIutT4V 

3. Conferindo no Node.js:

const crypto = require("crypto"); const fs = require("fs"); const b64 = crypto.createHash("sha384").update(fs.readFileSync("ola.js")).digest("base64"); console.log("sha384-" + b64); // sha384-VRIF0HPP850mGXweCqfgCPLNz1qvN/mbE/6GFGSIjO17kwio+6dSH0tY3YIutT4V 

Os três caminhos chegam ao mesmo resultado. Note que os primeiros bytes em hex (55 12 05) viram exatamente os quatro primeiros caracteres Base64 (VRIF). E colando os 96 dígitos hex no conversor Hex → Base64 do Mind vs Drive, a saída é a mesma string de 64 caracteres. Rodamos o JavaScript da própria página com esse valor para conferir.

O atributo final fica:

integrity="sha384-VRIF0HPP850mGXweCqfgCPLNz1qvN/mbE/6GFGSIjO17kwio+6dSH0tY3YIutT4V" 

As quatro armadilhas que mais quebram o SRI

1. Base64 do texto hex

# ERRADO: codifica os 96 caracteres ASCII, não os 48 bytes sha384sum ola.js | cut -d' ' -f1 | tr -d '\n' | base64 

O resultado tem 128 caracteres e nunca vai conferir. O hex precisa voltar a ser bytes antes do Base64. É isso que o openssl dgst -binary faz, e também o que um conversor Hex → Base64 faz.

2. O nome do arquivo junto com o hash

O sha384sum imprime hash nome-do-arquivo. A própria MDN alerta: se o nome tiver letras que também são dígitos hex, elas podem entrar na conversão. No nosso teste com o conversor:

  • colando …53e15 ola.js, sobra só o a de "ola" como dígito hex extra, a contagem fica ímpar e a ferramenta mostra erro (Invalid Hex: Length must be even). Pelo menos ela avisa;
  • colando …53e15 cafe.js, as letras c, a, f, e passam como hex válido. Viram 2 bytes a mais e a saída tem 66 caracteres terminando em …tT4Vyv4=. Não aparece erro nenhum, mas o hash está errado.

Regra prática: cole só os 96 dígitos. Se a saída não tiver exatamente 64 caracteres para SHA-384 (44 para SHA-256, 88 para SHA-512), tem algo errado.

3. CRLF × LF

O hash é calculado sobre os bytes, não sobre o "texto". O mesmo ola.js salvo com quebra de linha Windows (CRLF) tem 30 bytes e gera:

sha384-jTt8uNITct6nfMF6IbHT4SOBVATjCBIYAfWD5TzJeAQawThHq2opuqi/akZt2mbJ 

Se o Git, o editor ou o pipeline de deploy converter as quebras de linha depois de você gerar o hash, o navegador vai bloquear o arquivo. Gere o hash do arquivo exatamente como ele será servido.

4. Prefixos 0x e hex "bonitinho"

Hex copiado de debugger costuma vir como 0x55 0x12 0x05…. Em nossos testes, o conversor da página remove o x mas mantém o 0 de cada prefixo. Isso gera erro de tamanho ou, pior, bytes errados sem aviso: 0x48 0x65 0x6c 0x6c vira BIBlBsBs em vez de SGVsbA==. Espaços simples entre os bytes (48 65 6c 6c) funcionam normalmente. Na dúvida, limpe os prefixos antes de colar.

Como usar o conversor (4 passos)

  1. Abra o conversor Hex ↔ Base64 em português. Os botões de modo e os rótulos dos campos ainda aparecem em inglês.
  2. Deixe selecionado o modo Hex to Base64.
  3. Cole apenas os dígitos do hash no campo Hex String Input (maiúsculas, como as do Get-FileHash -Algorithm SHA384 do PowerShell, também funcionam).
  4. Confira se o contador de Base64 Output mostra 64 caracteres, clique em Copiar e coloque sha384- na frente.

Para conferir no sentido inverso, use o modo Base64 to Hex. A saída vem em maiúsculas, com espaço entre os bytes.

A conversão roda no navegador. Mesmo assim, um hash de arquivo público não é segredo. Não cole chaves privadas ou tokens em nenhuma ferramenta online.

Limites do SRI (e deste método)

  • O SRI garante que o arquivo é igual ao que você conferiu. Ele não garante que o arquivo é seguro. Se você gerar o hash de um arquivo já comprometido, o navegador vai aceitar esse arquivo sem reclamar.
  • URLs que mudam de conteúdo sem mudar de endereço (por exemplo, "última versão" de uma biblioteca) vão quebrar a cada atualização. Prefira URLs com versão fixa.
  • Base64 é só uma forma de escrever bytes. Não é criptografia e não esconde nada.

Aviso: a ferramenta citada neste artigo é do Mind vs Drive, a equipe por trás desta conta.

— The Mind vs Drive team