SenseiTeoría desde cero0/59

8 · SeguridadLección 2 de 4

Autenticación y permisos

Authentication and permissions

Cómo sabe un sistema quién le habla, una persona o un programa, y qué le deja hacer: contraseñas con sal, segundo factor, llaves de API, tokens JWT, OAuth, roles y el error de autorización más común.

⏱ 60 min lo esencial · 72 min todo20 conceptos nuevos2 calculadoras9 ejerciciosAPI y Orquestación
Secciones14
  1. 01Dos preguntas: quién eres y qué puedes hacer
  2. 02Personas: contraseña, segundo factor y sesión
  3. 03Máquinas: llaves de API y tokens Bearer
  4. 04JWT por dentro: encabezado, claims y firma
  5. 05Vida corta y revocación
  6. 06OAuth y client credentials: el token de los callers de Alba
  7. 07Autorización: roles, dueños e IDOR
  8. 08Máquinas en la nube, OIDC y auditoría extra
  9. 09Errores comunes
  10. 10En la vida real extra
  11. 11Ejercicios
  12. 12Lo que sigue
  13. 13Palabras que vas a oír
  14. 14Chequeo
La pregunta

Al clasificador de Alba le llegan millones de requests al día de tres programas distintos, y Ana entra a editar sus publicaciones. ¿Cómo sabe cada sistema quién es quién, sin guardar contraseñas, y cómo decide qué le deja hacer a cada uno?

Alba, la empresa que seguimos en todo el curso, es un marketplace en línea: recibe ≈ 2.5 millones de publicaciones nuevas al día y, a quien vende, le sugiere la categoría de cada foto entre 500 posibles. Lo hace un modelo de visión (una ResNet-50) que corre en Triton, un programa hecho para servir modelos, dentro de Kubernetes, el sistema que reparte los programas de Alba entre sus máquinas, en la nube de Amazon (AWS). Ese servicio, el clasificador, responde ≈ 10 millones de fotos al día: las de las publicaciones nuevas, que traen varias cada una, más las que piden otros equipos.

Al clasificador lo llaman 3 programas internos de Alba: el backend de publicaciones (el programa del servidor que arma cada publicación nueva), moderación (el que revisa que las publicaciones cumplan las reglas) y búsqueda (el que ordena el catálogo). A un programa que llama a otro se le dice caller, «el que llama», y cada pedido que le hace, una request. Del otro lado de la pantalla está Ana, una vendedora de Ciudad de México, que entra a Alba con su correo y su contraseña para publicar unos tenis.

Esta lección es sobre cómo cada pieza sabe quién le habla y qué le deja hacer. Usa una idea de «Cifrado, llaves y certificados»: la firma digital, un sello que solo puede poner quien tiene una llave secreta (la llave privada) y que cualquiera comprueba con otra llave que se publica (la llave pública). Si alguien cambia un solo byte de lo firmado, el sello ya no coincide.

01

Dos preguntas: quién eres y qué puedes hacer

Esencial

Two questions: who are you and what can you do

Piensa en un concierto. En la entrada te piden tu boleto y una identificación: comprueban que eres tú y que el boleto es de verdad. Eso es la autenticación (authentication, que en el trabajo se abrevia AuthN): comprobar la identidad de quien llega.

Adentro, tu pulsera dice «general» o «VIP». Con «general» no pasas al camerino, aunque nadie dude de quién eres. Eso es la autorización (authorization, AuthZ): decidir qué puede hacer una identidad que ya se comprobó.

Son dos preguntas distintas, y un sistema puede tener la primera perfecta y la segunda inexistente. Un sitio que pide contraseña y luego deja a cualquier usuario con sesión ver los pedidos de todos autentica muy bien y no autoriza nada. Es uno de los errores más comunes, y lo vas a ver a fondo en la sección de autorización.

Quién habla: personas y programas

En Alba hablan dos tipos de identidades:

  • Personas. Ana entra al sitio desde su teléfono. Marta, la persona de guardia del equipo (la que atiende los problemas fuera de horario), entra a la consola de AWS, la página web desde donde se administra la nube, para revisar una falla. Una persona demuestra quién es con algo que sabe (una contraseña), algo que tiene (su teléfono) o algo que es (su huella).
  • Programas. El backend de publicaciones llama al clasificador; Triton lee los pesos del modelo (los números que aprendió al entrenar) de S3, el almacén de archivos de AWS. Un programa no tiene huella ni teléfono: demuestra quién es con un secreto o con un token que le entrega alguien de confianza.

En la mayoría de los sistemas de ML, lo que más se diseña es lo segundo: llamadas de servicio a servicio. El inicio de sesión (login) de las personas lo resuelve el producto, casi siempre con piezas ya hechas. Pero conviene entender los dos, porque los errores son parecidos.

401 y 403: dos respuestas distintas

HTTP tiene un código de estado para cada pregunta, y vale la pena no confundirlos:

CódigoQué diceQué hace el cliente
401 Unauthorized«No sé quién eres»: falta la credencial, es falsa o ya caducóConseguir una credencial válida y volver a intentar
403 Forbidden«Sé quién eres, pero esto no te toca»Nada: repetir no sirve; hay que pedir el permiso

El nombre del 401 confunde: dice Unauthorized, pero significa «no autenticado». Es un error histórico del estándar. En el clasificador de Alba, una request sin credencial válida recibe 401 en la puerta de entrada y nunca llega al gateway, el programa que prepara la foto para el modelo. Una con credencial válida pero sin el permiso de clasificar recibe 403.

02

Personas: contraseña, segundo factor y sesión

Esencial

People: password, second factor and session

Ana crea su cuenta con su correo y la contraseña tenis2026, y Alba tiene que reconocerla la próxima vez. La pregunta parece fácil: ¿qué guarda Alba en su base de datos?

Nunca la contraseña

Lo más obvio sería guardar tenis2026 tal cual y compararla cuando Ana vuelva. Es lo peor. Las bases de datos se roban: por un error de permisos, un respaldo olvidado o un empleado. Si la base guarda las contraseñas en claro (tal cual, legibles), quien la robe tiene la de cada persona. Y como mucha gente repite su contraseña, también tiene la de su correo y su banco.

La salida es guardar una huella de la contraseña, no la contraseña. Un hash criptográfico, como SHA-256 (a fondo en «Tiempo, hashes e identificadores»), es una función que convierte cualquier texto en un número de tamaño fijo, fácil de calcular y prácticamente imposible de regresar al texto. Alba guarda el hash; cuando Ana vuelve, calcula el hash de lo que escribió y compara. Si coinciden, era la correcta, y Alba nunca tuvo que guardarla.

Pero un hash normal no basta: tiene dos problemas, cada uno con su arreglo.

Problema 1: el hash rápido

SHA-256 está hecho para ser rápido: para que tu computadora calcule la huella de un archivo de varios GB en segundos. Para contraseñas, eso es justo lo malo. Quien robó la base no puede «regresar» el hash, pero sí puede adivinar: probar aaaaaaaa, aaaaaaab… calcular el hash de cada una y ver si coincide. Es un ataque de fuerza bruta, y con un hash rápido una sola tarjeta gráfica (GPU), que hace miles de cuentas a la vez, prueba miles de millones por segundo.

El arreglo es un hash lento a propósito: una función que repite la cuenta muchas veces, o que además gasta mucha memoria (lo que más le escasea a una GPU que corre miles de intentos a la vez), para que cada intento tarde, por ejemplo, decenas de milisegundos. Para Ana, esperar 50 ms al entrar no se nota. Para quien adivina, multiplicar el costo de cada intento convierte segundos en días, y días en años.

Esos 50 ms son en un solo núcleo de una laptop: ahí saldrían 1 s ÷ 0.05 s = 20 intentos por segundo. Una GPU hace miles de intentos en paralelo, así que en total prueba del orden de 10⁴ por segundo, no 20.

Las funciones que se usan para esto son bcrypt, scrypt, Argon2 (la recomendada hoy, en su variante Argon2id) y PBKDF2, que repite cientos de miles de veces un HMAC (un hash que mezcla el texto con una llave). PBKDF2 y scrypt ya vienen en la biblioteca estándar de Python (hashlib); Argon2 y bcrypt se instalan como paquetes aparte.

¿Cuánto tarda adivinar? Depende de cuántas contraseñas posibles hay y de cuántas prueba el atacante por segundo:

Tiempo para probar todas las contraseñas
C=am
t=Cv
donde
a
cuántos símbolos puede tener cada carácter, en símbolos: 26 si solo son minúsculas, 62 con mayúsculas y dígitos
m
el largo de la contraseña, en caracteres
C
cuántas contraseñas posibles hay con ese largo y esos símbolos, en contraseñas
v
cuántos intentos por segundo hace el atacante, en intentos/s
t
el tiempo para probarlas todas, en segundos. En promedio atina a la mitad: t÷2

Los números de v son de una tarjeta gráfica de juego, una RTX 4090. Con SHA-256 calcula ≈ 2 × 10¹⁰ hashes por segundo: los ≈ 2.2 × 10¹⁰ medidos que usa «Cifrado, llaves y certificados», redondeados. Un hash lento bien configurado la baja a algo del orden de 10⁴ intentos por segundo: con PBKDF2 de 600,000 repeticiones da ≈ 1.5 × 10⁴, y aquí se redondea a 10⁴.

Ocho minúsculas, con hash rápido y con hash lentoLa cuenta
Símbolos, asolo minúsculas
dato del ejemplo
26
Largo, m8 caracteres, como tenisazo
dato del ejemplo
8
Contraseñas posibles, C
C=am = 26⁸
≈ 2.09 × 10¹¹
Con hash rápido, vuna RTX 4090 con SHA-256: ≈ 2.2 × 10¹⁰, redondeado
supuesto
2 × 10¹⁰ intentos/s
Tiempo con hash rápido, t
C÷v = 2.09 × 10¹¹ ÷ (2 × 10¹⁰)
≈ 10.4 s
Con hash lento, vla misma GPU con PBKDF2: ≈ 1.5 × 10⁴, redondeado
supuesto
10⁴ intentos/s
Tiempo con hash lento, t
C÷v = 2.09 × 10¹¹ ÷ 10⁴
≈ 2.09 × 10⁷ s
El mismo t, en días
2.09 × 10⁷ ÷ 86,400 s por día
≈ 242 días
Resultado
El mismo largo pasa de ≈ 10 segundos a ≈ 242 días, solo por usar un hash lento. Con 12 caracteres de 62 símbolos (C = 62¹² ≈ 3.2 × 10²¹), el hash lento lo lleva a ≈ 10¹⁰ años.

Problema 2: la misma contraseña, el mismo hash

Si Ana y Beto, otro vendedor de Alba, eligen los dos tenis2026, sus hashes son idénticos. Quien robe la base ve que comparten contraseña, y al adivinar una tiene las dos. Peor: el atacante puede calcular una sola vez los hashes de millones de contraseñas comunes, guardarlos en una tabla y buscar en ella los de cualquier base robada, sin volver a calcular nada.

El arreglo es la sal (salt): un número al azar, distinto para cada cuenta, que se mezcla con la contraseña antes del hash. La sal no es secreta: se guarda en claro junto al hash, porque Alba la necesita para repetir la cuenta. Lo que logra es que cada cuenta sea un problema aparte: la misma contraseña con dos sales da dos hashes sin parecido, y una tabla precalculada ya no sirve, porque tendría que calcularse de nuevo para cada sal.

Juntas, las dos ideas son el hash de contraseña: lo que se guarda es la sal y el hash lento de sal más contraseña, nunca la contraseña.

Lo que guarda la base de cuentas de Alba para Ana y Beto, que eligieron la misma contraseña, tenis2026. Sin sal, con SHA-256, los dos hashes son idénticos, 247214dc7f0901b3, y quien robe la base ve que comparten contraseña. Con sal, cada cuenta tiene su propia sal al azar (a1b2c3d4 para Ana, 0f1e2d3c para Beto) y su hash lento: 86de24cc para Ana y e605e630 para Beto, sin ningún parecido. La sal se guarda en claro; la contraseña no se guarda. LO QUE GUARDA LA BASE Ana y Beto eligen la misma: tenis2026 SIN SAL · SHA-256 CUENTA HASH GUARDADO Ana 247214dc7f0901b3 Beto 247214dc7f0901b3 iguales CON SAL · HASH LENTO CUENTA SAL (EN CLARO) HASH Ana a1b2c3d4… 86de24cc… Beto 0f1e2d3c… e605e630… La contraseña no se guarda en ningún lado.
Arriba, sin sal: Ana y Beto eligen tenis2026 y la base guarda dos hashes iguales. Abajo, con sal: cada uno tiene la suya, y los hashes no se parecen. La sal se guarda en claro; lo que no se guarda es la contraseña.
Para ir más hondoCuánto cuesta atacar muchas cuentas
Atacar muchas cuentas
tU=U×Cv
donde
U
cuántas cuentas robadas, cada una con su propia sal, en cuentas
C,v
las mismas de arriba: contraseñas posibles e intentos por segundo
tU
el tiempo para probar todas las contraseñas en todas las cuentas, en segundos. Sin sal, tU=C÷v: una sola pasada sirve para todas

Con 1 millón de cuentas robadas (U = 10⁶, un supuesto del ejemplo) y las ocho minúsculas con hash lento, tU = 10⁶ × 242 días: unos 660,000 años. Sin sal, los mismos 242 días bastarían para todas.

El código hace lo que guarda Alba, con PBKDF2 de la biblioteca estándar de Python, 600,000 repeticiones (lo que recomienda hoy OWASP, una organización abierta de seguridad web, para PBKDF2 con SHA-256) y sales fijas para que la salida no cambie:

Python
import hashlib, hmac

def guardar(contrasena, sal):        # lo que guarda Alba: la sal y el hash, nunca la contraseña
    h = hashlib.pbkdf2_hmac("sha256", contrasena.encode(), sal, 600_000)
    return sal, h

ana  = guardar("tenis2026", bytes.fromhex("a1b2c3d4e5f60718"))
beto = guardar("tenis2026", bytes.fromhex("0f1e2d3c4b5a6978"))  # misma contraseña, otra sal
print("Ana: ", ana[0].hex(), ana[1].hex()[:16])                # 16 de los 64 dígitos
print("Beto:", beto[0].hex(), beto[1].hex()[:16])
print("SHA-256 sin sal:", hashlib.sha256(b"tenis2026").hexdigest()[:16])

def revisar(intento, guardado):
    sal, h = guardado
    _, h2 = guardar(intento, sal)    # repite la cuenta con la misma sal
    return hmac.compare_digest(h, h2)

print(revisar("tenis2026", ana), revisar("tenis2025", ana))
Salida
Ana:  a1b2c3d4e5f60718 86de24cc80815a5b
Beto: 0f1e2d3c4b5a6978 e605e63099b8c9a5
SHA-256 sin sal: 247214dc7f0901b3
True False

La misma contraseña da dos hashes sin parecido. En una laptop, cada guardar tarda ≈ 50 ms; un SHA-256 suelto, menos de un microsegundo (una millonésima de segundo). En un sistema real, la sal no es fija: sale de secrets.token_bytes(16), 16 bytes al azar. Y hmac.compare_digest es una comparación como ==, hecha para no dar pistas por el tiempo que tarda.

Para ir más hondoPor qué se compara con hmac.compare_digest

== se sale en la primera diferencia, y su tiempo, medido muchas veces, le diría a un atacante cuántos bytes del valor esperado atinó; hmac.compare_digest tarda lo mismo falle donde falle. Con el hash de una contraseña eso le sirve poco (no sabe la sal), pero con una firma, como la del JWT de más abajo, sí: la idea completa está en «Cifrado, llaves y certificados».

¿Cuánto tarda adivinar una contraseña?Calculadora

Aplica las ecuaciones de la lección: C=am contraseñas posibles, t=C÷v segundos para probarlas todas y tU=U×C÷v para U cuentas, cada una con su sal. Arranca con ocho minúsculas contra un hash lento. Los valores de v son de una RTX 4090: ≈ 2 × 10¹⁰ intentos por segundo con un hash rápido (SHA-256; los ≈ 2.2 × 10¹⁰ de «Cifrado, llaves y certificados», redondeados) y ≈ 10⁴ con uno lento (con PBKDF2 de 600,000 repeticiones da ≈ 1.5 × 10⁴). Supone contraseñas al azar: una palabra común cae con una lista en segundos.

Contraseñas posibles, CC=am2.09 × 10^11
Tiempo para probarlas todas, t, en segundost=C÷v2.09 × 10^7
El mismo t, en díast entre 86,400 s del día; en promedio, la mitad2.42 × 10^2
El mismo t, en añosun año ≈ 3.16 × 10⁷ s6.62 × 10^-1
Para las U cuentas, tU, en añostU=U×C÷v; sin sal bastaría t para todas6.62 × 10^-1

Cada carácter más multiplica el tiempo por a; multiplicar v por 10 lo divide entre 10.

Empieza con las ocho minúsculas y el hash lento de la cuenta, v = 10,000 intentos por segundo. Cambia v a 20,000,000,000 (un hash rápido en la GPU) y mira cómo los ≈ 242 días se vuelven ≈ 10 segundos. Luego regresa v a 10,000 y sube m de uno en uno: cada carácter más multiplica el tiempo por a.

Un segundo factor

Aun con el mejor hash, una contraseña se puede robar de otras maneras: Ana la escribe en una página falsa que imita a Alba (phishing), o la usa también en otro sitio que guardaba todo en claro. Por eso existe la autenticación multifactor (multi-factor authentication, MFA): pedir, además de algo que sabes, algo que tienes o algo que eres.

El más común es un código de 6 dígitos que cambia cada 30 segundos en una app del teléfono. El más fuerte es una passkey (una llave guardada en tu teléfono que firma por ti) o una llave física (un aparatito USB que hace lo mismo): las dos firman solo para el sitio verdadero, así que en una página falsa no sirven.

Para ir más hondoTres segundos factores, de más débil a más fuerte
  • Un código que cambia cada 30 segundos en una app del teléfono (TOTP, time-based one-time password). La app y el servidor comparten un secreto desde el día en que escaneaste un código QR; cada uno calcula un HMAC del secreto con la hora, y de ahí salen 6 dígitos. Si coinciden, tienes el teléfono.
  • Un código por SMS. Mejor que nada, pero el más débil: un atacante puede convencer a la compañía de teléfono de pasarle tu número a otra tarjeta SIM (el chip del teléfono).
  • Una llave física o una passkey. El teléfono o la llave guardan una llave privada que nunca se le entrega al sitio, y firman un reto que manda el sitio. (En una llave física, la llave privada no sale nunca del aparato; una passkey puede copiarse, cifrada, entre tus dispositivos, por ejemplo con tu cuenta de Apple o de Google.) La firma va ligada al nombre del sitio, así que en una página falsa no sirve: es la única de las tres que resiste el phishing.

En Alba, el segundo factor de las vendedoras es opcional. Para Marta y el resto del equipo, que pueden tocar la infraestructura, conviene que sea obligatorio.

La sesión: no pedir la contraseña en cada clic

Ana no escribe su contraseña cada vez que abre una página. Después de entrar, el servidor crea una sesión: un número largo al azar (el id de sesión) que guarda en su base junto con «es Ana, entró a tal hora», y que le entrega al navegador en una cookie. El navegador la regresa sola en cada request a Alba, y el servidor la busca: «este número es de Ana».

Ese número vale tanto como la contraseña mientras dure: quien lo copie es Ana. Por eso la cookie se marca con tres opciones:

  • Secure: solo viaja por HTTPS, cifrada.
  • HttpOnly: el código JavaScript de la página (los programas que corren dentro de ella) no la puede leer, así que un script malicioso no la roba.
  • SameSite: el navegador no la manda cuando la request la provoca otro sitio; así una página ajena no puede hacer que tu navegador le pida algo a Alba a tu nombre. Con Strict, nunca la manda; con Lax, solo si la persona sigue un enlace hacia Alba.

Y por eso la sesión caduca, y al salir se borra del servidor: ahí sí se puede «apagar», porque el servidor la guarda.

03

Máquinas: llaves de API y tokens Bearer

Esencial

Machines: API keys and bearer tokens

Un programa no escribe contraseñas ni tiene teléfono. Lo más simple que puede mostrar es un secreto que el otro lado reconoce.

La llave de API

Una llave de API (API key) es un texto largo al azar, como ak_live_7Hq2…, que el servidor genera, le entrega al cliente y reconoce. El cliente la manda en cada request, en un header. Es lo que te dan muchos servicios de pago cuando te registras para usar su API.

Es fácil de usar y por eso está en todos lados, pero tiene problemas serios:

  • Casi nunca caduca. Algunos servicios dejan ponerle fecha, pero lo normal es que viva meses o años, hasta que alguien la cambia a mano.
  • Se filtra. Termina en un repositorio, en un log, en un mensaje de chat o en una captura de pantalla. Quien la encuentre es el cliente, sin límite de tiempo.
  • Rotarla rompe al cliente. Rotarla es cambiarla por una nueva (rotación), y eso obliga a actualizar cada programa que la usa al mismo tiempo, o a aceptar dos llaves válidas un rato.
  • No dice nada. El servidor tiene que buscarla en su base para saber de quién es y qué puede hacer.

Si se usa, se guarda como una contraseña: el servidor guarda solo su hash (aquí basta un hash rápido como SHA-256, porque la llave es larga y al azar: no hay lista de «llaves comunes» que probar), y el cliente la guarda en un gestor de secretos, nunca en el código.

El token de acceso

La mejora es no mandar el secreto de larga vida en cada request. El cliente usa su secreto una vez, ante alguien en quien todos confían, y a cambio recibe un token de acceso (access token): un permiso que dura poco, por ejemplo 15 minutos, y que es lo que viaja en cada request.

Viaja en el header Authorization, con la palabra Bearer («portador») antes: una request al clasificador de Alba lleva Authorization: Bearer eyJhbGciOiJSUzI1NiIs…, seguido de cientos de caracteres más, junto a los headers de siempre y los bytes de la foto.

«Portador» quiere decir exactamente eso: quien lo porta, lo usa. El servidor no pregunta quién lo trae; si el token es bueno, pasa. Es como un billete: no tiene tu nombre, y quien lo tenga lo gasta. El parecido se rompe en que un billete vale para siempre, y un token, minutos. Por eso un token de acceso viaja por HTTPS, no se escribe en los logs y caduca pronto: si se filtra, el daño dura minutos, no meses.

En Alba, el token va cifrado hasta el ALB (Application Load Balancer), el balanceador de AWS que recibe todas las requests de fuera: la puerta de entrada. De ahí al gateway sigue sin cifrar, por la red privada del clúster (el grupo de máquinas donde corren los programas de Alba). Es una decisión de Alba, que protege esa red con reglas de quién puede hablarle a quién.

Queda una pregunta: ¿cómo sabe el servidor que un token es bueno sin buscarlo en una base en cada request? Esa es la gracia del JWT.

04

JWT por dentro: encabezado, claims y firma

Esencial

Inside a JWT: header, claims and signature

Un JWT (JSON Web Token, que se pronuncia «jot» en inglés) no es un mecanismo de autenticación: es un formato. Es un texto con tres partes separadas por puntos, encabezado.claims.firma:

  • El encabezado (header) es un JSON chiquito que dice cómo se firmó: {"alg": "RS256", "typ": "JWT", "kid": "2026-11"}. alg es el algoritmo de la firma y kid, el nombre de la llave con que se firmó.
  • Los claims (las «afirmaciones») son otro JSON con lo que el token dice: quién es, para quién es y hasta cuándo vale.
  • La firma es una firma digital de las dos primeras partes, hecha por quien emitió el token.

Cada parte se escribe en base64url: una variante de base64 que cambia + y / por - y _ y quita el relleno =, para que el token se pueda poner en una URL o en un header sin problemas. Ojo: base64 no es cifrado. Cualquiera que tenga el token puede leer sus claims, solo con decodificarlo. Lo que no puede es cambiarlos sin romper la firma. Por eso en un JWT van ids y permisos, nunca secretos ni datos personales que no hagan falta.

Un JWT de moderación, por partes, en la versión de juguete del código, firmada con HS256 (el de Alba usa RS256: firma con llave privada y se verifica con la pública). Arriba, el token como texto: tres pedazos separados por puntos. Primera parte, el encabezado, en base64url: dice alg HS256 y typ JWT. Segunda parte, los claims: iss idp.alba.internal, sub moderacion, aud classifier, scope classify, iat y exp, que es iat más 900 segundos. Tercera parte, la firma: un HMAC-SHA256 del encabezado y los claims, hecho con la llave del emisor. Las dos primeras partes las lee cualquiera; la firma impide cambiarlas, porque sin la llave no se puede rehacer. UN JWT, POR PARTES eyJhbGci….eyJpc3Mi….dGhlLXNp… 1 · ENCABEZADO · CÓMO SE FIRMÓ {"alg": "HS256", "typ": "JWT"} el del código · en Alba, RS256 con su kid 2 · CLAIMS "iss": "idp.alba.internal"emisor "sub": "moderacion"quién "aud": "classifier"para quién "scope": "classify"qué permite "exp": iat + 900hasta cuándo 3 · FIRMA HMAC-SHA256(encabezado.claims, llave) sin la llave, no se puede rehacer
Las tres partes de un JWT, separadas por puntos. Las dos primeras son JSON en base64url y cualquiera las lee. La tercera es la firma de las dos primeras: si alguien cambia un solo carácter de los claims, la firma ya no coincide. Es el token de juguete del código de más abajo, firmado con HS256; el de Alba usa RS256.

Los claims

Los claims que define el estándar de JWT (el RFC 7519; los RFC son los documentos públicos que fijan los estándares de internet) tienen nombres cortos, de tres letras. Se pueden agregar otros: scope, por ejemplo, viene de los estándares de OAuth, que ves más abajo.

ClaimNombreQué diceEn el token de moderación
ississuer, emisorQuién emitió el tokenidp.alba.internal
subsubject, sujetoDe quién esmoderacion
audaudience, audienciaPara quién es: qué servicio lo debe aceptarclassifier
expexpirationHasta cuándo vale, en segundos desde 1970emitido + 900 s
iatissued atCuándo se emitió—
jtiJWT idUn id único de este tokent-5f1c…
scopealcance (no es del RFC 7519)Qué permiteclassify

exp y iat se escriben en tiempo Unix: los segundos que han pasado desde el 1 de enero de 1970, una forma de escribir un instante con un solo número. Por ejemplo, 1700000000 es el 14 de noviembre de 2023.

La aud importa más de lo que parece: un token que el emisor le dio a moderación para hablar con otro servicio también lleva una firma buena. Si el clasificador no revisa que aud diga classifier, aceptaría tokens que no eran para él.

Verificar sin preguntarle a nadie

La gracia del JWT es que el servidor lo verifica solo, sin llamar a nadie. Revisa, en este orden:

  1. 1

    La firma

    Con la llave del emisor, comprueba que la firma corresponde al encabezado y los claims. Si alguien cambió algo, no coincide. Si no coincide, 401.

  2. 2

    El emisor y la audiencia

    iss tiene que ser el emisor en el que confía, y aud tiene que ser él mismo. Si no, 401.

  3. 3

    Las fechas

    exp tiene que estar en el futuro, con un margen de unos segundos porque los relojes de dos máquinas nunca marcan exactamente la misma hora (desfase de reloj). Si ya pasó, 401.

  4. 4

    El permiso

    Y ahora sí, con la identidad comprobada, autoriza: ¿el scope incluye lo que pide? Si no, 403.

Hay dos maneras de firmar, y el encabezado dice cuál se usó:

  • HS256: un HMAC con SHA-256, es decir, una huella que solo puede calcular quien tiene la llave, que aquí es compartida. Quien verifica tiene la misma llave que quien firma, así que también podría fabricar tokens. Sirve si el que emite y el que verifica son el mismo programa.
  • RS256 o ES256: una firma con llave asimétrica. El emisor firma con su llave privada, que nunca sale de él, y cualquiera verifica con la llave pública. Quien verifica no puede fabricar tokens. Es lo normal cuando muchos servicios verifican los tokens de un solo emisor.

El código arma y verifica un JWT a mano, con HS256 y una llave de juguete (con RS256 haría falta una biblioteca de criptografía que no viene con Python). El token dura 900 segundos, 15 minutos; los tiempos son fijos para que la salida no cambie:

Python
import base64, hashlib, hmac, json

def b64(datos):                               # base64url sin el relleno «=»
    return base64.urlsafe_b64encode(datos).rstrip(b"=").decode()
def firmar(texto, llave):
    return b64(hmac.new(llave, texto.encode(), hashlib.sha256).digest())

llave = b"secreto-de-juguete"                 # solo para este ejemplo (HS256)
encabezado = {"alg": "HS256", "typ": "JWT"}
claims = {"iss": "idp.alba.internal", "sub": "moderacion", "aud": "classifier",
          "scope": "classify", "iat": 1700000000, "exp": 1700000900}
cuerpo = b64(json.dumps(encabezado).encode()) + "." + b64(json.dumps(claims).encode())
token = cuerpo + "." + firmar(cuerpo, llave)
print(len(token), token[:40] + "…")

def verificar(token, ahora):
    e, c, f = token.split(".")
    if not hmac.compare_digest(f, firmar(e + "." + c, llave)): return "firma mala"
    datos = json.loads(base64.urlsafe_b64decode(c + "=" * (-len(c) % 4)))
    if datos["iss"] != "idp.alba.internal" or datos["aud"] != "classifier": return "no es para mí"
    if ahora >= datos["exp"]: return "caducó"
    return "ok: " + datos["sub"]

print(verificar(token, 1700000300))           # 5 minutos después de emitido
print(verificar(token, 1700001000))           # a los 16 minutos y 40 s
falso = dict(claims, sub="backend-publicaciones")   # alguien cambia el sub…
c2 = b64(json.dumps(falso).encode())
print(verificar(token.split(".")[0] + "." + c2 + "." + token.split(".")[2], 1700000300))
Salida
257 eyJhbGciOiAiSFMyNTYiLCAidHlwIjogIkpXVCJ9…
ok: moderacion
caducó
firma mala

Fíjate en el último: cambiar sub para hacerse pasar por el backend de publicaciones es fácil, porque los claims se leen y se escriben con base64. Lo que no se puede es firmarlo sin la llave. Y fíjate en que verificar no lee el alg del token: siempre usa el algoritmo que espera. Hubo bibliotecas que sí lo leían, y bastaba un token con "alg": "none" (sin firma) para que lo aceptaran. Quien verifica decide el algoritmo, nunca el token.

JWKS: dónde están las llaves públicas

Si el emisor firma con su llave privada, los servicios necesitan su llave pública. El emisor la publica en una dirección fija, como un JSON con una lista de llaves: el JWKS (JSON Web Key Set). Cada llave lleva un id, el kid, y el encabezado de cada token dice con cuál kid se firmó.

Quien verifica guarda el JWKS en memoria y lo vuelve a bajar cada tanto, o cuando ve un kid que no conoce. No lo baja en cada request: eso volvería a poner al emisor en el camino de cada llamada.

Para ir más hondoCambiar las llaves sin cortar el servicio, y el JWKS en el ALB

Con el kid se cambian las llaves sin cortar el servicio: el emisor publica la llave nueva junto a la vieja, empieza a firmar con la nueva y, cuando los últimos tokens viejos ya caducaron, quita la vieja.

Un ejemplo concreto: el ALB de AWS, la puerta de entrada de Alba, verifica JWT desde noviembre de 2025. Según su documentación (noviembre de 2026), solo acepta tokens RS256 con llaves de 2,048 bits, y baja el JWKS de una dirección que tiene que ser pública. No hay problema en eso: son llaves públicas. Lo que sí queda en la red interna de Alba es el lugar donde los callers piden sus tokens.

05

Vida corta y revocación

Esencial

Short lifetime and revocation

Verificar sin preguntarle a nadie tiene un precio: nadie le puede avisar al servidor que un token ya no vale. Un JWT no se puede «des-firmar»: hasta su exp, la firma sigue siendo buena.

Cancelar una credencial antes de que caduque se llama revocación. Con una sesión es fácil: se borra de la base del servidor. Con un JWT, hay dos maneras, y las dos le quitan su ventaja:

  • Una lista de tokens revocados, por su jti, que cada servicio consulta. Ya no verifica solo: tiene que leer esa lista.
  • Preguntarle al emisor si el token sigue vivo (lo que OAuth, el estándar de la sección siguiente, llama introspección). Eso es otra llamada en el camino de cada request.

La salida que se usa casi siempre es otra: que el token dure poco. Si un token robado vale como mucho 15 minutos, el daño se acaba solo. Lo común es una vida de 5 a 60 minutos, aunque varios servicios que emiten tokens dan más si no se cambia (Microsoft Entra ID, entre 60 y 90 minutos; Auth0, 24 horas): la vida es algo que se configura. Y el cliente no pide un token por request: lo guarda en memoria y pide otro antes de que caduque.

Línea de tiempo de 0 a 30 minutos. Arriba, los tokens de un caller de Alba: el token 1 vale de 0 a 15 minutos, el token 2 se pide a los 12 y vale de 12 a 27, y el token 3 se pide a los 24. Siempre hay uno válido, y se traslapan 3 minutos. En medio, alguien roba el token 1 en el minuto 5: le sirve solo hasta el minuto 15, 10 minutos. Abajo, una llave de API robada en el minuto 5: sigue sirviendo después del minuto 30, hasta que alguien se dé cuenta y la cambie. CUÁNTO VALE LO QUE SE ROBA tokens de 15 min, renovados a los 12 TOKENS DEL CALLER token 1 token 2 token 3 TOKEN 1 ROBADO EN EL MIN 5 10 min y se acaba LLAVE DE API ROBADA EN EL MIN 5 0 15 min 30 min La llave sirve hasta que alguien la cambie
Arriba, los tokens de un caller: cada uno vale 15 minutos y el siguiente se pide a los 12, para que nunca haya un hueco. En medio, un token robado en el minuto 5: sirve solo hasta el minuto 15. Abajo, una llave de API robada: sirve hasta que alguien se dé cuenta y la cambie.

¿Y cuánto trabajo le da eso al emisor? Poco, si cada caller guarda su token en caché (en memoria, para reusarlo) en vez de pedir uno por request:

Tokens que se piden al día
n=I×1,440R
donde
I
cuántas instancias piden su propio token, en instancias. Una instancia es una copia del programa corriendo; cada una guarda su token. Si hay varios callers, se suman las de todos
R
cada cuántos minutos se renueva el token, en min. Tiene que ser menor que su vida, D
D
la vida del token, en min: lo que vale un token robado, como mucho
1,440
los minutos de un día
n
cuántos tokens pide al emisor, en tokens por día
Los tokens de los tres callers de AlbaLa cuenta
Vida del token, Dla de Alba
ficha de Alba
15 min
Renovación, Rsupuesto: 3 minutos antes de caducar
D − 3 = 15 − 3
12 min
Instancias, Isupuesto: 4 copias de cada uno de los 3 callers
3 × 4
12
Tokens al día, n
n=I×1,440÷R = 12 × 1,440 ÷ 12
1,440
Pedidos por segundo86,400 son los segundos de un día
n÷86,400 = 1,440 ÷ 86,400
≈ 0.017 por s
Sin caché, un token por requestlas ≈ 10 M fotos al día de Alba, una por request
10,000,000 ÷ 86,400
≈ 116 por s
Resultado
Con caché, el emisor entrega ≈ 1,440 tokens al día, uno cada minuto. Sin caché serían ≈ 116 por segundo, y cada request de Ana esperaría una llamada más. Y un token robado vale, como mucho, D = 15 minutos.
Vida del token: cuánto vale uno robado y cuánto trabaja el emisorCalculadora

Aplica n=I×1,440÷R: I instancias, cada una con su token, que lo renuevan cada R minutos, piden n tokens al día. Un token robado vale, como mucho, su vida D. Arranca con los 3 callers de Alba: tokens de 15 minutos y, como supuestos de la lección, renovación a los 12 minutos y 4 instancias por caller.

Tokens que se piden al día, nn=I×1,440÷R1,440
Pedidos por segundo al emisor, n÷86,400n entre los 86,400 s del día0.017
Lo que vale un token robado, como mucho, en minutossu vida D15
Margen antes de caducar, D−R, en minutoscon 0, el caller corre el riesgo de quedarse sin token válido3

Sin caché, cada request pediría un token: con las ≈ 10 M fotos al día de Alba serían ≈ 116 por segundo.

Empieza con los callers de Alba. Baja D a 5 minutos (y R a 4): la ventana de un token robado se reduce a un tercio y el emisor recibe el triple de pedidos, que siguen siendo pocos. Sube I a 500, como en un sistema enorme, y mira cuándo empieza a ser una carga.

Para ir más hondoSi de verdad hay que cortar ya

Cuando el riesgo lo pide (un empleado que se va, una cuenta robada), se combinan las dos cosas: tokens cortos y una lista de revocados chiquita, que solo guarda los tokens cancelados que todavía no caducan. Esa lista se vacía sola, porque a los 15 minutos ya no hace falta.

06

OAuth y client credentials: el token de los callers de Alba

Esencial

OAuth and client credentials: how Alba's callers get their token

Ya tienes las piezas: un token corto, firmado, que se verifica sin preguntar. Falta quién lo emite y cómo se pide.

El proveedor de identidad

El proveedor de identidad (identity provider, IdP) es el servicio que sabe quién es quién y emite los tokens. Guarda la lista de clientes y usuarios, revisa sus credenciales y firma los tokens con su llave privada. Ejemplos: Okta, Auth0, Microsoft Entra ID, Keycloak (que una empresa instala en sus propias máquinas) o Cognito de AWS. Alba tiene uno interno.

Tener un solo emisor es lo que deja que muchos servicios confíen en los mismos tokens: todos verifican con el mismo JWKS.

OAuth: un permiso sin dar la contraseña

OAuth 2.0 es el marco estándar para que un programa obtenga un token de acceso sin conocer la contraseña de nadie. Nació para casos como este: una app de fotos quiere publicar en tu red social. En vez de darle tu contraseña a la app, la red social te pregunta «¿dejas que esta app publique por ti?», y si dices que sí, le entrega a la app un token que solo sirve para publicar y que puedes retirar.

OAuth define varios caminos (flujos) para pedir un token, según quién lo pide. Para una persona en un navegador hay uno con redirecciones (el navegador te lleva a la página del proveedor y luego te regresa a la app) y una pantalla de permiso. Para un programa que habla por sí mismo, sin ninguna persona de por medio, está el más simple de todos.

Client credentials: máquina a máquina

En el flujo de client credentials (credenciales de cliente), el programa se presenta ante el proveedor de identidad con su nombre de cliente (client_id) y su secreto (o con un certificado), y recibe un token. No hay persona ni pantalla. Es lo que hacen los 3 callers de Alba: cada uno recibe un token de 15 minutos. El secreto de moderación vive en el gestor de secretos y se usa una vez cada 12 minutos, al renovar el token, no en cada request al clasificador.

Para ir más hondoLa request por dentro

Así se ve el pedido de moderación. Es solo una ilustración (el parámetro audience no es del estándar base de OAuth: lo agregan varios proveedores para decir para qué servicio es el token):

POST /oauth2/token HTTP/1.1
Host: idp.alba.internal
Content-Type: application/x-www-form-urlencoded
Authorization: Basic bW9kZXJhY2lvbjrigKY=

grant_type=client_credentials&scope=classify&audience=classifier

Es un POST, el método HTTP para mandar datos, a la ruta de tokens del proveedor. El cuerpo, la última línea, va en formato de formulario web (eso dice Content-Type): pares nombre=valor unidos con &. Dice qué flujo se usa (grant_type), qué permiso se pide (scope) y para qué servicio (audience). El Authorization: Basic lleva el client_id y el secreto en base64, que no es cifrado: por eso va por HTTPS.

La respuesta trae el token y su vida: {"access_token": "eyJ…", "token_type": "Bearer", "expires_in": 900}. Novecientos segundos son los 15 minutos de Alba.

El scope: qué permite el token

El scope (alcance) es la lista de permisos que lleva el token. El de los callers de Alba dice classify: sirve para pedir una clasificación y nada más. Si el clasificador tuviera una ruta de administración (una ruta es una dirección dentro del servicio, como /v1/classify; esta serviría, por ejemplo, para cambiar la versión del modelo), pediría otro scope, digamos classifier:admin, que ningún caller tiene. Un token robado de búsqueda clasifica fotos; no cambia el modelo.

El scope es una autorización gruesa: dice qué tipo de cosas puede hacer el portador. La fina, «¿esta publicación es tuya?», no cabe en un token: se revisa en el servidor.

El camino completo en Alba

Cómo se identifican los callers del clasificador de Alba · Los tres callers piden su token al proveedor de identidad y lo guardan. En cada request, el ALB lo verifica con el JWKS y el gateway decide con el client_id verificado. Toca cada caja para ver qué revisa.
  • Moderación · client_id propio
    Revisa en tandas (lotes sin prisa) que las publicaciones cumplan las reglas. Como los otros dos callers, tiene su client_id y su secreto en el gestor de secretos, y pide su token con client credentials.
  • Backend · de publicaciones
    El programa que arma la publicación de Ana y pide la categoría de su foto. Manda en cada request Authorization: Bearer … con el token que tiene en caché.
  • Búsqueda · client_id propio
    El tercer caller. Su token dice sub: busqueda y scope classify: puede clasificar, pero no usar ninguna ruta de administración.
  • Proveedor · de identidad
    El proveedor de identidad interno de Alba. Revisa client_id y secreto, y firma con su llave privada un JWT de 15 minutos con scope classify. Publica sus llaves públicas en su JWKS.
  • ALB · termina TLS, verifica
    El Application Load Balancer, el balanceador de AWS que es la puerta de entrada. Descifra el HTTPS y verifica el JWT: la firma (con el JWKS en memoria), el emisor (iss) y la expiración (exp), siempre; la audiencia (aud), porque Alba la configura como un claim extra que tiene que coincidir. Sin token válido responde 401 y la request no sigue. Si es bueno, lo pasa tal cual al gateway, que lee de él el client_id.
  • Gateway · FastAPI
    Recibe el token tal cual y lee el client_id de sus claims, que el ALB ya verificó. Con él decide tres cosas: si el scope alcanza (si no, 403), la cuota y la prioridad en la fila de Triton.
  • Baldes · uno por client_id
    Un token bucket por caller: un balde de fichas que se rellena a ritmo fijo; cada request gasta una. El de moderación: 50 requests por segundo, ráfagas de 100. Quien se pasa recibe 429 con Retry-After, y los demás ni se enteran.
  • Triton · sin entrada de fuera
    El programa que corre la ResNet-50 en la GPU. No tiene entrada desde fuera del clúster: solo el gateway le habla. No sabe nada de tokens: la identidad ya se resolvió antes.

El ALB, la puerta de entrada, descifra la conexión HTTPS y verifica el JWT: firma, emisor, audiencia y fecha. (La firma, el emisor y exp el ALB los revisa siempre; la audiencia, porque Alba se la configura como un claim extra que tiene que coincidir.) Una request sin token válido recibe 401 ahí mismo y nunca llega al gateway, el programa en Python que prepara la foto para el modelo.

Si el token es bueno, el ALB lo pasa tal cual. El gateway lee el client_id de sus claims, que el ALB ya verificó, y con él toma tres decisiones:

  • El permiso. ¿El scope trae classify? Si no, 403.
  • La cuota. Cada caller tiene su cuota, y se cuenta por el client_id verificado: la de moderación es de 50 requests por segundo. Si se pasa, recibe 429, Too Many Requests, y los otros dos callers ni se enteran. Cómo se cuenta una cuota y qué pasa cuando el gateway corre en varios pods lo explica «Balanceadores, proxies y gateways».
  • La prioridad. Las fotos que está publicando una persona van antes que las tandas (lotes de muchas fotos que no tienen prisa) de moderación.
07

Autorización: roles, dueños e IDOR

Esencial

Authorization: roles, owners and IDOR

La autenticación terminó: el sistema sabe que es Ana. Ahora la pregunta es otra: ¿qué le deja hacer?

RBAC: permisos por rol

Darle permisos a cada persona una por una se vuelve imposible con miles de usuarios. Lo normal es agruparlos: el RBAC (role-based access control, control de acceso por roles) define roles con un conjunto de permisos, y a cada identidad le asigna uno o varios roles.

RolEjemplo en AlbaPuede
vendedoraAnacrear y editar sus publicaciones
soporteMarta, de guardialeer cualquier publicación para ayudar; no editarlas
caller classifymoderación, búsqueda, backendpedir clasificaciones

Cuando alguien cambia de puesto, se le cambia el rol, no cincuenta permisos sueltos. Las políticas de IAM (el sistema de permisos de AWS) y los roles de Kubernetes son variantes del mismo patrón. Ojo con la tentación de un rol que lo pueda todo «por mientras»: el mínimo privilegio (cada identidad con solo los permisos que necesita) aplica igual a personas y a programas.

IDOR: el id en la URL

Ana edita su publicación con una request como PATCH /publicaciones/8811 (PATCH es el método HTTP para cambiar parte de algo; 8811 es el id, el número de su publicación). El servidor revisa la sesión: es Ana, tiene el rol de vendedora, puede editar publicaciones. ¿Y si Ana cambia el número a 8812, que es la bici de Beto?

Si el servidor solo revisó «¿hay sesión?» y «¿puede editar publicaciones?», edita la de Beto. Este error tiene nombre: IDOR (insecure direct object reference, referencia directa insegura a un objeto). La request pide un objeto por su id y el servidor no revisa de quién es ese objeto. Es de los fallos más comunes en APIs reales, y es difícil de ver en pruebas: con un solo usuario de prueba, todo funciona.

El arreglo es una línea, y va en el servidor, en cada request: además de quién eres y qué rol tienes, ¿este objeto es tuyo? Esconder el botón de «editar» en la pantalla no sirve: la request se puede escribir a mano.

Python
publicaciones = {8811: {"dueña": "ana", "titulo": "Tenis blancos"},
                 8812: {"dueña": "beto", "titulo": "Bici de ruta"}}
roles = {"ana": "vendedora", "beto": "vendedora", "marta": "soporte"}
permisos = {"vendedora": {"editar_propia"}, "soporte": {"leer_cualquiera"}}

def editar_mal(usuario, pub_id):              # solo revisa que haya sesión
    return "editada" if usuario else "401"

def editar_bien(usuario, pub_id):
    if not usuario: return "401"                          # ¿quién eres?
    pub = publicaciones.get(pub_id)
    if pub is None: return "404"
    if "editar_propia" in permisos[roles[usuario]] and pub["dueña"] == usuario:
        return "editada"                                  # ¿es tuya?
    return "403"

for quien, pid in [("ana", 8811), ("ana", 8812), ("marta", 8812), (None, 8811)]:
    print(quien, pid, editar_mal(quien, pid), editar_bien(quien, pid))
Salida
ana 8811 editada editada
ana 8812 editada 403
marta 8812 editada 403
None 8811 401 401

La versión mala deja a Ana editar la bici de Beto y a Marta, que solo debía leer, editar cualquier cosa. La buena revisa las tres cosas: sesión (401), rol y dueño (403).

Ana entra y edita: quién es y si la publicación es suya · Ana entra con contraseña y segundo factor, y recibe una sesión. Cada edición pasa por dos revisiones en el servidor: quién es (la sesión) y si la publicación es suya. Recorre el caso en que cambia el id en la URL.
  • Ana · vendedora
    Ana vende unos tenis desde Ciudad de México. Entra con su correo y su contraseña, más un segundo factor si lo activó.
  • Login · contraseña + código
    Toma la sal de Ana, repite el hash lento con lo que escribió y compara. Si activó el segundo factor, pide también el código. Si todo sale bien, crea una sesión y la entrega en una cookie.
  • Cuentas · sal + hash, sin contraseñas
    Guarda, por cuenta, la sal y el hash lento. Ninguna contraseña en claro: si alguien roba esta base, tiene que adivinarlas una por una.
  • Backend · de publicaciones
    En cada request revisa dos cosas: quién es (la sesión de la cookie; sin ella, 401) y si le toca (su rol y que la publicación sea suya; si no, 403).
  • Publicaciones · cada una con su dueña
    La 8811 es de Ana (tenis blancos); la 8812, de Beto (una bici). El dueño de cada objeto es lo que revisa la autorización fina.
  • Auditoría · solo crece
    El registro de auditoría: quién intentó qué, cuándo y con qué resultado. Se guarda donde nadie lo pueda editar.

¿Y si los ids no se pueden adivinar?

Una defensa que se oye mucho es usar ids al azar en vez de números seguidos (con ids seguidos, quien vea el 8811 sabe que el 8812 existe). Ayuda, pero no protege: los ids viajan en los enlaces que la gente comparte. Lo que de verdad protege es la revisión del dueño.

Para ir más hondoCuánto frenan los ids al azar
Atinar a un id que existe
p=EK
tid=KE×v
donde
E
cuántos ids existen de verdad, en ids
K
cuántos ids posibles hay, en ids
p
la probabilidad de que un intento al azar atine a uno que existe, entre 0 y 1
v
intentos por segundo del atacante, en intentos/s (la misma letra de las contraseñas)
tid
el tiempo esperado para atinar al primer id que existe, en segundos: se necesitan, en promedio, 1÷p=K÷E intentos
Ids seguidos contra ids al azar, con las publicaciones de AlbaLa cuenta
Ids que existen, Epublicaciones activas de Alba
ficha de Alba: ≈ 100 M
10⁸
Ids seguidos, pdel 1 al último: K ≈ E
E÷K ≈ 10⁸ ÷ 10⁸
≈ 1
Ids al azar de 64 bits, Kcada bit duplica las opciones
2⁶⁴
≈ 1.84 × 10¹⁹
Probabilidad por intento, p
E÷K = 10⁸ ÷ 1.84 × 10¹⁹
≈ 5.4 × 10⁻¹²
Intentos esperados, 1÷p
K÷E = 1.84 × 10¹⁹ ÷ 10⁸
≈ 1.84 × 10¹¹
Ritmo del atacante, vfrenado por una cuota
supuesto
1,000 intentos/s
Tiempo esperado, tid
K÷(E×v) = 1.84 × 10¹¹ ÷ 1,000
≈ 1.84 × 10⁸ s
El mismo tid, en añosun año ≈ 3.16 × 10⁷ s
1.84 × 10⁸ ÷ 3.16 × 10⁷
≈ 5.8 años
Resultado
Con ids seguidos, adivinar es trivial. Con 64 bits al azar y una cuota, el primer acierto tarda años; con un UUID al azar, de 122 bits, p baja a ≈ 1.9 × 10⁻²⁹. Pero el id sigue siendo público: viaja en enlaces que la gente comparte. Los ids al azar frenan la búsqueda a ciegas; la revisión del dueño es lo que de verdad protege.
Para ir más hondo¿403 o 404?

Si Ana pide una publicación ajena privada (un borrador de Beto), responder 403 le confirma que existe. Por eso muchos sistemas responden 404, «no existe», tanto si no existe como si no es suya: no filtran ni siquiera la existencia. En el código de arriba la bici de Beto es pública, así que 403 no revela nada. Lo que no cambia: la revisión se hace siempre, y en el servidor.

08

Máquinas en la nube, OIDC y auditoría

Extra

Machines in the cloud, OIDC and audit

Hasta aquí, los programas se identificaban ante el clasificador. Pero los pods de Alba (cada pod es una copia de un programa corriendo en Kubernetes) también le hablan a AWS: Fluent Bit (el programa que junta logs) escribe en S3, Triton lee los pesos del modelo. ¿Con qué se identifican?

Sin llaves guardadas

Lo peor sería una llave de AWS de larga vida dentro de la imagen del contenedor (el paquete con el programa y todo lo que necesita para correr) o en una variable de entorno: es una llave de API con poder sobre la nube, y se filtra igual que cualquier otra. La salida, que «Servicios gestionados, serverless y permisos» cuenta a fondo, es la identidad del workload (workload es el programa que corre). Cada pod corre con su cuenta de servicio de Kubernetes, y esa cuenta se liga a un rol de IAM. El pod recibe credenciales temporales que caducan solas, sin que nadie guarde una llave.

En Alba, cada rol tiene solo lo que su pod necesita. En S3, los archivos (objetos) viven en un bucket, y un prefijo es el principio de su nombre, como una carpeta: logs/. Fluent Bit solo escribe en el prefijo de logs; el job de etiquetado (la tarea que manda fotos a que personas les pongan la categoría correcta) solo lee el prefijo de fotos a etiquetar; Triton solo lee el prefijo del modelo. La política de Fluent Bit se ve más o menos así (ilustración; el nombre del bucket es inventado):

JSON
{ "Version": "2012-10-17",
  "Statement": [{ "Effect": "Allow",
                  "Action": "s3:PutObject",
                  "Resource": "arn:aws:s3:::alba-ml-datos/logs/*" }] }

Action dice qué puede hacer (s3:PutObject, escribir un objeto) y Resource, sobre qué: un ARN, el nombre único de un recurso en AWS, aquí todo lo que empieza con logs/ en ese bucket. Puede escribir objetos, y solo bajo logs/. No puede leer, ni borrar, ni tocar las fotos. Si alguien toma el pod de Fluent Bit, lo más que logra es escribir logs. Y como el bucket va cifrado con SSE-KMS, el rol también aparece en la política de la llave, con permiso para pedir llaves de datos y no para descifrar (lo ves en «Cifrado, llaves y certificados»). Ojo: escribir incluye sobrescribir un objeto que ya existe con el mismo nombre. Si eso importa, se activa el versionado del bucket, que guarda la versión anterior.

OIDC: identidad encima de OAuth

OAuth da permisos; no dice quién es la persona. OIDC (OpenID Connect) es una capa encima de OAuth que agrega eso: además del token de acceso, el proveedor entrega un ID token, un JWT con quién es el usuario (sub, su correo, su nombre), para la app que lo pidió. Es lo que pasa detrás de un botón de «Iniciar sesión con Google»: la app nunca ve tu contraseña, solo un token firmado por Google que dice quién eres.

OIDC también sirve para máquinas, y eso explica dos cosas que ya usas:

  • La identidad de los pods en EKS (el Kubernetes gestionado de AWS). Con IRSA (IAM Roles for Service Accounts, roles de IAM para cuentas de servicio), el clúster actúa como un proveedor OIDC: firma un JWT que dice «soy el pod con la cuenta de servicio classifier/triton», y AWS lo cambia por credenciales temporales del rol ligado.
  • Los tokens del pipeline de CI (el proceso que prueba y publica el código en cada cambio). Un job de GitHub Actions puede pedir un JWT firmado por GitHub que dice de qué repositorio y rama viene, y cambiarlo por credenciales de AWS. Así el pipeline publica una imagen sin una llave de AWS guardada en sus secretos.

En los dos casos el truco es el mismo de esta lección: un emisor de confianza firma un token corto, y el otro lado lo verifica con su llave pública.

El registro de auditoría

Autenticar y autorizar decide qué pasa. Falta poder contestar, después, qué pasó: quién hizo qué, cuándo y desde dónde. Eso es el registro de auditoría (audit log): una lista de eventos que solo crece, con la identidad verificada de cada uno.

En AWS lo lleva CloudTrail, un servicio que guarda las llamadas a la API de AWS (las que administran recursos, los eventos de administración, siempre; las que leen o escriben cada objeto de S3, los eventos de datos, solo si se activan), con qué rol, desde qué IP y si se permitió. Los eventos de administración se ven 90 días sin configurar nada; para guardarlos más tiempo se crea un trail, que los escribe en S3. Si un día alguien borra un bucket, el registro dice qué identidad fue; si borra objetos sueltos, solo queda escrito si se activaron los eventos de datos.

En Alba, el log de las acciones de soporte diría: «Marta, rol soporte, leyó la publicación 8812 a las 10:42». Para que sirva, se guarda donde ni quien lo genera lo pueda editar ni borrar: por ejemplo, en S3 con Object Lock, una opción que impide borrar o cambiar un objeto durante un plazo. Un registro que el atacante puede borrar no prueba nada.

09

Errores comunes

Esencial

Common mistakes

  1. 1

    «Uso JWT, así que está autenticado»

    Un JWT es un formato, no una garantía. Si nadie revisa la firma, el emisor, la audiencia y exp, cualquiera fabrica uno: los claims son solo JSON en base64. Revisa las cuatro cosas, con el algoritmo que tú esperas, nunca el que dice el token.

  2. 2

    Decidir con lo que el cliente declara

    Un header X-Caller, un campo es_admin en el body o el user_id de la URL los escribe el cliente. La cuota, los permisos y la prioridad salen de la identidad verificada: el client_id del token o la sesión.

  3. 3

    Revisar la sesión y olvidar al dueño

    Es el IDOR: comprobar que hay alguien con sesión, pero no que el objeto es suyo. Cada request que trae un id revisa, en el servidor, que ese objeto le toca a esa identidad.

  4. 4

    Guardar contraseñas con un hash rápido o sin sal

    SHA-256 de la contraseña es casi tan malo como guardarla. Usa una función hecha para contraseñas (Argon2id, scrypt, bcrypt o PBKDF2 con muchas repeticiones), con sal por cuenta. Nunca inventes la tuya.

  5. 5

    Tokens que duran días, o llaves que duran años

    Un token largo no se puede cancelar a tiempo, y una llave de API filtrada sirve hasta que alguien la cambie. Tokens de minutos, renovados desde un caché, y credenciales temporales para las máquinas.

  6. 6

    Un rol para todo

    Un solo rol con s3:* sobre * (todas las acciones de S3 sobre todos los recursos), compartido por todos los pods «para que funcione», convierte cualquier pod tomado en dueño de todos los datos. Un rol por componente, con el prefijo exacto que necesita.

  7. 7

    Tokens y secretos en los logs

    Loguear los headers completos de una request guarda el Authorization: Bearer … de cada caller, y quien lea los logs puede usarlos. Quita esos headers antes de escribir.

10

En la vida real

Extra

In real life

En Alba. Ana entra con correo y contraseña, que Alba guarda con hash lento y sal, más un segundo factor opcional. Los 3 callers internos piden un JWT de 15 minutos con client credentials y scope classify, y lo renuevan desde su caché. El ALB verifica firma, emisor, audiencia y fecha; el gateway decide permiso, cuota y prioridad con el client_id verificado. Ningún pod guarda llaves de AWS: cada uno tiene su rol mínimo.

Un LLM propio que sirven a varios equipos de una empresa (un modelo de lenguaje, como los que están detrás de un chat). Cada equipo tiene su llave o su client_id, y la cuota se cuenta por esa identidad verificada, aunque en tokens del modelo por minuto y no en requests (aquí «token» es un pedazo de texto que el modelo lee o escribe, no un token de acceso). Un equipo que se pasa recibe 429 solo él.

Un asistente con RAG para los empleados. RAG quiere decir que, antes de responder, el sistema busca los documentos que vienen al caso y se los pasa al LLM. Alba tiene uno: sus ≈ 8,000 empleados le preguntan y responde con los documentos de la empresa. Si un documento es solo de finanzas, la búsqueda tiene que filtrar por los permisos de quien pregunta antes de pasarle los pedazos al LLM. Filtrar después, en la respuesta, ya es tarde: el modelo leyó lo que no debía y puede repetirlo.

Un agente que hace acciones. Un agente es un programa en el que el LLM decide qué hacer y lo hace llamando a otras APIs. Alba tiene uno de soporte que, entre otras cosas, hace reembolsos; los de más de US$50 los aprueba una persona. El id del cliente sale del token de la sesión, nunca de lo que escribe el LLM: si el modelo dice «reembolsa al cliente 5521», el sistema revisa que 5521 sea quien está hablando. Los permisos se revisan en código, entre el modelo y las APIs.

Fuera de ML. Tu banco te pide la contraseña y un código del teléfono (dos factores), te cierra la sesión a los pocos minutos sin uso (vida corta) y te deja ver solo tus cuentas aunque cambies el número en la URL (revisión del dueño). Las mismas ideas, con más en juego.

11

Ejercicios

Esencial

Exercises

Resuélvelos con lápiz antes de abrir la solución; los números se pueden comprobar con las calculadoras.

  1. 1Fácil

    Para cada caso, di si es un problema de autenticación o de autorización, y qué código responde el servidor: (a) un caller manda un JWT que caducó hace 2 minutos; (b) Ana, con sesión, pide borrar la publicación de Beto; (c) búsqueda, con un token válido de scope classify, llama a una ruta de administración; (d) una request sin header Authorization.

    Ver la solución paso a paso
    • (a) Autenticación: el token ya no prueba nada. 401; el caller pide otro.
    • (b) Autorización: se sabe que es Ana, pero no es su publicación. 403 (o 404, si no se quiere revelar que existe).
    • (c) Autorización: es búsqueda, verificado, pero su scope no incluye administración. 403.
    • (d) Autenticación: no hay credencial. 401.
  2. 2Fácil

    Un sitio guarda el SHA-256 de cada contraseña, sin sal. ¿Qué dos cosas puede hacer quien roba la base, que no podría si el sitio usara un hash lento con sal?

    Ver la solución paso a paso
    • Adivinar rápido: con un hash rápido, una GPU prueba ≈ 2 × 10¹⁰ contraseñas por segundo; con uno lento, del orden de 10⁴.
    • Atacar a todos de una vez: sin sal, dos personas con la misma contraseña tienen el mismo hash, y una tabla de hashes precalculados de contraseñas comunes sirve para cualquier base. Con sal, cada cuenta es un problema aparte.
  3. 3Fácil

    Decodificas los claims de un token y ves "aud": "busqueda", "exp": 1700000900. El clasificador lo recibe en el instante 1700000500. ¿Lo acepta?

    Ver la solución paso a paso
    • No. La firma puede estar bien y exp estar en el futuro (faltan 400 s), pero aud dice que el token es para búsqueda, no para classifier. El clasificador responde 401: ese token no prueba que el portador pueda hablar con él.
  4. 4Medio

    Con la fórmula C=am, t=C÷v: una contraseña de 10 caracteres con minúsculas, mayúsculas y dígitos (a = 62), contra un hash lento (v = 10⁴ intentos por segundo). ¿Cuánto tarda en el peor caso, y en promedio? ¿Y si es de 8?

    Ver la solución paso a paso
    • C=am = 62¹⁰ ≈ 8.39 × 10¹⁷ contraseñas.
    • t=C÷v = 8.39 × 10¹⁷ ÷ 10⁴ ≈ 8.39 × 10¹³ s. Un año son ≈ 3.16 × 10⁷ s, así que 8.39 × 10¹³ ÷ 3.16 × 10⁷ ≈ 2.7 millones de años en el peor caso; en promedio, la mitad, ≈ 1.3 millones.
    • Con m = 8: C = 62⁸ ≈ 2.18 × 10¹⁴, t = 2.18 × 10¹⁴ ÷ 10⁴ ≈ 2.18 × 10¹⁰ s ≈ 692 años (346 en promedio).
    • Los dos caracteres extra multiplican por 62² = 3,844. Pero solo si la contraseña es al azar; una palabra con un año cae con una lista en segundos.
  5. 5Medio

    Los 3 callers de Alba renuevan su token de 15 minutos cada 12. Moderación decide subir a 40 instancias, cada una con su token, y los otros dos siguen con 4 cada uno. ¿Cuántos tokens pide al día cada uno y en total? ¿Es una carga para el proveedor de identidad?

    Ver la solución paso a paso
    • n=I×1,440÷R, con R = 12, así que cada instancia pide 1,440 ÷ 12 = 120 al día.
    • Moderación: 40 × 120 = 4,800. Cada uno de los otros dos: 4 × 120 = 480.
    • Total: I = 48, 48 × 120 = 5,760 al día, 5,760 ÷ 86,400 ≈ 0.067 por segundo. No es carga: es menos de un pedido cada diez segundos. La carga de verdad sería no cachear: un token por cada una de las ≈ 10 M requests al día.
  6. 6Medio

    Supón que las publicaciones de Alba (≈ 100 millones activas) usaran ids seguidos. Un atacante con una cuenta normal pide GET /publicaciones/{id}/borrador (el borrador es la versión que su dueño todavía no publica) con ids del 1 al 1,000,000, a 1,000 por segundo. ¿Cuánto tarda? ¿Qué gana si el servidor solo revisa la sesión? ¿Qué cambia si los ids fueran de 64 bits al azar?

    Ver la solución paso a paso
    • Tiempo = intentos ÷ v = 1,000,000 ÷ 1,000 por s = 1,000 s, ≈ 17 minutos.
    • Si solo se revisa la sesión, es un IDOR: se lleva los borradores de todos los que caigan en ese rango (con ids seguidos, casi todos existen).
    • Con ids al azar, la probabilidad de que un intento atine a un id que existe es p=E÷K: los ids que existen (E = 10⁸) entre los posibles (K = 2⁶⁴ ≈ 1.84 × 10¹⁹). p = 10⁸ ÷ 1.84 × 10¹⁹ ≈ 5.4 × 10⁻¹², así que en un millón de intentos espera 10⁶ × 5.4 × 10⁻¹² ≈ 5.4 × 10⁻⁶ aciertos: ninguno.
    • Lo que de verdad lo arregla: revisar que el borrador sea de quien lo pide; así, aun con ids seguidos, solo ve los suyos. Y una cuota por usuario hace que 1,000 por segundo ni siquiera sea posible.
  7. 7Medio

    Moderación manda sus requests con su token válido (scope classify) y, además, el header X-Caller: backend-publicaciones. (a) ¿Con qué cuota la cuenta el gateway? (b) Si el gateway usara ese header, ¿qué les pasaría a las fotos que publica Ana? (c) ¿Qué recibe moderación si pasa de sus 50 requests por segundo?

    Ver la solución paso a paso
    • (a) Con la de moderación: el gateway lee el client_id del token que el ALB verificó y no hace caso del header, que lo escribe el caller.
    • (b) Las tandas de moderación gastarían la cuota del backend de publicaciones y pasarían con su prioridad, delante de las fotos que una persona está publicando: Ana esperaría más, o su backend recibiría 429 por culpa de otro.
    • (c) 429, solo ella: los otros dos callers ni se enteran. Un 401 sería si su token no valiera; un 403, si su scope no alcanzara.
  8. 8Reto

    Alba tiene un asistente para sus ≈ 8,000 empleados que responde con los documentos de la empresa; algunos documentos solo los puede ver un área, como finanzas. Diseña su revocación. Supuesto del ejercicio: cuando alguien sale de la empresa, su acceso tiene que morir en 5 minutos o menos, y sus sesiones usan JWT. ¿Qué vida le das al token? ¿Qué agregas si 5 minutos es demasiado poco para renovar? ¿Qué pasa con los permisos sobre documentos?

    Ver la solución paso a paso
    • La ventana de un token robado o de una persona que ya salió es la vida del token, D. Si D ≤ 5 min, el token muere solo a tiempo: por ejemplo D = 5 y R = 4 (se renueva un minuto antes).
    • Carga, con n=I×1,440÷R: si las 8,000 personas estuvieran conectadas a la vez, cada una con su token, I = 8,000 y n = 8,000 × 1,440 ÷ 4 = 2.88 M al día; entre 86,400 s, ≈ 33 por segundo. Se puede, pero es carga real.
    • Alternativa: D = 15 min y una lista de revocados chiquita (por sub o jti) que el asistente consulta: solo trae a quienes salieron en los últimos 15 minutos, y se vacía sola.
    • Los permisos sobre documentos no pueden vivir solo en el token: si a alguien le quitan acceso a finanzas, la búsqueda tiene que filtrar con los permisos de ahora, antes de pasarle nada al LLM.
  9. 9Reto

    Un equipo propone: «El ALB ya verifica el JWT, así que el gateway solo decodifica los claims del token que le llega y saca de ahí el client_id, sin volver a revisar la firma». ¿Qué tiene que ser cierto para que eso sea seguro? Da dos maneras en que se rompe y cómo lo evitas.

    Ver la solución paso a paso
    • Tiene que ser cierto que toda request que llega al gateway pasó antes por la verificación del ALB: que nadie más puede llegarle, y que ninguna ruta del ALB se salta la verificación.
    • Se rompe si (1) otro pod del clúster puede llamar al gateway directo: le manda un JWT armado a mano, con sub: backend-publicaciones y una firma cualquiera, y como el gateway no revisa la firma, elige su cuota. Se evita con reglas de red que solo dejan entrar al ALB, o haciendo que el gateway vuelva a verificar la firma del JWT (es barato: no llama a nadie).
    • Se rompe si (2) alguien agrega al ALB una regla nueva (otra ruta, por ejemplo) y se le olvida ponerle la verificación del JWT: las requests de esa ruta llegan al gateway sin verificar. Se evita con la verificación en todas las reglas que llevan al gateway, y probándolo con una request que traiga un token falso: tiene que recibir 401.
12

Lo que sigue

Esencial

What comes next

  • «Datos personales y la ley» usa el registro de auditoría y la seudonimización (cambiar el id de una persona por otro que no la nombra): qué guarda el log de Alba sin el id de la vendedora en claro, y qué pasa cuando Ana pide borrar sus datos.
  • «Ataques y cadena de suministro» parte de aquí: autenticar y limitar a quien consulta es lo que frena la extracción del modelo (copiarlo a base de hacerle millones de preguntas), y la firma de imágenes usa la misma idea de un emisor de confianza que firma.
  • «Kubernetes» y «CI/CD y registro de imágenes» ponen esto en práctica: cuentas de servicio con IRSA, permisos por rol dentro del clúster, reglas de red que solo dejan al gateway hablarle a Triton, y el token OIDC con el que el pipeline publica sin llaves guardadas.
13

Palabras que vas a oír

Esencial

Words you will hear

Estos son los conceptos que presentó esta lección. Cada uno tiene su tarjeta con la definición completa.

Autenticaciónauthentication (AuthN)Comprobar quién es quien hace una request (una petición): una persona con su contraseña y un segundo factor, o un programa con un secreto o un token firmado. Si falla, el servidor responde 401 (el código de «no autenticado»).Más

Responde «¿quién eres?» y nada más: no dice qué puede hacer esa identidad, eso es la autorización. Se basa en algo que solo el dueño puede mostrar: algo que sabe (una contraseña), algo que tiene (un teléfono, una llave física) o algo que es (una huella). Entre programas, en algo que le entregó un emisor de confianza: una llave de API o un token de acceso como un JWT. El código 401 se llama Unauthorized, pero significa «no autenticado».

Analogía. El guardia de la entrada de un concierto, que revisa tu identificación. Se rompe en que una identificación no se copia con Ctrl+C, y un token sí: por eso los tokens caducan pronto.

Ejemplo. Un programa que llama al clasificador de Alba (un caller) manda un JWT que caducó hace 2 minutos: la autenticación falla y recibe 401. Pide un token nuevo al proveedor de identidad y repite.

Ver en el glosario →

Autorizaciónauthorization (AuthZ)Decidir qué puede hacer una identidad que ya se comprobó: qué rutas, qué acciones, qué objetos. Si no le toca, el servidor responde 403, «prohibido» (o 404, «no existe», para no revelar que existe).Más

Responde «¿qué puedes hacer?». Va después de la autenticación y se revisa en el servidor, en cada request, contra la identidad verificada. Tiene dos niveles: el grueso, «¿puede este tipo de identidad hacer esta acción?» (un scope del token, un rol de RBAC), y el fino, «¿este objeto en particular es suyo?». Olvidar el fino es el IDOR. Esconder un botón en la pantalla no es autorizar: la request se puede escribir a mano.

Analogía. La pulsera de un concierto: «general» no entra al camerino aunque nadie dude de quién eres. Se rompe en que la pulsera la revisa un guardia; en un sistema, cada puerta (cada ruta del servidor) tiene que revisarla sola.

Ejemplo. Ana, con sesión válida, pide editar la publicación 8812, que es de Beto. Está autenticada, pero la revisión del dueño falla: 403.

Ver en el glosario →

Hash de contraseñapassword hashLo que un sistema guarda en vez de la contraseña: una sal (un valor al azar, distinto en cada cuenta) y el resultado de una función de hash lenta a propósito (Argon2id, scrypt, bcrypt o PBKDF2). Al entrar, repite la cuenta y compara.Más

Resuelve dos problemas de guardar un hash normal. Uno: SHA-256 es rápido, y quien roba la base prueba del orden de miles de millones de contraseñas por segundo con una GPU; una función lenta (muchas repeticiones, o mucha memoria) baja eso a miles. Dos: sin sal, la misma contraseña da el mismo hash en todas las cuentas, y una tabla precalculada sirve para cualquier base; con una sal distinta por cuenta, cada una es un problema aparte. La sal no es secreta: se guarda en claro junto al hash. El tiempo para probarlas todas es t=am÷v, con a símbolos posibles por carácter, m caracteres de largo y v intentos por segundo. Nada de esto salva una contraseña común: esas caen con listas de filtraciones, y por eso se pide un segundo factor.

Ejemplo. Ocho minúsculas son 26⁸ ≈ 2.09 × 10¹¹ contraseñas. A ≈ 2 × 10¹⁰ intentos por segundo (hash rápido en una GPU) se prueban en ≈ 10 s; a 10⁴ (hash lento), en ≈ 242 días.

Ver en el glosario →

Autenticación multifactor (MFA)multi-factor authentication (MFA, 2FA)Pedir, además de la contraseña (algo que sabes), una prueba de otro tipo: algo que tienes, como un código del teléfono o una llave física, o algo que eres, como una huella.Más

Existe porque las contraseñas se roban fuera del sistema: con una página falsa (phishing) o porque la persona la repite en otro sitio que se filtró. Las formas más comunes: un código de 6 dígitos que cambia cada 30 segundos en una app (TOTP, time-based one-time password: un HMAC de un secreto compartido con la hora); un código por SMS, el más débil, porque el número se puede pasar a otra SIM; y una llave física o una passkey, que firma un reto con una llave privada ligada al nombre del sitio y por eso no sirve en una página falsa.

Ejemplo. Ana entra a Alba con correo, contraseña y, si lo activó, el código de su app. Aunque alguien tenga tenis2026, sin su teléfono no entra.

Ver en el glosario →

SesiónsessionLo que recuerda un servidor después de que entraste: un número largo al azar que guarda junto con «es Ana» y que el navegador le regresa en cada request (petición), normalmente en una cookie (un dato que el navegador guarda y regresa solo). Vale lo mismo que la contraseña mientras dure.Más

Evita pedir la contraseña en cada clic. El servidor guarda el id de sesión con la identidad y la hora, y lo entrega en una cookie marcada Secure (solo por HTTPS), HttpOnly (el JavaScript de la página no la lee) y SameSite (no viaja, o casi no, en requests que provoca otro sitio). Como el servidor la guarda, se puede cancelar al instante: al salir, se borra. Esa es la diferencia con un JWT que se verifica sin estado, que vale hasta su exp.

Ejemplo. Ana entra una vez; el servidor le da la cookie sid=8f3a… y la reconoce en cada página. Si pierde el teléfono y cierra todas sus sesiones, el servidor borra esos ids y la cookie robada deja de servir.

Ver en el glosario →

Llave de APIAPI keyUn texto largo al azar que un servicio le da a un cliente para que lo mande en cada request (petición) y así reconocerlo. Es simple, pero no caduca, se filtra con facilidad y cambiarla por una nueva (rotarla) obliga a actualizar cada programa que la usa.Más

Es el mecanismo de autenticación más simple entre programas: el servidor genera la llave, la asocia a un cliente y la busca en cada request. Sus problemas: vive meses o años; termina en repositorios, logs o mensajes; no dice nada de quién es ni qué puede hacer sin buscarla. Si se usa, el servidor guarda solo su hash (basta uno rápido, porque es larga y al azar) y el cliente la guarda en un gestor de secretos. La mejora es usarla solo para pedir un token de acceso corto, como en client credentials.

Ejemplo. Un servicio de pago te da ak_live_7Hq2…. Si aparece en un repositorio público, quien la encuentre la usa hasta que la cambies; un token de 15 minutos filtrado, como mucho 15 minutos.

Ver en el glosario →

Token de acceso (Bearer)access token, bearer tokenUn permiso que dura poco y que el cliente manda en cada request (petición), en el encabezado (header) Authorization: Bearer …. «Bearer» (portador) quiere decir que quien lo porta lo usa: el servidor no pregunta quién lo trae.Más

Separa el secreto de larga vida (que se usa una vez, ante el proveedor de identidad) de lo que viaja en cada request. Como cualquiera que lo copie puede usarlo, viaja por HTTPS (al menos por toda red que no sea de confianza), no se escribe en los logs y caduca pronto. Puede ser opaco (un número sin significado, que el servidor busca en su base) o un JWT que se verifica solo. Se obtiene con OAuth, por ejemplo con client credentials.

Ejemplo. El backend de publicaciones de Alba manda Authorization: Bearer eyJhbGciOiJSUzI1NiIs… en cada POST /v1/classify. El token vale 15 minutos y el backend pide otro a los 12.

Ver en el glosario →

JWT (JSON Web Token)JWTUn token con tres partes separadas por puntos, encabezado.claims.firma: dos JSON escritos en base64url (texto que cualquiera puede decodificar y leer) y una firma del emisor que impide cambiarlos. Se verifica sin preguntarle a nadie.Más

Es un formato, no un mecanismo. El encabezado dice el algoritmo (HS256, un HMAC con llave compartida; RS256 o ES256, una firma con llave asimétrica) y el kid de la llave. Los claims dicen quién, para quién y hasta cuándo. Quien verifica revisa la firma con la llave pública del JWKS, el iss, la aud y el exp, con el algoritmo que él espera: nunca el que dice el token (hubo bibliotecas que aceptaban "alg": "none"). Como se verifica sin estado, no se puede cancelar antes de su exp: por eso vive poco (revocación). Los claims no van cifrados: nada secreto adentro.

Ejemplo. El token de moderación dice {"iss": "idp.alba.internal", "sub": "moderacion", "aud": "classifier", "scope": "classify", "exp": …}. Si alguien cambia sub a backend-publicaciones, la firma ya no coincide y el ALB (el balanceador de entrada de Alba) responde 401.

Ver en el glosario →

ClaimsclaimsLo que afirma un token: quién es (sub), quién lo emitió (iss), para quién es (aud), cuándo caduca (exp) y qué permite (scope), entre otros. En un JWT van en un JSON firmado.Más

Los nombres cortos vienen del estándar: iss (issuer), sub (subject), aud (audience), exp (expiration) e iat (issued at), en segundos desde 1970, y jti, un id único del token que sirve para revocarlo. Se pueden agregar otros, como scope. Revisar la aud evita aceptar un token que el emisor dio para otro servicio. Cualquiera que tenga el token los lee, así que no llevan secretos ni datos personales que no hagan falta.

Ejemplo. Un token con "aud": "busqueda" llega al clasificador: la firma es buena y exp está en el futuro, pero no es para él. Lo rechaza con 401.

Ver en el glosario →

JWKS (las llaves públicas del emisor)JSON Web Key SetUn JSON que el emisor de tokens publica en una dirección fija con sus llaves públicas, cada una con su id (kid). Quien verifica un JWT busca ahí la llave que dice el encabezado del token.Más

Permite que muchos servicios verifiquen tokens de un solo proveedor de identidad sin compartir ningún secreto. Quien verifica lo guarda en memoria y lo vuelve a bajar cada tanto, o cuando ve un kid que no conoce; no en cada request. Así se cambian las llaves sin cortar el servicio: el emisor publica la nueva junto a la vieja, firma con la nueva y quita la vieja cuando los tokens viejos ya caducaron.

Ejemplo. El ALB de Alba (su balanceador de entrada) baja el JWKS del proveedor de identidad interno y verifica con la llave kid: 2026-11 cada token de los callers, sin llamar al emisor en cada request.

Ver en el glosario →

Revocación de un tokentoken revocationCancelar un token antes de que caduque. Con una sesión que guarda el servidor es fácil; con un JWT que se verifica sin estado no se puede «des-firmar», así que la salida es que dure poco.Más

Hay dos maneras de revocar un JWT y las dos le quitan su ventaja de verificarse solo: una lista de tokens cancelados (por jti o por sub) que cada servicio consulta, o preguntarle al emisor si el token sigue vivo (la introspección de OAuth). Lo común es una vida corta, de 5 a 60 minutos, aunque se configura (algunos proveedores dan más por omisión), con el cliente renovando desde su caché, y, cuando el riesgo lo pide, una lista chiquita que solo guarda los cancelados que todavía no caducan. La carga sobre el emisor es n=I×1,440÷R tokens al día, con I copias del programa que piden su propio token, cada una renovándolo cada R minutos (1,440 son los minutos de un día).

Ejemplo. Un token de los callers de Alba vale 15 minutos: si alguien lo roba en el minuto 5, le sirve hasta el minuto 15. Una llave de API robada sirve hasta que alguien la cambie.

Ver en el glosario →

Proveedor de identidad (IdP)identity provider (IdP)El servicio que sabe quién es quién y emite los tokens: guarda los clientes y usuarios, revisa sus credenciales y firma los tokens con su llave privada. Los demás servicios confían en lo que firma.Más

Tener un solo emisor deja que muchos servicios acepten los mismos tokens: todos verifican con su JWKS. Implementa OAuth y OIDC. Ejemplos: Okta, Auth0, Microsoft Entra ID, Cognito de AWS o Keycloak, que una empresa instala en sus máquinas. Como todos dependen de él, conviene que los clientes cacheen sus tokens: así una caída breve del emisor no tumba a nadie.

Ejemplo. Los 3 programas que llaman al clasificador de Alba (sus callers) piden su token al proveedor de identidad interno de Alba, con su client_id y scope classify; con caché, le piden ≈ 1,440 tokens al día en total.

Ver en el glosario →

OAuth 2.0OAuth 2.0El marco estándar para que un programa obtenga un token de acceso sin conocer la contraseña de nadie. Define varios flujos para pedirlo, según quién lo pide: una persona en un navegador o un programa solo.Más

Nació para que una app pudiera actuar en tu nombre (publicar en una red social, leer tu calendario) sin que le dieras tu contraseña: el servicio te pregunta si lo permites y le entrega a la app un token con scopes limitados que puedes retirar. Para personas usa un flujo con redirecciones y una pantalla de permiso; para máquinas, client credentials. OAuth da permisos, no dice quién es la persona: eso lo agrega OIDC.

Ejemplo. Una app de fotos pide publicar por ti: la red social te muestra «¿permitir publicar?», y la app recibe un token que solo sirve para publicar. Nunca vio tu contraseña.

Ver en el glosario →

Client credentialsclient credentials grantEl flujo de OAuth para máquinas: un programa se presenta ante el proveedor de identidad con su client_id y su secreto (o un certificado) y recibe un token de acceso, sin ninguna persona de por medio.Más

Es la manera estándar de autenticar llamadas de servicio a servicio. El programa hace un POST al endpoint de tokens con grant_type=client_credentials y el scope que pide; la respuesta trae el access_token, su tipo (Bearer) y expires_in. El secreto vive en un gestor de secretos y se usa solo al renovar, no en cada request: lo que viaja es el token corto.

Ejemplo. El servicio de moderación de Alba pide su token con grant_type=client_credentials&scope=classify y recibe uno con expires_in: 900, 15 minutos. Lo usa en todas sus requests al clasificador y pide otro a los 12.

Ver en el glosario →

ScopescopeLa lista de permisos que lleva un token: qué tipo de cosas puede hacer su portador. Un token con scope classify sirve para pedir clasificaciones y para nada más.Más

Es una autorización gruesa que viaja dentro del token, en los claims: el servicio revisa que el scope incluya la acción que se pide, y si no, responde 403. No sirve para la autorización fina («¿este objeto es tuyo?»), que depende de datos que solo tiene el servidor. Darle a cada cliente solo los scopes que necesita es mínimo privilegio aplicado a los tokens.

Ejemplo. Los programas que llaman al clasificador de Alba (sus callers) tienen classify. Una ruta para cambiar la versión del modelo pediría otro scope, como classifier:admin, que ninguno tiene: un token robado de búsqueda clasifica fotos, pero no cambia el modelo.

Ver en el glosario →

OIDC (OpenID Connect)OpenID ConnectUna capa encima de OAuth que agrega identidad: además del token de acceso, el proveedor entrega un ID token, un JWT que dice quién es el usuario. Es lo que hay detrás de «Iniciar sesión con…».Más

OAuth da permisos; OIDC dice quién eres. La app que pide el inicio de sesión recibe un ID token firmado por el proveedor, con sub, correo y nombre, y lo verifica con su JWKS, sin ver nunca la contraseña. También sirve para máquinas: un cluster de Kubernetes firma un JWT que dice qué cuenta de servicio tiene un pod, y la nube lo cambia por credenciales temporales (así funciona IRSA, IAM roles for service accounts, en EKS, el Kubernetes de AWS); un job de CI recibe un JWT que dice de qué repositorio y rama viene, y lo cambia por credenciales de la nube sin guardar llaves.

Ejemplo. Un pipeline de GitHub Actions (las automatizaciones de GitHub) pide un token OIDC que dice «repositorio de Alba, rama main», y AWS lo cambia por credenciales temporales de un rol que solo puede publicar imágenes.

Ver en el glosario →

RBAC (control de acceso por roles)role-based access controlDar permisos a roles, no a personas o programas sueltos, y asignarle a cada identidad uno o varios roles. Cuando alguien cambia de puesto, se le cambia el rol, no decenas de permisos.Más

Es el patrón más común de autorización: un rol como «vendedora» o «soporte» junta un conjunto de permisos. Las políticas de IAM (los permisos de AWS) y los roles de Kubernetes son variantes del mismo patrón. Responde «¿este tipo de identidad puede hacer esta acción?»; no responde «¿este objeto es suyo?», que se revisa aparte (si no, IDOR). La trampa es el rol que lo puede todo «por mientras», contra el mínimo privilegio.

Ejemplo. En Alba, Ana tiene el rol vendedora (editar sus publicaciones) y Marta el de soporte (leer cualquiera, no editar). Si Marta pasa a otro equipo, se le quita el rol de soporte y pierde todo de una vez.

Ver en el glosario →

IDOR (referencia directa insegura)insecure direct object referenceEl fallo de autorización en que una request (petición) pide un objeto por su id (/publicaciones/8812) y el servidor revisa que haya sesión, pero no que el objeto sea de quien lo pide. Cambiar el número deja ver o cambiar lo de otro.Más

Es de los fallos más comunes en APIs y es difícil de ver en pruebas, porque con un solo usuario de prueba todo funciona. El arreglo va en el servidor, en cada request: además de quién eres y qué rol tienes, revisar que el objeto te toca. Esconder el botón no sirve. Los ids al azar ayudan contra la búsqueda a ciegas (un intento al azar atina con probabilidad p=E÷K: los ids que existen entre los posibles), pero no sustituyen la revisión, porque los ids viajan en enlaces que se comparten. Muchos sistemas responden 404 en vez de 403 para no revelar que el objeto existe.

Ejemplo. Ana edita PATCH /publicaciones/8811, su publicación, y prueba 8812, la bici de Beto. Si el servidor solo revisa la sesión, la edita; si revisa el dueño, responde 403.

Ver en el glosario →

Cuota por clienteper-caller quotaUn presupuesto de requests (o de tokens de un modelo de lenguaje) para cada identidad verificada, normalmente con un token bucket (un balde de fichas que se rellena a ritmo fijo) por cada client_id, el nombre del cliente. Quien se pasa recibe 429 él solo, sin afectar a los demás.Más

La identidad decide la cuota: sale del client_id del token verificado, nunca de un header que el cliente escribe ni de la IP (detrás de una red compartida hay muchos clientes, y uno solo puede usar muchas). Se implementa con un token bucket y responde 429 con Retry-After. Si el balde vive en la memoria de cada pod, cada uno da la parte que le toca (la cuota entre el número de pods), y es aproximado; uno compartido en Redis es exacto pero agrega una pieza que se puede caer. La cuota no reemplaza un tope de requests en vuelo: varios clientes dentro de su cuota pueden, juntos, saturar el servicio, y eso es un 503 (servicio no disponible).

Ejemplo. El servicio de moderación tiene 50 requests por segundo con ráfagas de 100 en el clasificador de Alba. Con el gateway en 5 pods y el balde en memoria, cada pod le da 10 por segundo y ráfagas de 20.

Ver en el glosario →

Registro de auditoríaaudit logUna lista de eventos que solo crece y que dice quién hizo qué, cuándo y desde dónde, con la identidad verificada de cada uno. Sirve para investigar después; se guarda donde nadie lo pueda editar ni borrar.Más

Autenticar y autorizar deciden qué pasa; el registro de auditoría permite contestar qué pasó. En AWS lo lleva CloudTrail, con las llamadas a la API (las de administración, siempre; las que leen o escriben archivos en S3 (el almacén de archivos de AWS), si se activan): qué rol, desde qué IP, si se permitió. Para que pruebe algo, se escribe en un lugar que ni quien lo genera pueda cambiar (por ejemplo, S3 con Object Lock, que impide cambiar o borrar un archivo durante un plazo). No es lo mismo que el log de predicciones de un modelo, que sirve para medir y reentrenar.

Ejemplo. «Marta, rol soporte, leyó la publicación 8812 a las 10:42»: si Beto pregunta quién vio su publicación, la respuesta está ahí.

Ver en el glosario →

14

Chequeo

Esencial

Check

Intenta responder en tu cabeza antes de abrir cada respuesta.

  1. 1¿Qué diferencia hay entre autenticar y autorizar, y qué código responde cada falla?Ver respuesta

    Autenticar es comprobar quién eres; si falla, 401. Autorizar es decidir qué puede hacer una identidad ya comprobada; si falla, 403.

  2. 2¿Por qué una contraseña se guarda con un hash lento y con sal, y no con SHA-256?Ver respuesta

    El hash lento hace que cada intento de adivinar tarde: con ocho minúsculas, de ≈ 10 segundos a ≈ 242 días. La sal hace que cada cuenta sea un problema aparte, así que una tabla precalculada no sirve.

  3. 3Si cualquiera puede leer los claims de un JWT, ¿qué impide cambiarlos?Ver respuesta

    La firma: cubre el encabezado y los claims, y sin la llave del emisor no se puede rehacer. Quien verifica revisa firma, emisor, audiencia y exp, con el algoritmo que él espera.

  4. 4¿Por qué los tokens duran 15 minutos y no un mes?Ver respuesta

    Porque un JWT no se puede «des-firmar»: vale hasta su exp. Una vida corta limita el daño de uno robado, y como el caller lo renueva desde su caché, el emisor apenas recibe ≈ 1,440 pedidos al día (12 instancias que renuevan cada 12 minutos).

  5. 5¿De dónde saca el gateway de Alba la identidad para decidir la cuota?Ver respuesta

    Del client_id del JWT que verificó el ALB, nunca de un header que escribe el caller ni de la IP.

  6. 6¿Qué es un IDOR y dónde se arregla?Ver respuesta

    Pedir un objeto por su id sin que el servidor revise si es tuyo. Se arregla en el servidor, en cada request, revisando el dueño; los ids al azar solo frenan la búsqueda a ciegas.

Repasar los 20 conceptos de esta lección con tarjetas Sigue · 45Datos personales y la leySeguridad ← 43 · Cifrado, llaves y certificados