Guía completa de cabeceras de seguridad web
Implementa CSP, HSTS, X-Frame-Options y cabeceras seguras. Cubre content security policy, CORS, referrer policy, permissions policy, aislamiento entre orígenes y pruebas con escáneres.
Introducción
Las cabeceras de seguridad HTTP son metadatos de respuesta que le indican al navegador cómo tratar el contenido de tu sitio: qué scripts pueden ejecutarse, quién puede insertar la página en un iframe, cuánta información del referrer se filtra a terceros y si alguna vez es aceptable usar HTTP plano. Son la capa de defensa más barata que puedes desplegar: una sola línea de configuración del servidor puede neutralizar clases enteras de ataques como el clickjacking o los ataques de degradación.
Esta guía cubre las cabeceras que importan, el ataque que mitiga cada una, cómo configurarlas en Nginx, Apache y Express, y cómo desplegarlas sin romper producción. El objetivo es una base defendible que puedas copiar hoy, más el conocimiento suficiente para endurecerla con el tiempo.
Qué hacen realmente las cabeceras de seguridad
Cada respuesta que envía tu servidor puede llevar instrucciones de política. El navegador las lee antes de renderizar cualquier cosa y las aplica incluso contra tu propio marcado. Ese es el punto: si un atacante logra inyectar una etiqueta <script> a través de un campo de comentarios, un Content-Security-Policy estricto igualmente impide que se ejecute, porque el navegador verifica la política declarada, no las intenciones de nadie.
Las cabeceras no arreglan código vulnerable: un CSP no va a parchar la inyección que dejó entrar al <script>. Lo que hacen es elevar el costo de la explotación y contener el daño cuando algo más falla. Piensa en ellas como el airbag, no los frenos.
También cumplen una función más silenciosa: controlar la fuga de información. Referrer-Policy decide cuánto de la URL actual ven los terceros, y Permissions-Policy decide a qué APIs del dispositivo puede acceder la página (y cada script de terceros dentro de ella.
Content-Security-Policy (CSP)
CSP es la cabecera más capaz de la lista y la más fácil de configurar mal. Declara qué orígenes pueden proveer cada tipo de recurso: scripts, estilos, imágenes, fuentes, frames, destinos de XHR y WebSocket. Un navegador que respeta la política se niega a cargar o ejecutar cualquier cosa fuera de ella, que es exactamente lo que quieres cuando marcado controlado por un atacante llega a la página.
Una política base
Content-Security-Policy: default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; font-src 'self'; connect-src 'self'; frame-ancestors 'none'; base-uri 'self'; form-action 'self'; object-src 'none'
Leyéndola: default-src 'self' significa que, salvo que una directiva más específica diga otra cosa, solo se cargan recursos del mismo origen. frame-ancestors 'none' es la defensa contra clickjacking: nadie puede insertar esta página en un iframe. object-src 'none' elimina los embeds de plugins; Flash hace tiempo que no existe, pero la directiva sigue protegiendo rutas heredadas de PDF y applets. base-uri 'self' evita que un <base> inyectado reescriba todas las URLs relativas de la página, y form-action 'self' limita a dónde pueden enviarse los formularios.
Dos excepciones se cuelan en la mayoría de los sitios reales: data: en img-src para imágenes e iconos inline, y un origen de CDN o API en script-src o connect-src. Agrégalas de forma deliberada. Cada origen extra es un agujero que un atacante también puede usar si ese origen llega a servir contenido subido por usuarios; https: como origen genérico, o un CDN público que aloja archivos subibles, debilita la política para todos.
Scripts inline: nonces, hashes y strict-dynamic
Una política base 'self' bloquea todos los <script> inline de la página, incluidos los tuyos. Hay tres formas estándar de permitir scripts inline específicos sin reabrir la puerta de unsafe-inline.
Nonces (recomendado para páginas dinámicas). El servidor genera un valor aleatorio por petición, lo marca en los scripts que quiere permitir y lo repite en la cabecera:
<!-- El servidor genera un nonce aleatorio nuevo en cada petición -->
<script nonce="4f2c9a1e">
console.log("allowed");
</script>
Content-Security-Policy: script-src 'self' 'nonce-4f2c9a1e'
El nonce debe ser criptográficamente aleatorio y distinto en cada respuesta. Un nonce estático o adivinable equivale a no tener nonce: un script inyectado simplemente lo reutiliza. Los frameworks con renderizado en servidor (Next.js, Nuxt, Rails, Laravel) exponen nonces por petición directamente; en un sitio puramente estático, los hashes son la vía práctica.
Hashes (para scripts inline estáticos). Generas el hash del contenido exacto del script y autorizas el digest:
# Genera un hash SHA-256 del contenido del script
echo -n "console.log('hello');" | openssl dgst -sha256 -binary | openssl base64 -A
Content-Security-Policy: script-src 'self' 'sha256-abc123='
Reemplaza abc123= por el digest base64 real. Los hashes son frágiles por diseño: cambia un solo carácter del script, incluido un espacio, y la política lo rechaza. Resérvalos para fragmentos de arranque que nunca cambian.
strict-dynamic (para bundlers modernos). Le dice al navegador que un script que entró a la página mediante nonce o hash puede cargar otros scripts, sin listar cada URL de chunk:
Content-Security-Policy: script-src 'nonce-4f2c9a1e' 'strict-dynamic'; object-src 'none'
Es el patrón que realmente necesitan los bundlers con code splitting, y funciona en todo navegador con CSP Level 3 (Chrome 52+, Firefox 52+, Safari 15.4+). Para el tratamiento completo — interacciones entre directivas, propagación de nonces, configuración por framework — consulta Content Security Policy: cabeceras CSP, nonces, hashes.
Una nota sobre unsafe-hashes
unsafe-hashes existe para un caso muy concreto: permitir atributos de manejadores de eventos inline (onclick="...") y atributos style="..." mediante hash. No hace lo que su nombre sugiere para los elementos <script> y <style>, y aparece constantemente en políticas copiadas donde no hace falta. Salvo que puedas nombrar el atributo exacto que cubre, déjalo fuera.
Modo de solo informe y reportes de violaciones
Nunca apliques un CSP nuevo a ciegas. Content-Security-Policy-Report-Only evalúa la política, reporta cada violación y no bloquea nada:
Content-Security-Policy-Report-Only: default-src 'self'; report-uri /csp-report
report-uri todavía funciona en casi todas partes pero está deprecado. La Reporting API es el mecanismo actual: declaras un grupo de endpoints con nombre y apuntas el CSP hacia él.
Reporting-Endpoints: csp="https://reports.example.com/csp"
Content-Security-Policy: default-src 'self'; report-to csp
Con report-to, el navegador agrupa las violaciones y las envía por POST como application/reports+json; con report-uri, envía reportes individuales como application/csp-report. Enviar ambos es la opción pragmática durante la migración: los navegadores que entienden report-to lo usan y el resto recurre al anterior. Un endpoint de recolección se ve así:
// Payload moderno de la Reporting API (report-to)
app.post("/csp", express.json({ type: "application/reports+json" }), (req, res) => {
for (const report of req.body) {
console.log("CSP violation:", report.body);
}
res.status(204).end();
});
// Formato heredado (report-uri)
app.post("/csp-report", express.json({ type: "application/csp-report" }), (req, res) => {
console.log("CSP violation:", req.body["csp-report"]);
res.status(204).end();
});
Referencia de directivas CSP
| Directiva | Controla |
|---|---|
default-src | Fallback para todos los tipos de recurso |
script-src | Orígenes de JavaScript |
style-src | Orígenes de CSS |
img-src | Orígenes de imágenes |
font-src | Orígenes de fuentes |
connect-src | XHR, fetch, WebSocket, EventSource |
frame-src | Orígenes de iframes |
frame-ancestors | Quién puede insertar esta página (anti-clickjacking) |
object-src | Embeds de Flash, Java, PDF |
media-src | Orígenes de audio y video |
manifest-src | Manifiesto de la web app |
worker-src | Web Workers |
base-uri | Restricción del elemento <base> |
form-action | Destinos de envío de formularios |
upgrade-insecure-requests | Actualización automática de HTTP a HTTPS |
report-uri | Endpoint de reportes heredado (deprecado) |
report-to | Grupo de endpoints de la Reporting API |
Cuando CSP falla
El fallo clásico es aplicar una política copiada de un blog: el analytics deja de cargar, las fuentes se rompen, los iframes de pago desaparecen, y te enteras por tickets de soporte. La solución es de procedimiento, no técnica: primero modo de solo informe, déjalo madurar, corrige cada violación legítima añadiendo el origen o quitando la dependencia, y recién entonces aplica. La sección de despliegue más abajo tiene la secuencia completa.
El segundo clásico es el JSON embebido. Las apps que serializan datos del servidor en un <script> inline (window.__DATA__ = {...}) se rompen con un script-src estricto: el patrón solo sobrevive detrás de un nonce, y normalmente es más limpio obtener los datos vía connect-src.
Strict-Transport-Security (HSTS)
HTTPS bloquea los ataques de intermediario, pero la primera petición HTTP sigue yendo sin protección. Un atacante en la red puede interceptarla, eliminar la redirección y mantener a la víctima hablando HTTP plano: es el ataque de SSL stripping. HSTS cierra esa brecha: una vez que el navegador ve la cabecera, rechaza toda petición HTTP a ese dominio hasta que expire max-age.
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
max-age=31536000: un año, en segundos. Los navegadores reinician el contador en cada visita HTTPS, así que los usuarios activos nunca lo pierden.includeSubDomains: la política cubre todos los subdominios. No lo actives hasta estar seguro de que todos los subdominios sirven HTTPS; undev.example.comolvidado en HTTP plano queda inaccesible durante un año.preload: una solicitud de inclusión en la lista de precarga integrada del navegador.
HSTS es confianza en el primer uso por diseño: nada protege la primera visita, antes de que el navegador haya visto la cabecera. La lista de precarga existe para arreglar eso: los dominios viajan dentro del propio binario del navegador. Registra el tuyo en hstspreload.org. Requisitos:
- Un certificado HTTPS válido en el dominio raíz y todos los subdominios
- Una redirección de HTTP a HTTPS en el mismo host
max-age >= 31536000,includeSubDomainsypreloaden la cabecera
Trata el preload como efectivamente permanente. Las solicitudes de eliminación tardan meses en propagarse por los ciclos de release de los navegadores, y durante ese tiempo cada subdominio afectado debe seguir sirviendo HTTPS válido o dejar de funcionar. Si algún subdominio pudiera necesitar HTTP plano en el futuro — el sospechoso habitual es tooling interno viejo — omite preload.
X-Frame-Options
El clickjacking carga tu página en un iframe transparente y la superpone sobre un señuelo, de modo que los clics del usuario caen en botones que no puede ver: “confirmar transferencia” escondido bajo “reclama tu premio”. X-Frame-Options controla quién puede insertar la página:
X-Frame-Options: DENY
X-Frame-Options: SAMEORIGIN
DENY bloquea todo enmarcado, incluido el de tus propias páginas; SAMEORIGIN permite solo iframes del mismo origen. Existía un tercer valor, ALLOW-FROM, pero se eliminó de la especificación y ningún navegador actual lo respeta. Para reglas de inserción por origen, usa CSP frame-ancestors 'self' https://partner.example: acepta una lista de orígenes y comodines.
Mantén X-Frame-Options junto a frame-ancestors: los navegadores que entienden CSP usan la directiva, y los más viejos recurren a la cabecera. Nunca entran en conflicto: cuando ambos están presentes, gana CSP.
X-Content-Type-Options
Los navegadores solían adivinar el Content-Type por su cuenta: servías un archivo como text/plain y, si parecía HTML, algunos navegadores lo renderizaban igual. Eso es un vector de ataque: permite que un usuario suba un archivo de texto plano que contiene marcado, consigue que lo interpreten como HTML, y tienes XSS almacenado sin ninguna inyección en tus plantillas.
X-Content-Type-Options: nosniff
Con nosniff, el navegador respeta el tipo declarado: un script servido como algo que no es JavaScript no se ejecuta, una hoja de estilos sin text/css no se aplica. nosniff es el único valor válido; cualquier otro no hace nada.
La cabecera no cuesta nada y a veces expone bugs reales: un servidor que etiqueta los .js como text/plain se romperá ruidosamente con nosniff en lugar de funcionar en silencio. La mayoría de los equipos lo toma como una ventaja: saca a la luz una configuración MIME rota antes de que lo haga un atacante.
Referrer-Policy
Cada petición que hace la página, y cada enlace que el usuario pulsa, puede llevar la URL actual en la cabecera Referer. Esa URL puede contener tokens de sesión, consultas de búsqueda, IDs de usuario o rutas internas que preferirías no entregar a un CDN, un proveedor de analytics o el sitio al que apunta un enlace.
Referrer-Policy: strict-origin-when-cross-origin
| Valor | Referrer enviado |
|---|---|
no-referrer | Ninguno |
no-referrer-when-downgrade | URL completa en HTTPS→HTTPS, nada en HTTPS→HTTP |
same-origin | URL completa solo para peticiones del mismo origen |
origin | Solo el origen (sin ruta) |
strict-origin | Solo el origen, nada en degradación a HTTP |
origin-when-cross-origin | URL completa mismo origen, solo origen entre orígenes |
strict-origin-when-cross-origin | URL completa mismo origen, solo origen entre orígenes, nada en degradación |
unsafe-url | URL completa siempre (no recomendado) |
strict-origin-when-cross-origin es el default correcto para casi todo sitio: las peticiones del mismo origen conservan la URL completa para que tu analytics y tu routing sigan funcionando, las peticiones entre orígenes reciben solo el origen, y las que degradan a HTTP no reciben nada. También es el default de los navegadores modernos: enviarlo explícitamente mantiene la garantía aunque cambie el default del navegador.
Si la app depende de inspección del referrer (flujos de retorno de OAuth, tracking de afiliados, callbacks de pago), prueba esos caminos antes de endurecer más. no-referrer y strict-origin rompen integraciones que esperan un referrer completo.
Permissions-Policy
El navegador expone decenas de APIs de dispositivo y plataforma: cámara, micrófono, geolocalización, USB, acelerómetro. Permissions-Policy declara cuáles de ellas pueden usar la página y sus iframes embebidos. Antes se llamaba Feature-Policy, así que seguirás viendo ese nombre en configuraciones antiguas.
Permissions-Policy: camera=(), microphone=(), geolocation=(self), payment=(self "https://payments.example.com")
() deniega la funcionalidad a todos, (self) la permite solo a este origen, y una lista de orígenes la concede a embeds concretos. La forma de denegación vacía es la que se paga sola: un tag de marketing de terceros no puede encender el micrófono cuando la cabecera dice microphone=(), intente lo que intente el script.
Una base restrictiva para un sitio de contenido típico:
Permissions-Policy: accelerometer=(), autoplay=(), camera=(), display-capture=(), encrypted-media=(), fullscreen=(self), geolocation=(), gyroscope=(), microphone=(), midi=(), payment=(), picture-in-picture=(), publickey-credentials-get=(), screen-wake-lock=(), sync-xhr=(), usb=(), web-share=()
Concede funcionalidades de forma deliberada, por origen, y combina la cabecera con el atributo allow del iframe cuando un embed de confianza necesite una: la cabecera pone el techo y allow delega dentro de él.
Cross-Origin Resource Sharing (CORS)
CORS es un animal distinto del resto de esta guía. Todas las demás cabeceras restringen lo que la página puede hacer; CORS relaja la política del mismo origen para que otros orígenes lean tus respuestas. Una política CORS mal configurada no rompe tu sitio: entrega los datos de tu API a quien los pida.
Peticiones simples
Para peticiones GET/POST planas sin cabeceras personalizadas, el navegador envía la petición con una cabecera Origin y verifica la respuesta:
Access-Control-Allow-Origin: https://example.com
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Max-Age: 86400
Si Access-Control-Allow-Origin no coincide con el origen solicitante, el navegador bloquea la respuesta: la petición ya llegó al servidor, así que CORS nunca es sustituto de autenticación ni de limitación de peticiones.
Credenciales y la regla del comodín
Las cookies y las cabeceras de autorización solo viajan entre orígenes cuando la página pide credenciales y el servidor lo acepta:
Access-Control-Allow-Origin: https://example.com
Access-Control-Allow-Credentials: true
Access-Control-Allow-Headers: Content-Type, Authorization
La especificación prohíbe Access-Control-Allow-Origin: * junto con Access-Control-Allow-Credentials: true: los navegadores rechazan la combinación directamente. Debes hacer eco del origen exacto, lo que significa que la lista de permitidos vive en el código, no en el valor de la cabecera.
Peticiones preflight
Las peticiones con cabeceras personalizadas, Authorization, cuerpos JSON o métodos más allá de GET/POST/HEAD disparan un preflight: el navegador envía primero una petición OPTIONS y solo continúa si la respuesta lo permite.
# Respuesta al preflight OPTIONS
Access-Control-Allow-Origin: https://example.com
Access-Control-Allow-Methods: GET, POST, PUT, DELETE
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Max-Age: 86400
Access-Control-Max-Age cachea el resultado del preflight, así el navegador no repite OPTIONS en cada llamada; 86400 es el techo habitual al que lo limitan los navegadores.
Un detalle operativo que muerde en producción: cuando el origen permitido es dinámico, añade Vary: Origin a la respuesta. Sin eso, las cachés compartidas pueden servir a peticiones de un origen una respuesta sellada para otro, y los errores de CORS aparecen y desaparecen según el estado de la caché.
El análisis profundo (trampas con tokens, ataques de reflexión de origen, configuración por framework) está en Seguridad CORS: orígenes, cabeceras, preflight, credenciales. Para patrones de cabeceras por endpoint en APIs, consulta la receta Proteger APIs con encabezados de seguridad HTTP.
Aislamiento entre orígenes (COOP, COEP, CORP)
Estas tres cabeceras trabajan juntas para aislar el contexto de navegación de tu página de otros orígenes. Existen por los ataques de canal lateral tipo Spectre: una página maliciosa que comparta proceso o relación de opener con la tuya podría, en principio, leer datos que no debería. Los navegadores condicionan funcionalidades potentes (SharedArrayBuffer, temporizadores de alta resolución) a un flag crossOriginIsolated que solo se obtiene desplegando las tres.
COOP (Cross-Origin-Opener-Policy)
Cross-Origin-Opener-Policy: same-origin
COOP corta la relación window.opener entre tu página y las ventanas de otros orígenes. Si tu sitio abre (o es abierto por) una página de otro origen, ambas terminan en grupos de contexto de navegación y procesos separados, de modo que ninguna puede manipular a la otra. Si la app usa flujos de OAuth o pago con popups, same-origin-allow-popups permite que los popups sigan devolviendo datos por postMessage mientras el resto queda aislado.
COEP (Cross-Origin-Embedder-Policy)
Cross-Origin-Embedder-Policy: require-corp
COEP invierte la dirección: exige que cada recurso que la página carga (imágenes, scripts, iframes) opte explícitamente por ser embebido entre orígenes mediante CORP o CORS. Ese es también su costo: los embeds de terceros que no envían Cross-Origin-Resource-Policy ni un Access-Control-Allow-Origin coincidente simplemente dejan de cargar. credentialless es la variante más suave: los recursos de otros orígenes sin credenciales cargan sin CORP, y cubre la mayoría de embeds de analytics y assets estáticos.
CORP (Cross-Origin-Resource-Policy)
Cross-Origin-Resource-Policy: same-origin
CORP es la contraparte del lado del recurso, y se define en las respuestas que tú sirves. same-origin restringe el recurso a tu origen, same-site permite a los subdominios hermanos, y cross-origin lo declara embebible en cualquier parte: la elección correcta para assets públicos de CDN y una forma de que tus recursos satisfagan el COEP del sitio de un partner.
Despliega COOP primero (rara vez rompe algo), luego CORP en tus propios assets, y activa COEP solo tras auditar cada embed de terceros: require-corp con un embed sin preparar es el camino más corto a widgets en blanco.
Configuración del servidor
Las cabeceras pertenecen tanto al borde como a la aplicación. Si hay un CDN o un balanceador delante, puede inyectar cabeceras en cada respuesta, incluidas las páginas de error que la app nunca ve. Dondequiera que las definas, asegúrate de que lleguen a todas las respuestas: en Nginx y Apache eso significa always, que mantiene las cabeceras también en respuestas 4xx y 5xx. A los atacantes les encantan las páginas de error; las cabeceras de seguridad deberían estar ahí para recibirlos.
Nginx
server {
listen 443 ssl http2;
server_name example.com;
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
add_header X-Frame-Options "DENY" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header Permissions-Policy "camera=(), microphone=(), geolocation=()" always;
add_header Content-Security-Policy "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; font-src 'self'; connect-src 'self'; frame-ancestors 'none'; base-uri 'self'; form-action 'self'; object-src 'none'" always;
}
Una peculiaridad de Nginx: add_header dentro de un bloque location reemplaza, en lugar de fusionar, las directivas add_header del nivel server, y las cabeceras heredadas desaparecen de esa ubicación sin aviso. Mantenlas todas en un mismo nivel o repite el conjunto completo.
Apache
<IfModule mod_headers.c>
Header always set Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
Header always set X-Frame-Options "DENY"
Header always set X-Content-Type-Options "nosniff"
Header always set Referrer-Policy "strict-origin-when-cross-origin"
Header always set Permissions-Policy "camera=(), microphone=(), geolocation=()"
Header always set Content-Security-Policy "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; font-src 'self'; connect-src 'self'; frame-ancestors 'none'; base-uri 'self'; form-action 'self'; object-src 'none'"
</IfModule>
Express.js
No configures las cabeceras de seguridad una por una: Helmet trae defaults sensatos y es el estándar para apps Node. La guía completa está en la receta Configura headers de seguridad HTTP con Helmet en Node.js; la configuración centrada en CSP se ve así:
const helmet = require("helmet");
app.use(helmet({
contentSecurityPolicy: {
directives: {
defaultSrc: ["'self'"],
scriptSrc: ["'self'", "https://cdn.jsdelivr.net"],
styleSrc: ["'self'", "https://fonts.googleapis.com"],
fontSrc: ["'self'", "https://fonts.gstatic.com"],
imgSrc: ["'self'", "data:", "https:"],
connectSrc: ["'self'", "https://api.example.com"],
frameAncestors: ["'none'"],
baseUri: ["'self'"],
formAction: ["'self'"],
objectSrc: ["'none'"],
},
},
strictTransportSecurity: {
maxAge: 31536000,
includeSubDomains: true,
preload: true,
},
}));
Los defaults de Helmet son deliberadamente conservadores (X-Frame-Options, nosniff y una política de referrer estricta vienen activados), y el propio CSP es opt-in porque solo tú sabes qué orígenes necesita legítimamente la app.
Estrategia de despliegue
Desplegar todas las cabeceras de seguridad de golpe es como se rompen los sitios. Hazlo por riesgo: primero las cabeceras de riesgo cero, luego CSP vía modo de solo informe, y por último el conjunto de aislamiento entre orígenes cuando realmente lo necesites.
- Conjunto base:
X-Content-Type-Options,X-Frame-Options,Referrer-Policy,Permissions-Policy. Ninguna puede romper una página bien comportada; despliégalas en todas partes desde el primer día. - HSTS: solo después de confirmar que todos los subdominios sirven HTTPS. Empieza con un
max-agecorto (300 segundos), súbelo a lo largo de días, luego añadeincludeSubDomainsy considerapreload. - CSP en modo de solo informe: deja que las violaciones se acumulen durante una o dos semanas con tráfico real. Clasifica cada una: añade el origen legítimo o elimina el script inline que detectó.
- CSP en modo de aplicación: cambia la misma política a
Content-Security-Policyy mantén el endpoint de reportes activo. Las violaciones siguen llegando mucho después de la aplicación; monitóralas. - Aislamiento entre orígenes: despliega COOP y CORP de forma amplia; activa COEP solo cuando necesites
crossOriginIsolatedo hayas auditado cada embed.
Pruebas
Escáneres en línea
- securityheaders.com: califica de A+ a F, la verificación más rápida
- observatory.mozilla.org: el escáner de Mozilla, con análisis más profundo de CSP y TLS
- csp-evaluator.withgoogle.com: evalúa políticas CSP en concreto y marca configuraciones vulnerables a bypass
Línea de comandos
curl -sI https://example.com | grep -iE "strict-transport|content-security|x-frame|x-content|referrer|permissions"
DevTools del navegador
La pestaña Security de Chrome DevTools muestra la conexión TLS y marca el contenido inseguro; la pestaña Network expone todas las cabeceras de respuesta por petición. Para CSP en concreto, la consola registra cada violación con la URL bloqueada y la directiva que la rechazó: es el primer lugar donde mirar cuando algo desaparece de la página.
Reportes de violaciones CSP
Los endpoints de reporte de la sección CSP (report-uri y report-to) son también tu monitoreo de producción: un pico repentino de violaciones de script-src bloqueadas suele significar que se publicó un script de terceros nuevo, no un ataque, pero solo lo sabes si alguien está leyendo los reportes.
Mejores Prácticas
- Empezar con CSP en modo de solo informe: recolecta violaciones del tráfico real antes de aplicar nada
- Usar nonces en lugar de hashes para contenido dinámico: los hashes se rompen con cualquier cambio; los nonces siguen a la petición
- Definir
frame-ancestors 'none': la protección anti-clickjacking más fuerte; afloja solo si un embed legítimo lo necesita - Incluir
object-src 'none': los embeds de plugins están muertos, mantén el agujero cerrado - Usar
strict-origin-when-cross-origin: el default de referrer seguro para la privacidad que mantiene funcionando el analytics interno - Escalar HSTS gradualmente:
max-agecorto primero,includeSubDomainssolo cuando todo subdominio esté en HTTPS,preloadal final - Enviar cabeceras también en respuestas de error: usa
alwaysen Nginx y Apache; las páginas 4xx y 5xx también son superficie de ataque - Deshabilitar funcionalidades sin uso en Permissions-Policy: cada
()es una API que un script de terceros no puede tocar - Usar Helmet para Node.js: defaults revisados en lugar de cabeceras hechas a mano
- Revisar el CSP mensualmente: los scripts de terceros nuevos llegan en silencio y se rompen con políticas estrictas
- Limitar CORS por ruta: un
Access-Control-Allow-Originglobal casi nunca es lo que una app necesita - Leer los reportes de violaciones: un sistema de reportes sin monitoreo es solo latencia
Errores Comunes
- Usar
unsafe-inlineen CSP: permite exactamente lo que CSP existe para impedir; toda técnica de bypass empieza ahí Access-Control-Allow-Origin: *con credenciales: los navegadores lo rechazan y depurarlo consume horas; haz eco del origen en su lugar- Olvidar
alwaysen Nginx/Apache: las páginas de error salen sin cabeceras de seguridad - Activar
preloadde HSTS demasiado pronto: un subdominio que luego necesite HTTP queda inaccesible durante meses - Usar
X-Frame-Options: ALLOW-FROM: eliminado de la especificación; los navegadores modernos lo ignoran - Aplicar CSP sin fase de solo informe: las páginas de producción se rompen en silencio, un embed de terceros por vez
- Olvidar
object-src:default-srcno cubre los embeds de plugins en todos los navegadores; defineobject-src 'none'explícitamente - Saltarse las cabeceras en respuestas de API:
nosniff, un CORS bien delimitado y una postura sin caché también aplican a endpoints JSON - Permitir
unsafe-eval: algunos frameworks lo piden en desarrollo; nunca debería sobrevivir hasta producción - Activar COEP
require-corpsin auditar los embeds: los iframes e imágenes de terceros sin CORP dejan de cargar al instante
Ver También
- Content Security Policy: cabeceras CSP, nonces, hashes
- Seguridad CORS: orígenes, cabeceras, preflight, credenciales
- OWASP Top 10: Explicado con Mitigaciones
- Guía completa de seguridad en APIs
- Configura headers de seguridad HTTP con Helmet en Node.js
- Proteger APIs con encabezados de seguridad HTTP
- MDN: Content-Security-Policy
- W3C: Content Security Policy Level 3
- MDN: HTTP Headers
Preguntas frecuentes
¿Qué cabeceras de seguridad debería configurar primero?
Empieza por el conjunto de riesgo cero: X-Content-Type-Options: nosniff, X-Frame-Options: SAMEORIGIN (o DENY), Referrer-Policy: strict-origin-when-cross-origin y una Permissions-Policy restrictiva. Ninguna puede romper una página bien comportada. Luego añade HSTS tras verificar HTTPS en todas partes, y CSP al final vía modo de solo informe: es la única que puede tumbar el sitio si la apuras.
¿Cuál es la diferencia entre frame-ancestors de CSP y X-Frame-Options?
frame-ancestors es el reemplazo moderno: acepta una lista de orígenes y comodines, mientras que X-Frame-Options solo entiende DENY y SAMEORIGIN (ALLOW-FROM está muerto). Cuando ambos están presentes, los navegadores que soportan CSP usan frame-ancestors e ignoran la cabecera. Despliega ambos: la cabecera cubre a los navegadores anteriores a CSP.
¿Las APIs también necesitan cabeceras de seguridad?
Sí, de forma selectiva. Las APIs JSON se benefician de nosniff (evita confusión de tipos de contenido), un CORS correctamente delimitado y Cache-Control: no-store para payloads sensibles. CSP y frame-ancestors importan menos en respuestas puras de API, pero siguen siendo seguro barato: la misma API a veces sirve errores HTML o archivos subidos por usuarios.
¿Cómo depuro violaciones de CSP?
La consola del navegador registra cada violación con la URL bloqueada y la directiva que la rechazó: empieza ahí. En producción, mantén report-uri o report-to activos para que las violaciones se agreguen en tu endpoint, y ejecuta las políticas nuevas primero en modo de solo informe para que nada se rompa mientras recolectas datos.
¿Debería usar nonce o hash en CSP?
Nonce para páginas dinámicas, hash para estáticas. Un nonce se genera por petición, así que encaja con HTML renderizado en servidor; un hash se calcula una vez sobre el contenido exacto, así que encaja con scripts que nunca cambian, como un fragmento de arranque en un sitio estático. Si te encuentras manteniendo una lista larga de hashes, esa es la señal para pasar a nonces.
¿Debería usar strict-dynamic en CSP?
Úsalo cuando un script de arranque de confianza carga otros scripts: el caso estándar de los bundlers con code splitting. strict-dynamic permite que un script aprobado por nonce traiga lo que necesite, así dejas de mantener una lista de URLs de chunks. Requiere CSP Level 3 (Chrome 52+, Firefox 52+, Safari 15.4+), que cubre en la práctica todos los navegadores actuales.
¿Qué se rompe al activar Cross-Origin-Embedder-Policy: require-corp?
Todo recurso de otro origen que no haya optado explícitamente (mediante CORP de su lado o un Access-Control-Allow-Origin de CORS) deja de cargar. Los videos embebidos, los iframes de terceros, los scripts de publicidad y las imágenes alojadas fuera son las víctimas habituales. Audita los embeds primero, o usa credentialless como paso intermedio.
Recursos Relacionados
Content Security Policy: cabeceras CSP, nonces, hashes
Desplegá Content Security Policy sin romper tu sitio: directivas CSP, nonces, hashes, strict-dynamic, reportes e integración por framework.
GuideSeguridad CORS: orígenes, cabeceras, preflight, credenciales
Cómo funciona CORS de verdad: política de mismo origen, preflight, cabeceras, credenciales, misconfiguraciones que rompen producción y las reglas de seguridad que importan.
GuideOWASP Top 10: Explicado con Mitigaciones
Guía orientada a desarrolladores sobre los 10 riesgos de seguridad más críticos de OWASP: cómo funciona cada vulnerabilidad, ejemplos del mundo real y mitigaciones prácticas.
GuideGuía Completa de Gestión de Secretos
Gestiona secretos de aplicaciones de forma segura en producción: Vault, AWS, Azure, GCP, secretos de Kubernetes, rotación, CI/CD y cuándo un gestor sobra.
RecipeConfigura headers de seguridad HTTP con Helmet en Node.js
Establece headers de seguridad HTTP en apps Express con Helmet: CSP, HSTS, X-Frame-Options, X-Content-Type-Options y CORS para seguridad web OWASP
RecipeProteger APIs con encabezados de seguridad HTTP
Cómo configurar headers de seguridad esenciales como HSTS, CSP y X-Frame-Options para proteger APIs y aplicaciones web de ataques comunes.