Introducción

Si alguna vez implementaste autenticación en una SPA (Single Page Application) usando tokens directamente en el navegador, probablemente conviviste con una preocupación constante: ¿dónde guardo el access token de forma segura? localStorage es vulnerable a ataques XSS (Cross-Site Scripting), sessionStorage tiene las mismas debilidades e incluso las cookies accesibles vía JavaScript pueden ser comprometidas. Ese es exactamente el problema que resuelve el patrón BFF — Backend For Frontend.

El BFF (Backend For Frontend) es un patrón arquitectónico en el que un servidor backend intermedio actúa como proxy de autenticación entre la SPA y el proveedor de identidad (como Azure Entra ID o Keycloak — una alternativa gratuita y open source). En lugar de que la SPA trate directamente con tokens OAuth2, el BFF recibe los tokens, los almacena de forma segura en el servidor y establece una sesión con el navegador mediante cookies HttpOnly — inaccesibles para JavaScript, lo que elimina los vectores de ataque XSS sobre las credenciales.

En este artículo, vas a entender por qué el BFF se convirtió en la recomendación oficial del IETF para SPAs, cómo funciona la arquitectura en la práctica y cómo implementarla desde cero usando Angular 16+ en el front-end y ASP.NET Core 8 en el backend con Azure Entra ID. Si todavía no conoces los fundamentos de la autenticación y los tipos de Client ID, te recomiendo leer primero Autenticación y Autorización: JWT, OAuth2 y OpenID Connect, donde explico JWT, OAuth2 y OpenID Connect en detalle.

📦 Código fuente: La implementación completa de este artículo está en el repositorio blog-zocateli-sample en GitHub. Mira los ejemplos en C# / BFF Server y Angular / BFF SPA.


¿Por Qué las SPAs No Deberían Gestionar Tokens Directamente?

Antes de entender el BFF, es importante comprender por qué el modelo tradicional de tokens en el navegador es arriesgado. En una SPA convencional con OAuth2, el flujo funciona así:

  1. La SPA redirige al usuario al proveedor de identidad.
  2. Tras el login, la SPA recibe los tokens (access token, ID token, refresh token).
  3. La SPA almacena los tokens en el navegador y los envía en las solicitudes a las APIs.

El problema está en el paso 3. Cualquier lugar de almacenamiento accesible para JavaScript es vulnerable:

Lugar de almacenamiento¿Vulnerable a XSS?¿Vulnerable a CSRF?Observación
localStorageSíNoCualquier script malicioso puede leer tokens
sessionStorageSíNoMisma vulnerabilidad, alcance por pestaña
Cookie (sin HttpOnly)SíSíEl peor caso — vulnerable a ambos
Cookie HttpOnlyNoSí (mitigable)Inaccesible para JS + protección CSRF posible

⚠️ Atención: Un solo ataque XSS exitoso en una SPA que almacena tokens en localStorage puede comprometer todas las credenciales del usuario, incluidos los refresh tokens que otorgan acceso prolongado. A diferencia de una cookie de sesión robada (que expira), un refresh token puede usarse durante días o semanas.

La recomendación del IETF para OAuth 2.0 en aplicaciones basadas en navegador es clara: las SPAs deberían usar un componente backend (BFF) para gestionar tokens, en lugar de manejarlos directamente en el navegador.

Los Riesgos Concretos

  • XSS (Cross-Site Scripting): si un atacante logra inyectar JavaScript en la página (mediante una dependencia comprometida, una entrada sin sanitizar, etc.), puede leer los tokens de localStorage/sessionStorage y enviarlos a un servidor externo.
  • Ataques a la cadena de suministro: bibliotecas npm/yarn comprometidas pueden incluir código malicioso que lee tokens del almacenamiento del navegador.
  • Token replay: los tokens capturados pueden usarse desde cualquier lugar, ya que no están vinculados a un navegador o IP específicos.

¿Qué Es el Patrón BFF (Backend For Frontend)?

El BFF (Backend For Frontend) es un patrón arquitectónico en el que un servidor backend dedicado actúa como intermediario entre el front-end (SPA) y los servicios de identidad/APIs protegidas. El concepto fue popularizado por Sam Newman y adaptado específicamente para la seguridad de SPAs por la comunidad OAuth.

Cómo Funciona la Arquitectura BFF

Diagrama de arquitectura BFF que muestra el flujo de comunicación entre SPA Angular, BFF Server, APIs protegidas y Azure Entra ID

Flujo Paso a Paso

Diagrama de secuencia que muestra los 11 pasos del flujo de autenticación BFF entre SPA Angular, BFF Server y Azure Entra ID

  1. El usuario abre la SPA Angular en el navegador.
  2. La SPA verifica si hay una sesión activa llamando a GET /bff/user en el BFF.
  3. Si no está autenticado, la SPA redirige el navegador a GET /bff/login.
  4. El BFF inicia el flujo OAuth 2.0 Authorization Code (con Client Secret) contra Azure Entra ID.
  5. El usuario se autentica en Azure Entra ID y otorga el consentimiento.
  6. Azure Entra ID devuelve el authorization code al BFF (callback).
  7. El BFF intercambia el code por access token, ID token y refresh token.
  8. El BFF almacena los tokens en la sesión del servidor (memoria, Redis, base de datos, etc.).
  9. El BFF emite una cookie de sesión HttpOnly, Secure, SameSite=Strict al navegador.
  10. La SPA hace solicitudes a las APIs vía BFF (/api/*), enviando la cookie automáticamente.
  11. El BFF lee la sesión, recupera el access token y hace proxy de la solicitud a la API real, incluyendo el token en el header Authorization: Bearer.

ℹ️ Información: Observa que la SPA nunca ve ni manipula tokens. Toda la gestión de credenciales queda en el servidor BFF, que es un entorno controlado y seguro — un Confidential Client en OAuth 2.0.

Ventajas del BFF

AspectoSPA tradicional (tokens en el navegador)BFF (tokens en el servidor)
Tokens en el navegadorSí (localStorage/sessionStorage)No — quedan en el servidor
Vulnerable a XSSSí — los tokens pueden ser robadosNo — cookie HttpOnly inaccesible
Tipo de Client OAuthPublic ClientConfidential Client (más seguro)
Client SecretNo puede usarseSí — seguro en el servidor
Refresh tokensEn el navegador (riesgo)En el servidor (seguro)
CSRFNo aplicaMitigable con SameSite + tokens
ComplejidadMenor (todo en el front-end)Mayor (servidor adicional)
Recomendación del IETFNo recomendado para nuevos proyectosRecomendado

Implementando el BFF con ASP.NET Core 8

Vamos a construir el BFF paso a paso. El proyecto ASP.NET Core actuará simultáneamente como servidor de autenticación (OpenID Connect), gestor de sesión y reverse proxy para las APIs protegidas.

Estructura del Proyecto

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
MinhaSPA.Bff/
├── Program.cs                    # Configuración principal del BFF
├── appsettings.json             # Configuración de Azure Entra ID y proxy
├── Endpoints/
│   └── BffEndpoints.cs          # Endpoints /bff/login, /bff/logout, /bff/user
├── Properties/
│   └── launchSettings.json
├── MinhaSPA.Bff.csproj
nginx/
├── nginx.conf                    # Configuración de NGINX como reverse proxy
└── Dockerfile                    # Contenedor NGINX para producción

Creación del Proyecto y Dependencias

1
2
3
4
5
6
# Crear proyecto ASP.NET Core 8 (vacío — sin template MVC/API)
dotnet new web -n MinhaSPA.Bff --framework net8.0
cd MinhaSPA.Bff

# Paquetes de autenticación OpenID Connect
dotnet add package Microsoft.AspNetCore.Authentication.OpenIdConnect

ℹ️ Información: En esta arquitectura, NGINX actúa como reverse proxy delante del BFF, sirviendo los archivos estáticos de Angular y reenviando las solicitudes /bff/* y /api/* a ASP.NET Core. El BFF, a su vez, hace proxy de las llamadas /api/* a las APIs protegidas vía HttpClient, inyectando el access token.

Configuración (appsettings.json)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
{
  "AzureAd": {
    "Instance": "https://login.microsoftonline.com/",
    "TenantId": "seu-tenant-id",
    "ClientId": "seu-client-id-do-bff",
    "ClientSecret": "seu-client-secret",
    "CallbackPath": "/signin-oidc",
    "SignedOutCallbackPath": "/signout-callback-oidc"
  },
  "ApiProxy": {
    "BaseUrl": "https://api.seudominio.com",
    "TimeoutSeconds": 30
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information"
    }
  }
}

Configuración Principal (Program.cs)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
// Program.cs — BFF con autenticación OpenID Connect, sesión HttpOnly y proxy vía HttpClient
using System.Net.Http.Headers;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authentication.OpenIdConnect;
using Microsoft.IdentityModel.Protocols.OpenIdConnect;

var builder = WebApplication.CreateBuilder(args);

// ===== 1. SESIÓN Y COOKIES =====
// Configurar cookie de sesión HttpOnly, Secure, SameSite
builder.Services.AddAuthentication(options =>
{
    options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
})
.AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options =>
{
    options.Cookie.Name = "MinhaSPA.Session";
    options.Cookie.HttpOnly = true;       // JavaScript NO puede acceder a esta cookie
    options.Cookie.SecurePolicy = CookieSecurePolicy.Always;  // Solo HTTPS
    options.Cookie.SameSite = SameSiteMode.Strict;            // Protección CSRF
    options.ExpireTimeSpan = TimeSpan.FromHours(8);           // Sesión de 8 horas
    options.SlidingExpiration = true;                          // Renovación automática

    // Devolver 401 en lugar de redirigir al login en llamadas AJAX
    options.Events.OnRedirectToLogin = context =>
    {
        if (context.Request.Path.StartsWithSegments("/api") ||
            context.Request.Path.StartsWithSegments("/bff"))
        {
            context.Response.StatusCode = 401;
            return Task.CompletedTask;
        }
        context.Response.Redirect(context.RedirectUri);
        return Task.CompletedTask;
    };
})
// ===== 2. OPENID CONNECT CON AZURE ENTRA ID =====
.AddOpenIdConnect(OpenIdConnectDefaults.AuthenticationScheme, options =>
{
    var azureAd = builder.Configuration.GetSection("AzureAd");

    options.Authority = $"{azureAd["Instance"]}{azureAd["TenantId"]}/v2.0";
    options.ClientId = azureAd["ClientId"];
    options.ClientSecret = azureAd["ClientSecret"];  // Confidential Client — ¡seguro!
    options.CallbackPath = azureAd["CallbackPath"];
    options.SignedOutCallbackPath = azureAd["SignedOutCallbackPath"];

    options.ResponseType = OpenIdConnectResponseType.Code;         // Authorization Code Flow
    options.SaveTokens = true;               // Guardar tokens en la sesión (¡server-side!)
    options.GetClaimsFromUserInfoEndpoint = true;
    options.MapInboundClaims = false;        // Mantener claims originales de Azure Entra

    // Scopes: openid + profile + email + scopes de tu API
    options.Scope.Clear();
    options.Scope.Add("openid");
    options.Scope.Add("profile");
    options.Scope.Add("email");
    options.Scope.Add("offline_access");     // Refresh token para renovación silenciosa
    options.Scope.Add("api://sua-api-client-id/User.Read");

    // Evento: renovar access token expirado usando refresh token
    options.Events = new OpenIdConnectEvents
    {
        OnTokenValidated = async context =>
        {
            // Aquí puedes añadir claims personalizadas, cargar roles de la base de datos, etc.
            var nome = context.Principal?.FindFirst("name")?.Value;
            Console.WriteLine($"Usuario autenticado: {nome}");
        }
    };
});

builder.Services.AddAuthorization();

// ===== 3. HTTPCLIENT PARA PROXY DE LAS APIS =====
// HttpClient con nombre para hacer proxy de las solicitudes /api/* a la API real
var apiBaseUrl = builder.Configuration["ApiProxy:BaseUrl"] ?? "https://api.seudominio.com";
var timeoutSeconds = builder.Configuration.GetValue<int>("ApiProxy:TimeoutSeconds", 30);

builder.Services.AddHttpClient("ApiProxy", client =>
{
    client.BaseAddress = new Uri(apiBaseUrl);
    client.Timeout = TimeSpan.FromSeconds(timeoutSeconds);
    client.DefaultRequestHeaders.Accept.Add(
        new MediaTypeWithQualityHeaderValue("application/json"));
});

// ===== 4. CORS (para desarrollo local) =====
builder.Services.AddCors(options =>
{
    options.AddPolicy("PermitirAngular", corsBuilder =>
    {
        corsBuilder
            .WithOrigins("http://localhost:4200")
            .AllowAnyHeader()
            .AllowAnyMethod()
            .AllowCredentials();  // Necesario para cookies cross-origin en dev
    });
});

// ===== 5. ANTIFORGERY (protección CSRF) =====
builder.Services.AddAntiforgery(options =>
{
    options.HeaderName = "X-XSRF-TOKEN";   // Header que Angular enviará
    options.Cookie.Name = "XSRF-TOKEN";    // Cookie que Angular leerá
    options.Cookie.HttpOnly = false;        // Angular necesita leer esta cookie (solo la CSRF)
    options.Cookie.SameSite = SameSiteMode.Strict;
    options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
});

var app = builder.Build();

app.UseHttpsRedirection();
app.UseCors("PermitirAngular");
app.UseAuthentication();
app.UseAuthorization();

// ===== 6. ENDPOINTS DEL BFF =====
// Endpoint: verificar el estado de autenticación del usuario
app.MapGet("/bff/user", (HttpContext ctx) =>
{
    if (ctx.User.Identity?.IsAuthenticated != true)
    {
        return Results.Unauthorized();
    }

    // Devolver claims del usuario (del ID Token, almacenado en la sesión)
    var claims = ctx.User.Claims.Select(c => new { c.Type, c.Value }).ToList();
    return Results.Ok(new
    {
        IsAuthenticated = true,
        Nome = ctx.User.FindFirst("name")?.Value,
        Email = ctx.User.FindFirst("email")?.Value,
        Claims = claims
    });
}).RequireAuthorization();

// Endpoint: iniciar login vía OpenID Connect
app.MapGet("/bff/login", (HttpContext ctx, string? returnUrl) =>
{
    var redirectUri = returnUrl ?? "/";
    return Results.Challenge(
        new AuthenticationProperties { RedirectUri = redirectUri },
        [OpenIdConnectDefaults.AuthenticationScheme]
    );
});

// Endpoint: logout — limpia la sesión local y redirige a Azure Entra
app.MapGet("/bff/logout", async (HttpContext ctx) =>
{
    await ctx.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
    await ctx.SignOutAsync(OpenIdConnectDefaults.AuthenticationScheme,
        new AuthenticationProperties { RedirectUri = "/" });
});

// ===== 7. PROXY A LAS APIs — /api/* se envían por proxy a la API real con access token =====
app.MapMethods("/api/{**remainder}", new[] { "GET", "POST", "PUT", "DELETE", "PATCH" },
    async (HttpContext ctx, IHttpClientFactory httpClientFactory, string remainder) =>
{
    // Recuperar el access token de la sesión del usuario
    var accessToken = await ctx.GetTokenAsync("access_token");
    if (string.IsNullOrEmpty(accessToken))
    {
        return Results.Unauthorized();
    }

    // Crear solicitud para la API real
    var client = httpClientFactory.CreateClient("ApiProxy");
    var targetPath = $"/{remainder}{ctx.Request.QueryString}";

    using var requestMessage = new HttpRequestMessage(
        new HttpMethod(ctx.Request.Method), targetPath);

    // Inyectar el access token en el header Authorization
    requestMessage.Headers.Authorization =
        new AuthenticationHeaderValue("Bearer", accessToken);

    // Copiar el body en solicitudes con cuerpo (POST, PUT, PATCH)
    if (ctx.Request.ContentLength > 0 || ctx.Request.ContentType != null)
    {
        requestMessage.Content = new StreamContent(ctx.Request.Body);
        if (ctx.Request.ContentType != null)
        {
            requestMessage.Content.Headers.ContentType =
                System.Net.Http.Headers.MediaTypeHeaderValue.Parse(ctx.Request.ContentType);
        }
    }

    // Reenviar headers relevantes
    foreach (var header in new[] { "Accept", "Accept-Language", "X-Request-ID" })
    {
        if (ctx.Request.Headers.TryGetValue(header, out var value))
        {
            requestMessage.Headers.TryAddWithoutValidation(header, value.ToString());
        }
    }

    // Enviar solicitud a la API real
    var response = await client.SendAsync(requestMessage);

    // Devolver la respuesta de la API a Angular
    ctx.Response.StatusCode = (int)response.StatusCode;
    ctx.Response.ContentType = response.Content.Headers.ContentType?.ToString() ?? "application/json";
    await response.Content.CopyToAsync(ctx.Response.Body);

}).RequireAuthorization();

// ===== 8. FALLBACK (solo en desarrollo sin NGINX) =====
if (app.Environment.IsDevelopment())
{
    app.UseDefaultFiles();
    app.UseStaticFiles();
    app.MapFallbackToFile("index.html");
}

app.Run();

💡 Consejo: SaveTokens = true hace que los tokens se almacenen en la cookie de sesión cifrada por ASP.NET Core Data Protection. En producción, para evitar cookies muy grandes, considera usar almacenamiento de sesión distribuido con Redis o SQL Server.


Configurando NGINX como Reverse Proxy

En producción, NGINX se sitúa delante de toda la arquitectura. Es responsable de servir los archivos estáticos de Angular (quitándole esa responsabilidad a ASP.NET Core), reenviar las solicitudes /bff/* y /api/* al BFF, gestionar TLS/SSL y aplicar rate limiting y caché de forma eficiente.

Diagrama de Arquitectura con NGINX

Diagrama de arquitectura con NGINX como reverse proxy que muestra el flujo entre Navegador, NGINX, archivos estáticos, BFF ASP.NET Core y APIs protegidas

Configuración de NGINX (nginx/nginx.conf)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
# nginx.conf — Reverse proxy para BFF + SPA Angular
worker_processes auto;
events {
    worker_connections 1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile      on;
    keepalive_timeout 65;

    # ===== RATE LIMITING =====
    # Protección contra abuso — limitar solicitudes por IP
    limit_req_zone $binary_remote_addr zone=bff_limit:10m rate=30r/s;
    limit_req_zone $binary_remote_addr zone=api_limit:10m rate=60r/s;

    # ===== GZIP =====
    gzip on;
    gzip_types text/plain text/css application/json application/javascript text/xml;
    gzip_min_length 256;

    # ===== UPSTREAM — BFF ASP.NET Core =====
    upstream bff_backend {
        server bff:5000;          # Nombre del contenedor Docker o IP del BFF
        keepalive 32;             # Conexiones persistentes para mejor rendimiento
    }

    server {
        listen 80;
        server_name app.seudominio.com;

        # Redirigir HTTP a HTTPS
        return 301 https://$server_name$request_uri;
    }

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

        # ===== TLS/SSL =====
        ssl_certificate     /etc/nginx/ssl/fullchain.pem;
        ssl_certificate_key /etc/nginx/ssl/privkey.pem;
        ssl_protocols       TLSv1.2 TLSv1.3;
        ssl_ciphers         HIGH:!aNULL:!MD5;
        ssl_prefer_server_ciphers on;

        # ===== SECURITY HEADERS =====
        add_header X-Frame-Options "DENY" always;
        add_header X-Content-Type-Options "nosniff" always;
        add_header X-XSS-Protection "1; mode=block" always;
        add_header Referrer-Policy "strict-origin-when-cross-origin" always;
        add_header Content-Security-Policy "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self' https://login.microsoftonline.com" always;
        add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

        # ===== RUTAS /bff/* — Proxy al BFF (autenticación) =====
        location /bff/ {
            limit_req zone=bff_limit burst=10 nodelay;

            proxy_pass http://bff_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            # Importante: reenviar cookies al BFF
            proxy_pass_request_headers on;
            proxy_cookie_path / /;
        }

        # ===== RUTAS /api/* — Proxy al BFF (que hace proxy a la API real) =====
        location /api/ {
            limit_req zone=api_limit burst=20 nodelay;

            proxy_pass http://bff_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            # Reenviar cookies (sesión del BFF)
            proxy_pass_request_headers on;
            proxy_cookie_path / /;

            # Timeouts para evitar bloqueos en APIs lentas
            proxy_connect_timeout 10s;
            proxy_send_timeout    30s;
            proxy_read_timeout    30s;
        }

        # ===== CALLBACKS DE OPENID CONNECT =====
        location /signin-oidc {
            proxy_pass http://bff_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_pass_request_headers on;
        }

        location /signout-callback-oidc {
            proxy_pass http://bff_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_pass_request_headers on;
        }

        # ===== ANGULAR SPA — Archivos estáticos =====
        location / {
            root /usr/share/nginx/html;   # Build de Angular (ng build)
            index index.html;
            try_files $uri $uri/ /index.html;  # SPA fallback — Angular routing

            # Caché agresiva para assets estáticos
            location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff2?)$ {
                expires 1y;
                add_header Cache-Control "public, immutable";
            }
        }
    }
}

Docker Compose para NGINX + BFF

Para simplificar el despliegue, usa Docker Compose para orquestar NGINX y el BFF:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# docker-compose.yml — NGINX + BFF ASP.NET Core
version: "3.8"

services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
      - ./dist/minha-spa:/usr/share/nginx/html:ro   # Build de Angular
    depends_on:
      - bff
    restart: unless-stopped

  bff:
    build:
      context: ./MinhaSPA.Bff
      dockerfile: Dockerfile
    environment:
      - ASPNETCORE_URLS=http://+:5000
      - AzureAd__TenantId=${AZURE_TENANT_ID}
      - AzureAd__ClientId=${AZURE_CLIENT_ID}
      - AzureAd__ClientSecret=${AZURE_CLIENT_SECRET}
    expose:
      - "5000"    # Solo accesible internamente por NGINX
    restart: unless-stopped

💡 Consejo: En desarrollo local, puedes usar el ng serve de Angular con proxy hacia el BFF (vía proxy.conf.json) sin necesidad de NGINX. NGINX solo entra en escena en los entornos de staging y producción, donde el rendimiento, TLS y los headers de seguridad son esenciales.


Renovación Automática de Tokens en el BFF

Un aspecto crítico del BFF es la renovación silenciosa de los access tokens usando el refresh token. El access token tiene una vida corta (normalmente 1 hora en Azure Entra ID), pero el refresh token permite obtener nuevos tokens sin que el usuario tenga que iniciar sesión de nuevo.

Añade este middleware en Program.cs para renovar los tokens automáticamente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
// Middleware de renovación automática de tokens — añadir ANTES de UseAuthorization()
app.Use(async (context, next) =>
{
    if (context.User.Identity?.IsAuthenticated == true)
    {
        var expiresAt = await context.GetTokenAsync("expires_at");

        if (DateTimeOffset.TryParse(expiresAt, out var expiracao) &&
            expiracao < DateTimeOffset.UtcNow.AddMinutes(5)) // Renovar 5 min antes de expirar
        {
            var refreshToken = await context.GetTokenAsync("refresh_token");

            if (!string.IsNullOrEmpty(refreshToken))
            {
                try
                {
                    // Montar la solicitud de renovación a Azure Entra ID
                    var config = context.RequestServices
                        .GetRequiredService<IConfiguration>();
                    var azureAd = config.GetSection("AzureAd");

                    using var httpClient = new HttpClient();
                    var tokenEndpoint = $"{azureAd["Instance"]}{azureAd["TenantId"]}/oauth2/v2.0/token";

                    var tokenRequest = new FormUrlEncodedContent(new Dictionary<string, string>
                    {
                        ["grant_type"] = "refresh_token",
                        ["client_id"] = azureAd["ClientId"]!,
                        ["client_secret"] = azureAd["ClientSecret"]!,
                        ["refresh_token"] = refreshToken,
                        ["scope"] = "openid profile email offline_access api://sua-api-client-id/User.Read"
                    });

                    var response = await httpClient.PostAsync(tokenEndpoint, tokenRequest);

                    if (response.IsSuccessStatusCode)
                    {
                        var payload = await response.Content
                            .ReadFromJsonAsync<Dictionary<string, object>>();

                        // Actualizar tokens en la sesión
                        var authInfo = await context.AuthenticateAsync();
                        authInfo.Properties?.UpdateTokenValue(
                            "access_token", payload!["access_token"].ToString()!);
                        authInfo.Properties?.UpdateTokenValue(
                            "refresh_token", payload["refresh_token"].ToString()!);
                        authInfo.Properties?.UpdateTokenValue(
                            "expires_at",
                            DateTimeOffset.UtcNow
                                .AddSeconds(Convert.ToDouble(payload["expires_in"]))
                                .ToString("o"));

                        // Reemitir la cookie de sesión con los nuevos tokens
                        await context.SignInAsync(
                            CookieAuthenticationDefaults.AuthenticationScheme,
                            context.User,
                            authInfo.Properties);
                    }
                }
                catch (Exception ex)
                {
                    // Registrar el error — no interrumpir la solicitud
                    var logger = context.RequestServices
                        .GetRequiredService<ILogger<Program>>();
                    logger.LogWarning(ex, "Fallo al renovar el access token");
                }
            }
        }
    }

    await next(context);
});

⚠️ Atención: En aplicaciones de producción con múltiples instancias, la renovación de tokens requiere un cuidado especial para evitar race conditions (varias instancias renovando simultáneamente). Usa un lock distribuido (Redis, por ejemplo) o delega la renovación a un único worker.


Implementando Angular 16+ con el BFF

La gran ventaja del BFF para el front-end es la simplicidad: la SPA Angular no necesita ninguna biblioteca de autenticación (como MSAL). Solo hace solicitudes HTTP normales y el navegador envía la cookie de sesión automáticamente.

Servicio de Autenticación (auth.service.ts)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
// src/app/auth/auth.service.ts — Servicio de autenticación vía BFF (¡sin MSAL!)
import { Injectable, inject } from "@angular/core";
import { HttpClient } from "@angular/common/http";
import { BehaviorSubject, Observable, catchError, of, tap } from "rxjs";

// Interfaz que representa al usuario autenticado
export interface UsuarioBff {
  isAuthenticated: boolean;
  nome: string;
  email: string;
  claims: { type: string; value: string }[];
}

@Injectable({ providedIn: "root" })
export class AuthService {
  private http = inject(HttpClient);

  // Estado reactivo del usuario
  private usuarioSubject = new BehaviorSubject<UsuarioBff | null>(null);
  public usuario$ = this.usuarioSubject.asObservable();

  /**
   * Verifica si el usuario está autenticado consultando al BFF.
   * La cookie HttpOnly la envía automáticamente el navegador.
   */
  verificarAutenticacao(): Observable<UsuarioBff | null> {
    return this.http
      .get<UsuarioBff>("/bff/user", { withCredentials: true })
      .pipe(
        tap((usuario) => this.usuarioSubject.next(usuario)),
        catchError(() => {
          // 401 = no autenticado — comportamiento esperado
          this.usuarioSubject.next(null);
          return of(null);
        })
      );
  }

  /**
   * Redirige el navegador al endpoint de login del BFF.
   * El BFF iniciará el flujo OAuth2 Authorization Code con Azure Entra ID.
   */
  login(returnUrl: string = "/"): void {
    window.location.href = `/bff/login?returnUrl=${encodeURIComponent(returnUrl)}`;
  }

  /**
   * Redirige al endpoint de logout del BFF.
   * El BFF limpia la sesión local y redirige a Azure Entra para el logout global.
   */
  logout(): void {
    window.location.href = "/bff/logout";
  }

  /** Devuelve true si el usuario está autenticado. */
  get isAutenticado(): boolean {
    return this.usuarioSubject.value?.isAuthenticated === true;
  }

  /** Devuelve el nombre del usuario autenticado. */
  get nomeUsuario(): string {
    return this.usuarioSubject.value?.nome ?? "";
  }
}

Guard de Autenticación (auth.guard.ts)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
// src/app/auth/auth.guard.ts — Guard para proteger rutas (Angular 16+ functional guard)
import { inject } from "@angular/core";
import { CanActivateFn, Router } from "@angular/router";
import { AuthService } from "./auth.service";
import { map, take } from "rxjs";

export const authGuard: CanActivateFn = () => {
  const authService = inject(AuthService);
  const router = inject(Router);

  return authService.verificarAutenticacao().pipe(
    take(1),
    map((usuario) => {
      if (usuario?.isAuthenticated) {
        return true;
      }
      // Redirigir al login en el BFF, pasando la URL actual como returnUrl
      authService.login(window.location.pathname);
      return false;
    })
  );
};

Interceptor CSRF (csrf.interceptor.ts)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// src/app/auth/csrf.interceptor.ts — Interceptor que envía el token CSRF al BFF
import { HttpInterceptorFn } from "@angular/common/http";

/**
 * Interceptor funcional (Angular 16+) que lee la cookie XSRF-TOKEN
 * y la envía en el header X-XSRF-TOKEN en solicitudes mutables (POST, PUT, DELETE).
 *
 * Angular HttpClient con withXsrfConfiguration ya lo hace automáticamente
 * para solicitudes same-origin, pero este interceptor garantiza el comportamiento
 * explícito y funciona con configuraciones personalizadas.
 */
export const csrfInterceptor: HttpInterceptorFn = (req, next) => {
  // Solo las solicitudes que modifican datos necesitan el token CSRF
  const metodosMutaveis = ["POST", "PUT", "DELETE", "PATCH"];

  if (metodosMutaveis.includes(req.method.toUpperCase())) {
    // Leer la cookie XSRF-TOKEN (definida por el BFF con HttpOnly=false)
    const csrfToken = obterCookie("XSRF-TOKEN");

    if (csrfToken) {
      req = req.clone({
        setHeaders: { "X-XSRF-TOKEN": csrfToken },
      });
    }
  }

  return next(req);
};

/** Utilidad para leer una cookie por nombre. */
function obterCookie(nome: string): string | null {
  const match = document.cookie.match(new RegExp(`(^| )${nome}=([^;]+)`));
  return match ? decodeURIComponent(match[2]) : null;
}

Configuración de la Aplicación (app.config.ts)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// src/app/app.config.ts — Configuración standalone de Angular 16+ con BFF
import { ApplicationConfig } from "@angular/core";
import { provideRouter } from "@angular/router";
import {
  provideHttpClient,
  withInterceptors,
  withXsrfConfiguration,
} from "@angular/common/http";
import { routes } from "./app.routes";
import { csrfInterceptor } from "./auth/csrf.interceptor";

export const appConfig: ApplicationConfig = {
  providers: [
    provideRouter(routes),
    provideHttpClient(
      // Configuración XSRF nativa de Angular (redundancia de seguridad)
      withXsrfConfiguration({
        cookieName: "XSRF-TOKEN",
        headerName: "X-XSRF-TOKEN",
      }),
      // Interceptor CSRF personalizado para control explícito
      withInterceptors([csrfInterceptor])
    ),
  ],
};

Rutas Protegidas (app.routes.ts)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// src/app/app.routes.ts — Rutas con guard de autenticación vía BFF
import { Routes } from "@angular/router";
import { authGuard } from "./auth/auth.guard";

export const routes: Routes = [
  {
    path: "",
    loadComponent: () =>
      import("./home/home.component").then((m) => m.HomeComponent),
  },
  {
    path: "dashboard",
    loadComponent: () =>
      import("./dashboard/dashboard.component").then((m) => m.DashboardComponent),
    canActivate: [authGuard], // Protegida — requiere autenticación vía BFF
  },
  {
    path: "admin",
    loadComponent: () =>
      import("./admin/admin.component").then((m) => m.AdminComponent),
    canActivate: [authGuard],
  },
];

Componente que Consume la API (dashboard.component.ts)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// src/app/dashboard/dashboard.component.ts — Consumo de API protegida vía proxy del BFF
import { Component, OnInit, inject } from "@angular/core";
import { CommonModule } from "@angular/common";
import { HttpClient } from "@angular/common/http";
import { AuthService } from "../auth/auth.service";

@Component({
  selector: "app-dashboard",
  standalone: true,
  imports: [CommonModule],
  template: `
    <h2>Dashboard</h2>
    <p>¡Hola, {{ auth.nomeUsuario }}!</p>

    <button (click)="carregarDados()">Cargar Datos de la API</button>
    <button (click)="auth.logout()">Logout</button>

    <div *ngIf="dados">
      <h3>Respuesta de la API:</h3>
      <pre>{{ dados | json }}</pre>
    </div>

    <div *ngIf="erro" class="erro">
      <p>Error: {{ erro }}</p>
    </div>
  `,
})
export class DashboardComponent implements OnInit {
  auth = inject(AuthService);
  private http = inject(HttpClient);

  dados: any = null;
  erro: string | null = null;

  ngOnInit(): void {
    this.carregarDados();
  }

  carregarDados(): void {
    // La solicitud va a /api/dados en el BFF (mismo dominio)
    // El BFF hace proxy a la API real, inyectando el access token
    // La cookie de sesión la envía automáticamente el navegador
    this.http
      .get("/api/dados", { withCredentials: true })
      .subscribe({
        next: (data) => {
          this.dados = data;
          this.erro = null;
        },
        error: (err) => {
          this.erro = `Fallo al cargar datos: ${err.status} ${err.statusText}`;
          if (err.status === 401) {
            this.auth.login(window.location.pathname); // La sesión expiró
          }
        },
      });
  }
}

ℹ️ Información: Observa que Angular no usa ninguna biblioteca de autenticación (ni MSAL, ni angular-oauth2-oidc). Las solicitudes son HTTP puro con HttpClient. El navegador envía la cookie de sesión automáticamente y el BFF gestiona todo el flujo OAuth2 entre bastidores.


BFF vs. SPA Tradicional: Comparativa Detallada

Para entender cuándo usar cada enfoque, mira esta comparativa lado a lado:

AspectoSPA tradicional (MSAL en el navegador)SPA con BFF (tokens en el servidor)
Biblioteca en el front-end@azure/msal-angularNinguna — solo HttpClient
Dónde quedan los tokenslocalStorage / sessionStorageSesión del servidor (memoria, Redis)
Tipo de cookieNo usa (o cookie accesible vía JS)HttpOnly + Secure + SameSite=Strict
OAuth Client TypePublic Client (sin secret)Confidential Client (con secret)
Flujo OAuthAuth Code + PKCE (en el navegador)Auth Code + Secret (en el servidor)
Vulnerable a XSSSí — tokens accesibles vía JSNo — tokens inaccesibles para JS
Complejidad en el front-endMayor (config MSAL, interceptors, guards)Menor (HTTP puro, sin config de auth)
Complejidad en el back-endMenor (la API solo valida tokens)Mayor (BFF gestiona sesión, proxy, renovación)
Renovación de tokensMSAL la hace en silencio vía iframeEl BFF renueva en el servidor vía refresh token
Adecuado paraMVPs, apps internas, bajo riesgoProducción, apps públicas, datos sensibles
Recomendación del IETFAceptable con PKCERecomendado para nuevos proyectos

Protección CSRF en el BFF

Como el BFF usa cookies para la autenticación, es potencialmente vulnerable a CSRF (Cross-Site Request Forgery). Un sitio malicioso podría intentar enviar solicitudes al BFF usando las cookies de la víctima. Para mitigarlo, uso tres capas de protección:

1
2
// Ya configurado en Program.cs
options.Cookie.SameSite = SameSiteMode.Strict;

El atributo SameSite=Strict indica al navegador que no envíe la cookie en solicitudes originadas desde otros dominios. Esto bloquea la mayoría de los ataques CSRF en navegadores modernos.

El Antiforgery de ASP.NET Core emite una cookie XSRF-TOKEN legible por JavaScript y espera que Angular envíe el valor en el header X-XSRF-TOKEN. Un sitio atacante no puede leer cookies de otro dominio, por lo que no puede falsificar ese header.

3. Validación de Origin/Referer

En escenarios de alta seguridad, añade la validación del header Origin o Referer:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Middleware de validación de origin — añadir antes de los endpoints
app.Use(async (context, next) =>
{
    var method = context.Request.Method;
    var metodosMutaveis = new[] { "POST", "PUT", "DELETE", "PATCH" };

    if (metodosMutaveis.Contains(method, StringComparer.OrdinalIgnoreCase))
    {
        var origin = context.Request.Headers.Origin.FirstOrDefault();
        var originsPermitidas = new[] { "https://app.seudominio.com", "http://localhost:4200" };

        if (!string.IsNullOrEmpty(origin) && !originsPermitidas.Contains(origin))
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsJsonAsync(new
            {
                Erro = "Origin no permitida",
                Origin = origin
            });
            return;
        }
    }

    await next(context);
});

Consejos y Buenas Prácticas

  • Usa sesión distribuida en producción: almacenar sesiones solo en memoria no funciona cuando tienes múltiples instancias del BFF. Usa Redis o SQL Server para el almacenamiento distribuido de sesiones, garantizando que cualquier instancia pueda atender cualquier solicitud.

  • Implementa health checks en el BFF: el BFF es un punto crítico de la arquitectura. Si cae, toda la SPA se queda sin autenticación. Configura health checks, monitorización y redundancia. Considera ejecutar al menos 2 réplicas en producción.

  • Separa el BFF de la API de negocio: el BFF debe hacer solo proxy y gestión de sesión. No pongas lógica de negocio en el BFF — mantenlo ligero y con una única responsabilidad. Las APIs protegidas (Resource Servers) deben validar los access tokens de forma independiente.

  • Configura timeouts adecuados en NGINX y HttpClient: en NGINX, define proxy_connect_timeout, proxy_send_timeout y proxy_read_timeout para evitar que APIs lentas bloqueen el BFF. En ASP.NET Core, el HttpClient con nombre ya tiene un timeout configurado vía appsettings.json.

  • No expongas endpoints internos: asegúrate de que solo /bff/* y /api/* sean accesibles externamente. Los endpoints de diagnóstico, métricas y health check deben estar protegidos o ser accesibles solo internamente.

  • Monitoriza el tamaño de la cookie de sesión: con SaveTokens = true, los tokens se almacenan dentro de la cookie cifrada por ASP.NET Core. Los tokens de Azure Entra ID pueden ser grandes (1-3KB). Si la cookie de sesión supera los 4KB, los navegadores pueden rechazarla. En ese caso, migra a una sesión server-side con Redis.

  • Prueba XSS con regularidad: aunque el BFF protege los tokens contra XSS, un ataque XSS todavía puede secuestrar la sesión del usuario (enviando solicitudes autenticadas en su nombre). Mantén la sanitización de entradas, CSP (Content-Security-Policy) y audita las dependencias npm con npm audit.

⚠️ Atención: El BFF no elimina la necesidad de proteger la SPA contra XSS. Elimina la posibilidad de robo de tokens, pero un XSS activo puede enviar solicitudes autenticadas mientras la sesión esté activa. Combina el BFF con headers CSP, sanitización de entradas y auditorías regulares de dependencias.


Conclusión

El patrón BFF (Backend For Frontend) es hoy el enfoque más seguro para la autenticación en Single Page Applications, siendo la recomendación oficial del IETF para aplicaciones basadas en navegador. Al trasladar la gestión de tokens a un servidor intermedio y usar cookies HttpOnly para comunicarse con el navegador, eliminamos el principal vector de ataque — el acceso de JavaScript a credenciales sensibles.

En este artículo, implementé un BFF completo con ASP.NET Core 8 que actúa como Confidential Client en OAuth 2.0, gestiona sesiones seguras y renueva los tokens automáticamente. Usé NGINX como reverse proxy delante de la arquitectura — sirviendo los archivos estáticos de Angular, reenviando solicitudes al BFF, gestionando TLS/SSL y aplicando headers de seguridad y rate limiting. En el lado del front-end, construí una SPA Angular 16+ que aprovecha la simplicidad del BFF — sin necesidad de bibliotecas de autenticación, con guards basados en llamadas HTTP y protección CSRF en múltiples capas.

El trade-off consciente de este patrón es una complejidad adicional en el backend a cambio de una seguridad significativamente mayor. Para aplicaciones que manejan datos sensibles, autentican usuarios reales y buscan cumplir con las buenas prácticas de seguridad, el BFF es el camino recomendado. Si todavía no conoces los fundamentos de OAuth2, JWT y OpenID Connect, consulta Autenticación y Autorización: JWT, OAuth2 y OpenID Connect. Si necesitas un proveedor de identidad gratuito y self-hosted compatible con el BFF, mira Keycloak: Autenticación Gratuita con Contenedores y C# — al implementar OAuth 2.0 y OpenID Connect, Keycloak funciona como Identity Provider para el BFF sin ningún cambio en la arquitectura. Y para automatizar el build y el despliegue de este stack, mira Makefile: Automatizando tareas para Python, Hugo y Docker.


Lee También


Referencias