SRI na prática: por que o seu integrity="sha384-…" não bate (o hex do sha384sum não é Base64)
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
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,sha384ousha512), 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 comintegrityfalha.
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ó oade "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 letrasc,a,f,epassam 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)
- Abra o conversor Hex ↔ Base64 em português. Os botões de modo e os rótulos dos campos ainda aparecem em inglês.
- Deixe selecionado o modo Hex to Base64.
- Cole apenas os dígitos do hash no campo Hex String Input (maiúsculas, como as do
Get-FileHash -Algorithm SHA384do PowerShell, também funcionam). - 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
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.