Temario Lección 73 de 156 · Terceros en tu propio sitio
Terceros en tu propio sitio

Subresource Integrity

Por qué importa Cuando incrustas https://cdn.example/lib.js, confías en quien controle ese servidor hoy y todos los días que vengan. Si lo hackean, o el archivo cambia sin avisar, tus visitantes ejecutan el código nuevo en tu sitio. Subresource Integrity permite al navegador rechazar cualquier versión que no aprobaste.

Piensa en el precinto de seguridad de un bote de medicinas. Compruebas el precinto antes de tragarte nada. Si está roto, no te lo tomas, lo haya puesto quien lo haya puesto en la estantería.

Subresource Integrity (SRI): un atributo integrity en una etiqueta <script> o <link rel="stylesheet"> que contiene un hash del archivo exacto que esperas. El navegador calcula el hash de lo que descarga y se niega a usar el archivo si los hashes no coinciden.

Hash: una función que convierte cualquier dato en una huella corta de tamaño fijo. Los mismos bytes siempre dan la misma huella; cambia un byte y la huella cambia por completo. SHA-384 es el hash que más se usa con SRI.

Cómo es la etiqueta

<script src="https://cdn.example/lib.js"
        integrity="sha384-iht3RcshTShmtRmXjSLQ8CjUTiVO41jHRJzgK44j1lSJHvfC4YAeuY4ZOoMtzhi5"
        crossorigin="anonymous"></script>

El valor es el nombre del algoritmo, un guion, y luego el hash escrito en Base64 (una forma de escribir bytes con letras, dígitos, + y /). La parte crossorigin="anonymous" hace falta para los archivos de otro sitio: el navegador los descarga sin cookies y el servidor debe permitirlo con una cabecera Access-Control-Allow-Origin; si no, la comprobación no puede hacerse y el archivo se bloquea. SRI funciona en todos los navegadores principales (comprobado en octubre de 2026).

Calcular uno en Python

import base64, hashlib
data = b"console.log('hi')"
digest = hashlib.sha384(data).digest()          # 48 raw bytes
print("sha384-" + base64.b64encode(digest).decode("ascii"))

hashlib.new(name, data) hace lo mismo con cualquier algoritmo indicado por su nombre, como "sha256" o "sha512". Fíjate en .digest() (los bytes en bruto, lo que quiere SRI) frente a .hexdigest() (texto hexadecimal, que aquí sería incorrecto).

Cómo lo comprueba el navegador

  1. Divide el atributo por los espacios. Puedes enumerar varios hashes, por ejemplo mientras cambias de versión de un archivo.
  2. Quédate solo con los trozos con un algoritmo que conozca: sha256, sha384, sha512. Ignora el resto. (Un trozo puede terminar en ?options; quita esa parte.)
  3. Si no queda nada utilizable, no hace ninguna comprobación y usa el archivo. Una errata como sha385-... desactiva por tanto la protección sin avisar. Prueba siempre que un hash equivocado bloquea de verdad el archivo.
  4. Si no, toma el algoritmo más fuerte que haya (sha512 gana a sha384, que gana a sha256) y mira solo los trozos con ese algoritmo. Si alguno coincide con el hash del archivo, el archivo se usa; si no coincide ninguno, se bloquea.

Una idea equivocada muy común: "SRI mantiene el archivo en privado". No oculta nada, y el tercero sigue viendo la petición. SRI solo garantiza que el código es el código que aprobaste. Tampoco puede funcionar con archivos que cambian todo el rato, como un script de anuncios; para esos, la respuesta honesta suele ser no incrustarlos.

En otros lenguajes
# Shell (OpenSSL)
openssl dgst -sha384 -binary lib.js | openssl base64 -A
// JavaScript (Node)
const crypto = require("crypto");
const sri = "sha384-" + crypto.createHash("sha384").update(fs.readFileSync("lib.js")).digest("base64");
// Go
sum := sha512.Sum384(data)
sri := "sha384-" + base64.StdEncoding.EncodeToString(sum[:])
// PHP
$sri = 'sha384-' . base64_encode(hash('sha384', $data, true));
// C#
var sri = "sha384-" + Convert.ToBase64String(SHA384.HashData(data));

Los empaquetadores pueden añadir SRI por ti (por ejemplo el plugin webpack-subresource-integrity).

Resumen

  • SRI fija un script o una hoja de estilo incrustados a los bytes exactos que aprobaste.
  • El valor es algorithm-Base64(hash), y los archivos de otros sitios necesitan además crossorigin="anonymous".
  • El navegador solo usa el algoritmo más fuerte de la lista, y un atributo sin nada utilizable significa que no se comprueba nada.
Tu turno

Escribe tres funciones:

  1. sri_hash(data, algorithm="sha384"): data son bytes. Devuelve el valor SRI: el nombre del algoritmo, un guion y el Base64 del resumen en bruto (usa hashlib.new(algorithm, data).digest() y base64.b64encode).
  2. verify_sri(data, integrity): comprueba data como lo hace un navegador. Divide integrity por los espacios en blanco; quédate con los trozos cuya parte anterior al primer - es sha256, sha384 o sha512 y cuyo valor no está vacío, quitando todo lo que va desde un ? en adelante. Si no te quedas con ninguno, devuelve True (sin comprobación). Si no, usa solo el algoritmo más fuerte que haya y devuelve True si alguno de sus valores coincide con el hash de los datos en ese algoritmo, y si no False.
  3. script_tag(url, data): devuelve exactamente <script src="URL" integrity="VALUE" crossorigin="anonymous"></script> con el valor sha384 de data.
Imprime al final la etiqueta de la biblioteca de práctica. Las pruebas usan datos aleatorios.

¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección

Este ejercicio se abre pronto

Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.