Generador de hash SRI

¿Qué es Subresource Integrity?

Cuando una página carga un script del servidor de otro (una CDN, un proveedor de analítica, un servicio de fuentes) le está dando su confianza entera. Los bytes que vuelvan se ejecutan con todos los privilegios de tu página. Si ese servidor se ve comprometido, o simplemente sirve algo distinto un día, tus visitantes lo ejecutan.

Subresource Integrity es el arreglo. Pones un hash criptográfico del archivo que esperas en un atributo integrity de la etiqueta script o link. El navegador descarga el archivo, lo hashea y se niega a ejecutarlo si el hash no coincide. Una CDN comprometida ahora te rompe la página en vez de apoderarse de ella, que es un fallo mucho mejor.

El atributo tiene la forma sha384- seguido de una cadena en base64. Esta página calcula esa cadena a partir de un archivo que elijas o de un texto que pegues, te da la etiqueta completa para copiar y, en el otro modo, coge un atributo que ya tengas y te dice si un navegador lo aceptaría.

Cómo usarlo

1. Dale los bytes exactos del archivo. Elige el archivo local o pega su contenido. El hash es de los bytes tal y como se sirven, así que un solo salto de línea al final cambia la respuesta: por eso generar desde una copia que tu editor ha reformateado no va a coincidir.
2. Elige el algoritmo y copia la etiqueta, no solo el valor. sha384 es lo habitual y lo que usan los ejemplos de la propia norma. La etiqueta generada incluye crossorigin, que no es opcional para un archivo de otro origen.
3. O cambia a Comprobar para probar un atributo que ya tienes. Pega el atributo integrity junto al archivo y obtienes un veredicto, el algoritmo que el navegador consultaría de verdad y la lista de las expresiones que se ignoraron.

Un segundo algoritmo sustituye al primero, no lo respalda

Esta es la regla sobre la que gira la página, y casi nadie la conoce. Cuando un atributo integrity lista varias expresiones de hash, el navegador no las comprueba todas ni acepta una coincidencia con cualquiera de ellas. La norma dice que elige la función de hash más fuerte de la lista y usa solo esa, descartando todas las más débiles antes de comparar nada. El orden es fijo: sha256 es más débil que sha384, que es más débil que sha512.

La consecuencia es afilada. Si pones un sha256 correcto y un sha512 mal tecleado, tu archivo se bloquea: el hash correcto se tira sin leerlo. Si pones un sha256 mal tecleado y un sha384 correcto, tu archivo carga perfectamente y el hash roto nunca importó. Añadir un segundo algoritmo parece defensa en profundidad y no lo es en absoluto; es una sustitución, y traslada en silencio toda tu confianza al que sea más fuerte.

Hay un caso en el que varios hashes sí significan cualquiera de estos, y es el útil: varias expresiones con el mismo algoritmo. Así es como permites dos versiones válidas de un archivo durante un despliegue, y el navegador aceptará una coincidencia con cualquiera. Así que sha384-A sha384-B es una disyuntiva real, y sha256-A sha512-B no lo es.

Cuando compruebas aquí un atributo, todo lo que esa regla descarte se lista aparte, porque la regla es invisible en el atributo y un veredicto sin ella sería un misterio.

Otras dos cosas que lo rompen en silencio

La primera es el crossorigin que falta. Las peticiones a otro origen que llevan integrity están obligadas a usar CORS, así que una etiqueta script que apunta a una CDN con atributo integrity y sin crossorigin no carga en absoluto, y el fallo se ve exactamente igual que un hash equivocado, lo que manda a la gente a recalcular un valor que estaba bien desde el principio. Todas las etiquetas que genera esta página incluyen crossorigin="anonymous". También implica que la propia CDN tiene que enviar cabeceras CORS permisivas; si no lo hace, no puedes usar SRI con ella.

La segunda es cómo se calcula el valor. La norma dice que hay que aplicar el algoritmo de hash a los bytes y después codificar el resultado en base64: base64 del digest crudo. Muchísimos intentos caseros hashean primero a una cadena hexadecimal y codifican eso, lo que produce un valor que parece correcto y no coincide jamás. Las longitudes lo delatan: un digest sha384 son 48 bytes y se codifica en 64 caracteres base64, mientras que base64 de su forma hexadecimal de 96 caracteres son 128. El generador enseña los dos uno al lado del otro para que la diferencia se vea en vez de afirmarse.

Una más, menos dramática: un navegador que no reconozca un algoritmo ignora esa expresión en lugar de rechazar el archivo. Es deliberado, y es lo que te permite añadir hoy un algoritmo futuro sin romper nada, pero también significa que un atributo lleno de algoritmos que nadie soporta no protege absolutamente nada.

Límites honestos

Esta página no puede descargar una URL por ti. Un navegador no tiene permiso para leer desde un script un archivo de otro origen salvo que ese servidor dé permiso con CORS, la misma regla que hace obligatorio el crossorigin de la etiqueta. Así que eliges el archivo local o pegas el contenido, y cualquier herramienta que parezca descargarte la URL lo está haciendo en un servidor, lo que significa confiarle esa descarga. Hacerlo en local es a la vez la opción honesta y la privada.

El hash cubre los bytes y nada más. No te dice que el archivo sea seguro, ni que esté bien escrito, ni que venga de quien crees: solo que no ha cambiado desde que tomaste el hash. Si hasheas un archivo comprometido, SRI te garantiza fielmente el archivo comprometido.

También te ata a una versión. Cualquier actualización del archivo, incluida una corrección de seguridad que publique el proveedor, fallará la comprobación hasta que regeneres el valor. Ese es el trato que hace SRI, y por eso encaja mucho mejor con URLs versionadas que con un latest flotante.

Por último, integrity se aplica a scripts y hojas de estilo. No es un mecanismo general para imágenes, fuentes o peticiones fetch, así que una etiqueta generada aquí va en un elemento script o link y en ningún otro sitio.

¿Por qué es gratis?

Porque no cuesta nada mantenerlo. El hasheo ocurre en tu navegador con la Web Crypto API que ya está ahí; el archivo que elijas no sale de tu máquina, no se sube nada y ningún servidor lo ve.

Ni cuenta, ni registro, ni nada reservado. Las reglas salen de la propia norma de Subresource Integrity, y las comprobaciones que las verifican usan los digest de ejemplo que publica la norma, contrastados con una implementación distinta.