# OpenID Connect

## Qué es

OpenID Connect es una forma estándar de que una aplicación averigüe quién es una
persona a partir de un servicio que acaba de iniciar la sesión de esa persona.
Su especificación lo llama una capa sencilla de identidad sobre OAuth 2.0, y así
funciona: las mismas redirecciones, endpoints y tokens que OAuth, más un token
adicional, un endpoint adicional y las reglas para comprobarlos. Suele
abreviarse como OIDC. La especificación principal se hizo definitiva en febrero
de 2014; el texto actual, que incorpora su segundo conjunto de correcciones,
está fechado el 15 de diciembre de 2023 y lo mantiene un grupo de trabajo de la
OpenID Foundation.

OAuth por sí solo responde a «¿qué tiene permitido hacer esta aplicación?». Le
entrega un token de acceso destinado a una API, que no está pensado para que lo
lea la propia aplicación. OpenID Connect añade «¿quién ha iniciado sesión?» y responde con un token
de ID: un JSON Web Token dirigido a la propia aplicación que indica quién es la
persona, quién avala esa identidad, cuándo se emitió y a qué aplicación está
destinado. Los tokens de ID deben estar firmados; como excepción, la
especificación permite `alg: none` únicamente si el tipo de respuesta no devuelve ningún
token de ID desde el endpoint de autorización y el cliente solicitó
explícitamente `none` al registrarse.

La especificación cambia los nombres de los roles de OAuth para esta función. El
proveedor OpenID (OpenID Provider, OP) es un servidor de autorización OAuth que
autentica a las personas y emite tokens de ID. La parte que confía en el
proveedor (Relying Party, RP) es el cliente OAuth que necesita saber quién es la
persona. La persona es el usuario final (End-User). Una petición se convierte en
una petición OpenID Connect al incluir `openid` en su alcance, y ese valor es
obligatorio: «Si no está presente el valor de alcance openid, el comportamiento
queda completamente sin especificar».

Otros valores de alcance solicitan datos de perfil. `profile` abarca nombre, apodo,
imagen, configuración regional y declaraciones similares; `email` añade `email` y `email_verified`, y
`address` y `phone` hacen lo que indican sus nombres. La aplicación puede obtener esas
declaraciones del endpoint UserInfo del proveedor, una API normal protegida por
OAuth a la que se llama con el token de acceso.

Hay tres formas de utilizarlo. El flujo de código de autorización envía por el
navegador solo un código de corta duración y obtiene los tokens mediante una
petición HTTPS al endpoint de tokens; el flujo implícito devuelve los tokens
directamente en la redirección; el híbrido combina ambos. Una especificación
complementaria, OpenID Connect Discovery 1.0, permite a la aplicación consultar
todos los endpoints y las claves de firma desde una única dirección.

## Por qué importa

La razón para adoptarlo es el inicio de sesión único. Con un proveedor de
identidad delante de muchas aplicaciones, las personas mantienen un solo
conjunto de credenciales, las aplicaciones no almacenan ninguna y la política
que decide cómo iniciar sesión, desde las reglas de contraseñas hasta un segundo
factor, se establece una sola vez en el proveedor. Desactivar una cuenta en el
proveedor impide que inicie una sesión nueva en cualquier aplicación que confíe
en él, lo que convierte la gestión de bajas en un solo paso en vez de una lista.

También cierra una brecha de seguridad que puede aparecer cuando los equipos
construyen el inicio de sesión sobre OAuth a secas. El RFC 6749 advierte de que, en el flujo implícito,
un cliente público no tiene forma de saber a qué cliente se emitió un token de
acceso, por lo que uno que suponga que solo el propietario del recurso puede
entregarle un token válido queda expuesto a la suplantación: un atacante que
posea un token emitido a otra aplicación puede presentarlo y ser tomado por la
persona que hay detrás. Un token de ID nombra la aplicación a la que está
destinado en su declaración `aud`, y la aplicación la comprueba.

Al ser un estándar, el trabajo se puede trasladar. La especificación promete
información de perfil interoperable, de modo que el código que inicia sesiones
mediante un proveedor puede hacerlo mediante otro y, con Discovery, la
aplicación descubre los endpoints y las claves de firma del proveedor a partir de
su URL de emisor en vez de ajustes copiados a mano.

Por último, OpenID Connect da a cada persona un identificador estable. La
especificación dice explícitamente que el par formado por `iss` —quién emitió el
token— y `sub` —el identificador del sujeto— es el único par de declaraciones en
el que una aplicación puede confiar como identificador estable de una persona.
El valor de `sub` es único dentro del emisor, nunca se reasigna y tiene como
máximo 255 caracteres ASCII. Un proveedor incluso puede emitir un `sub` distinto
para cada aplicación, un identificador por pares, para que las aplicaciones no
puedan correlacionar las actividades de una persona sin permiso.

## Cómo se aplica en la práctica

Considere una aplicación web registrada en un OpenID Provider en `https://server.example.com` con el ID
de cliente `s6BhdRkqt3`; los valores siguientes proceden de los propios ejemplos de la
especificación. La aplicación empieza por leer la configuración del proveedor
desde la dirección conocida bajo la URL del emisor:

```http
GET /.well-known/openid-configuration HTTP/1.1
Host: server.example.com
```

La respuesta es un documento JSON. Una versión abreviada:

```json
{
  "issuer": "https://server.example.com",
  "authorization_endpoint": "https://server.example.com/connect/authorize",
  "token_endpoint": "https://server.example.com/connect/token",
  "userinfo_endpoint": "https://server.example.com/connect/userinfo",
  "jwks_uri": "https://server.example.com/jwks.json",
  "scopes_supported": ["openid", "profile", "email", "address", "phone"],
  "id_token_signing_alg_values_supported": ["RS256", "ES256", "HS256"]
}
```

Discovery exige que el `issuer` de ese documento sea idéntico a la URL de emisor que
la aplicación puso delante de la ruta conocida, y la aplicación se detiene si
difiere. Después envía el navegador de la persona al endpoint de autorización
con el flujo de código, el alcance `openid` y dos valores aleatorios que ha guardado
vinculados a la sesión del navegador: `state` para la redirección y `nonce` para el
token de ID. Un cliente público añadiría también los parámetros PKCE, que el RFC
9700 hace obligatorios para él; aquí se omiten para mantener cortas las líneas.

```http
GET /connect/authorize?response_type=code&client_id=s6BhdRkqt3
    &redirect_uri=https%3A%2F%2Fclient.example.org%2Fcb
    &scope=openid%20profile%20email
    &state=af0ifjsldkj&nonce=n-0S6_WzA2Mj HTTP/1.1
Host: server.example.com
```

El proveedor inicia la sesión de la persona, redirige el navegador de vuelta con
un código y la aplicación canjea ese código en el endpoint de tokens exactamente
igual que en OAuth a secas. La diferencia está en la respuesta, que ahora
incluye un `id_token` junto al token de acceso —abreviado aquí—:

```json
{
  "access_token": "SlAV32hkKG",
  "token_type": "Bearer",
  "refresh_token": "8xLOxBtZp8",
  "expires_in": 3600,
  "id_token": "eyJhbGciOiJSUzI1NiIsImtpZCI6IjFlOWdkazcifQ.ewogImlzc..."
}
```

El token de ID consta de tres partes base64url separadas por puntos. La primera
se decodifica como `{"alg":"RS256","kid":"1e9gdk7"}`: el algoritmo de firma y el ID de la clave dentro del
conjunto de claves publicado por el proveedor. La parte central contiene las
declaraciones, y el ejemplo de la especificación dice:

```json
{
  "iss": "https://server.example.com",
  "sub": "24400320",
  "aud": "s6BhdRkqt3",
  "nonce": "n-0S6_WzA2Mj",
  "exp": 1311281970,
  "iat": 1311280970,
  "auth_time": 1311280969,
  "acr": "urn:mace:incommon:iap:silver"
}
```

Antes de confiar en una sola palabra del contenido, la aplicación valida el
token, y la especificación enumera los pasos. `iss` debe coincidir exactamente con
el emisor del proveedor. `aud` debe contener el propio ID de cliente de la
aplicación y ninguna audiencia en la que esta no confíe. La firma debe
verificarse con las claves del proveedor obtenidas de `jwks_uri`, mediante el algoritmo
de la cabecera; cuando el token llega directamente del endpoint de tokens por
TLS, como aquí, comprobar el certificado TLS del servidor puede sustituir la
comprobación de la firma. La hora actual debe ser anterior a `exp`. `nonce` debe ser
igual al valor que envió la aplicación. Solo entonces inicia la sesión de la
persona, usando como clave `https://server.example.com` junto con `24400320`, y utiliza el token de acceso para
obtener declaraciones de correo y perfil del endpoint UserInfo si las necesita.

Un único proveedor para muchos sistemas supone un cambio tanto organizativo como
técnico. Uno de los proyectos de este sitio, la [gestión de acceso entre M365 e inicio de sesión único](/es/portfolio/led-access-management-across-m365-and-sso/), consolidó identidades y
accesos en M365, 1Password, Red Hat SSO y OKTA SSO, aplicó el mínimo privilegio
y normalizó las altas y bajas para revocar el acceso con prontitud cuando
alguien se marchaba.

## Dónde surgen los problemas

**Se usa el correo electrónico como clave de cuenta.** Es la elección evidente y
la equivocada. La especificación dice que un proveedor puede reutilizar una
dirección de correo para otra persona con el tiempo y que `email`, `phone_number`, `preferred_username` y `name` no
deben utilizarse como identificadores únicos. Una aplicación que busque personas
por correo puede entregar la cuenta de alguien al siguiente propietario de esa
dirección. Almacene `iss` y `sub` juntos como clave, conserve el correo como
atributo y, antes de confiar en una dirección para cualquier uso, compruebe que
`email_verified` sea true.

**Un token de acceso se toma como prueba de quién inició sesión.** Algunas
aplicaciones reciben un token de acceso, llaman a una API con él y tratan la
respuesta como un inicio de sesión. El token puede haberse emitido a una
aplicación completamente distinta; ese es el caso de suplantación sobre el que
advierte el RFC 6749. Inicie la sesión con el token de ID y solo después de confirmar que
su `aud` nombra su propio ID de cliente.

**El token de ID se decodifica, pero nunca se comprueba.** Leer las
declaraciones de un token solo requiere decodificar base64url, sin ninguna
clave, y esa facilidad es la trampa. Un token cuya firma, `iss`, `aud` o `exp` no se
verifique puede ser falsificado, pertenecer a otra aplicación o haber caducado.
Utilice una biblioteca mantenida, proporciónele el emisor y el ID de cliente y
deje que ejecute todas las comprobaciones de la lista de la especificación, en
lugar de elegir las cómodas.

**El nonce falta, es fijo o nunca se compara.** Sin él, un token de ID capturado
de un inicio de sesión puede reutilizarse en otro. El RFC 9700 añade que el
nonce debe ser específico de un inicio de sesión y estar vinculado al navegador
que lo comenzó. La especificación sugiere una forma de hacerlo: guardar un valor
criptográficamente aleatorio en una cookie de sesión HttpOnly, enviar su hash
como `nonce` y compararlos cuando vuelva el token de ID.

**Las claves de firma se guardan en caché para siempre.** Los proveedores rotan
las claves, y una aplicación que conserve el conjunto de ayer rechaza todos los
tokens firmados con la nueva. La especificación espera que el proveedor publique
las claves en `jwks_uri` y marque cada token con un `kid`, y que la aplicación vuelva a
obtener el conjunto de claves cuando encuentre un `kid` que no conoce. Guarde las
claves en caché, pero trate un `kid` desconocido como señal para actualizarla en
vez de como motivo para hacer fallar el inicio de sesión.

**Dos organizaciones cliente en un host se tratan como un único emisor.** Un
proveedor puede ejecutar varios emisores en un host, y la ruta forma parte del
identificador del emisor: el sujeto `1234` en `https://example.com` y el sujeto `1234` en `https://example.com/sales` son
personas distintas. Almacene la cadena completa del emisor, compárela
exactamente y nunca la recorte hasta dejar solo un nombre de host.

## Lecturas adicionales

- [OpenID Connect Core 1.0](https://openid.net/specs/openid-connect-core-1_0.html)
  — token de ID, tres flujos, declaraciones estándar y pasos de validación en la
  edición que incorpora el conjunto 2 de erratas de diciembre de 2023.
- [OpenID Connect Discovery 1.0](https://openid.net/specs/openid-connect-discovery-1_0.html)
  — documento de configuración de la dirección conocida y regla de que su emisor
  debe coincidir con la URL de emisor bajo la que se obtuvo.
- [RFC 6749: marco de autorización OAuth 2.0](https://www.rfc-editor.org/rfc/rfc6749)
  — marco sobre el que se construye OpenID Connect, con la advertencia de la
  sección 10.16 sobre usar tokens de acceso para identificar personas.
- [RFC 7519: JSON Web Token (JWT)](https://www.rfc-editor.org/rfc/rfc7519)
  — formato de token utilizado por todos los tokens de ID.
- [RFC 9700: mejores prácticas actuales de seguridad de OAuth 2.0](https://www.rfc-editor.org/rfc/rfc9700)
  — recomendaciones actuales sobre PKCE, nonce y redirección, aplicables tanto a
  OpenID Connect como a OAuth.

<https://engineer.company/es/glossary/openid-connect/>
