{"canonical_url":"https://engineer.company/es/glossary/oauth/","content_markdown":"# OAuth\n\n## Qué es\n\nOAuth es un protocolo que permite a una aplicación utilizar los datos de una\npersona alojados en otro servicio, con su aprobación y dentro de unos límites\nque puede ver, sin que la aplicación llegue a conocer su contraseña. La versión\nen uso es OAuth 2.0, publicada por el IETF en octubre de 2012 como RFC 6749, y\nse encuentra escrita como OAuth 2.0 y OAuth2 con tanta frecuencia como\nsimplemente OAuth. Sustituyó a OAuth 1.0, y ambas versiones son incompatibles.\n\nLa especificación distingue cuatro roles. El propietario del recurso es quien\npuede conceder acceso, normalmente una persona. El servidor de recursos contiene\nlos datos protegidos y responde a peticiones que incluyen un token. El cliente\nes la aplicación que quiere acceder: una aplicación web, una aplicación de\nteléfono, un script o un agente de IA. El servidor de autorización inicia la\nsesión del propietario, le pide su consentimiento y emite tokens. Un producto\npequeño puede ejecutar el servidor de recursos y el servidor de autorización\ncomo un único sistema; una empresa suele tener un proveedor de identidad delante\nde muchas API.\n\nEl cliente recibe un token de acceso, una cadena que representa un alcance y una\nduración de acceso concretos. Envía el token con cada petición al servidor de\nrecursos. El RFC describe esa cadena como normalmente opaca para el cliente: el\ncliente la transporta, pero no está destinada a que la lea. El servidor de\nautorización también puede entregar un token de actualización, que el cliente\ncanjea por un nuevo token de acceso cuando caduca el anterior, sin volver a\npreguntar a la persona.\n\nUn cliente obtiene su primer token mediante una concesión. El RFC 6749 define\ncuatro: código de autorización, implícita, credenciales de contraseña del\npropietario del recurso y credenciales de cliente. La de credenciales de cliente\nsirve para un programa que actúa en su propio nombre, sin una persona\ninvolucrada. La concesión de código de autorización es la relevante para todo lo\ndemás, porque las recomendaciones de seguridad actuales han retirado las\nconcesiones implícita y de contraseña. Esas recomendaciones, junto con la prueba\nde clave para el intercambio de códigos (Proof Key for Code Exchange, PKCE) y\nlas reglas de los tokens al portador, se están integrando en un único documento\nOAuth 2.1 del IETF. En su decimosexto borrador, fechado el 3 de septiembre de\n2026, sigue siendo un Internet-Draft, un trabajo en curso y no un estándar.\n\nOAuth trata de autorización, no de autenticación. Un token indica a la API lo\nque puede hacer el cliente; no le dice al cliente de forma fiable quién es la\npersona. Iniciar sesiones a partir de OAuth es la función de OpenID Connect, que\nañade un token destinado a que lo lea el cliente.\n\n## Por qué importa\n\nEl RFC 6749 empieza por el problema que pretendía eliminar. Para permitir que\nuna aplicación de terceros accediera a sus datos, usted le daba su contraseña.\nLa aplicación tenía entonces que almacenarla, normalmente en texto claro. Podía\nacceder a todo lo que permitiera la contraseña y durante el tiempo que quisiera.\nSolo podía cortar el acceso de una aplicación cambiando la contraseña, lo que\ntambién cortaba el de todas las demás. Y cuando alguna sufría una intrusión,\nquedaban comprometidos la contraseña y todo lo que protegía. OAuth elimina cada\nuno de esos problemas: la aplicación nunca posee la contraseña, el token tiene\nun alcance y una caducidad, y puede retirarse el acceso de un cliente sin\nafectar a los demás.\n\nUn equipo se encuentra con OAuth desde ambos lados. Cuando usted es responsable\nde una API, OAuth permite que socios, integraciones y herramientas de los\npropios clientes la llamen en nombre de un usuario sin que nadie almacene la\ncontraseña de otra persona. Cuando consume una API, OAuth es lo que ofrecen\ncalendarios, buzones, sistemas contables y almacenes de archivos, de modo que la\nparte cliente es código que su equipo escribe y mantiene. Los agentes de IA que\nactúan por una persona ocupan el mismo lugar que cualquier otro cliente: deberían\ntener un token limitado a lo que esa persona permitió, nunca sus credenciales.\n\nLos alcances convierten el mínimo privilegio en algo que un servidor puede hacer\ncumplir. Un token que permita a un servicio de impresión leer fotos no debería\npermitirle borrarlas, y otro emitido para una API debería ser rechazado por\notra. Las recomendaciones de seguridad del IETF de 2025, el RFC 9700, piden\nprecisamente eso: limitar los privilegios de un token de acceso al mínimo\nnecesario para el caso de uso y restringir los tokens al servidor de recursos\npara el que se emitieron.\n\n## Cómo se aplica en la práctica\n\nEl propio RFC ilustra el caso de un servicio de impresión que quiere obtener\nfotos de un sitio donde se comparten imágenes. Este es el intercambio mediante\nla concesión de código de autorización con PKCE, la forma que las\nrecomendaciones actuales piden utilizar a todos los clientes. Antes de nada, el\ncliente genera un verificador de código aleatorio de entre 43 y 128 caracteres y\nlo guarda para sí. Calcula su hash con SHA-256 y redirige el navegador de la persona al servidor\nde autorización con el resultado codificado en base64url, el desafío de código:\n\n```http\nGET /authorize?response_type=code\u0026client_id=s6BhdRkqt3\u0026state=xyz\n    \u0026redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb\n    \u0026code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM\n    \u0026code_challenge_method=S256 HTTP/1.1\nHost: server.example.com\n```\n\nEl servidor de autorización inicia la sesión de la persona, muestra lo que\nsolicita el servicio de impresión y, cuando esta lo aprueba, redirige el\nnavegador de vuelta con un código de autorización de corta duración. El cliente\ncomprueba que `state` tenga el valor que envió:\n\n```http\nHTTP/1.1 302 Found\nLocation: https://client.example.com/cb?code=SplxlOBeZQQYbYS6WxSbIA\n          \u0026state=xyz\n```\n\nEl código no vale nada por sí solo. El cliente lo canjea mediante una petición\nHTTPS al endpoint de tokens del servidor de autorización y esta vez envía el\npropio verificador:\n\n```http\nPOST /token HTTP/1.1\nHost: server.example.com\nContent-Type: application/x-www-form-urlencoded\n\ngrant_type=authorization_code\u0026code=SplxlOBeZQQYbYS6WxSbIA\n\u0026redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb\n\u0026client_id=s6BhdRkqt3\n\u0026code_verifier=dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk\n```\n\nEl servidor calcula el hash del verificador, lo compara con el desafío que\nguardó junto al código y solo si coinciden devuelve los tokens, marcados para\nque ninguna caché los almacene:\n\n```http\nHTTP/1.1 200 OK\nContent-Type: application/json;charset=UTF-8\nCache-Control: no-store\nPragma: no-cache\n\n{\n  \"access_token\":\"2YotnFZFEjr1zCsicMWpAA\",\n  \"token_type\":\"Bearer\",\n  \"expires_in\":3600,\n  \"refresh_token\":\"tGzv3JOkF0XG5Qx2TlKWIA\"\n}\n```\n\nA partir de ahí, el cliente envía `Authorization: Bearer 2YotnFZFEjr1zCsicMWpAA` en cada llamada a la API de fotos. Una\nhora después, el token ha caducado, la API responde con `401 Unauthorized` y `error=\"invalid_token\"` en su cabecera\n`WWW-Authenticate`, y el cliente canjea el token de actualización por uno nuevo. Pedir algo\nfuera del alcance concedido recibe, en cambio, `403 Forbidden` e `insufficient_scope`. El verificador protege\ncontra el uso de un código interceptado: un código copiado del dispositivo durante\nsu transmisión, el ataque contra el que se diseñó inicialmente PKCE, no puede\ncanjearlo nadie que carezca del verificador, y el propio verificador no se envió\nen la petición de autorización ni en la redirección del navegador.\n\nEsa misma delegación permite que el software participe en flujos de trabajo con\nagentes. En la página de este sitio sobre [convertir software empresarial existente en herramientas que puedan invocar agentes de IA](/es/ai-tools/), OAuth proporciona el acceso\ndelegado: un agente actúa en nombre de un usuario sin intercambiar una\ncontraseña y solo dentro de los permisos de ese usuario.\n\n## Dónde surgen los problemas\n\n**Una comprobación de redirección permisiva envía el código a otra persona.** Un\nservidor de autorización que acepte cualquier URI de redirección que empiece por\nun prefijo registrado, o que coincida con un comodín, puede ser inducido a\nentregar un código a una página controlada por un atacante. El RFC 9700 exige\nque los servidores de autorización comparen las URI de redirección mediante\ncoincidencia exacta de cadenas con las registradas, con una excepción para los\nnúmeros de puerto en localhost de aplicaciones nativas, y prohíbe tanto a\nclientes como a servidores utilizar redireccionadores abiertos que envíen el\nnavegador a cualquier URL encontrada en un parámetro de consulta.\n\n**El callback acepta una respuesta que nadie solicitó.** Si el cliente acepta\ncualquier código que llegue a su URI de redirección, un atacante puede\nintroducir su propio código a través del navegador de una víctima y hacer que\nesta acabe trabajando en la cuenta del atacante. Es una falsificación de\npetición entre sitios dirigida a la redirección. Un cliente puede confiar en\nPKCE como protección una vez que haya confirmado que el servidor lo admite; de\nlo contrario, envía un valor `state` de un solo uso vinculado a la sesión del\nnavegador de la persona y rechaza cualquier respuesta que no lo devuelva.\n\n**Los tokens viajan en las URL.** La concesión implícita coloca el token de\nacceso directamente en la redirección, donde el historial del navegador y las\ncabeceras `Referer` pueden llevarlo a lugares a los que nunca debía llegar, y nada lo\nvincula al cliente que lo solicitó. El RFC 9700 dice que los clientes no\ndeberían usarla, y el borrador OAuth 2.1 la omite. Lo mismo ocurre con una API\nque acepte un token como parámetro de consulta: el RFC 6750 dice que las URL de\nlas páginas nunca deberían contener tokens al portador. Utilice la concesión de\ncódigo y envíe los tokens en la cabecera `Authorization`.\n\n**La aplicación pide la contraseña de todos modos.** La concesión de\ncredenciales de contraseña del propietario del recurso permite que un cliente\nrecopile el nombre de usuario y la contraseña de una persona y los cambie por un\ntoken, lo que anula la razón de ser de OAuth. El RFC 9700 establece que no debe\nusarse: expone las credenciales al cliente, acostumbra a las personas a escribir\nsu contraseña en lugares distintos del servidor de autorización y nunca se\ndiseñó para funcionar con autenticación de dos factores ni con inicios de sesión\nde varios pasos. Envíe a las personas al servidor de autorización con la\nconcesión de código y utilice credenciales de cliente cuando no intervenga\nninguna persona.\n\n**Un token robado funciona para cualquiera que lo posea.** El RFC 6750 define un\ntoken al portador como aquel que puede utilizar cualquier parte que lo posea:\ntenerlo es toda la prueba. Utilice tokens de acceso de corta duración,\nrestrinja cada uno a la API para la que se emitió y, cuando lo que está en juego\nlo justifique, vincule los tokens al cliente mediante TLS mutuo (RFC 8705) o\nDPoP (RFC 9449). Los tokens de actualización de clientes públicos, como las\naplicaciones de teléfono y de navegador, deben estar vinculados al cliente o\nrotarse: cada actualización devuelve un token nuevo e invalida el antiguo. Si\ntambién se utiliza una copia robada, una de las partes acaba presentando un\ntoken invalidado, el servidor revoca el activo y el ataque se detiene a costa de\nque el cliente legítimo deba volver a pedir a la persona una nueva concesión.\n\n## Lecturas adicionales\n\n- [RFC 6749: marco de autorización OAuth 2.0](https://www.rfc-editor.org/rfc/rfc6749)\n  — los cuatro roles, los cuatro tipos de concesión y los endpoints, tal como se\n  publicaron en octubre de 2012.\n- [RFC 7636: prueba de clave para el intercambio de códigos en clientes públicos de OAuth](https://www.rfc-editor.org/rfc/rfc7636)\n  — verificador y desafío de código, con el ejemplo S256 utilizado arriba.\n- [RFC 9700: mejores prácticas actuales de seguridad de OAuth 2.0](https://www.rfc-editor.org/rfc/rfc9700)\n  — recomendaciones de enero de 2025: coincidencia exacta de redirecciones, PKCE\n  para todos los clientes y eliminación de las concesiones implícita y de\n  contraseña.\n- [RFC 6750: uso de tokens al portador](https://www.rfc-editor.org/rfc/rfc6750)\n  — cómo presenta un cliente un token de acceso y cómo indica una API que falta,\n  ha caducado o tiene un alcance demasiado limitado.\n- [Marco de autorización OAuth 2.1](https://datatracker.ietf.org/doc/draft-ietf-oauth-v2-1/)\n  — borrador del grupo de trabajo que integra estos documentos en uno y que en\n  octubre de 2026 sigue siendo un Internet-Draft.\n\n\u003chttps://engineer.company/es/glossary/oauth/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Cómo permite OAuth actuar por un usuario sin su contraseña: cuatro roles, intercambio de código con PKCE paso a paso y cinco fallos de despliegue.","formats":{"gemtext":"https://engineer.company/es/glossary/oauth/index.gmi","gopher":"https://engineer.company/es/glossary/oauth/gophermap","html":"https://engineer.company/es/glossary/oauth/","json":"https://engineer.company/es/glossary/oauth/index.json","markdown":"https://engineer.company/es/glossary/oauth/index.md","pdf":"https://engineer.company/es/glossary/oauth/index.pdf"},"kind":"page","language":"es","title":"¿Qué es OAuth?","url":"https://engineer.company/es/glossary/oauth/","version":1}