8. Autenticación y autorización
Para cada solicitud se plantean dos preguntas distintas:
- ¿Quién es el usuario? Esto es la autenticación: el usuario se ha identificado con un nombre de usuario y una contraseña, y cada solicitud posterior debe demostrar que proviene de él;
- ¿Tiene permiso para acceder a esta página? Esto es la autorización: en el caso de estudio, solo un usuario con el rol ADMIN administra los médicos y los clientes.
Dado que el servidor no tiene estado (véase el capítulo sobre los ámbitos), la prueba de identidad debe incluirse en cada solicitud. Se usa un token llamado JWT (*JSON Web Token*): después del inicio de sesión, el servidor genera un token que contiene la identidad del usuario y lo firma con una clave secreta. El token se almacena en una cookie; el navegador lo reenvía con cada solicitud; el servidor verifica la firma. El usuario puede leer su token, pero no puede modificarlo: cualquier modificación invalida la firma. Es el mismo principio que el de la sesión de [Flask] (ejemplo 20), pero con un formato estandarizado (RFC 7519) que entienden todos los lenguajes de programación y con una fecha de expiración incorporada en el token.
[Flask] no tiene un mecanismo de seguridad integrado, a diferencia de [Spring] ([Spring Security]) o de [ASP.NET Core]. Existen extensiones ([Flask-Login], [Flask-JWT-Extended]...), pero el mecanismo es lo bastante simple como para escribirlo a mano con las herramientas de los capítulos anteriores, lo que tiene la ventaja de hacerlo transparente:
- la autenticación está a cargo de una función [before_request] (capítulo anterior), que recupera el token de la cookie, lo verifica y almacena el usuario autenticado en [g], el objeto de la solicitud;
- la autorización está a cargo de decoradores aplicados a las acciones ([@login_required], [@role_required("ADMIN")]), construidos como el decorador [@with_language] del ejemplo 12.
Se usan dos bibliotecas, instaladas con el archivo [requirements.txt] de los ejemplos: [PyJWT], que genera y verifica tokens, y [bcrypt], que calcula el hash de las contraseñas.
8.1. Ejemplo 25: inicio de sesión, token, página protegida
8.1.1. Configuración: config.py y app.py
El token se firma con una clave secreta, que no debe estar escrita directamente en el código. Es hora de separar la configuración del código:
Un archivo de configuración de [Flask] es simplemente un módulo [Python]: sus variables en mayúsculas pasan a ser claves de [app.config]. [JWT_SECRET] es la clave de firma del token; el estándar exige, para el algoritmo utilizado (HMAC-SHA256), una clave de al menos 256 bits, es decir, 32 bytes. [JWT_DURATION_MINUTES] es la vida útil de un token.
- línea 21: lectura del archivo de configuración, indicado mediante una ruta relativa a la carpeta de la aplicación;
- línea 22: lectura de las variables de entorno cuyos nombres comienzan con [FLASK_]: [FLASK_JWT_SECRET] reemplaza la clave [JWT_SECRET] del archivo. El valor de una variable se interpreta como JSON siempre que sea posible ([FLASK_JWT_DURATION_MINUTES=30] produce el entero 30). En producción, la clave secreta la proporciona el entorno, y el archivo contiene solo un valor de desarrollo;
- líneas 24–26: los dos servicios de autenticación, el segundo de los cuales recibe la clave y la vida útil del token;
- línea 32: el registro de la función [before_request] que lee el token.
En [Linux] o [macOS], la aplicación se iniciaría con una clave distinta de la siguiente manera:
y en [Windows] (PowerShell):
8.1.2. Usuarios: auth/users.py
- líneas 9–13: un usuario: su nombre de usuario, nombre, rol y el hash de su contraseña. Un servidor nunca almacena una contraseña, ni siquiera cifrada: si se robara la base de datos, también se robarían las contraseñas (y mucha gente usa la misma contraseña en todas partes). Almacena el resultado de una función hash, una función unidireccional: se puede calcular el hash de una contraseña, pero no se puede recuperar una contraseña a partir de su hash. Para verificar una contraseña ingresada, se calcula su hash y se compara con el que está almacenado;
- líneas 18–19: cálculo del hash con el algoritmo [bcrypt], diseñado para contraseñas. Tiene dos características distintivas. Es intencionalmente lento, con una lentitud ajustable (el parámetro [rounds], o costo: 2^10 ciclos de cálculo): unas decenas de milisegundos, imperceptibles para un usuario, pero que hacen muy costoso para un atacante probar miles de millones de contraseñas. Usa un salt: [gensalt] genera aleatoriamente un salt, lo mezcla con la contraseña antes de calcular el hash y lo almacena dentro del propio hash; así, dos usuarios con la misma contraseña tendrán hashes diferentes. [bcrypt] opera con bytes: [encode()] convierte la cadena en bytes ([UTF-8]). Solo considera los primeros 72 bytes de una contraseña, y la versión 5 de la biblioteca rechaza las contraseñas más largas (el caso de estudio lo tiene en cuenta);
- líneas 26–28: dos usuarios de prueba, almacenados en memoria y organizados en un diccionario construido por comprensión ([{key: value for ...}]). El ejemplo 28 y el caso de estudio los almacenarán en una base de datos.
8.1.3. El servicio de autenticación: auth/service.py
- líneas 24–31: verificación de un nombre de usuario y una contraseña. [bcrypt.checkpw] calcula el hash de la contraseña ingresada con el salt del hash almacenado y compara ambos hashes. Un nombre de usuario desconocido y una contraseña incorrecta dan el mismo resultado, [None];
- líneas 34–44: generación del token. Su contenido es un diccionario de afirmaciones (claims) sobre el usuario. Algunas tienen nombres estandarizados: [sub] (*subject*), el identificador del usuario; [iat] (*issued at*), la fecha de creación; [exp] (*expiration*), la fecha de expiración. Las demás son arbitrarias: en este caso, el nombre y el rol. [jwt.encode] genera el token y lo firma con el algoritmo [HS256] (HMAC-SHA256, una firma con una clave secreta compartida). Las fechas deben ser fechas con zona horaria: [datetime.now(timezone.utc)];
- líneas 48–30: verificación del token. [jwt.decode] verifica la firma y la fecha de expiración, y luego devuelve las afirmaciones. Cualquier anomalía (token falsificado, expirado o mal formado) lanza una excepción de la familia [InvalidTokenError]. El parámetro [algorithms] especifica los algoritmos aceptados: sin él, un atacante podría crear un token que declare un algoritmo distinto (o incluso ninguno, [none]).
8.1.4. Seguridad: auth/security.py
- líneas 13–15: antes de cada acción, se verifica el token de la cookie; [g.user] contiene las afirmaciones de un token válido, o [None]. Esta función no rechaza nada: establece quién es el usuario. Esto es la autenticación;
- líneas 20–31: el decorador que exige un usuario autenticado. Para un visitante anónimo, no devuelve la acción, sino que redirige a la página de inicio de sesión. Si el navegador envió una cookie, significa que el token no es válido (expirado o falsificado): aprovechamos para eliminarla ([delete_cookie] envía una cookie vacía que ya expiró).
8.1.5. Los controladores
- líneas 20–26: el inicio de sesión. Si falla, el formulario se vuelve a mostrar con el nombre de usuario ingresado y un mensaje deliberadamente vago: decir “nombre de usuario desconocido” le revelaría a un atacante qué nombres de usuario existen;
- líneas 27–32: si tiene éxito, el token se almacena en una cookie, con una redirección a la página protegida (esquema PRG). La cookie es [httponly]: el [JavaScript] de la página no puede leerla, lo que protege el token contra la inyección de scripts (XSS); es [samesite="Lax"]: el navegador no la envía con una solicitud POST originada en otro sitio, lo que protege la aplicación contra los ataques CSRF (ejemplo 18); su duración ([max_age], que acepta un [timedelta]) es la del token. En producción, con HTTPS, agregaríamos [secure=True]: la cookie nunca se enviaría por una conexión no cifrada;
- líneas 38–41: cerrar sesión elimina la cookie. Es una acción POST: un simple enlace a [/logout], colocado en otro sitio o dentro de una imagen, no puede cerrar la sesión del usuario sin que este lo sepa. Cabe señalar una limitación de los tokens: el token en sí sigue siendo válido hasta que expira. Alguien que haya hecho una copia podría seguir usándolo. Por eso su vida útil es limitada.
- línea 10: la página está protegida;
- línea 13: la acción usa [g.user], con la garantía de que no es [None].
8.1.6. Las vistas
- línea 8: el nombre de usuario ingresado se vuelve a mostrar después de un fallo; la expresión [login or ''] se evalúa como una cadena vacía si [login] es [None] (o está ausente).
- líneas 9–11: el contenido del token, mostrado con fines ilustrativos;
- líneas 14–16: cierre de sesión, mediante un formulario reducido a un solo botón.
8.1.7. Ejecución
Solicitemos la página protegida [/profile] sin haber iniciado sesión:
Una contraseña incorrecta:

Inicio de sesión exitoso. Con [curl], guardamos en un archivo la cookie recibida:
El token consta de tres partes, separadas por puntos y codificadas cada una en Base64: el encabezado, el contenido y la firma. Las dos primeras partes pueden decodificarse sin ninguna clave:
Las fechas se expresan en segundos transcurridos desde el 1 de enero de 1970; la hora de expiración es una hora después de la creación. En el navegador, la página de perfil muestra este mismo contenido:

Un usuario malicioso modifica su token: reemplaza en el contenido el rol ***[USER]*** por ***[ADMIN]***, vuelve a codificar esta parte en Base64 y conserva la firma original. El servidor recalcula la firma del contenido modificado, que ya no coincide:
El token falsificado se rechaza y se elimina. Para generar una firma válida, habría que conocer la clave secreta; de ahí la importancia de mantenerla en secreto y de elegir una clave larga y aleatoria.
8.2. Ejemplo 26: roles
El ejemplo 26 agrega una página de administración, restringida al rol ADMIN. Solo se muestran los archivos nuevos o modificados.
8.2.1. Un decorador con un parámetro: auth/security.py
- líneas 37–47: [@role_required("ADMIN")] tiene un parámetro. La expresión que sigue a [@] se evalúa primero: [role_required("ADMIN")] devuelve una función, [decorator], que es el decorador propiamente dicho, aplicado a la acción. Tenemos, por lo tanto, tres funciones anidadas: [role_required] recibe el rol, [decorator] recibe la acción y [protected_action] recibe los parámetros de la solicitud y realiza el trabajo. Cada una tiene acceso a las variables de las funciones que la contienen ([role], [action]);
- línea 42: un usuario autenticado que no tiene el rol solicitado recibe un error 403 (*Forbidden*). Esto es muy distinto de lo que sucede con un usuario anónimo, que es redirigido a la página de inicio de sesión: iniciar sesión no serviría de nada, ya que el usuario ya está autenticado.
8.2.2. El controlador: controllers/admin.py
- líneas 12–14: los decoradores se aplican de abajo hacia arriba: [role_required] envuelve la acción y luego [login_required] envuelve toda la estructura. En tiempo de ejecución, el orden se invierte: la envoltura exterior, [login_required], se ejecuta primero. Así, cuando se ejecuta [role_required] , el usuario está necesariamente autenticado y [g.user] no es [None].
8.2.3. La página de error: app.py
- líneas 37–39: un manejador de errores registrado para un código específico (el error 403) muestra nuestra página.
8.2.4. Ejecución
Marie, con el rol USER, sigue el enlace a la página de administración:

En cambio, el administrador tiene acceso a ella:

Con [curl]: un usuario con el rol USER, seguido de un visitante anónimo:
Proteger las acciones una por una tiene un defecto: un solo descuido deja una página abierta a todos. El caso de estudio invertirá esta lógica: todas las acciones están protegidas de forma predeterminada, y un decorador [@public] designa las pocas excepciones (la página de inicio de sesión, el registro).
8.3. Ejemplo 27: CAPTCHA y límite de intentos
Un formulario de inicio de sesión es un blanco de ataques: un programa puede probar miles de contraseñas por minuto (ataque de fuerza bruta). Dos protecciones se complementan:
- un CAPTCHA (*Completely Automated Public Turing test to tell Computers and Humans Apart*): una imagen que contiene un código distorsionado, fácil de leer para una persona pero difícil para un programa;
- un límite de intentos: después de tres intentos fallidos, la dirección IP del cliente se bloquea durante un minuto.
El ejemplo 27 se basa en el ejemplo 25 (sin la página de administración) y agrega estas dos medidas de seguridad.
8.3.1. La imagen CAPTCHA: auth/captcha_drawing.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 | |
La imagen tiene formato SVG (*Scalable Vector Graphics*): un gráfico vectorial descrito en XML, es decir, en texto, que el servidor genera sin una biblioteca de gráficos y que el navegador muestra directamente en la página.
- línea 11: el módulo [random] de [Python] produce secuencias de números predecibles (cualquiera que conozca unos pocos valores puede adivinar los siguientes): es adecuado para simulaciones, no para seguridad. El módulo [secrets] ofrece un generador criptográfico impredecible;
- líneas 16–48: una “fuente” minimalista: cada carácter es una lista de trazos, y cada trazo es una lista de coordenadas [x, y] en una cuadrícula de 4 × 6. Se excluyen los caracteres que se confunden fácilmente ([0] y [O], [1], [I] y [L]);
- línea 51: ["".join(FONT)] une las claves del diccionario: los caracteres disponibles;
- líneas 57–58: texto aleatorio. [_] es el nombre convencional de una variable sin uso;
- líneas 69–103: el dibujo. Cada carácter se agranda, se rota y se desplaza al azar, y cada uno de sus puntos se desplaza ligeramente; cada trazo se convierte en un elemento [<path>] del SVG ([M]: desplazamiento, [L]: línea). Tres curvas ([C]: curva de Bézier) cruzan la imagen para confundir a los programas de reconocimiento. Los formatos [:.1f] escriben los números con un decimal.
8.3.2. El servicio de CAPTCHA: auth/captcha.py
- líneas 28–33: un nuevo CAPTCHA: texto aleatorio, un identificador aleatorio e imposible de adivinar ([secrets.token_urlsafe]) y la imagen. Para cada identificador, el servidor almacena la respuesta esperada y una fecha de expiración. La página recibe solo el identificador y la imagen: la respuesta nunca sale del servidor;
- líneas 36–42: verificación. [pop] elimina la entrada del diccionario y la devuelve: el CAPTCHA se consume en todos los casos, tenga éxito o no la verificación. Sin esto, un programa podría probar todas las respuestas posibles sobre la misma imagen. La comparación ignora las mayúsculas y los espacios alrededor de lo escrito.
Este servicio conserva datos en memoria en el servidor: es una desviación del principio de servidor sin estado (véase el capítulo sobre los ámbitos), aceptable para datos de corta duración. Con varios servidores, los datos tendrían que almacenarse en un sistema de almacenamiento compartido (una base de datos, [Redis]...). Observe también que los CAPTCHA que nunca se han utilizado no se eliminan: el caso de estudio limpia periódicamente los CAPTCHA vencidos.
8.3.3. Límite de intentos: auth/limiter.py
- líneas 12–15: para cada dirección IP, un número de intentos fallidos y una fecha de fin de bloqueo ([datetime.min], la fecha más antigua posible, significa «no bloqueada»);
- líneas 26–32: el número de segundos que faltan para que termine el bloqueo, redondeado hacia arriba al entero más próximo ([math.ceil]);
- líneas 34–40: un fallo más. [setdefault] obtiene el contador de la dirección, creándolo si no existe. En el tercer fallo, la dirección se bloquea durante un minuto y el contador se reinicia a cero;
- líneas 42–44: una conexión exitosa borra el contador.
8.3.4. El controlador: controllers/auth.py
- línea 25: la dirección del cliente, IP;
- líneas 28–30: una dirección bloqueada ni siquiera es atendida;
- líneas 32–34: el CAPTCHA se verifica antes que la contraseña: verificarlo casi no cuesta nada, mientras que [bcrypt] es lento a propósito. Un programa que introduzca un CAPTCHA incorrecto no provocaría, por tanto, la ejecución de [bcrypt]. Todo fallo, ya sea del CAPTCHA o de la contraseña, se contabiliza;
- línea 39: un inicio de sesión exitoso borra el contador de fallos;
- líneas 54–56: cada vez que se muestra el formulario, se genera un nuevo CAPTCHA, incluso después de un fallo.
8.3.5. La vista: templates/auth/login.html
- línea 17: la imagen SVG se inserta tal cual en la página, mediante el filtro [safe] (ejemplo 14). Es legítimo: este HTML lo generó el servidor y no contiene ninguna entrada del usuario;
- línea 19: el identificador del CAPTCHA, en un campo oculto;
- línea 20: el navegador no sugiere entradas anteriores para este campo.
8.3.6. Ejecución

Un código copiado incorrectamente:

En el tercer intento fallido, la dirección queda bloqueada:

Con [curl], cuatro intentos con un identificador de CAPTCHA inventado:
Incluso con la contraseña correcta, el cuarto intento se rechaza sin verificación.