# política de seguridad de contenido

## Qué es

Content Security Policy, o política de seguridad de contenido, es un conjunto de reglas que un sitio web entrega al navegador sobre lo que sus páginas pueden ejecutar, obtener y enviar, y que el navegador hace cumplir en nombre del sitio. Casi siempre se abrevia como CSP. El sitio envía las reglas en una cabecera de respuesta `Content-Security-Policy` o las escribe en un elemento `meta` de la página, y desde ese momento se rechaza antes de cargarlo cualquier script, hoja de estilos, imagen, fuente, marco o conexión que las reglas no permitan.

Una política es una cadena breve de directivas separadas por puntos y coma. Cada directiva identifica un tipo de recurso o comportamiento y las fuentes que acepta. Una política estricta tiene este aspecto, con una directiva por línea para facilitar la lectura, aunque en la transmisión sea un único valor de cabecera:

```text
default-src 'self';
script-src 'nonce-q8Zt3VwR1mKx7NpL2cYfJA==' 'strict-dynamic';
object-src 'none';
base-uri 'none';
form-action 'self';
frame-ancestors 'none'
```

El vocabulario es reducido. `'self'` significa el origen de la propia página. Un host como `https://static.example.com` o un esquema como `https:` amplían ese alcance. `'none'` no permite nada. Un nonce es un valor aleatorio que el servidor genera para una respuesta y escribe tanto en la política como en cada elemento de script que avala. Un hash es el resumen criptográfico del texto exacto de un script en línea, para que pueda ejecutarse ese script y ningún otro. Dos palabras clave, `'unsafe-inline'` y `'unsafe-eval'`, vuelven a desactivar protecciones, y sus nombres son una advertencia acertada.

`default-src` es la regla de respaldo para las directivas de obtención que una política omite, como `script-src`, `style-src`, `img-src` y `connect-src`. Solo es un respaldo para ellas. Las directivas que gobiernan el comportamiento en lugar de la obtención de recursos, entre ellas `base-uri`, `form-action` y `frame-ancestors`, quedan sin restricciones salvo que se escriban expresamente.

Una política también puede funcionar en modo de observación. Si se envía como `Content-Security-Policy-Report-Only`, no bloquea nada y, en su lugar, notifica cada infracción a un endpoint identificado con `report-to`, que utiliza la Reporting API del navegador. La directiva anterior, `report-uri`, está obsoleta en favor de esta. El texto actual del estándar es Content Security Policy Level 3, un borrador de trabajo del W3C elaborado por Web Application Security Working Group.

## Por qué importa

El ataque contra el que se diseñó CSP es cross-site scripting. Alguien consigue introducir texto de su elección en una página, mediante un campo de comentarios, un término de búsqueda repetido en el HTML o una dependencia comprometida, y el navegador lo ejecuta como script con toda la autoridad del código del propio sitio: puede leer la página, actuar como el usuario que ha iniciado sesión y enviar lo que encuentre a cualquier lugar. La primera defensa es escapar correctamente la salida, y eso tiene que hacerse bien en cada plantilla, en cada línea y en cada ocasión. CSP es la segunda defensa. Cuando se cuela un error de escape, el script inyectado todavía tiene que superar la política, y una que solo ejecuta scripts con el nonce de esa respuesta lo rechaza.

También limita el alcance de un script que sí se ejecuta. `connect-src` decide con qué hosts puede comunicarse, lo que reduce los destinos a los que un script de robo de datos puede enviar lo que recopila. `frame-ancestors` decide qué sitios pueden mostrar la página dentro de un marco, la defensa estándar contra el clickjacking, donde una página se superpone a otra para que un clic llegue a un lugar que el usuario nunca pretendió pulsar. `form-action` decide adónde pueden enviar datos los formularios, y `base-uri` impide que un elemento `base` inyectado redirija silenciosamente todas las direcciones relativas de la página.

Conviene precisar a quién protege CSP. Se ejecuta en el navegador, así que protege a la persona que lee la página del contenido que un atacante haya introducido en ella. No protege al servidor frente a esa misma persona, que puede editar o eliminar la cabecera en su propio navegador en segundos. Una política es una razón para confiar menos en la página, nunca para confiar más en la petición.

El coste consiste sobre todo en hacer inventario. Una política obliga al equipo a conocer todos los orígenes desde los que sus páginas cargan recursos, todos los scripts en línea y todos los controladores de eventos escritos como atributos. Un sitio nuevo puede construirse con una política estricta desde el primer commit por muy poco. Uno antiguo con controladores en línea, un gestor de etiquetas y varios widgets paga primero la limpieza, que suele ser el verdadero proyecto.

## Cómo se aplica en la práctica

Este sitio se impone una política de este tipo. La [página de seguridad](/es/security/) enumera una Content Security Policy estricta, declarada en la propia página, con `form-action 'none'`, porque el sitio no envía formularios a ninguna parte. Todas las páginas HTML declaran `script-src 'none'`: no se ejecuta JavaScript ni ningún service worker. El sitio no hace peticiones a terceros; todo lo que necesita una página procede de su propio host, así que hay muy poco que permitir.

Una aplicación con usuarios que han iniciado sesión necesita algo más que una lista breve de elementos permitidos. En una plataforma con datos profesionales y de organizaciones,
[el middleware proxy de Next.js establece una Content-Security-Policy con un nonce por petición y `strict-dynamic`](/es/portfolio/hardened-the-application-with-nonce-based-csp/),
junto con HSTS y cookies SameSite. Un nonce nuevo en cada respuesta significa que solo se ejecutarán los elementos de script que el servidor haya marcado en esa respuesta. Con `strict-dynamic` en la política, un script al que el nonce otorga confianza puede cargar por sí mismo más scripts, de modo que la política no necesita nombrar todos los hosts desde los que un paquete obtiene sus fragmentos. Esa plataforma parte del supuesto de que el cliente es hostil. Por eso el servidor vuelve a comprobar los permisos de cada petición, y los controles del frontend solo cuentan para la experiencia de usuario. CSP es allí una de varias capas, protege a los usuarios del código inyectado y deja la decisión de autorización en otro lugar.

## Dónde surgen los problemas

**La política entra en vigor y medio sitio deja de funcionar.** Aplicar directamente una política estricta bloquea el script en línea que nadie recordaba y la etiqueta de seguimiento que alguien añadió hace dos años. Envíela primero como `Content-Security-Policy-Report-Only`, lea los informes hasta que se estabilicen, permita o elimine cada fuente que señalen y solo entonces aplíquela. La cabecera de solo informe tiene que ser una cabecera real: la especificación no la admite en un elemento `meta`.

**La lista de elementos permitidos confía en un host completo.** `script-src https://cdn.example.com` permite todos los archivos de ese host, incluidas versiones antiguas de bibliotecas y endpoints que devuelven la entrada de quien llama como script. La propia especificación dice que desplegar una política eficaz contra cross-site scripting es un reto y recomienda lo que denomina Strict CSP: `script-src` construido con nonces o hashes y `'strict-dynamic'`, más `base-uri` con `'self'` o `'none'`.

**Se supone que `'unsafe-inline'` permite todos los scripts en línea.** Cuando aparece un nonce o un hash en la misma lista de fuentes, los navegadores que los entienden ignoran `'unsafe-inline'`. La regla permite conservar `'unsafe-inline'` como respaldo para navegadores demasiado antiguos para conocer los nonces, mientras los actuales aplican la lista estricta, y sorprende a un equipo que añade un nonce a un script y ve bloqueados los demás scripts en línea.

**El nonce deja de ser secreto.** La especificación exige un valor nuevo cada vez que se envía una política y recomienda al menos 128 bits procedentes de un generador criptográficamente seguro. Un nonce fijado en una plantilla, o una página completa con su nonce guardada en una caché compartida y servida a todo el mundo, da al atacante el valor que necesita para marcar su propio script.

**Una política en un elemento `meta` hace menos que la misma política en una cabecera.** El navegador ignora `frame-ancestors`, `report-uri` y `sandbox` cuando llegan de esa forma, y la política solo gobierna lo que aparece después del elemento en el documento, así que todo lo que esté antes en la cabecera HTML se carga sin comprobar. Un sitio que no puede decidir sus cabeceras de respuesta sigue obteniendo protección real de una política `meta`, situada lo antes posible en la cabecera HTML, pero la protección contra la inclusión en marcos necesita la cabecera de respuesta.

**Una segunda política restringe en vez de flexibilizar.** Una respuesta puede llevar varias políticas, procedentes de un framework, un proxy y una CDN, y un recurso tiene que cumplirlas todas. Añadir una política solo puede restringir, así que una cabecera permisiva añadida después para arreglar una petición bloqueada no hace nada, y hay que corregir la política que la bloqueó.

## Lecturas adicionales

- [Content Security Policy Level 3](https://www.w3.org/TR/CSP3/)
  — el propio estándar, con la recomendación Strict CSP y una sección sobre el robo de nonces.
- [Estándar HTML: el elemento meta](https://html.spec.whatwg.org/multipage/semantics.html)
  — la directiva pragma que aplica una política declarada en la página, las directivas que descarta y por qué pueden eludirla los recursos obtenidos antes.
- [Reporting API](https://www.w3.org/TR/reporting-1/)
  — el mecanismo de endpoints que utiliza `report-to` para leer las infracciones antes de aplicar la política.
- [Trusted Types](https://www.w3.org/TR/trusted-types/)
  — el estándar complementario que activa una directiva `require-trusted-types-for`, dirigido al script inyectado a través del DOM.

<https://engineer.company/es/glossary/csp/>
