Content Security Policy (CSP): De la Teoría de Mitigación al Hardening en Producción

• Ataque: El atacante inyecta una cadena de JavaScript que el navegador interpreta en el contexto de seguridad de la víctima.
• Condición: Falta de escaping contextual en plantillas de servidor o asignación insegura de datos no confiables en el DOM.
• Impacto: Robo de tokens de sesión (localStorage), suplantación de identidad, ejecución de acciones forzadas, exfiltración de PII.
• Directiva CSP: Content-Security-Policy: default-src 'self'; script-src 'self' 'nonce-r4nd0mStr1ng' 'strict-dynamic';

• Ataque: Inyección de etiquetas directas <script>exploit()</script> o atributos de eventos HTML <svg onload="exploit()">,
  <img src=x onerror="exploit()"> o <button onclick="exploit()">.
• Condición: La aplicación evalúa HTML crudo suministrado por el usuario y permite scripts en línea sin control.
• Impacto: Ejecución inmediata de código arbitrario sin requerir descargas externas.
• Directiva CSP: Prohibido script-src 'unsafe-inline'. Usar únicamente Nonces: Content-Security-Policy: script-src 'nonce-EDNnf03nce24hgngs';

// INSEGURO (Requiere 'unsafe-inline')
// <button id="pay-btn" onclick="processPayment(1250)">Pagar</button>

// SEGURO (Compatible con CSP estricta)
// <button id="pay-btn" data-amount="1250">Pagar</button>
document.addEventListener('DOMContentLoaded', () => {
  const payBtn = document.querySelector('#pay-btn');
  if (payBtn) {
    payBtn.addEventListener('click', (e) => {
      const amount = e.currentTarget.getAttribute('data-amount');
      processPayment(amount);
    });
  }
});

• Ataque: Inyección de strings dentro de sinks de compilación dinámica en tiempo de ejecución (eval("result = " + userInput)).
• Condición: Uso de APIs de JavaScript que invocan el compilador interno del motor V8/SpiderMonkey sobre cadenas no estáticas.
• Impacto: Ejecución remota de código en el contexto del cliente (DOM XSS / Logic Hijacking).
• Directiva CSP: Por defecto CSP bloquea invocaciones a eval() a menos que se fuerce 'unsafe-eval'.

• Ataque: Un repositorio o CDN público (https://cdn.example.com/lib.js) sufre una intrusión. El script legítimo es reemplazado por un payload malicioso.
• Condición: Confianza ciega en dominios externos en la directiva script-src.
• Impacto: Compromiso total de todas las sesiones de usuarios.

<script
  src="https://trusted-cdn.example.com/library-v3.2.1.min.js"
  integrity="sha384-wqnC6nPujCwJxDYsn5hFpu6zkYYqSbId6G5v5luhmsTuWn9u5Dk1h5Fp9Gqj5U7m"
  crossorigin="anonymous">
</script>

• Ataque: Un paquete dependiente en npm es comprometido y se empaqueta dentro del bundle final app.bundle.js.
• Límite de CSP: Dado que se sirve desde 'self' con nonce válido, CSP no bloquea su ejecución interna, pero mitiga canales de exfiltración de red (connect-src).
• Mitigación Real: Lockfiles obligatorios en CI (--frozen-lockfile), escaneo automatizado (Trivy, Snyk, npm audit) y generación de SBOM CycloneDX.

• Ataque: Descubrimiento de un endpoint JSONP vulnerable en un dominio autorizado (<script src="https://api.trusted.com/user?callback=maliciousPayload"></script>).
• Impacto: Bypass total de CSP en políticas basadas en allowlists de dominio.
• Solución: Migrar inmediatamente a políticas basadas en Nonces estrictos con 'strict-dynamic' y reemplazar JSONP por CORS con respuestas application/json.

Inyección de URIs ejecutables en atributos href="javascript:...". En CSP Level 3 son bloqueadas si no existe 'unsafe-inline'.

// Validación estricta en PHP 8+
function sanitizeUserUrl(string $url): string {
    $filtered = filter_var($url, FILTER_VALIDATE_URL);
    if ($filtered === false) {
        return '#';
    }
    $scheme = strtolower(parse_url($filtered, PHP_URL_SCHEME) ?? '');
    if (!in_array($scheme, ['https', 'http'], true)) {
        return '#';
    }
    return esc_url($filtered);
}

Inserción de elementos <object data="malicious.swf"> para ejecutar plugins heredados.

Inyección de etiquetado <base href="https://attacker.com/assets/"> para forzar la carga de scripts relativos desde servidores remotos.

Manipulación del atributo action de un formulario para redirigir credenciales a servidores maliciosos.

Embeber la aplicación dentro de un <iframe> transparente en una página maliciosa.

Cuando un atacante ejecuta JavaScript, intenta extraer datos comprometedores. CSP actúa como cortafuegos saliente limitando los vectores de transporte:

Controla qué URLs puede cargar tu sitio dentro de un iframe (frame-src 'none' o proveedores aprobados como Stripe).

Reescribe automáticamente todas las URLs HTTP secundarias a HTTPS antes de emitir la petición a la red.

# /etc/nginx/conf.d/security_headers.conf

server {
    listen 443 ssl http2;
    server_name app.miempresa.com;

    # Opciones de hardening complementarias
    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=(), payment=()" always;

    # Política CSP Base (Backend PHP/Node inyecta los nonces específicos)
    add_header Content-Security-Policy "default-src 'self'; object-src 'none'; base-uri 'self'; form-action 'self'; frame-ancestors 'none'; img-src 'self' data: https:; font-src 'self' data:; connect-src 'self'; upgrade-insecure-requests;" always;
}

app.miempresa.com {
    encode gzip zstd
    
    header {
        Content-Security-Policy "default-src 'self'; object-src 'none'; base-uri 'self'; form-action 'self'; frame-ancestors 'none'; upgrade-insecure-requests;"
        X-Content-Type-Options "nosniff"
        Referrer-Policy "strict-origin-when-cross-origin"
    }

    reverse_proxy localhost:3000
}

import express from 'express';
import helmet from 'helmet';
import crypto from 'node:crypto';

const app = express();

app.use((req, res, next) => {
  res.locals.cspNonce = crypto.randomBytes(16).toString('base64');
  next();
});

app.use((req, res, next) => {
  helmet({
    contentSecurityPolicy: {
      directives: {
        defaultSrc: ["'self'"],
        scriptSrc: [
          `'nonce-${res.locals.cspNonce}'`,
          "'strict-dynamic'",
          "'unsafe-inline'",
          "https:"
        ],
        styleSrc: ["'self'", `'nonce-${res.locals.cspNonce}'`],
        objectSrc: ["'none'"],
        baseUri: ["'self'"],
        formAction: ["'self'"],
        frameAncestors: ["'none'"],
        upgradeInsecureRequests: []
      }
    }
  })(req, res, next);
});