8. Autenticación y autorización
Con cada solicitud surgen 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.
La prueba de identidad debe acompañar a cada solicitud. [Laravel] normalmente almacena el identificador del usuario conectado en su sesión (véase el capítulo sobre ámbitos), que es la solución más simple para una aplicación web. El caso de estudio, en todas sus versiones ([ASP.NET Core MVC], [Spring MVC], [NestJS], [Flask]), usa en cambio un token (JWT (*JSON Web Token*)), que usaremos aquí: 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. El formato está estandarizado (RFC 7519), es entendido por todos los lenguajes de programación y el token incluye su fecha de expiración. Lo más importante es que el servidor no necesita almacenar nada: cualquier servidor que conozca la clave puede verificar el token.
[Laravel] cuenta con un sistema de autenticación completo, cuyos componentes usaremos tal cual:
- la autenticación está a cargo de un *guard* (guardia): un objeto que, para cada solicitud, identifica al usuario autenticado. [Laravel] proporciona un guard que lee la sesión; nosotros escribiremos el nuestro, que lee el token, en unas pocas líneas. El resto de la aplicación solo ve el guard: [auth()->user()], [#[CurrentUser]] y [@auth] en las vistas;
- la protección de las páginas está a cargo del middleware de ruta (capítulo anterior): [auth] exige un usuario autenticado, [can:admin] exige autorización;
- las autorizaciones se describen mediante Gates (p. ej., ejemplo 26);
- Las contraseñas se procesan con hash mediante la fachada [Hash] (con el algoritmo *bcrypt*), y los límites de intentos se aplican mediante la fachada [RateLimiter] (ejemplo 27).
La generación y la verificación de tokens están a cargo de la biblioteca [firebase/php-jwt], la más utilizada en [PHP], instalada por el archivo [composer.json] de los ejemplos.
8.1. Ejemplo 25: inicio de sesión, token, página protegida
8.1.1. Configuración: .env, config/jwt.php y config/auth.php
El token se firma con una clave secreta, que no debe estar escrita directamente en el código. Es momento de separar realmente la configuración del código. Los ajustes específicos de una instalación se encuentran en el archivo [.env] (ejemplo 01), que ahora incluye dos líneas nuevas:
El estándar exige, para el algoritmo utilizado (HMAC-SHA256), una clave de al menos 256 bits, es decir, 32 bytes; la biblioteca rechaza una clave más corta. Sin embargo, el código no lee el archivo [.env]: lee la configuración de la aplicación, un conjunto de archivos [PHP] almacenados en la carpeta [config], cada uno de los cuales devuelve un arreglo. Creamos el archivo [config/jwt.php]:
- Línea 6: la función [env] lee una variable del entorno del proceso o, en su defecto, del archivo [.env]; su segundo parámetro es un valor predeterminado. Una variable de entorno tiene prioridad sobre el archivo: en producción, la clave secreta la proporciona el entorno y el archivo [.env] no contiene ninguna;
- línea 8: las variables de entorno son cadenas: [(int)] convierte la duración en un entero.
El código lee estos valores mediante la función [config]: [config('jwt.secret')] hace referencia a la clave [secret] del archivo [jwt.php]. [env] solo se llama en los archivos de configuración: en producción, el comando [php artisan config:cache] combina toda la configuración en un único archivo para acelerar el proceso, y [.env] ya no se lee. El archivo [config/auth.php] configura la autenticación:
[Laravel] tiene su propia configuración de autenticación (el archivo [vendor/laravel/framework/config/auth.php]; véase el ejemplo 01); la configuración de la aplicación la complementa: las claves que proporciona reemplazan a las del framework, mientras que las demás conservan sus valores. Declaramos un guard llamado [jwt], con el controlador [jwt] (línea 12), y lo establecemos como el guard predeterminado (línea 7). El controlador [jwt] no existe en [Laravel]: lo definimos en [bootstrap/app.php].
En [Linux] o [macOS], iniciaríamos la aplicación con una clave diferente de la siguiente manera:
y en [Windows] (PowerShell):
8.1.2. Usuarios: app/Auth/User.php y UsersService.php
- Línea 9: un usuario. [Laravel] espera que los usuarios autenticados implementen la interfaz [Authenticatable]: sus métodos le proporcionan el identificador del usuario, su contraseña con hash y el token de sesión «recordarme», que aquí no es necesario. En una aplicación típica, el modelo [Eloquent] de la tabla de usuarios (próximo capítulo) la implementa;
- líneas 12–18: el nombre de usuario, el nombre, el rol, el hash de la contraseña y el contenido del token que autenticó al usuario (vacío para un usuario obtenido de la lista de usuarios). Un servidor nunca almacena una contraseña, aunque esté cifrada: si la base de datos fuera robada, las contraseñas también lo serían (y muchas personas usan 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á registrado.
- Líneas 11–14: dos usuarios de prueba, escritos directamente en el programa (el ejemplo 28 y el caso de estudio los usarán para poblar una base de datos): para cada nombre de usuario, el nombre, el rol y el hash de la contraseña. El hash se genera con el algoritmo bcrypt, diseñado para contraseñas. Tiene dos características distintivas. Es intencionalmente lento, con un nivel de lentitud ajustable (el costo, aquí establecido en 10: 2^10 ciclos de cálculo, lo que da como resultado el hash [$10$]): unas pocas decenas de milisegundos, imperceptibles para un usuario, pero que hacen muy costoso para un atacante probar miles de millones de contraseñas. Está salado: una sal generada aleatoriamente se mezcla con la contraseña antes de aplicar el hash y se almacena dentro del propio hash (los 22 caracteres que siguen a [$10$]); así, dos usuarios con la misma contraseña tendrán hashes diferentes. Los hashes se calcularon una vez por todas con la función [password_hash] de [PHP] (línea 10): calcularlos en cada solicitud sería una pérdida de tiempo innecesaria, ya que la aplicación se reconstruye con cada solicitud. [bcrypt] considera solo los primeros 72 bytes de una contraseña: el caso de estudio lo tiene en cuenta;
- Líneas 16–23: el usuario correspondiente a un nombre de usuario, o [null]. [isset] comprueba la existencia de una clave; la asignación [[$name, $role, $hash] = ...] desestructura un arreglo: cada variable recibe el elemento correspondiente.
8.1.3. El servicio de autenticación: app/Auth/AuthService.php
- líneas 20–30: verificación de un nombre de usuario y una contraseña. [Hash::check] calcula el hash de la contraseña ingresada con la sal del hash almacenado y compara los dos hashes. Un nombre de usuario desconocido y una contraseña incorrecta producen el mismo resultado, [null];
- líneas 33–45: generación del token. Su contenido es un arreglo 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 fechas se expresan en segundos transcurridos desde el 1 de enero de 1970 (la función [time()] de [PHP]). Los demás campos son opcionales: aquí, 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);
- Líneas 49–58: verificación del token. [JWT::decode] verifica la firma y la fecha de expiración, y luego devuelve las afirmaciones (un objeto, convertido en arreglo mediante [(array)]). Cualquier anomalía (token falsificado, expirado o malformado) lanza una excepción; [catch (Throwable)] las captura todas ([Throwable] es la interfaz de todas las excepciones y errores de [PHP]; el nombre de la variable es opcional cuando no se usa). El objeto [Key] asocia la clave con un algoritmo: un token que especifique un algoritmo diferente (o ninguno, [none]) sería rechazado. El token válido se convierte en un [User], sin hash, junto con sus afirmaciones (parámetro llamado [claims]).
8.1.4. El guard: bootstrap/app.php
- línea 20: el token ya está firmado; la cookie que lo transporta no está cifrada (ejemplo 22), lo que permite examinarla;
- línea 22: el middleware [auth] redirigirá a los visitantes anónimos a la página de inicio de sesión;
- líneas 28–39: [Auth::viaRequest] define un controlador de guard mediante una función simple: recibe la solicitud y devuelve el usuario autenticado, o [null] para un visitante anónimo. Se llama solo si la aplicación necesita al usuario y, una vez que ha encontrado uno, [Laravel] lo conserva durante toda la solicitud (para un visitante anónimo, se llama en cada solicitud) (el middleware [auth], [auth()->user()]...). No rechaza nada: determina quién es el usuario. Esto es la autenticación. [app(AuthService::class)] solicita un objeto al contenedor (véase el ejemplo 06): la función [app] da acceso al contenedor en cualquier lugar;
- Líneas 34–39: si el navegador envió una cookie pero su token no es válido (expirado o manipulado), aprovechamos para eliminarla. [Cookie::forget] crea una cookie vacía que ya ha expirado; [Cookie::queue] la pone en cola: el middleware [AddQueuedCookiesToResponse] del grupo [web] la agregará a la respuesta, sea cual sea esa respuesta.
8.1.5. Los controladores
- líneas 30–34: el inicio de sesión. Si falla, se vuelve a mostrar el formulario con el nombre de usuario ingresado y un mensaje deliberadamente vago: decir «nombre de usuario desconocido» revelaría a un atacante qué nombres de usuario existen;
- líneas 39–41: si tiene éxito, el token se almacena en una cookie y el usuario es redirigido 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 (en minutos) es la misma que la del token. En producción, con HTTPS, agregaríamos [secure: true]: la cookie nunca se enviaría por una conexión sin cifrar;
- Líneas 46–49: cerrar sesión elimina la cookie ([withoutCookie]). 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. Observe una limitación de los tokens: el propio token sigue siendo válido hasta que expira. Alguien que haya hecho una copia de él aún podría usarlo. Por eso su duración es limitada.
- Línea 14: el atributo [#[CurrentUser]] solicita al contenedor el usuario autenticado, el que encontró el guard (véase el ejemplo 12 para los atributos de parámetros). La acción está protegida por el middleware [auth] (véase la tabla de rutas): se garantiza que recibirá un usuario. También podría obtenerse mediante [auth()->user()] o [$request->user()].
La tabla de rutas:
- Línea 14: el middleware [auth] protege la página de perfil. Para un visitante anónimo, lanza una excepción [AuthenticationException], que [Laravel] convierte en una redirección a la página de inicio de sesión ([redirectGuestsTo]). [auth] es un alias, un nombre corto que [Laravel] asocia con el middleware [Illuminate\Auth\Middleware\Authenticate]. Un grupo de rutas puede protegerse de una sola vez: [Route::middleware('auth')->group(...)].
8.1.6. Las vistas
- Línea 6: el formulario de inicio de sesión está protegido contra solicitudes falsificadas, como todos los formularios (ejemplo 18);
- línea 9: el nombre de usuario ingresado se vuelve a mostrar después de un intento fallido.
- Líneas 8–10: el contenido del token, mostrado con fines ilustrativos;
- líneas 13–16: el 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], primero se debe solicitar el formulario para obtener el token anti-CSRF y la cookie de sesión (ejemplo 18), y luego enviar el formulario conservando la cookie recibida:
El token consta de tres partes, separadas por puntos, cada una codificada en Base64: el encabezado, el contenido y la firma. Las dos primeras partes pueden decodificarse sin ninguna clave:
El tiempo de expiración es de una hora (3600 segundos) 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 el rol [USER]*** del contenido 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 es rechazado y eliminado (el valor [deleted] y la fecha expirada indican al navegador que elimine la cookie). 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. Una autorización: bootstrap/app.php
- Línea 44: la fachada [Gate] (una «puerta») define una autorización llamada [admin]. La función recibe al usuario autenticado (y, opcionalmente, otros parámetros: por ejemplo, el objeto al que se accede) y devuelve [true] si el usuario tiene el permiso solicitado. Un permiso puede verificarse de varias maneras: [Gate::allows('admin')] o [Gate::authorize('admin')] (que lanza una excepción, 403) en el código, [@can('admin')] en las vistas, y el middleware [can:admin] en las rutas. Para un mayor número de reglas, [Laravel] sugiere agruparlas por clase de modelo en políticas (*policies*).
8.2.2. La tabla de rutas y el controlador
- línea 19: dos componentes de middleware, ejecutados en orden: [auth] verifica que haya un usuario autenticado (de lo contrario, redirige a la página de inicio de sesión) y luego [can:admin] verifica que el usuario tenga el permiso [admin] (de lo contrario, un error 403, *Forbidden*). El texto que sigue a [:] es el parámetro del middleware, que [Laravel] le pasa después de [$next]. La diferencia entre las dos respuestas de denegación es significativa: para un usuario que está autenticado pero no tiene el rol solicitado, iniciar sesión no serviría de nada, ya que ya está autenticado.
El controlador no realiza ninguna comprobación: esa es la responsabilidad del middleware. [Laravel] también permite especificar el middleware directamente en la propia acción, mediante atributos: [#[Middleware('auth')]], [#[Authorize('admin')]].
8.2.3. Vistas
La página de error 403: [Laravel] busca una vista [errors/<code>.blade.php] cuando ocurre un error HTTP y la muestra en lugar de su página estándar (véase el capítulo anterior). No hay nada que declarar. La página de perfil ofrece un enlace a la página de administración:
- Líneas 7–11: la directiva [@can] muestra su bloque solo si el usuario tiene el permiso; [@else] maneja el caso contrario. Esto evita mostrar un enlace que conduciría a un error; sin embargo, es solo una medida de comodidad: la protección real proviene de la lógica de enrutamiento.
8.2.4. Ejecución
Marie, con el rol USER, sigue el enlace a la página de administración:

El administrador, en cambio, tiene acceso a ella:

Con [curl]: un usuario con el rol USER (el archivo [token.txt], obtenido iniciando sesión como en el ejemplo 25, pero en el ejemplo 26: los dos ejemplos firman sus tokens con claves diferentes), seguido de un visitante anónimo:
Proteger las rutas una por una tiene un defecto: si se olvida una, la página queda accesible para todos. El caso de estudio invertirá esta lógica: todas las rutas se protegen de forma predeterminada mediante un grupo, y solo unas pocas rutas (la página de inicio de sesión, la página de registro) se excluyen.
8.3. Ejemplo 27: CAPTCHA y límites 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 un humano 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 y agrega estas dos medidas de seguridad.
8.3.1. La imagen CAPTCHA: app/Auth/CaptchaDrawing.php
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 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | |
La imagen está en 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íneas 16–49: 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íneas 56–64: una cadena de texto aleatoria, seleccionada entre los caracteres de la fuente ([array_keys], las claves de la tabla). Las funciones [rand] y [mt_rand] de [PHP] producen secuencias de números predecibles (cualquiera que conozca unos pocos valores puede adivinar los siguientes): son adecuadas para simulaciones, no para seguridad. [random_int] es un generador criptográfico; es impredecible;
- líneas 67–70: un número de punto flotante aleatorio, generado a partir de un entero aleatorio ([PHP_INT_MAX] es el mayor entero en [PHP]);
- líneas 77–118: el dibujo. Cada carácter se escala, se rota y se desplaza de forma aleatoria, y cada uno de sus puntos se desplaza ligeramente; cada trazo se convierte en un elemento [<path>] de SVG ([M]: desplazamiento, [L]: línea). Tres curvas ([C]: curva de Bézier) cruzan la imagen para interferir con los programas de reconocimiento. La función [sprintf] da formato a una cadena: [%s] inserta en ella una cadena, y [%.1f] inserta un número con un decimal. [str_split] divide una cadena en caracteres.
8.3.2. El servicio de CAPTCHA: app/Auth/CaptchaService.php
- Líneas 15–24: un nuevo CAPTCHA: un texto aleatorio, un identificador aleatorio imposible de adivinar ([Str::random] también usa un generador criptográfico) y la imagen. Para cada identificador, el servidor almacena la respuesta esperada en el caché (ejemplo 20) durante diez minutos: [Cache::put(key, value, seconds)]. Transcurrido este tiempo, el caché la descarta automáticamente. La página recibe solo el identificador y la imagen: la respuesta nunca sale del servidor. La clase [Captcha] combina el identificador y la imagen;
- líneas 27–35: la verificación. [Cache::pull] lee el valor y lo elimina del caché: el CAPTCHA se consume en todos los casos, ya sea que tenga éxito o no. Sin esto, un programa podría probar todas las respuestas posibles sobre la misma imagen. La comparación ignora las mayúsculas y minúsculas ([strcasecmp] devuelve 0 para dos cadenas iguales, sin importar si las letras son mayúsculas o minúsculas) y los espacios alrededor de la entrada ([trim]).
8.3.3. El controlador: app/Http/Controllers/AuthController.php
- línea 38: el límite lo maneja la fachada [RateLimiter] de [Laravel], que cuenta los «intentos» bajo una clave en el caché. Aquí la clave es la dirección IP del cliente;
- líneas 41–44: a una dirección bloqueada ni siquiera se le presta atención. [tooManyAttempts(key, 3)] es verdadero si la clave ha alcanzado 3 intentos; [availableIn] devuelve el número de segundos que faltan para que termine el bloqueo;
- líneas 46–54: el CAPTCHA se verifica antes que la contraseña; verificarlo casi no cuesta nada, mientras que [bcrypt] es intencionalmente lento. Por lo tanto, un programa que ingrese un CAPTCHA incorrecto no activaría [bcrypt]. Cada fallo, ya sea del CAPTCHA o de la contraseña, se contabiliza: [RateLimiter::hit(key, 60)] agrega un intento y establece la duración del contador en 60 segundos. En el tercer fallo, la dirección queda bloqueada hasta el final de esos 60 segundos, contados desde el primer fallo;
- línea 55: un inicio de sesión exitoso borra los intentos fallidos;
- líneas 67–71: cada vez que se muestra el formulario, se genera un nuevo CAPTCHA, incluso después de un intento fallido.
[Laravel] también proporciona un componente de middleware, [throttle], que limita el número de solicitudes de una ruta ([->middleware('throttle:5,1')]: 5 solicitudes por minuto); nosotros elegimos contar solo los intentos fallidos, para no incomodar a un usuario que inicia sesión normalmente.
8.3.4. La vista: resources/views/auth/login.blade.php
- Línea 18: la imagen SVG se inserta en la página tal cual, sin escape (ejemplo 14). Esto es legítimo: este HTML fue generado por el servidor y no contiene ninguna entrada del usuario;
- Línea 20: el identificador del captcha, en un campo oculto;
- línea 21: el navegador no sugiere entradas anteriores para este campo.
8.3.5. Ejecución

Un código copiado incorrectamente:

Después de tres intentos fallidos, la dirección queda bloqueada:

Con [curl], cuatro intentos con un identificador de CAPTCHA inventado (después de obtener, como en el ejemplo 25, la cookie de sesión y el token anti-CSRF):
Incluso con la contraseña correcta, el cuarto intento es rechazado sin ser procesado.