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.
| Aspecto | Autenticación (AuthN) | Autorización (AuthZ) |
|---|---|---|
| Pregunta | “¿Quién eres?” | “¿Qué puedes hacer?” |
| Cuándo | Ocurre primero | Ocurre después de la autenticación |
| Mecanismo | Login, contraseñas, tokens, biometría | Roles, claims, políticas, scopes |
| Protocolo | OpenID Connect, SAML | OAuth 2.0 |
| Ejemplo | Iniciar sesión con correo y contraseña | Acceder 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 (.):
| |
- Header — contiene el tipo de token y el algoritmo de firma.
- Payload — contiene los claims (afirmaciones) sobre la entidad y metadatos.
- Signature — garantiza que el token no fue alterado.
Ejemplo de JWT Decodificado
Header:
| |
Payload:
| |
Claims Importantes en el Contexto de Azure Entra ID
| Claim | Descripción |
|---|---|
iss | Emisor del token (issuer) — identifica Azure Entra ID |
sub | Sujeto — identificador único del usuario |
aud | Audiencia — la aplicación/API para la que se emitió el token |
exp | Expiración del token (Unix timestamp) |
iat | Momento de emisión (issued at) |
roles | Roles asignados al usuario en la aplicación |
scp | Scopes delegados — permisos concedidos |
tid | Tenant ID de Azure Entra |
oid | Object 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:
- Firma — verificar con la clave pública del emisor (disponible en el endpoint JWKS).
- Emisor (
iss) — confirmar que el emisor es el esperado. - Audiencia (
aud) — confirmar que el token fue emitido para tu API. - Expiración (
exp) — rechazar tokens expirados. - 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:
- Resource Owner — el usuario dueño de los datos (por ejemplo, el titular de la cuenta).
- Client — la aplicación que quiere acceder a los datos en nombre del usuario.
- Authorization Server — el servidor que autentica al usuario y emite tokens (por ejemplo, Azure Entra ID).
- 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:
| Flujo | Escenario | Seguridad |
|---|---|---|
| Authorization Code + PKCE | SPAs, apps móviles, web apps | Alta |
| Client Credentials | Comunicación servidor a servidor (M2M) | Alta |
| On-Behalf-Of (OBO) | APIs que llaman a otras APIs en nombre del usuario | Alta |
| Device Code | Dispositivos sin navegador (IoT, CLI) | Media |
⚠️ 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:
- El Client genera un
code_verifier(string aleatoria) y uncode_challenge(hash SHA-256 del verifier). - El Client redirige al usuario al Authorization Server con el
code_challenge. - El usuario se autentica y otorga su consentimiento para el acceso.
- El Authorization Server devuelve un authorization code al Client.
- El Client intercambia el authorization code +
code_verifierpor un access token. - El Client usa el access token para acceder al Resource Server (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
| Token | Propósito | Formato | ¿Quién lo consume? |
|---|---|---|---|
| ID Token | Información de identidad del usuario | JWT | El Client (front-end) |
| Access Token | Autorización para acceder a recursos protegidos | JWT* | El Resource Server |
| Refresh Token | Obtener nuevos access tokens sin re-autenticación | Opaco | El 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 claimsub.profile— devuelvename,family_name,given_name,picture, etc.email— devuelveemailyemail_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):
| |
- El usuario accede al Service Provider (tu aplicación)
- El SP detecta que el usuario no está autenticado y genera un SAML AuthnRequest (XML)
- El navegador se redirige al Identity Provider con el AuthnRequest
- El usuario se autentica en el IdP (login, MFA, etc.)
- El IdP genera una SAML Response que contiene una Assertion (declaración firmada con los datos del usuario)
- 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:
| |
ℹ️ 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?
| Aspecto | SAML 2.0 | OpenID Connect |
|---|---|---|
| Formato | XML | JSON (JWT) |
| Transporte | HTTP Redirect / POST | HTTP Redirect / REST |
| Tamaño del token | Grande (XML verboso) | Compacto (JWT) |
| Escenarios ideales | SSO corporativo, federación B2B, legado | SPAs, APIs REST, móvil, microservicios |
| Soporte móvil | Débil (XML pesado) | Nativo (JSON + PKCE) |
| Madurez | Desde 2005, muy difundido en enterprise | Desde 2014, estándar para apps modernas |
| Identity Providers | ADFS, Shibboleth, PingFederate, Keycloak | Azure Entra, Google, Keycloak, Auth0 |
| Protocolo base | Independiente | Construido 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? | Ejemplos | Flujos recomendados |
|---|---|---|---|
| Pública | No | SPA, móvil, desktop, CLI | Authorization Code + PKCE |
| Confidencial | Sí | Web app server-side, daemon, API | Auth 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:
| |
Ejemplo con Angular 16+ y @azure/msal-angular:
Primero, instala las dependencias necesarias:
| |
Configuración de MSAL (auth-config.ts):
| |
Módulo principal con API standalone (app.config.ts):
| |
Rutas protegidas (app.routes.ts):
| |
Componente con login y llamada a la API (home.component.ts):
| |
💡 Consejo: En Angular 16+, el
MsalInterceptorinyecta automáticamente el access token en todas las solicitudes HTTP que coincidan con los patrones configurados enprotectedResourceMap. No necesitas gestionar tokens manualmente — basta con usarHttpClientnormalmente.
ℹ️ 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:
| |
Ejemplo con Python (Flask + MSAL):
| |
⚠️ 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.environpor 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):
| |
💡 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ística | SPA (Public Client) | Server-Side (Confidential) | API REST / Daemon (Confidential) |
|---|---|---|---|
| Dónde se ejecuta | Navegador del usuario | Servidor web | Servidor backend |
| Client Secret | No | Sí | Sí (o certificado) |
| Flujo OAuth | Auth Code + PKCE | Auth Code + Secret | Client Credentials |
| Interacción del usuario | Sí (login interactivo) | Sí (login interactivo) | No (M2M) |
| Tokens recibidos | ID Token + Access Token | ID Token + Access Token | Solo Access Token |
| Refresh Token | Sí (con offline_access) | Sí | No (usa caché de token) |
| Ejemplo de app | Angular, React, Vue | Flask, ASP.NET, Express | Cron job, microservicio, daemon |
| Plataforma en el portal | Single-page application | Web | Ninguna (solo app permissions) |
| Biblioteca MSAL | @azure/msal-angular | msal-python / MSAL.NET | msal-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:
| |
Configuración (appsettings.json):
| |
Configuración de Program.cs:
| |
Controller con endpoints protegidos (DadosController.cs):
| |
💡 Consejo: El paquete
Microsoft.Identity.Websimplifica 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 enProgram.cs. Además, métodos de extensión comoUser.GetDisplayName()yUser.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.Fullpara 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,nbfy 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
- Keycloak: Autenticación Gratuita con Contenedores y C# — identity provider open-source con soporte para OAuth 2.0, OIDC y SAML 2.0
- Pipeline de Configuración en .NET 8+: IOptions, Secrets y Docker — entiende cómo .NET 8+ carga configuraciones de JWT, claves y secretos a través del pipeline de configuración e IOptions.
- BFF Backend For Frontend: Seguridad en SPAs
- Terminal vs Pipeline: diferencias al ejecutar scripts
- Makefile: Automatizando tareas para Python, Hugo y Docker
- El Programador Pragmático: lecciones prácticas del libro
Referencias
- Microsoft Identity Platform — Visión general — documentación oficial de Azure Entra ID (antiguo Azure AD) y sus flujos de autenticación.
- RFC 7519 — JSON Web Token (JWT) — especificación oficial de JWT del IETF.
- RFC 6749 — OAuth 2.0 Authorization Framework — especificación oficial de OAuth 2.0.
- RFC 7636 — Proof Key for Code Exchange (PKCE) — extensión de seguridad de OAuth 2.0 utilizada por clientes públicos.
- OpenID Connect Core 1.0 — especificación oficial de OpenID Connect.
- @azure/msal-angular — MSAL Angular — biblioteca oficial de Microsoft para autenticación en SPAs Angular.
- MSAL Python — Microsoft Authentication Library for Python — biblioteca oficial de Microsoft para autenticación en aplicaciones Python.
- Microsoft.Identity.Web — Proteger APIs ASP.NET Core — documentación oficial para proteger APIs con Azure Entra ID en ASP.NET Core.
- Microsoft.Identity.Web — Repositorio GitHub — código fuente y ejemplos oficiales del paquete NuGet.
- OAuth 2.0 Security Best Current Practice (IETF) — recomendaciones de seguridad actualizadas para implementaciones OAuth 2.0.
- SAML 2.0 Core Specification (OASIS) — especificación oficial de SAML 2.0 por OASIS.
- Azure Key Vault — Visión general — servicio de Azure para gestión de secretos, claves y certificados.
- Keycloak — Sitio oficial — identity provider open-source con soporte para OAuth 2.0, OIDC y SAML 2.0.
- Repositorio blog-zocateli-sample — Entra ID — código fuente C# de los ejemplos de este artículo
- Repositorio blog-zocateli-sample — Auth SPA (Angular) — front-end Angular con MSAL
- Repositorio blog-zocateli-sample — Python OAuth — ejemplos Flask con Authorization Code Flow y Client Credentials

Al comentar, aceptas nuestra Política de Privacidad, Términos de Uso, Política de Eliminación de Datos.