Introducción

Cuando veo un error de CORS en la consola del navegador, casi siempre veo el mismo reflejo en el equipo unos minutos después: alguien pone Access-Control-Allow-Origin: *, desactiva alguna protección en el navegador de desarrollo y da la tarea por resuelta. Eso no resuelve nada. Solo enmascara la regla de seguridad que impide que un sitio cualquiera lea respuestas sensibles de tu API.

CORS no es un capricho de Chrome, Firefox o Edge. Es el mecanismo que usa el servidor para decirle al navegador qué origins pueden leer una respuesta cross-origin. El navegador aplica la regla, pero la decisión viene del backend o de la capa de borde. Si lo configuro de forma laxa, no solo elimino el error visual de la consola: amplío la superficie de ataque de mi aplicación.

Este es el quinto artículo de la serie Seguridad para Devs. En el artículo sobre JWT, OAuth2 y OpenID Connect, cubrí identidad y tokens. En el artículo sobre BFF, mostré cómo sacar el token del navegador. En el artículo sobre API Gateway, discutí la política de seguridad centralizada en el borde. Ahora cierro un hueco que aparece en prácticamente toda SPA, portal administrativo e integración web: cómo configurar CORS sin convertir una protección importante en un adorno decorativo.

Al final de este artículo, mostraré qué protege realmente CORS, cómo funciona la Same-Origin Policy, cuándo el navegador envía un preflight OPTIONS, qué hace cada header, qué errores encuentro más en pentests y code reviews, y cómo configurar CORS correctamente en NGINX y en ASP.NET Core. También separaré una confusión común: CORS no sustituye la autenticación, la autorización ni la protección contra CSRF.

⚠️ Atención: Desactivar CORS porque estorba es como quitarse el cinturón de seguridad porque aprieta. La incomodidad es señal de que la protección sigue funcionando.

Requisitos previos

Para seguir los ejemplos con un contexto real, recomiendo:

  • Conocimiento básico de HTTP, headers y métodos como GET, POST, PUT y OPTIONS.
  • Familiaridad mínima con el navegador, DevTools y solicitudes fetch.
  • En el backend, alguna experiencia con ASP.NET Core y el pipeline de middlewares.
  • En la capa de borde, lectura básica de configuración de NGINX.

También ayuda haber leído al menos los artículos anteriores de la serie, porque haré referencia a autorización, cookies HttpOnly, BFF y gateway varias veces. Aun así, este texto es autocontenido y responde directamente a la pregunta principal: por qué existe CORS y cómo lo configuro con seguridad.

El Problema que Resuelve CORS: Same-Origin Policy

Antes de hablar de headers, necesito hablar de origin. Un origin es la combinación de esquema + host + puerto. Para el navegador, https://app.com y http://app.com no son lo mismo. https://app.com y https://api.app.com tampoco. La tabla siguiente resume los casos más comunes:

URL de la solicitudOrigin de la página¿Same-origin?Motivo
https://app.com/apihttps://app.comSímismo esquema, host y puerto
http://app.com/apihttps://app.comNoesquema diferente
https://api.app.comhttps://app.comNohost diferente
https://app.com:8443https://app.comNopuerto diferente

A partir de esta definición entra la Same-Origin Policy, o SOP. Esta política del navegador impide que un script cargado desde un origin lea libremente respuestas que vienen de otro. El punto central aquí es el verbo leer. El navegador puede incluso permitir que se disparen algunas solicitudes cross-origin, pero no entrega la respuesta al JavaScript de la página si la política no se cumple.

Sin SOP, un sitio malicioso abierto por la víctima podría enviar un fetch a su webmail, a su banca en línea o al panel administrativo en el que ya está autenticada, reaprovechando las cookies que el navegador envía automáticamente. Si la respuesta volviera libremente al JavaScript del atacante, bastaría con parsear el JSON o el HTML y exfiltrarlo todo. La SOP existe precisamente para cortar ese camino.

¿Y dónde entra CORS? CORS es la excepción controlada a esta regla. El servidor de destino informa, mediante headers HTTP, qué origins pueden leer su respuesta. El navegador recibe la respuesta, verifica esos headers y decide si libera o no el contenido al JavaScript de la página.

Este detalle explica una confusión que veo cada semana: curl, Postman, Insomnia y las llamadas backend a backend no tienen problemas de CORS porque no hay navegador aplicando la SOP. Si el endpoint responde 200 en Postman y falla en el navegador, el problema no es “la API está rota”. El problema es que el navegador exige una política explícita para esa lectura cross-origin.

ℹ️ Información: El header Origin viene del navegador y no puede ser sobrescrito por el JavaScript de la página. Por eso el servidor puede tomar decisiones de política basándose en él dentro de un contexto de navegador.

Anatomía de una Solicitud CORS: Simple vs Preflight

No toda solicitud cross-origin pasa por el mismo flujo. El navegador separa estas llamadas en solicitudes simples y solicitudes con preflight.

Una solicitud simple es la que usa GET, HEAD o POST, con headers limitados y un Content-Type restringido a formatos como text/plain, application/x-www-form-urlencoded o multipart/form-data. En estos casos, el navegador envía la llamada real con el header Origin y evalúa la respuesta. Si el servidor devuelve un Access-Control-Allow-Origin compatible, el JavaScript puede leer el resultado.

Cuando salgo de ese sobre y uso PUT, DELETE, PATCH, Authorization, Content-Type: application/json u otros headers personalizados, el navegador entra en un modo más cauteloso. Antes de la solicitud real envía un OPTIONS llamado preflight preguntando si el servidor acepta esa combinación de origin, método y headers.

sequenceDiagram participant B as Navegador (app.com) participant S as Servidor (api.com) B->>S: OPTIONS /pedidos (Origin, Access-Control-Request-Method: PUT) S-->>B: 204 (Access-Control-Allow-Origin, -Allow-Methods, -Allow-Headers) Note over B: El navegador valida el preflight B->>S: PUT /pedidos (Origin, Authorization, body JSON) S-->>B: 200 (Access-Control-Allow-Origin)

Flujo de preflight CORS mostrando OPTIONS, headers de permiso y la solicitud real

En el flujo anterior, el navegador quiere garantizar dos cosas antes de disparar la llamada real: si ese origin puede acceder al recurso y si los elementos potencialmente más sensibles de la llamada están permitidos. Y aquí llego a una regla práctica importante: si tu OPTIONS falla, la solicitud real ni siquiera llega a ocurrir.

Este es un ejemplo realista de preflight:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
OPTIONS /api/security/cors/pedidos HTTP/1.1
Origin: https://app.zocate.li
Access-Control-Request-Method: POST
Access-Control-Request-Headers: Authorization, Content-Type

HTTP/1.1 204 No Content
Access-Control-Allow-Origin: https://app.zocate.li
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
Access-Control-Allow-Headers: Authorization, Content-Type
Access-Control-Allow-Credentials: true
Access-Control-Max-Age: 600
Vary: Origin

Si esta respuesta llega correcta, el navegador sigue con la llamada real. Si llega incompleta, duplicada, con un status incorrecto o sin los headers esperados, DevTools muestra un error de CORS y el JavaScript no accede a la respuesta.

💡 Consejo: Access-Control-Max-Age reduce la latencia porque permite al navegador cachear el resultado del preflight. Sin él, cada llamada no simple puede generar un OPTIONS extra antes de la solicitud real.

Los Headers de CORS, Uno a Uno

Cuando enseño CORS en mentorías, intento salir del “pon cualquier cosa hasta que desaparezca el error” e ir a una lectura literal de los headers. Son pocos, pero cada uno tiene un papel bien definido.

HeaderDirecciónFunción
OriginRequestidentifica el origin de la página que hizo la llamada
Access-Control-Allow-OriginResponseinforma qué origin puede leer la respuesta
Access-Control-Allow-MethodsResponseinforma qué métodos se permiten en el recurso
Access-Control-Allow-HeadersResponseinforma qué headers personalizados pueden enviarse
Access-Control-Allow-CredentialsResponsepermite enviar cookies y credenciales cuando es true
Access-Control-Expose-HeadersResponsepermite que JavaScript lea headers de respuesta
Access-Control-Max-AgeResponsedefine la caché del preflight en segundos
Access-Control-Request-MethodRequestinforma qué método quiere usar la llamada real
Access-Control-Request-HeadersRequestinforma qué headers quiere enviar la llamada real

El header más famoso es Access-Control-Allow-Origin, pero también es el peor configurado. Si pongo *, estoy diciendo que cualquier origin puede leer esa respuesta. Eso puede tener sentido en un recurso totalmente público, como un catálogo estático sin autenticación. En una API autenticada, suele ser señal de un error conceptual.

Existe además una regla que sorprende a mucha gente: Access-Control-Allow-Origin: * no puede combinarse con Access-Control-Allow-Credentials: true. El navegador rechaza esa combinación porque las credenciales exigen un origin explícito. Si hay cookies, certificado de cliente o Authorization de por medio, el servidor necesita devolver un origin validado, no un wildcard.

Otro header subestimado es Vary: Origin. Si mi aplicación refleja dinámicamente el origin válido, las cachés intermedias y las CDNs necesitan saber que la respuesta varía con ese header. Sin Vary: Origin, corro el riesgo de servir a https://app.zocate.li una respuesta cacheada construida para otro origin.

Por último, Access-Control-Expose-Headers aparece cuando el backend envía metadatos útiles en la respuesta, como X-Total-Count, Location o algún correlation id, y quiero que el JavaScript pueda leerlos. Sin este header, muchos headers de respuesta siguen invisibles para la página, aunque la llamada se haya permitido.

ℹ️ Información: CORS confía en Origin como metadato del navegador. No es un mecanismo de autenticación. Si un endpoint es sensible, sigue necesitando validar token, sesión, claims y autorización en el backend.

Los Errores Clásicos que Todo Equipo Comete

Después de revisar decenas de APIs, diría que los errores de CORS se repiten con un patrón casi industrial. El primero es el más obvio: usar Access-Control-Allow-Origin: * en una API autenticada. Muchas veces el equipo lo hace para “destrabar el front” sin darse cuenta de que está anunciando lectura global para cualquier página de internet. Si la API depende de cookies o credenciales, el navegador seguirá bloqueando en varios escenarios. Si no depende, el daño puede seguir existiendo igualmente en recursos sensibles expuestos.

El segundo error es más peligroso porque parece sofisticado: reflejar el Origin recibido sin validarlo. El código hace algo como response.Headers["Access-Control-Allow-Origin"] = request.Headers["Origin"] y listo. Eso equivale a aceptar cualquier origin, pero con un detalle peor: ahora funciona incluso con credenciales. En un pentest, este tipo de configuración entra de inmediato en la lista de hallazgos relevantes.

El tercer error es la validación laxa de la allowlist. Veo mucho endsWith("exemplo.com"), que acepta evil-exemplo.com, y startsWith("https://exemplo.com"), que acepta https://exemplo.com.evil.com. Si mi política depende de una comparación de strings ingenua, la protección ya nació comprometida.

El cuarto error es intentar “resolver CORS en el frontend”. Aparece como plugin del navegador, proxy improvisado que llega a producción, flag para desactivar la seguridad web o un parche en el dev server que enmascara la ausencia de la política real. En el entorno local puede reducir la fricción temporalmente, pero no corrige el backend y además empuja la decisión de seguridad hacia quien no debería tomarla.

El quinto error es confundir CORS con autenticación o autorización. Si un origin está permitido, eso solo significa que el navegador podrá leer la respuesta. No significa que el usuario esté autenticado, que el token sea válido ni que el recurso pueda accederse. La verificación de permisos sigue siendo obligación del backend.

El sexto error, y quizá el más irritante en producción, es hacer que el OPTIONS pase por autenticación o por un redirect. Si el preflight recibe 401, 302 o cualquier respuesta distinta de la que espera el navegador, la llamada real muere ahí. El preflight debe tratarse de forma pública, rápida y predecible.

⚠️ Atención: Reflejar Origin sin validar junto con Access-Control-Allow-Credentials: true convierte un problema de configuración en una vulnerabilidad de exfiltración de datos autenticados. Aparece con frecuencia en auditorías OWASP y con Burp Suite.

CORS no es CSRF (y no protege contra él)

Aquí está una de las confusiones más comunes en arquitectura web. CORS y CSRF no son el mismo problema. CORS regula si el JavaScript de un origin puede leer la respuesta de otro origin. CSRF explota el hecho de que el navegador puede enviar cookies automáticamente en una solicitud cross-origin, incluso cuando el atacante no puede leer la respuesta.

Imagina una transferencia bancaria disparada por un formulario POST simple alojado en un sitio malicioso. El atacante no necesita leer el JSON de respuesta para causar daño. Solo necesita que el navegador de la víctima envíe las cookies de sesión automáticamente al dominio legítimo. Eso es CSRF. CORS puede incluso impedir que el JavaScript malicioso lea el resultado, pero la acción en el servidor puede haber ocurrido igualmente.

Por eso la defensa contra CSRF es otra: tokens anti-CSRF, cookies SameSite, validación de Origin o Referer en el servidor y, en muchos escenarios modernos, el patrón BFF con un control claro de sesión. El artículo de JWT, OAuth2 y OpenID Connect ayuda a separar identidad de transporte, y el artículo de API Gateway muestra dónde entran las políticas transversales en la arquitectura.

Me gusta resumirlo así: CORS decide si la página puede ver. CSRF explota el hecho de que el navegador puede enviar. Son verbos diferentes, riesgos diferentes y controles diferentes.

💡 Consejo: CORS relaja la Same-Origin Policy de forma controlada. CSRF abusa del envío automático de cookies. Configurar uno no elimina el otro.

Configurando CORS en NGINX

En mi stack, NGINX normalmente aparece como reverse proxy y capa de borde. Eso vuelve tentadora la idea de resolver CORS ahí mismo. En muchos casos es una buena elección, sobre todo para recursos estáticos, APIs consolidadas detrás del mismo proxy o cuando quiero centralizar la política de borde. Lo que no puedo hacer es responder CORS en NGINX y en el backend al mismo tiempo, porque los headers duplicados suelen hacer que el navegador lo rechace todo.

El anti-pattern clásico es este:

1
2
3
4
5
# No uses esto en una API autenticada
location /api/ {
    add_header Access-Control-Allow-Origin *;
    proxy_pass http://backend;
}

Parece simple, pero es inseguro para una API con credenciales e insuficiente para el preflight. La versión segura necesita allowlist, respuesta consistente para OPTIONS, Vary: Origin y always para cubrir también las respuestas de error.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
map $http_origin $cors_origin {
    default "";
    "https://app.zocate.li" $http_origin;
    "https://admin.zocate.li" $http_origin;
}

location /api/security/cors/ {
    if ($cors_origin != "") {
        add_header Access-Control-Allow-Origin $cors_origin always;
        add_header Access-Control-Allow-Credentials true always;
        add_header Vary Origin always;
    }

    if ($request_method = OPTIONS) {
        add_header Access-Control-Allow-Origin $cors_origin always;
        add_header Access-Control-Allow-Methods "GET, POST, PUT, DELETE, OPTIONS" always;
        add_header Access-Control-Allow-Headers "Authorization, Content-Type, X-Demo-Token" always;
        add_header Access-Control-Max-Age 600 always;
        return 204;
    }

    proxy_pass http://backend_cors;
}

📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog: BlogSamples/Security/Cors/

Uso map porque me ayuda a mantener la allowlist explícita y evita comparaciones de strings laxas repartidas por la configuración. El if en NGINX requiere cuidado, pero en este caso sirve para aplicar el header solo cuando el origin fue validado previamente. El always es importante porque, sin él, varios headers no aparecen en respuestas 4xx y 5xx, lo que complica el diagnóstico y puede romper el comportamiento esperado en el navegador.

Otro detalle relevante: OPTIONS no debe exigir autenticación. El preflight necesita responderse antes de la llamada real. Si redirijo al login o paso el OPTIONS por un middleware de auth sin excepción, el navegador ni siquiera llega al endpoint de negocio.

Y necesito repetir la regla más importante de esta sección: elige una capa para responder CORS. Si NGINX añade Access-Control-Allow-Origin y ASP.NET Core hace lo mismo, el resultado frecuente es una respuesta inválida desde el punto de vista del navegador.

⚠️ Atención: Dos headers Access-Control-Allow-Origin en la misma respuesta suelen invalidar toda la política. Si el borde responde CORS, el backend debe dejar de responder el mismo bloque.

Configurando CORS en ASP.NET Core

En ASP.NET Core, prefiero trabajar con named policies. Dejan explícita la intención de cada grupo de endpoints y reducen la tentación de esparcir AllowAnyOrigin() por toda la aplicación. Para el sample de este artículo, creé una policy llamada FrontendSpa con allowlist cerrada, AllowCredentials() y caché de preflight de diez minutos.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
builder.Services.AddCors(options =>
{
    options.AddPolicy("FrontendSpa", policy =>
    {
        policy.SetIsOriginAllowed(origin =>
                  origin is "https://app.zocate.li" or "https://admin.zocate.li")
              .WithMethods("GET", "POST", "PUT", "DELETE")
              .WithHeaders("Authorization", "Content-Type")
              .AllowCredentials()
              .SetPreflightMaxAge(TimeSpan.FromMinutes(10));
    });
});

app.UseCors();

app.MapGroup("/api/security/cors")
   .RequireCors("FrontendSpa");

📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog: BlogSamples/Security/Cors/

Este modelo tiene tres ventajas. La primera es la claridad: puedo mirar el nombre de la policy y saber en qué contexto se aplica. La segunda es la seguridad: cuando uso AllowCredentials(), el framework me empuja hacia origins explícitos o hacia una validación dinámica bien pensada. La tercera es el mantenimiento: puedo aplicar una política diferente para BlazorWasm, para un endpoint público de lectura o para una SPA autenticada sin mezclar escenarios.

Existe además una protección interesante del propio framework: AllowAnyOrigin().AllowCredentials() genera una excepción en runtime. Eso es bueno. ASP.NET Core está impidiendo una combinación que el navegador no acepta y que casi siempre señala una decisión insegura.

Otro punto crítico es el orden del middleware. Cuando uso UseCors, debe ir antes del mapeo de endpoints y, en pipelines más complejos, antes de la autorización del recurso que depende del preflight. Si la respuesta del OPTIONS queda bloqueada por otra capa, la política nunca llega a aplicarse.

En el sample del artículo también dejé dos comportamientos diferentes para que fuera didáctico: un endpoint público que acepta solo GET con AllowAnyOrigin() y un endpoint privado que sigue devolviendo 401 si no llega un header de demo. El objetivo es mostrar que CORS aprobado no equivale a acceso autorizado.

Consejos y Buenas Prácticas

  • Usa una allowlist explícita para APIs autenticadas. Prefiero listar cada origin de confianza o validar contra un conjunto cerrado. Esto evita wildcards accidentales y reduce el espacio para un bypass de la validación.

  • Elige una única capa para responder CORS. O responde NGINX, o responde el backend. Cuando los dos intentan ayudar al mismo tiempo, el navegador suele interpretarlo como error.

  • Envía siempre Vary: Origin cuando reflejes un origin validado. Sin eso, proxies y CDNs pueden servir la respuesta equivocada a otro origin y abrir un bug difícil de rastrear.

  • Mantén el preflight público, rápido y predecible. OPTIONS debe responder 204 o 200 sin redirigir al login. Si el preflight falla, la llamada real ni siquiera empieza.

  • No trates CORS como autorización. El backend sigue siendo responsable del token, la sesión, los claims y las políticas de permisos. CORS solo define lo que el navegador deja leer.

  • Prueba origins maliciosos de forma automatizada. Me gusta incluir en la prueba de integración al menos un Origin: https://evil.example y verificar que la API no devuelve el origin ni libera credentials.

Ejemplo Práctico

Pongamos todo en un escenario de extremo a extremo. Imagina una SPA en https://app.zocate.li consumiendo una API protegida en https://api.zocate.li detrás de NGINX. El frontend envía cookies o credenciales y necesita consultar un endpoint privado.

En el navegador, la llamada puede ser así:

1
2
3
4
5
6
7
await fetch("https://api.zocate.li/api/security/cors/privado", {
  method: "GET",
  credentials: "include",
  headers: {
    "X-Demo-Token": "token-seguro"
  }
});

Si la policy FrontendSpa está correcta, el navegador envía Origin: https://app.zocate.li, recibe Access-Control-Allow-Origin: https://app.zocate.li y sigue con normalidad. Si cambio el origin a https://evil.example, la solicitud puede incluso llegar al servidor en algunos escenarios, pero el navegador no entrega la respuesta al JavaScript porque la política no la autoriza.

En el sample del artículo, creé una prueba de integración exactamente para esto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
[Fact]
public async Task Get_Com_Origin_Nao_Permitida_Nao_Deve_Retornar_Header_Cors()
{
    using var client = _factory.CreateClient();
    using var request = new HttpRequestMessage(
        HttpMethod.Get,
        "/api/security/cors/diagnostico");

    request.Headers.Add("Origin", "https://evil.example");

    using var response = await client.SendAsync(request);

    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
    Assert.False(response.Headers.TryGetValues("Access-Control-Allow-Origin", out _));
}

📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog: BlogSamples/Security/Cors/

También me gusta probar el preflight, porque es donde mucha configuración falla por detalles. En el sample, el OPTIONS para /api/security/cors/pedidos valida Origin, Access-Control-Request-Method y Access-Control-Request-Headers, y la prueba confirma que los headers de respuesta esperados aparecen con status 204 No Content.

El comportamiento esperado en DevTools es simple:

  • origin permitido: OPTIONS devuelve 204, la llamada real ocurre y el frontend lee la respuesta.
  • origin no permitido: la solicitud puede aparecer en la pestaña Network, pero la consola registra un error de CORS y la página no accede a la respuesta.
  • credencial ausente o token inválido: CORS pasa, pero el backend devuelve 401 o 403 normalmente.

Este último caso es el más importante para cerrar el concepto: CORS es un filtro de lectura en el navegador; la autorización sigue siendo una regla de negocio y de seguridad del servidor.

Resumen Objetivo

  • CORS es el mecanismo que permite al servidor relajar la Same-Origin Policy en el navegador, definiendo mediante headers qué origins pueden leer una respuesta cross-origin.
  • Same-Origin Policy compara esquema, host y puerto; cambiar cualquiera de estos elementos convierte la llamada en cross-origin para el navegador.
  • Preflight es una solicitud OPTIONS enviada antes de llamadas no simples, como PUT, DELETE, Authorization o Content-Type: application/json.
  • Access-Control-Allow-Origin: * no puede combinarse con Access-Control-Allow-Credentials: true; las credenciales exigen un origin explícito y validado.
  • Reflejar Origin sin validar equivale a aceptar cualquier sitio y puede permitir la exfiltración de datos autenticados cuando se combina con credentials.
  • NGINX debe responder CORS con allowlist, always y Vary: Origin cuando sea la capa elegida; duplicar headers con el backend rompe la respuesta en el navegador.
  • ASP.NET Core ofrece policies con nombre e impide en runtime la combinación insegura AllowAnyOrigin().AllowCredentials().
  • CORS no protege contra CSRF; CORS regula la lectura de la respuesta, mientras que CSRF explota el envío automático de cookies y exige defensas específicas.

Lee También

Referencias