Introducción

Si desarrollas aplicaciones web, APIs o sistemas distribuidos, ya te has enfrentado a la necesidad de responder dos preguntas fundamentales: "¿quién eres?" (autenticación) y "¿qué puedes hacer?" (autorización). Estos dos conceptos son los pilares de cualquier sistema seguro, pero con frecuencia generan confusión — especialmente cuando entran en escena protocolos como OAuth2, OpenID Connect y tokens como JWT.

En este artículo, voy a desmitificar estos conceptos de forma práctica y didáctica. Vas a entender la diferencia entre autenticación y autorización, cómo funciona JWT (JSON Web Token) por dentro, el papel de OAuth 2.0 en la delegación de acceso y cómo OpenID Connect agrega la capa de identidad que faltaba. Además, voy a explorar los tipos de Client ID que existen en Azure Entra ID (antiguo Azure AD) y cuándo usar cada uno para aplicaciones SPA, Server-Side y API REST.

Este contenido está dirigido a desarrolladores back-end, front-end y full-stack que quieren implementar autenticación y autorización de forma correcta y segura. Si trabajas con automatización e integración de sistemas, este artículo también te será útil — así como entender las diferencias entre terminal y pipeline es importante para los contextos de ejecución, la seguridad de tus flujos depende de comprender cómo se gestionan las identidades. Y si ya dominas estos fundamentos y quieres llevar la seguridad de tu SPA al siguiente nivel, revisa BFF Backend For Frontend: Seguridad en SPAs, donde aplico estos conceptos en el patrón BFF. Si buscas una solución open-source y gratuita para implementar todo esto en tu propia infraestructura, consulta Keycloak: Autenticación Gratuita con Contenedores y C#.

📦 Código fuente: La implementación completa de este artículo está en el repositorio blog-zocateli-sample en GitHub. Consulta los ejemplos en C# / Entra ID, Angular / MSAL y Python / Flask.


Autenticación vs. Autorización: ¿Cuál Es la Diferencia?

Antes de profundizar en los protocolos, es fundamental entender la diferencia entre estos dos conceptos que, aunque relacionados, tienen responsabilidades completamente distintas.

La autenticación (Authentication — AuthN) es el proceso de verificar la identidad de un usuario o sistema. Es la respuesta a la pregunta: "¿Eres quien dices ser?". Cuando escribes tu correo y contraseña en una pantalla de login, estás pasando por un proceso de autenticación. Otros ejemplos incluyen biometría, certificados digitales y tokens de acceso.

La autorización (Authorization — AuthZ) es el proceso de verificar permisos. Después de confirmar quién eres, el sistema necesita decidir: "¿Qué tienes permitido hacer?". Un usuario autenticado puede tener acceso a ciertos recursos, pero no a todos. Por ejemplo, un desarrollador puede tener permiso para leer logs de producción, pero no para eliminar bases de datos.

AspectoAutenticación (AuthN)Autorización (AuthZ)
Pregunta“¿Quién eres?”“¿Qué puedes hacer?”
CuándoOcurre primeroOcurre después de la autenticación
MecanismoLogin, contraseñas, tokens, biometríaRoles, claims, políticas, scopes
ProtocoloOpenID Connect, SAMLOAuth 2.0
EjemploIniciar sesión con correo y contraseñaAcceder al endpoint /admin de la API

ℹ️ Información: Un error muy común es tratar OAuth 2.0 como un protocolo de autenticación. En realidad, OAuth 2.0 es un protocolo de autorización. La capa de autenticación la agrega OpenID Connect, que se construye sobre OAuth 2.0.


¿Qué Es JWT (JSON Web Token)?

JWT (se pronuncia “jot”) es un estándar abierto definido en el RFC 7519 para transmitir información de forma compacta y segura entre partes como un objeto JSON. Se usa ampliamente como formato de token en flujos de autenticación y autorización.

Estructura de un JWT

Un JWT se compone de tres partes separadas por puntos (.):

1
xxxxx.yyyyy.zzzzz
  1. Header — contiene el tipo de token y el algoritmo de firma.
  2. Payload — contiene los claims (afirmaciones) sobre la entidad y metadatos.
  3. Signature — garantiza que el token no fue alterado.

Ejemplo de JWT Decodificado

Header:

1
2
3
4
5
{
  "alg": "RS256",
  "typ": "JWT",
  "kid": "abc123"
}

Payload:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
{
  "iss": "https://login.microsoftonline.com/{tenant-id}/v2.0",
  "sub": "user-object-id",
  "aud": "api://minha-api-client-id",
  "exp": 1739750400,
  "iat": 1739746800,
  "name": "Lincoln Zocateli",
  "preferred_username": "[email protected]",
  "roles": ["Admin", "Reader"],
  "scp": "User.Read Profile.Read"
}

Claims Importantes en el Contexto de Azure Entra ID

ClaimDescripción
issEmisor del token (issuer) — identifica Azure Entra ID
subSujeto — identificador único del usuario
audAudiencia — la aplicación/API para la que se emitió el token
expExpiración del token (Unix timestamp)
iatMomento de emisión (issued at)
rolesRoles asignados al usuario en la aplicación
scpScopes delegados — permisos concedidos
tidTenant ID de Azure Entra
oidObject ID del usuario en el directorio

⚠️ Atención: Nunca almacenes información sensible en el payload de un JWT. El payload está codificado en Base64, pero no cifrado — cualquiera puede decodificarlo. La firma solo garantiza integridad, no confidencialidad. Si necesitas confidencialidad, usa JWE (JSON Web Encryption) según el RFC 7516.

Validación de un JWT

Al recibir un JWT, tu aplicación DEBE validar:

  1. Firma — verificar con la clave pública del emisor (disponible en el endpoint JWKS).
  2. Emisor (iss) — confirmar que el emisor es el esperado.
  3. Audiencia (aud) — confirmar que el token fue emitido para tu API.
  4. Expiración (exp) — rechazar tokens expirados.
  5. Not Before (nbf) — si está presente, rechazar tokens antes del tiempo permitido.

OAuth 2.0: El Protocolo de Autorización

OAuth 2.0 es un framework de autorización definido en el RFC 6749 que permite a las aplicaciones obtener acceso limitado a los recursos de un usuario en un servidor, sin exponer las credenciales del usuario a la aplicación.

Los Cuatro Roles de OAuth 2.0

El protocolo define cuatro roles fundamentales:

  1. Resource Owner — el usuario dueño de los datos (por ejemplo, el titular de la cuenta).
  2. Client — la aplicación que quiere acceder a los datos en nombre del usuario.
  3. Authorization Server — el servidor que autentica al usuario y emite tokens (por ejemplo, Azure Entra ID).
  4. Resource Server — la API que protege los recursos y valida los tokens.

Principales Flujos (Grant Types)

OAuth 2.0 define varios flujos para distintos escenarios. Cada tipo de aplicación utiliza el flujo más adecuado a su arquitectura:

FlujoEscenarioSeguridad
Authorization Code + PKCESPAs, apps móviles, web appsAlta
Client CredentialsComunicación servidor a servidor (M2M)Alta
On-Behalf-Of (OBO)APIs que llaman a otras APIs en nombre del usuarioAlta
Device CodeDispositivos sin navegador (IoT, CLI)Media
ImplicitSPAs (OBSOLETO — no usar)Baja
Resource Owner Password (ROPC)Login directo con contraseña (OBSOLETO)Baja

⚠️ Atención: Los flujos Implicit y Resource Owner Password Credentials (ROPC) se consideran obsoletos e inseguros. La recomendación del IETF y de Microsoft es usar Authorization Code con PKCE para todas las aplicaciones públicas (SPAs y móviles).

El Flujo Authorization Code con PKCE

Este es el flujo recomendado para la mayoría de las aplicaciones modernas. Veamos el paso a paso:

  1. El Client genera un code_verifier (string aleatoria) y un code_challenge (hash SHA-256 del verifier).
  2. El Client redirige al usuario al Authorization Server con el code_challenge.
  3. El usuario se autentica y otorga su consentimiento para el acceso.
  4. El Authorization Server devuelve un authorization code al Client.
  5. El Client intercambia el authorization code + code_verifier por un access token.
  6. El Client usa el access token para acceder al Resource Server (API).
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
┌──────────┐                              ┌───────────────────┐
│  Client   │──(1) Auth Request + PKCE ──►│ Authorization     │
│  (App)    │                              │ Server            │
│           │◄─(4) Authorization Code ─────│ (Azure Entra ID)  │
│           │──(5) Code + Verifier ───────►│                   │
│           │◄─(6) Access Token ──────────│                   │
│           │                              └───────────────────┘
│           │──(7) API Request + Token ──►┌───────────────────┐
│           │◄─(8) Protected Resource ────│ Resource Server   │
└──────────┘                              │ (Tu API)          │
                                          └───────────────────┘

OpenID Connect: Identidad Sobre OAuth 2.0

OpenID Connect (OIDC) es una capa de identidad construida sobre OAuth 2.0. Mientras OAuth 2.0 responde “¿a qué puedes acceder?”, OIDC responde “¿quién eres?”.

OIDC introduce un nuevo tipo de token: el ID Token. Este token es un JWT que contiene información sobre el usuario autenticado (nombre, correo, foto, etc.) y se emite junto con el access token.

Diferencia Entre los Tokens

TokenPropósitoFormato¿Quién lo consume?
ID TokenInformación de identidad del usuarioJWTEl Client (front-end)
Access TokenAutorización para acceder a recursos protegidosJWT*El Resource Server
Refresh TokenObtener nuevos access tokens sin re-autenticaciónOpacoEl Authorization Server

ℹ️ Información: El Access Token emitido por Azure Entra ID es un JWT, pero la especificación OAuth 2.0 no obliga a ese formato — algunos proveedores usan tokens opacos. Valida siempre el token según la documentación de tu proveedor.

Scopes de OpenID Connect

OIDC define scopes estandarizados que determinan qué información del usuario se devuelve:

  • openid — obligatorio para habilitar el flujo OIDC; devuelve el claim sub.
  • profile — devuelve name, family_name, given_name, picture, etc.
  • email — devuelve email y email_verified.
  • offline_access — solicita un refresh token para renovar el acceso.

SAML 2.0: El Protocolo de Identidad Corporativa

Antes de pasar a los tipos de Client ID en Azure Entra, vale la pena conocer otro protocolo muy usado en entornos corporativos: SAML 2.0 (Security Assertion Markup Language). Mientras OpenID Connect domina el panorama de las aplicaciones modernas (SPAs, APIs REST, móviles), SAML sigue siendo el estándar en muchas organizaciones — especialmente para integración con sistemas legados, ERPs y federación entre empresas.

¿Qué Es SAML 2.0?

SAML 2.0 es un estándar abierto basado en XML, definido por OASIS, para intercambiar datos de autenticación y autorización entre un Identity Provider (IdP) y un Service Provider (SP). Se publicó en 2005 y se convirtió en el protocolo dominante para Single Sign-On (SSO) corporativo durante la última década.

¿Cómo Funciona el Flujo SAML?

El flujo más común es el SP-Initiated SSO (el login comienza en el servicio al que el usuario quiere acceder):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
┌──────────┐                              ┌───────────────────┐
│  Usuario  │──(1) Accede al servicio ─────►│ Service Provider  │
│ (Browser) │                              │ (Tu Aplicación)   │
│           │◄─(2) Redirect al IdP ────────│                   │
│           │──(3) Login en IdP ──────────►┌───────────────────┐
│           │                              │ Identity Provider │
│           │◄─(4) SAML Response (XML) ────│ (Azure AD, ADFS,  │
│           │──(5) POST al SP ────────────►│  Keycloak, etc.)  │
│           │◄─(6) Sesión establecida ─────└───────────────────┘
└──────────┘                              │ Service Provider  │
                                          └───────────────────┘
  1. El usuario accede al Service Provider (tu aplicación)
  2. El SP detecta que el usuario no está autenticado y genera un SAML AuthnRequest (XML)
  3. El navegador se redirige al Identity Provider con el AuthnRequest
  4. El usuario se autentica en el IdP (login, MFA, etc.)
  5. El IdP genera una SAML Response que contiene una Assertion (declaración firmada con los datos del usuario)
  6. El navegador hace POST de la SAML Response al SP, que valida la firma y establece la sesión

SAML Assertion: La Estructura

Una SAML Assertion es un documento XML firmado digitalmente que contiene:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
<saml:Assertion xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"
                ID="_abc123" IssueInstant="2025-12-15T10:00:00Z">
  <saml:Issuer>https://idp.empresa.com</saml:Issuer>
  <saml:Subject>
    <saml:NameID>[email protected]</saml:NameID>
  </saml:Subject>
  <saml:Conditions NotBefore="2025-12-15T10:00:00Z"
                   NotOnOrAfter="2025-12-15T11:00:00Z">
    <saml:AudienceRestriction>
      <saml:Audience>https://app.seudominio.com</saml:Audience>
    </saml:AudienceRestriction>
  </saml:Conditions>
  <saml:AttributeStatement>
    <saml:Attribute Name="email">
      <saml:AttributeValue>[email protected]</saml:AttributeValue>
    </saml:Attribute>
    <saml:Attribute Name="role">
      <saml:AttributeValue>Admin</saml:AttributeValue>
    </saml:Attribute>
  </saml:AttributeStatement>
</saml:Assertion>

ℹ️ Información: A diferencia de JWT (que es compacto y basado en JSON), la SAML Assertion es basada en XML — más verbosa, pero con un modelo de firma digital consolidado y ampliamente auditado (XML Signature).

SAML 2.0 vs OpenID Connect: ¿Cuándo Usar Cada Uno?

AspectoSAML 2.0OpenID Connect
FormatoXMLJSON (JWT)
TransporteHTTP Redirect / POSTHTTP Redirect / REST
Tamaño del tokenGrande (XML verboso)Compacto (JWT)
Escenarios idealesSSO corporativo, federación B2B, legadoSPAs, APIs REST, móvil, microservicios
Soporte móvilDébil (XML pesado)Nativo (JSON + PKCE)
MadurezDesde 2005, muy difundido en enterpriseDesde 2014, estándar para apps modernas
Identity ProvidersADFS, Shibboleth, PingFederate, KeycloakAzure Entra, Google, Keycloak, Auth0
Protocolo baseIndependienteConstruido sobre OAuth 2.0

💡 Consejo: En la práctica, muchos identity providers modernos soportan ambos protocolos. Keycloak, por ejemplo, es un IdP open-source que implementa OAuth 2.0, OpenID Connect y SAML 2.0 — lo que permite atender tanto aplicaciones modernas como sistemas legados con un único servidor de identidad.

Recomendación práctica:

  • Para nuevas aplicaciones (SPAs, APIs, móvil): usa OpenID Connect
  • Para integración con sistemas corporativos legados (SAP, Salesforce, ADFS): usa SAML 2.0
  • Para entornos mixtos: usa un IdP que soporte ambos (Azure Entra ID, Keycloak) y configura cada aplicación con el protocolo más adecuado

Tipos de Client ID en Azure Entra ID

En Azure Entra ID, cuando registras una aplicación, obtienes un Client ID (también llamado Application ID). Sin embargo, el tipo de registro y la configuración de plataforma varían según la naturaleza de la aplicación. Esto afecta directamente al flujo OAuth utilizado y al nivel de seguridad.

Aplicación Pública vs. Confidencial

Azure Entra ID clasifica las aplicaciones en dos tipos fundamentales:

Tipo¿Puede guardar un secret?EjemplosFlujos recomendados
PúblicaNoSPA, móvil, desktop, CLIAuthorization Code + PKCE
ConfidencialSíWeb app server-side, daemon, APIAuth Code + Secret, Client Credentials

💡 Consejo: Una aplicación es pública cuando se ejecuta en un entorno que el usuario controla (navegador, celular, desktop) — donde no es posible almacenar un secret de forma segura. Una aplicación es confidencial cuando se ejecuta en un servidor que tú controlas.

1. Client ID para Aplicaciones SPA (Single Page Application)

Una SPA (Single Page Application) es una aplicación front-end que se ejecuta íntegramente en el navegador, como aplicaciones React, Angular o Vue.js. Como el código se ejecuta del lado del cliente, no es posible almacenar Client Secrets — cualquier secret quedaría expuesto en el código fuente o en las herramientas de desarrollo del navegador.

Configuración en Azure Entra ID:

  • Tipo de plataforma: Single-page application
  • Tipo de aplicación: Public client
  • Redirect URI: http://localhost:4200 (dev) / https://app.seudominio.com (producción)
  • Flujo OAuth: Authorization Code con PKCE
  • Client Secret: NO usar — las aplicaciones públicas no deben tener secret

Registro vía Azure CLI:

1
2
3
4
5
6
7
8
9
# Registrar una aplicación SPA en Azure Entra ID
az ad app create \
  --display-name "Mi SPA Angular" \
  --sign-in-audience "AzureADMyOrg" \
  --enable-id-token-issuance true \
  --enable-access-token-issuance false \
  --web-redirect-uris "" \
  --public-client-redirect-uris "http://localhost:4200" \
  --is-fallback-public-client true

Ejemplo con Angular 16+ y @azure/msal-angular:

Primero, instala las dependencias necesarias:

1
npm install @azure/msal-browser @azure/msal-angular

Configuración de MSAL (auth-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
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
// src/app/auth-config.ts — Configuración de MSAL para Angular 16+
import { MsalGuardConfiguration, MsalInterceptorConfiguration } from "@azure/msal-angular";
import {
  BrowserCacheLocation,
  InteractionType,
  IPublicClientApplication,
  LogLevel,
  PublicClientApplication,
} from "@azure/msal-browser";

// Configuración de MSAL — NO incluye client secret (app pública)
export function MSALInstanceFactory(): IPublicClientApplication {
  return new PublicClientApplication({
    auth: {
      clientId: "seu-client-id-aqui",             // Application (client) ID
      authority: "https://login.microsoftonline.com/seu-tenant-id",
      redirectUri: "http://localhost:4200",         // Redirect URI configurada en el portal
      postLogoutRedirectUri: "http://localhost:4200",
    },
    cache: {
      cacheLocation: BrowserCacheLocation.SessionStorage, // sessionStorage para SPAs
      storeAuthStateInCookie: false,
    },
    system: {
      loggerOptions: {
        logLevel: LogLevel.Info,
        loggerCallback: (level, message) => console.log(message),
      },
    },
  });
}

// Configuración de MsalGuard — protege rutas que requieren autenticación
export function MSALGuardConfigFactory(): MsalGuardConfiguration {
  return {
    interactionType: InteractionType.Redirect, // Redirect o Popup
    authRequest: {
      scopes: ["openid", "profile", "email"],
    },
  };
}

// Configuración de MsalInterceptor — inyecta el access token automáticamente en las solicitudes HTTP
export function MSALInterceptorConfigFactory(): MsalInterceptorConfiguration {
  const protectedResources = new Map<string, Array<string>>();
  // Toda solicitud a tu API recibirá el token automáticamente
  protectedResources.set("https://api.seudominio.com/*", ["api://minha-api/User.Read"]);
  // Microsoft Graph (opcional)
  protectedResources.set("https://graph.microsoft.com/v1.0/*", ["User.Read"]);

  return {
    interactionType: InteractionType.Redirect,
    protectedResourceMap: protectedResources,
  };
}

Módulo principal con API standalone (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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// src/app/app.config.ts — Configuración standalone de Angular 16+
import { ApplicationConfig, importProvidersFrom } from "@angular/core";
import { provideRouter } from "@angular/router";
import { provideHttpClient, withInterceptorsFromDi, HTTP_INTERCEPTORS } from "@angular/common/http";
import {
  MsalModule,
  MsalService,
  MsalGuard,
  MsalInterceptor,
  MsalBroadcastService,
  MSAL_INSTANCE,
  MSAL_GUARD_CONFIG,
  MSAL_INTERCEPTOR_CONFIG,
} from "@azure/msal-angular";
import {
  MSALInstanceFactory,
  MSALGuardConfigFactory,
  MSALInterceptorConfigFactory,
} from "./auth-config";
import { routes } from "./app.routes";

export const appConfig: ApplicationConfig = {
  providers: [
    provideRouter(routes),
    provideHttpClient(withInterceptorsFromDi()),
    importProvidersFrom(MsalModule),
    {
      provide: HTTP_INTERCEPTORS,
      useClass: MsalInterceptor, // El interceptor inyecta el token en las solicitudes automáticamente
      multi: true,
    },
    {
      provide: MSAL_INSTANCE,
      useFactory: MSALInstanceFactory,
    },
    {
      provide: MSAL_GUARD_CONFIG,
      useFactory: MSALGuardConfigFactory,
    },
    {
      provide: MSAL_INTERCEPTOR_CONFIG,
      useFactory: MSALInterceptorConfigFactory,
    },
    MsalService,
    MsalGuard,             // Guard para proteger rutas
    MsalBroadcastService,  // Service para observar eventos de autenticación
  ],
};

Rutas protegidas (app.routes.ts):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
// src/app/app.routes.ts — Rutas con MsalGuard para proteger el acceso
import { Routes } from "@angular/router";
import { MsalGuard } from "@azure/msal-angular";
import { HomeComponent } from "./home/home.component";
import { DashboardComponent } from "./dashboard/dashboard.component";

export const routes: Routes = [
  { path: "", component: HomeComponent },
  {
    path: "dashboard",
    component: DashboardComponent,
    canActivate: [MsalGuard], // Ruta protegida — requiere autenticación
  },
];

Componente con login y llamada a la API (home.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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
// src/app/home/home.component.ts — Componente con login y consumo de API
import { Component, OnInit, OnDestroy, inject } from "@angular/core";
import { CommonModule } from "@angular/common";
import { HttpClient } from "@angular/common/http";
import { MsalService, MsalBroadcastService } from "@azure/msal-angular";
import { InteractionStatus } from "@azure/msal-browser";
import { Subject, filter, takeUntil } from "rxjs";

@Component({
  selector: "app-home",
  standalone: true,
  imports: [CommonModule],
  template: `
    <div *ngIf="!isAutenticado">
      <h2>Bienvenido</h2>
      <button (click)="login()">Login con Azure Entra ID</button>
    </div>
    <div *ngIf="isAutenticado">
      <h2>Hola, {{ nomeUsuario }}!</h2>
      <button (click)="chamarApi()">Llamar API Protegida</button>
      <button (click)="logout()">Logout</button>
      <pre *ngIf="dadosApi">{{ dadosApi | json }}</pre>
    </div>
  `,
})
export class HomeComponent implements OnInit, OnDestroy {
  private msalService = inject(MsalService);
  private broadcastService = inject(MsalBroadcastService);
  private http = inject(HttpClient);
  private destroy$ = new Subject<void>();

  isAutenticado = false;
  nomeUsuario = "";
  dadosApi: any = null;

  ngOnInit(): void {
    // Observar cambios en el estado de autenticación
    this.broadcastService.inProgress$
      .pipe(
        filter((status) => status === InteractionStatus.None),
        takeUntil(this.destroy$)
      )
      .subscribe(() => {
        const accounts = this.msalService.instance.getAllAccounts();
        this.isAutenticado = accounts.length > 0;
        if (this.isAutenticado) {
          this.nomeUsuario = accounts[0].name ?? accounts[0].username;
        }
      });
  }

  login(): void {
    // Inicia el flujo de login vía redirect (Authorization Code + PKCE)
    this.msalService.loginRedirect({
      scopes: ["openid", "profile", "email", "api://minha-api/User.Read"],
    });
  }

  logout(): void {
    this.msalService.logoutRedirect({
      postLogoutRedirectUri: "http://localhost:4200",
    });
  }

  chamarApi(): void {
    // El MsalInterceptor inyecta el access token automáticamente
    this.http.get("https://api.seudominio.com/api/dados").subscribe({
      next: (data) => (this.dadosApi = data),
      error: (err) => console.error("Error al llamar a la API:", err),
    });
  }

  ngOnDestroy(): void {
    this.destroy$.next();
    this.destroy$.complete();
  }
}

💡 Consejo: En Angular 16+, el MsalInterceptor inyecta automáticamente el access token en todas las solicitudes HTTP que coincidan con los patrones configurados en protectedResourceMap. No necesitas gestionar tokens manualmente — basta con usar HttpClient normalmente.

ℹ️ Información: Aunque MSAL funciona bien para SPAs, el enfoque más seguro hoy es el patrón BFF (Backend For Frontend), que evita exponer tokens en el navegador. Consulta la implementación completa en BFF Backend For Frontend: Seguridad en SPAs.

2. Client ID para Aplicaciones Server-Side (Web App)

Las aplicaciones server-side son aplicaciones web tradicionales que se ejecutan en el servidor (por ejemplo, ASP.NET, Django, Express.js). Como el código se ejecuta en un entorno controlado, estas aplicaciones pueden almacenar un Client Secret de forma segura.

Configuración en Azure Entra ID:

  • Tipo de plataforma: Web
  • Tipo de aplicación: Confidential client
  • Redirect URI: https://app.seudominio.com/auth/callback
  • Flujo OAuth: Authorization Code (con Client Secret)
  • Client Secret: Sí — almacenado de forma segura en el servidor (por ejemplo, variable de entorno, Key Vault)

Registro vía Azure CLI:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# Registrar una aplicación web confidencial
az ad app create \
  --display-name "Mi Web App" \
  --sign-in-audience "AzureADMyOrg" \
  --web-redirect-uris "https://app.seudominio.com/auth/callback" \
  --enable-id-token-issuance true

# Crear un Client Secret (válido por 2 años)
az ad app credential reset \
  --id "seu-app-object-id" \
  --display-name "Prod Secret" \
  --years 2

Ejemplo con Python (Flask + MSAL):

 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
# app.py — Aplicación Flask con autenticación vía Azure Entra ID
import os
from flask import Flask, redirect, url_for, session, request
import msal

app = Flask(__name__)
app.secret_key = os.environ.get("FLASK_SECRET_KEY", "dev-secret-key")

# Configuración — Client Secret almacenado en variable de entorno
CLIENT_ID = os.environ["AZURE_CLIENT_ID"]
CLIENT_SECRET = os.environ["AZURE_CLIENT_SECRET"]  # Seguro en el servidor
AUTHORITY = f"https://login.microsoftonline.com/{os.environ['AZURE_TENANT_ID']}"
REDIRECT_URI = "https://app.seudominio.com/auth/callback"
SCOPE = ["User.Read"]  # Scopes de Microsoft Graph

# Crear instancia confidencial de MSAL
def criar_msal_app():
    return msal.ConfidentialClientApplication(
        CLIENT_ID,
        authority=AUTHORITY,
        client_credential=CLIENT_SECRET,  # Secret usado aquí (servidor seguro)
    )

@app.route("/login")
def login():
    """Inicia el flujo de autenticación OAuth 2.0 Authorization Code."""
    msal_app = criar_msal_app()
    # Generar URL de autorización
    auth_url = msal_app.get_authorization_request_url(
        scopes=SCOPE,
        redirect_uri=REDIRECT_URI,
    )
    return redirect(auth_url)

@app.route("/auth/callback")
def callback():
    """Callback de Azure Entra ID tras la autenticación."""
    msal_app = criar_msal_app()
    code = request.args.get("code")

    # Intercambiar el authorization code por tokens
    result = msal_app.acquire_token_by_authorization_code(
        code,
        scopes=SCOPE,
        redirect_uri=REDIRECT_URI,
    )

    if "access_token" in result:
        session["user"] = result.get("id_token_claims")
        session["access_token"] = result["access_token"]
        return redirect(url_for("index"))
    else:
        return f"Error en la autenticación: {result.get('error_description')}", 401

@app.route("/")
def index():
    """Página principal — requiere autenticación."""
    user = session.get("user")
    if not user:
        return redirect(url_for("login"))
    return f"Hola, {user.get('name')}! Estás autenticado."

if __name__ == "__main__":
    app.run(debug=True, port=5000)

⚠️ Atención: Nunca expongas el Client Secret en el código fuente, repositorios Git o logs. Usa variables de entorno, Azure Key Vault o herramientas de gestión de secretos. En el ejemplo anterior, los valores vienen de os.environ por seguridad.

3. Client ID para APIs REST (Comunicación Máquina a Máquina)

Cuando una API backend o un servicio daemon necesita acceder a otra API protegida sin interacción del usuario, se utiliza el flujo Client Credentials. En este escenario, la propia aplicación se autentica con su Client ID y Client Secret (o certificado), sin involucrar a ningún usuario.

Configuración en Azure Entra ID:

  • Tipo de plataforma: Ninguna (no necesita Redirect URI)
  • Tipo de aplicación: Confidential client
  • Flujo OAuth: Client Credentials
  • Client Secret o Certificado: Sí — obligatorio
  • Permisos: Application permissions (no delegados)

Escenarios comunes:

  • Cron jobs y servicios programados que consumen APIs
  • Microservicio A llamando al Microservicio B
  • Pipelines de CI/CD que acceden a recursos protegidos
  • Daemons y workers en segundo plano

Ejemplo con Python (requests + MSAL):

 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
# daemon_service.py — Servicio M2M con Client Credentials
import os
import msal
import requests

# Configuración del daemon/servicio
CLIENT_ID = os.environ["AZURE_CLIENT_ID"]
CLIENT_SECRET = os.environ["AZURE_CLIENT_SECRET"]
TENANT_ID = os.environ["AZURE_TENANT_ID"]
AUTHORITY = f"https://login.microsoftonline.com/{TENANT_ID}"

# Scope de la API destino — formato: api://<client-id>/.default
API_SCOPE = ["api://api-destino-client-id/.default"]
API_BASE_URL = "https://api.seudominio.com"

def obter_token_m2m():
    """Obtiene un access token usando Client Credentials (sin usuario)."""
    app = msal.ConfidentialClientApplication(
        CLIENT_ID,
        authority=AUTHORITY,
        client_credential=CLIENT_SECRET,
    )

    # Intenta usar el token en caché antes de solicitar uno nuevo
    result = app.acquire_token_silent(API_SCOPE, account=None)
    if not result:
        # Solicita un nuevo token vía Client Credentials
        result = app.acquire_token_for_client(scopes=API_SCOPE)

    if "access_token" in result:
        return result["access_token"]
    else:
        raise Exception(f"Error al obtener el token: {result.get('error_description')}")

def chamar_api_protegida():
    """Chama a API protegida usando o access token M2M."""
    token = obter_token_m2m()

    # Incluir el token en el header Authorization
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    }

    response = requests.get(f"{API_BASE_URL}/api/dados", headers=headers)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    dados = chamar_api_protegida()
    print(f"Datos recibidos de la API: {dados}")

💡 Consejo: Para escenarios de producción con alta seguridad, prefiere certificados en lugar de Client Secrets para la autenticación de servicios M2M. Los certificados ofrecen mayor seguridad y pueden gestionarse vía Azure Key Vault.


Tabla Comparativa: ¿Qué Tipo de Client ID Usar?

Esta tabla resume las decisiones que debes tomar al registrar tu aplicación en Azure Entra ID:

CaracterísticaSPA (Public Client)Server-Side (Confidential)API REST / Daemon (Confidential)
Dónde se ejecutaNavegador del usuarioServidor webServidor backend
Client SecretNoSíSí (o certificado)
Flujo OAuthAuth Code + PKCEAuth Code + SecretClient Credentials
Interacción del usuarioSí (login interactivo)Sí (login interactivo)No (M2M)
Tokens recibidosID Token + Access TokenID Token + Access TokenSolo Access Token
Refresh TokenSí (con offline_access)SíNo (usa caché de token)
Ejemplo de appAngular, React, VueFlask, ASP.NET, ExpressCron job, microservicio, daemon
Plataforma en el portalSingle-page applicationWebNinguna (solo app permissions)
Biblioteca MSAL@azure/msal-angularmsal-python / MSAL.NETmsal-python / MSAL.NET

Protegiendo tu API con C#: Validación de Tokens en ASP.NET Core

Independientemente del tipo de cliente que llame a tu API, la API REST necesita validar el access token recibido. Veamos cómo hacerlo en C# con ASP.NET Core usando el paquete Microsoft.Identity.Web, que es la forma recomendada por Microsoft para proteger APIs con Azure Entra ID.

Primero, crea el proyecto e instala las dependencias:

1
2
3
4
5
6
7
# Crear proyecto Web API
dotnet new webapi -n MinhaApiProtegida --framework net8.0
cd MinhaApiProtegida

# Instalar paquetes de autenticación Microsoft Identity
dotnet add package Microsoft.Identity.Web
dotnet add package Microsoft.Identity.Web.MicrosoftGraph  # Opcional: si necesitas llamar a Graph

Configuración (appsettings.json):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
{
  "AzureAd": {
    "Instance": "https://login.microsoftonline.com/",
    "TenantId": "seu-tenant-id",
    "ClientId": "api://seu-client-id-da-api",
    "Audience": "api://seu-client-id-da-api",
    "Scopes": "User.Read Admin.Full"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information"
    }
  }
}

Configuración de 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
// Program.cs — API REST protegida con Azure Entra ID (ASP.NET Core 8)
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.Identity.Web;

var builder = WebApplication.CreateBuilder(args);

// Configura autenticación JWT Bearer con Azure Entra ID
// Microsoft.Identity.Web se encarga automáticamente de:
// - Obtener las claves públicas (JWKS) de Azure Entra ID
// - Validar issuer, audience, firma y expiración del token
// - Validar scopes y roles
builder.Services
    .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApi(builder.Configuration.GetSection("AzureAd"));

// Configurar políticas de autorización basadas en roles y scopes
builder.Services.AddAuthorizationBuilder()
    .AddPolicy("LeituraPermitida", policy =>
        policy.RequireScope("User.Read"))       // Exige el scope User.Read
    .AddPolicy("AdminOnly", policy =>
        policy.RequireRole("Admin"));            // Exige el role Admin

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Configurar CORS para permitir solicitudes de la SPA Angular
builder.Services.AddCors(options =>
{
    options.AddPolicy("PermitirSPA", corsBuilder =>
    {
        corsBuilder
            .WithOrigins("http://localhost:4200", "https://app.seudominio.com")
            .AllowAnyHeader()
            .AllowAnyMethod();
    });
});

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseCors("PermitirSPA");
app.UseAuthentication();  // Middleware de autenticación (valida el JWT)
app.UseAuthorization();   // Middleware de autorización (verifica policies)
app.MapControllers();

app.Run();

Controller con endpoints protegidos (DadosController.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
// Controllers/DadosController.cs — Endpoints protegidos con autorización granular
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Identity.Web;
using Microsoft.Identity.Web.Resource;

namespace MinhaApiProtegida.Controllers;

[ApiController]
[Route("api/[controller]")]
[Authorize]  // Todos los endpoints exigen autenticación por defecto
public class DadosController : ControllerBase
{
    /// <summary>
    /// Endpoint protegido — requiere un access token válido con el scope User.Read.
    /// Puede ser llamado por SPAs (delegated) o daemons (application).
    /// </summary>
    [HttpGet]
    [RequiredScope(RequiredScopesConfigurationKey = "AzureAd:Scopes")] // Valida el scope
    public IActionResult ObterDados()
    {
        // Extraer información del token JWT validado
        var usuario = User.GetDisplayName()
                     ?? User.FindFirst("preferred_username")?.Value
                     ?? "Desconocido";

        var objectId = User.GetObjectId();             // OID de Azure Entra
        var tenantId = User.GetTenantId();             // Tenant ID
        var scopes = User.FindFirst("scp")?.Value;     // Scopes delegados

        return Ok(new
        {
            Mensagem = "¡Acceso autorizado!",
            Usuario = usuario,
            ObjectId = objectId,
            TenantId = tenantId,
            Scopes = scopes,
            Timestamp = DateTime.UtcNow
        });
    }

    /// <summary>
    /// Endpoint admin — requiere el role 'Admin' asignado en Azure Entra ID.
    /// </summary>
    [HttpGet("admin")]
    [Authorize(Policy = "AdminOnly")] // Exige el role Admin
    public IActionResult ObterDadosAdmin()
    {
        var roles = User.Claims
            .Where(c => c.Type == "roles" || c.Type == System.Security.Claims.ClaimTypes.Role)
            .Select(c => c.Value)
            .ToList();

        return Ok(new
        {
            Mensagem = "¡Bienvenido, administrador!",
            Roles = roles,
            Usuario = User.GetDisplayName()
        });
    }

    /// <summary>
    /// Endpoint que diferencia llamadas delegadas (usuario) de llamadas M2M (daemon).
    /// Útil cuando la misma API es consumida por SPAs y por servicios backend.
    /// </summary>
    [HttpGet("info")]
    public IActionResult InformacoesToken()
    {
        var scopeClaim = User.FindFirst("scp");        // Presente en tokens delegados
        var rolesClaim = User.FindFirst("roles");      // Presente en tokens de aplicación

        var tipoFluxo = scopeClaim != null
            ? "Delegado (usuario vía SPA/Web App)"
            : "Aplicación (M2M vía Client Credentials)";

        return Ok(new
        {
            TipoFluxo = tipoFluxo,
            Issuer = User.FindFirst("iss")?.Value,
            Audience = User.FindFirst("aud")?.Value,
            Expiracao = User.FindFirst("exp")?.Value,
            Scopes = scopeClaim?.Value,
            Roles = rolesClaim?.Value
        });
    }
}

💡 Consejo: El paquete Microsoft.Identity.Web simplifica enormemente la validación de tokens en ASP.NET Core. Obtiene automáticamente las claves JWKS de Azure Entra ID y valida issuer, audience, firma y expiración — todo configurado con una sola línea en Program.cs. Además, métodos de extensión como User.GetDisplayName() y User.GetObjectId() facilitan la extracción de claims del JWT ya validado.


Consejos y Buenas Prácticas

  • Usa siempre PKCE en aplicaciones públicas: aunque el framework no lo exija, PKCE protege contra ataques de interceptación del authorization code. Azure Entra ID soporta PKCE en todos los flujos.

  • Prefiere certificados en lugar de Client Secrets en producción: los Client Secrets expiran y pueden filtrarse en logs. Los certificados gestionados por Azure Key Vault son más seguros y admiten rotación automatizada.

  • Define scopes granulares en tu API: en lugar de un único scope genérico, crea scopes como User.Read, User.Write, Admin.Full para aplicar el principio de mínimo privilegio.

  • Valida TODOS los campos del JWT en tu API: no confíes solo en la firma. Valida iss, aud, exp, nbf y los scopes/roles necesarios para cada endpoint.

  • Usa Managed Identities cuando sea posible: para servicios que se ejecutan en Azure (App Service, Functions, VMs), usa Managed Identities en lugar de Client Secrets. Esto elimina la necesidad de gestionar credenciales.

  • Configura tiempos de expiración adecuados: los Access Tokens deben tener una vida corta (por defecto: 1 hora en Azure Entra). Usa Refresh Tokens para la renovación. Nunca amplíes en exceso el tiempo de expiración.

  • Implementa el logout correctamente: además de limpiar los tokens localmente, redirige al usuario al endpoint de logout de Azure Entra (/oauth2/v2.0/logout) para terminar la sesión en el proveedor de identidad.

⚠️ Atención: Nunca valides tokens solo en el front-end. La validación real debe ocurrir en la API (Resource Server). El front-end puede inspeccionar el ID Token para mostrar información del usuario, pero la autorización siempre ocurre en el backend.


Conclusión

Entender la diferencia entre autenticación y autorización es la base para construir sistemas seguros. JWT ofrece un formato compacto y autocontenido para transportar claims de identidad y permisos. OAuth 2.0 resuelve el problema de la delegación de acceso sin exponer credenciales, mientras que OpenID Connect agrega la capa de identidad que permite saber quién es el usuario autenticado.

En la práctica, al usar Azure Entra ID, elegir el tipo correcto de Client ID es decisivo para la seguridad de tu aplicación: las aplicaciones SPA usan clientes públicos con PKCE, las aplicaciones server-side usan clientes confidenciales con secrets, y las APIs/daemons usan el flujo Client Credentials para comunicación máquina a máquina. Y si el escenario requiere integración con sistemas legados, SAML 2.0 sigue siendo el protocolo adecuado — muchos identity providers, incluido Azure Entra ID, soportan ambos protocolos simultáneamente.

Lo más importante es seguir el principio de que cada aplicación debe tener solo los permisos necesarios para cumplir su función. Para SPAs que manejan datos sensibles, considera adoptar el patrón BFF (Backend For Frontend), que lleva los tokens al servidor — mira cómo implementarlo en BFF Backend For Frontend: Seguridad en SPAs. Si necesitas un identity provider gratuito y open-source que soporte OAuth 2.0, OpenID Connect y SAML 2.0 en tu propia infraestructura, consulta Keycloak: Autenticación Gratuita con Contenedores y C#. Si te gustó este contenido, deja un comentario con tus dudas o compártelo con otros desarrolladores. Para profundizar en la automatización de proyectos, revisa también Makefile: Automatizando tareas para Python, Hugo y Docker.


Lee También


Referencias