{"canonical_url":"https://engineer.company/es/glossary/openid-connect/","content_markdown":"# OpenID Connect\n\n## Qué es\n\nOpenID Connect es una forma estándar de que una aplicación averigüe quién es una\npersona a partir de un servicio que acaba de iniciar la sesión de esa persona.\nSu especificación lo llama una capa sencilla de identidad sobre OAuth 2.0, y así\nfunciona: las mismas redirecciones, endpoints y tokens que OAuth, más un token\nadicional, un endpoint adicional y las reglas para comprobarlos. Suele\nabreviarse como OIDC. La especificación principal se hizo definitiva en febrero\nde 2014; el texto actual, que incorpora su segundo conjunto de correcciones,\nestá fechado el 15 de diciembre de 2023 y lo mantiene un grupo de trabajo de la\nOpenID Foundation.\n\nOAuth por sí solo responde a «¿qué tiene permitido hacer esta aplicación?». Le\nentrega un token de acceso destinado a una API, que no está pensado para que lo\nlea la propia aplicación. OpenID Connect añade «¿quién ha iniciado sesión?» y responde con un token\nde ID: un JSON Web Token dirigido a la propia aplicación que indica quién es la\npersona, quién avala esa identidad, cuándo se emitió y a qué aplicación está\ndestinado. Los tokens de ID deben estar firmados; como excepción, la\nespecificación permite `alg: none` únicamente si el tipo de respuesta no devuelve ningún\ntoken de ID desde el endpoint de autorización y el cliente solicitó\nexplícitamente `none` al registrarse.\n\nLa especificación cambia los nombres de los roles de OAuth para esta función. El\nproveedor OpenID (OpenID Provider, OP) es un servidor de autorización OAuth que\nautentica a las personas y emite tokens de ID. La parte que confía en el\nproveedor (Relying Party, RP) es el cliente OAuth que necesita saber quién es la\npersona. La persona es el usuario final (End-User). Una petición se convierte en\nuna petición OpenID Connect al incluir `openid` en su alcance, y ese valor es\nobligatorio: «Si no está presente el valor de alcance openid, el comportamiento\nqueda completamente sin especificar».\n\nOtros valores de alcance solicitan datos de perfil. `profile` abarca nombre, apodo,\nimagen, configuración regional y declaraciones similares; `email` añade `email` y `email_verified`, y\n`address` y `phone` hacen lo que indican sus nombres. La aplicación puede obtener esas\ndeclaraciones del endpoint UserInfo del proveedor, una API normal protegida por\nOAuth a la que se llama con el token de acceso.\n\nHay tres formas de utilizarlo. El flujo de código de autorización envía por el\nnavegador solo un código de corta duración y obtiene los tokens mediante una\npetición HTTPS al endpoint de tokens; el flujo implícito devuelve los tokens\ndirectamente en la redirección; el híbrido combina ambos. Una especificación\ncomplementaria, OpenID Connect Discovery 1.0, permite a la aplicación consultar\ntodos los endpoints y las claves de firma desde una única dirección.\n\n## Por qué importa\n\nLa razón para adoptarlo es el inicio de sesión único. Con un proveedor de\nidentidad delante de muchas aplicaciones, las personas mantienen un solo\nconjunto de credenciales, las aplicaciones no almacenan ninguna y la política\nque decide cómo iniciar sesión, desde las reglas de contraseñas hasta un segundo\nfactor, se establece una sola vez en el proveedor. Desactivar una cuenta en el\nproveedor impide que inicie una sesión nueva en cualquier aplicación que confíe\nen él, lo que convierte la gestión de bajas en un solo paso en vez de una lista.\n\nTambién cierra una brecha de seguridad que puede aparecer cuando los equipos\nconstruyen el inicio de sesión sobre OAuth a secas. El RFC 6749 advierte de que, en el flujo implícito,\nun cliente público no tiene forma de saber a qué cliente se emitió un token de\nacceso, por lo que uno que suponga que solo el propietario del recurso puede\nentregarle un token válido queda expuesto a la suplantación: un atacante que\nposea un token emitido a otra aplicación puede presentarlo y ser tomado por la\npersona que hay detrás. Un token de ID nombra la aplicación a la que está\ndestinado en su declaración `aud`, y la aplicación la comprueba.\n\nAl ser un estándar, el trabajo se puede trasladar. La especificación promete\ninformación de perfil interoperable, de modo que el código que inicia sesiones\nmediante un proveedor puede hacerlo mediante otro y, con Discovery, la\naplicación descubre los endpoints y las claves de firma del proveedor a partir de\nsu URL de emisor en vez de ajustes copiados a mano.\n\nPor último, OpenID Connect da a cada persona un identificador estable. La\nespecificación dice explícitamente que el par formado por `iss` —quién emitió el\ntoken— y `sub` —el identificador del sujeto— es el único par de declaraciones en\nel que una aplicación puede confiar como identificador estable de una persona.\nEl valor de `sub` es único dentro del emisor, nunca se reasigna y tiene como\nmáximo 255 caracteres ASCII. Un proveedor incluso puede emitir un `sub` distinto\npara cada aplicación, un identificador por pares, para que las aplicaciones no\npuedan correlacionar las actividades de una persona sin permiso.\n\n## Cómo se aplica en la práctica\n\nConsidere una aplicación web registrada en un OpenID Provider en `https://server.example.com` con el ID\nde cliente `s6BhdRkqt3`; los valores siguientes proceden de los propios ejemplos de la\nespecificación. La aplicación empieza por leer la configuración del proveedor\ndesde la dirección conocida bajo la URL del emisor:\n\n```http\nGET /.well-known/openid-configuration HTTP/1.1\nHost: server.example.com\n```\n\nLa respuesta es un documento JSON. Una versión abreviada:\n\n```json\n{\n  \"issuer\": \"https://server.example.com\",\n  \"authorization_endpoint\": \"https://server.example.com/connect/authorize\",\n  \"token_endpoint\": \"https://server.example.com/connect/token\",\n  \"userinfo_endpoint\": \"https://server.example.com/connect/userinfo\",\n  \"jwks_uri\": \"https://server.example.com/jwks.json\",\n  \"scopes_supported\": [\"openid\", \"profile\", \"email\", \"address\", \"phone\"],\n  \"id_token_signing_alg_values_supported\": [\"RS256\", \"ES256\", \"HS256\"]\n}\n```\n\nDiscovery exige que el `issuer` de ese documento sea idéntico a la URL de emisor que\nla aplicación puso delante de la ruta conocida, y la aplicación se detiene si\ndifiere. Después envía el navegador de la persona al endpoint de autorización\ncon el flujo de código, el alcance `openid` y dos valores aleatorios que ha guardado\nvinculados a la sesión del navegador: `state` para la redirección y `nonce` para el\ntoken de ID. Un cliente público añadiría también los parámetros PKCE, que el RFC\n9700 hace obligatorios para él; aquí se omiten para mantener cortas las líneas.\n\n```http\nGET /connect/authorize?response_type=code\u0026client_id=s6BhdRkqt3\n    \u0026redirect_uri=https%3A%2F%2Fclient.example.org%2Fcb\n    \u0026scope=openid%20profile%20email\n    \u0026state=af0ifjsldkj\u0026nonce=n-0S6_WzA2Mj HTTP/1.1\nHost: server.example.com\n```\n\nEl proveedor inicia la sesión de la persona, redirige el navegador de vuelta con\nun código y la aplicación canjea ese código en el endpoint de tokens exactamente\nigual que en OAuth a secas. La diferencia está en la respuesta, que ahora\nincluye un `id_token` junto al token de acceso —abreviado aquí—:\n\n```json\n{\n  \"access_token\": \"SlAV32hkKG\",\n  \"token_type\": \"Bearer\",\n  \"refresh_token\": \"8xLOxBtZp8\",\n  \"expires_in\": 3600,\n  \"id_token\": \"eyJhbGciOiJSUzI1NiIsImtpZCI6IjFlOWdkazcifQ.ewogImlzc...\"\n}\n```\n\nEl token de ID consta de tres partes base64url separadas por puntos. La primera\nse decodifica como `{\"alg\":\"RS256\",\"kid\":\"1e9gdk7\"}`: el algoritmo de firma y el ID de la clave dentro del\nconjunto de claves publicado por el proveedor. La parte central contiene las\ndeclaraciones, y el ejemplo de la especificación dice:\n\n```json\n{\n  \"iss\": \"https://server.example.com\",\n  \"sub\": \"24400320\",\n  \"aud\": \"s6BhdRkqt3\",\n  \"nonce\": \"n-0S6_WzA2Mj\",\n  \"exp\": 1311281970,\n  \"iat\": 1311280970,\n  \"auth_time\": 1311280969,\n  \"acr\": \"urn:mace:incommon:iap:silver\"\n}\n```\n\nAntes de confiar en una sola palabra del contenido, la aplicación valida el\ntoken, y la especificación enumera los pasos. `iss` debe coincidir exactamente con\nel emisor del proveedor. `aud` debe contener el propio ID de cliente de la\naplicación y ninguna audiencia en la que esta no confíe. La firma debe\nverificarse con las claves del proveedor obtenidas de `jwks_uri`, mediante el algoritmo\nde la cabecera; cuando el token llega directamente del endpoint de tokens por\nTLS, como aquí, comprobar el certificado TLS del servidor puede sustituir la\ncomprobación de la firma. La hora actual debe ser anterior a `exp`. `nonce` debe ser\nigual al valor que envió la aplicación. Solo entonces inicia la sesión de la\npersona, usando como clave `https://server.example.com` junto con `24400320`, y utiliza el token de acceso para\nobtener declaraciones de correo y perfil del endpoint UserInfo si las necesita.\n\nUn único proveedor para muchos sistemas supone un cambio tanto organizativo como\nté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\naccesos en M365, 1Password, Red Hat SSO y OKTA SSO, aplicó el mínimo privilegio\ny normalizó las altas y bajas para revocar el acceso con prontitud cuando\nalguien se marchaba.\n\n## Dónde surgen los problemas\n\n**Se usa el correo electrónico como clave de cuenta.** Es la elección evidente y\nla equivocada. La especificación dice que un proveedor puede reutilizar una\ndirección de correo para otra persona con el tiempo y que `email`, `phone_number`, `preferred_username` y `name` no\ndeben utilizarse como identificadores únicos. Una aplicación que busque personas\npor correo puede entregar la cuenta de alguien al siguiente propietario de esa\ndirección. Almacene `iss` y `sub` juntos como clave, conserve el correo como\natributo y, antes de confiar en una dirección para cualquier uso, compruebe que\n`email_verified` sea true.\n\n**Un token de acceso se toma como prueba de quién inició sesión.** Algunas\naplicaciones reciben un token de acceso, llaman a una API con él y tratan la\nrespuesta como un inicio de sesión. El token puede haberse emitido a una\naplicación completamente distinta; ese es el caso de suplantación sobre el que\nadvierte el RFC 6749. Inicie la sesión con el token de ID y solo después de confirmar que\nsu `aud` nombra su propio ID de cliente.\n\n**El token de ID se decodifica, pero nunca se comprueba.** Leer las\ndeclaraciones de un token solo requiere decodificar base64url, sin ninguna\nclave, y esa facilidad es la trampa. Un token cuya firma, `iss`, `aud` o `exp` no se\nverifique puede ser falsificado, pertenecer a otra aplicación o haber caducado.\nUtilice una biblioteca mantenida, proporciónele el emisor y el ID de cliente y\ndeje que ejecute todas las comprobaciones de la lista de la especificación, en\nlugar de elegir las cómodas.\n\n**El nonce falta, es fijo o nunca se compara.** Sin él, un token de ID capturado\nde un inicio de sesión puede reutilizarse en otro. El RFC 9700 añade que el\nnonce debe ser específico de un inicio de sesión y estar vinculado al navegador\nque lo comenzó. La especificación sugiere una forma de hacerlo: guardar un valor\ncriptográficamente aleatorio en una cookie de sesión HttpOnly, enviar su hash\ncomo `nonce` y compararlos cuando vuelva el token de ID.\n\n**Las claves de firma se guardan en caché para siempre.** Los proveedores rotan\nlas claves, y una aplicación que conserve el conjunto de ayer rechaza todos los\ntokens firmados con la nueva. La especificación espera que el proveedor publique\nlas claves en `jwks_uri` y marque cada token con un `kid`, y que la aplicación vuelva a\nobtener el conjunto de claves cuando encuentre un `kid` que no conoce. Guarde las\nclaves en caché, pero trate un `kid` desconocido como señal para actualizarla en\nvez de como motivo para hacer fallar el inicio de sesión.\n\n**Dos organizaciones cliente en un host se tratan como un único emisor.** Un\nproveedor puede ejecutar varios emisores en un host, y la ruta forma parte del\nidentificador del emisor: el sujeto `1234` en `https://example.com` y el sujeto `1234` en `https://example.com/sales` son\npersonas distintas. Almacene la cadena completa del emisor, compárela\nexactamente y nunca la recorte hasta dejar solo un nombre de host.\n\n## Lecturas adicionales\n\n- [OpenID Connect Core 1.0](https://openid.net/specs/openid-connect-core-1_0.html)\n  — token de ID, tres flujos, declaraciones estándar y pasos de validación en la\n  edición que incorpora el conjunto 2 de erratas de diciembre de 2023.\n- [OpenID Connect Discovery 1.0](https://openid.net/specs/openid-connect-discovery-1_0.html)\n  — documento de configuración de la dirección conocida y regla de que su emisor\n  debe coincidir con la URL de emisor bajo la que se obtuvo.\n- [RFC 6749: marco de autorización OAuth 2.0](https://www.rfc-editor.org/rfc/rfc6749)\n  — marco sobre el que se construye OpenID Connect, con la advertencia de la\n  sección 10.16 sobre usar tokens de acceso para identificar personas.\n- [RFC 7519: JSON Web Token (JWT)](https://www.rfc-editor.org/rfc/rfc7519)\n  — formato de token utilizado por todos los tokens de ID.\n- [RFC 9700: mejores prácticas actuales de seguridad de OAuth 2.0](https://www.rfc-editor.org/rfc/rfc9700)\n  — recomendaciones actuales sobre PKCE, nonce y redirección, aplicables tanto a\n  OpenID Connect como a OAuth.\n\n\u003chttps://engineer.company/es/glossary/openid-connect/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Cómo inicia sesiones OpenID Connect sobre OAuth: token de ID y sus declaraciones, recorrido desde el descubrimiento hasta la validación y seis errores.","formats":{"gemtext":"https://engineer.company/es/glossary/openid-connect/index.gmi","gopher":"https://engineer.company/es/glossary/openid-connect/gophermap","html":"https://engineer.company/es/glossary/openid-connect/","json":"https://engineer.company/es/glossary/openid-connect/index.json","markdown":"https://engineer.company/es/glossary/openid-connect/index.md","pdf":"https://engineer.company/es/glossary/openid-connect/index.pdf"},"kind":"page","language":"es","title":"¿Qué es OpenID Connect?","url":"https://engineer.company/es/glossary/openid-connect/","version":1}