Skip to content

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

25-jwt/
├── app/
│   ├── Auth/
│   │   ├── AuthService.php
│   │   ├── User.php
│   │   └── UsersService.php
│   └── Http/
│       └── Controllers/
│           ├── AuthController.php
│           └── ProfileController.php
├── bootstrap/
│   └── app.php
├── config/
│   ├── auth.php
│   └── jwt.php
├── resources/
│   └── views/
│       ├── auth/
│       │   └── login.blade.php
│       ├── layout.blade.php
│       └── profile/
│           └── profile.blade.php
├── routes/
│   └── web.php
└── ...

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:

1
2
3
# la clave que firma los tokens JWT (al menos 32 caracteres), y su duración
JWT_SECRET=a-secret-key-of-at-least-32-characters-for-example-25
JWT_DURATION_MINUTES=60

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]:

<?php
// config/jwt.php: la configuración de los tokens JWT, leída por config('jwt.secret')...
// env(NAME, default): la variable NAME del entorno o del archivo .env
return [
    // la clave que firma los tokens (al menos 32 caracteres): nunca en el código
    'secret' => env('JWT_SECRET'),
    // la duración de un token, en minutos
    'duration' => (int) env('JWT_DURATION_MINUTES', 60),
    // el nombre de la cookie que transporta el token
    'cookie' => 'token',
];
  • 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:

<?php
// config/auth.php: la autenticación. Este archivo COMPLETA la configuración
// predeterminada de Laravel (vendor/laravel/framework/config/auth.php)
return [
    // el "guard" usado por omisión: el que lee el token JWT
    'defaults' => [
        'guard' => 'jwt',
    ],
    'guards' => [
        // un guard con el controlador [jwt], definido en bootstrap/app.php (Auth::viaRequest)
        'jwt' => [
            'driver' => 'jwt',
        ],
    ],
];

[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:

JWT_SECRET="another-key-of-at-least-thirty-two-characters" php artisan serve

y en [Windows] (PowerShell):

$env:JWT_SECRET="another-key-of-at-least-thirty-two-characters"
php artisan serve

8.1.2. Usuarios: app/Auth/User.php y UsersService.php

<?php
// app/Auth/User.php: un usuario. Authenticatable: la interfaz que
// Laravel espera de los usuarios autenticados

namespace App\Auth;

use Illuminate\Contracts\Auth\Authenticatable;

readonly class User implements Authenticatable
{
    public function __construct(
        public string $login,
        public string $name,
        public string $role,
        // el HASH de la contraseña (vacío para un usuario leído desde un token)
        public string $passwordHash = '',
        // el contenido del token que autenticó al usuario
        public array $claims = [],
    ) {
    }

    // el identificador del usuario: su login
    public function getAuthIdentifierName(): string
    {
        return 'login';
    }

    public function getAuthIdentifier(): string
    {
        return $this->login;
    }

    public function getAuthPasswordName(): string
    {
        return 'passwordHash';
    }

    public function getAuthPassword(): string
    {
        return $this->passwordHash;
    }

    // el token "recordarme" de las sesiones: inútil aquí
    public function getRememberToken(): ?string
    {
        return null;
    }

    public function setRememberToken($value): void
    {
    }

    public function getRememberTokenName(): string
    {
        return '';
    }
}
  • 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.
<?php
// app/Auth/UsersService.php: los usuarios, en memoria (el ejemplo 28 y
// el caso de estudio los pondrán en una base de datos)

namespace App\Auth;

class UsersService
{
    // NUNCA guardamos una contraseña, solo su hash bcrypt, calculado
    // de una vez por todas con: php -r "echo password_hash('marie', PASSWORD_BCRYPT);"
    private const USERS = [
        'marie' => ['Marie Pélissier', 'USER', '$2y$10$2DnOgGBiVcyc07su9rj2E.EvOoyPFzHN/h9PLKDuoW5P7UGtclW6W'],
        'admin' => ['Administrator', 'ADMIN', '$2y$10$m5o9euCi0EdgoZkLVw.UsO58RxJcqhMBfVrlLMCIOh2LyGSjuN29K'],
    ];

    public function find(string $login): ?User
    {
        if (! isset(self::USERS[$login])) {
            return null;
        }
        [$name, $role, $hash] = self::USERS[$login];
        return new User($login, $name, $role, $hash);
    }
}
  • 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

<?php
// app/Auth/AuthService.php: la verificación de las contraseñas y los tokens JWT

namespace App\Auth;

use Firebase\JWT\JWT;
use Firebase\JWT\Key;
use Illuminate\Support\Facades\Hash;
use Throwable;

class AuthService
{
    public function __construct(private UsersService $users)
    {
    }

    // el usuario, o null si el login es desconocido o la contraseña es incorrecta.
    // Hash::check aplica hash a la contraseña ingresada con la sal del hash almacenado,
    // y luego compara los dos resultados
    public function validate(?string $login, ?string $password): ?User
    {
        if (! $login || $password === null) {
            return null;
        }
        $user = $this->users->find($login);
        if ($user === null || ! Hash::check($password, $user->passwordHash)) {
            return null;
        }
        return $user;
    }

    // el token JWT del usuario, firmado con la clave secreta (HMAC-SHA256)
    public function createToken(User $user): string
    {
        $now = time();
        // el contenido del token: los "claims" (afirmaciones sobre el usuario)
        $claims = [
            'sub' => $user->login,
            'name' => $user->name,
            'role' => $user->role,
            'iat' => $now,
            'exp' => $now + config('jwt.duration') * 60,
        ];
        return JWT::encode($claims, config('jwt.secret'), 'HS256');
    }

    // el usuario descrito por un token cuya firma y fecha de expiración
    // son válidas; null en caso contrario (token falsificado, expirado o ilegible)
    public function check(string $token): ?User
    {
        try {
            // decode devuelve un objeto; (array) lo convierte en un arreglo asociativo
            $claims = (array) JWT::decode($token, new Key(config('jwt.secret'), 'HS256'));
        } catch (Throwable) {
            return null;
        }
        return new User($claims['sub'], $claims['name'], $claims['role'], claims: $claims);
    }
}
  • 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

<?php
// bootstrap/app.php: la aplicación del ejemplo 25

use App\Auth\AuthService;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cookie;

(require __DIR__.'/../../vendor/autoload.php')->addPsr4('App\\', __DIR__.'/../app/');

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        // la ruta que sirve Bootstrap (véase el ejemplo 15)
        then: fn () => require __DIR__.'/../../common/bootstrap.php')
    ->withMiddleware(function (Middleware $middleware): void {
        // el token ya está firmado: la cookie que lo transporta no está cifrada
        $middleware->encryptCookies(except: ['token']);
        // un visitante anónimo que solicita una página protegida: se le envía a /login
        $middleware->redirectGuestsTo('/login');
    })
    ->withExceptions()
    ->booted(function () {
        // el controlador de guard [jwt] (véase config/auth.php): una función que recibe la
        // solicitud y devuelve el usuario autenticado, o null para un visitante anónimo
        Auth::viaRequest('jwt', function (Request $request) {
            $token = $request->cookie(config('jwt.cookie'));
            if ($token === null) {
                return null;
            }
            $user = app(AuthService::class)->check($token);
            if ($user === null) {
                // una cookie presente pero no válida (expirada, token falsificado): la eliminamos
                Cookie::queue(Cookie::forget(config('jwt.cookie')));
            }
            return $user;
        });
    })
    ->create();
  • 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

<?php
// app/Http/Controllers/AuthController.php: inicio y cierre de sesión

namespace App\Http\Controllers;

use App\Auth\AuthService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\View\View;

class AuthController
{
    public function __construct(private AuthService $auth)
    {
    }

    public function home(): RedirectResponse
    {
        return redirect('/profile');
    }

    public function form(): View
    {
        return view('auth.login');
    }

    public function login(Request $request): View|RedirectResponse
    {
        $login = $request->input('login');
        $user = $this->auth->validate($login, $request->input('password'));
        if ($user === null) {
            // un mensaje deliberadamente vago: no decimos si es el login o la contraseña
            return view('auth.login', ['login' => $login,
                'error' => 'Incorrect login or password.']);
        }
        // el token, en una cookie: el JavaScript de la página no puede leerla
        // (httpOnly); no viaja con las solicitudes POST provenientes de otros sitios
        // (sameSite); desaparece al mismo tiempo que expira el token (duración en minutos)
        return redirect('/profile')->withCookie(cookie(config('jwt.cookie'),
            $this->auth->createToken($user), config('jwt.duration'),
            httpOnly: true, sameSite: 'lax'));
    }

    // cierre de sesión: solo POST (un simple enlace, colocado en otro sitio, no puede
    // cerrar la sesión del usuario sin que lo sepa); eliminamos la cookie
    public function logout(): RedirectResponse
    {
        return redirect('/login')->withoutCookie(config('jwt.cookie'));
    }
}
  • 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.
<?php
// app/Http/Controllers/ProfileController.php: una página reservada a los usuarios autenticados

namespace App\Http\Controllers;

use App\Auth\User;
use Illuminate\Container\Attributes\CurrentUser;
use Illuminate\View\View;

class ProfileController
{
    // #[CurrentUser]: el contenedor proporciona el usuario autenticado de la solicitud,
    // el encontrado por el guard (véase bootstrap/app.php)
    public function display(#[CurrentUser] User $user): View
    {
        return view('profile.profile', ['user' => $user]);
    }
}
  • 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:

<?php
// routes/web.php: las rutas del ejemplo 25

use App\Http\Controllers\AuthController;
use App\Http\Controllers\ProfileController;
use Illuminate\Support\Facades\Route;

Route::get('/', [AuthController::class, 'home']);
Route::get('login', [AuthController::class, 'form']);
Route::post('login', [AuthController::class, 'login']);
Route::post('logout', [AuthController::class, 'logout']);

// el middleware [auth]: la ruta es accesible solo para un usuario autenticado
Route::get('profile', [ProfileController::class, 'display'])->middleware('auth');
  • 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

@extends('layout')

@section('content')
  <h1 class="h3">Login</h1>
  <form method="post" action="/login">
    @csrf
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ $login ?? '' }}" required>
    </div>
    <div class="mb-3">
      <label class="form-label" for="password">Password</label>
      <input class="form-control" type="password" id="password" name="password" required>
    </div>
    <button class="btn btn-primary" type="submit">Log in</button>
  </form>
  @isset($error)
    <div class="alert alert-danger mt-3">{{ $error }}</div>
  @endisset
  <p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
@endsection
  • 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.
@extends('layout')

@section('content')
  <h1 class="h3">Hello {{ $user->name }}</h1>
  <p>Your role: <b>{{ $user->role === 'ADMIN' ? 'administrator' : 'user' }}</b>.</p>
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    @foreach ($user->claims as $key => $value)
      <tr><td><code>{{ $key }}</code></td><td>{{ $value }}</td></tr>
    @endforeach
  </table>
  {{-- cierre de sesión: un formulario POST reducido a su botón --}}
  <form method="post" action="/logout">
    @csrf
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
@endsection
  • 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:

curl -i http://localhost:8000/profile
1
2
3
4
HTTP/1.1 302 Found
Location: http://localhost:8000/login
Content-Type: text/html; charset=utf-8
...

Una contraseña incorrecta:

Image

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:

curl -c token.txt -b token.txt http://localhost:8000/login
curl -i -c token.txt -b token.txt -d "_token=...&login=marie&password=marie" http://localhost:8000/login
1
2
3
4
HTTP/1.1 302 Found
Location: http://localhost:8000/profile
Set-Cookie: token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJtYXJpZSIsIm5hbWUiOiJNYXJpZSBQXHUwMGU5bGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwNDM5NjgyLCJleHAiOjE3OTA0NDMyODJ9.cvP1bi4zFamN79t2nqG7WXYLIF3kewt6UTOVb3swNtw; expires=Sat, 26 Sep 2026 17:21:22 GMT; Max-Age=3600; path=/; httponly; samesite=lax
...

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:

{"typ":"JWT","alg":"HS256"}
{"sub":"marie","name":"Marie Pélissier","role":"USER","iat":1790439682,"exp":1790443282}

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:

Image

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:

curl -i -b "token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.<modified content>.cvP1bi4zFamN79t2nqG7WXYLIF3kewt6UTOVb3swNtw" http://localhost:8000/profile
1
2
3
4
HTTP/1.1 302 Found
Location: http://localhost:8000/login
Set-Cookie: token=deleted; expires=Fri, 26 Sep 2025 16:21:27 GMT; Max-Age=0; path=/; httponly; samesite=lax
...

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

<?php
// bootstrap/app.php: la aplicación del ejemplo 26

use App\Auth\AuthService;
use App\Auth\User;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cookie;
use Illuminate\Support\Facades\Gate;

(require __DIR__.'/../../vendor/autoload.php')->addPsr4('App\\', __DIR__.'/../app/');

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        // la ruta que sirve Bootstrap (véase el ejemplo 15)
        then: fn () => require __DIR__.'/../../common/bootstrap.php')
    ->withMiddleware(function (Middleware $middleware): void {
        // el token ya está firmado: la cookie que lo transporta no está cifrada
        $middleware->encryptCookies(except: ['token']);
        // un visitante anónimo que solicita una página protegida: se le envía a /login
        $middleware->redirectGuestsTo('/login');
    })
    ->withExceptions()
    ->booted(function () {
        // el controlador de guard [jwt] (véase config/auth.php): una función que recibe la
        // solicitud y devuelve el usuario autenticado, o null para un visitante anónimo
        Auth::viaRequest('jwt', function (Request $request) {
            $token = $request->cookie(config('jwt.cookie'));
            if ($token === null) {
                return null;
            }
            $user = app(AuthService::class)->check($token);
            if ($user === null) {
                // una cookie presente pero no válida (expirada, token falsificado): la eliminamos
                Cookie::queue(Cookie::forget(config('jwt.cookie')));
            }
            return $user;
        });
        // una AUTORIZACIÓN con nombre [admin]: la función recibe el usuario
        // autenticado y dice si tiene el derecho solicitado
        Gate::define('admin', fn (User $user) => $user->role === 'ADMIN');
    })
    ->create();
  • 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

<?php
// routes/web.php: las rutas del ejemplo 26

use App\Http\Controllers\AdminController;
use App\Http\Controllers\AuthController;
use App\Http\Controllers\ProfileController;
use Illuminate\Support\Facades\Route;

Route::get('/', [AuthController::class, 'home']);
Route::get('login', [AuthController::class, 'form']);
Route::post('login', [AuthController::class, 'login']);
Route::post('logout', [AuthController::class, 'logout']);

// el middleware [auth]: la ruta es accesible solo para un usuario autenticado
Route::get('profile', [ProfileController::class, 'display'])->middleware('auth');

// dos middlewares: [auth] (un usuario autenticado), luego [can:admin] (que tiene
// la autorización [admin], véase bootstrap/app.php)
Route::get('admin', [AdminController::class, 'display'])->middleware(['auth', 'can:admin']);
  • 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.
<?php
// app/Http/Controllers/AdminController.php: una página reservada al rol ADMIN

namespace App\Http\Controllers;

use App\Auth\User;
use Illuminate\Container\Attributes\CurrentUser;
use Illuminate\View\View;

class AdminController
{
    public function display(#[CurrentUser] User $user): View
    {
        return view('admin.admin', ['name' => $user->name]);
    }
}

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

@extends('layout')
{{-- la página del error 403, que Laravel muestra por sí mismo: una vista
     errors/<code>.blade.php reemplaza la página de error estándar de este código --}}

@section('content')
  <div class="alert alert-danger">
    <h1 class="h4">Error 403</h1>
    <p class="mb-0">Access denied: this page is reserved for administrators.</p>
  </div>
  <p><a href="/profile">Back to the profile</a></p>
@endsection

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:

@extends('layout')

@section('content')
  <h1 class="h3">Hello {{ $user->name }}</h1>
  <p>Your role: <b>{{ $user->role === 'ADMIN' ? 'administrator' : 'user' }}</b>.</p>
  {{-- @can: el bloque se muestra solo si el usuario tiene la autorización [admin] --}}
  @can('admin')
    <p><a href="/admin">The administration area</a></p>
  @else
    <p><a href="/admin">The administration area</a> (which is forbidden to you)</p>
  @endcan
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    @foreach ($user->claims as $key => $value)
      <tr><td><code>{{ $key }}</code></td><td>{{ $value }}</td></tr>
    @endforeach
  </table>
  {{-- cierre de sesión: un formulario POST reducido a su botón --}}
  <form method="post" action="/logout">
    @csrf
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
@endsection
  • 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:

Image

El administrador, en cambio, tiene acceso a ella:

Image

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:

curl -i -b token.txt http://localhost:8000/admin
curl -i http://localhost:8000/admin
HTTP/1.1 403 Forbidden
Content-Type: text/html; charset=utf-8
...
        <div class="alert alert-danger">
    <h1 class="h4">Error 403</h1>
    <p class="mb-0">Access denied: this page is reserved for administrators.</p>
  </div>
...
HTTP/1.1 302 Found
Location: http://localhost:8000/login
...

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

<?php
// app/Auth/CaptchaDrawing.php: el dibujo de un captcha, una imagen SVG (texto XML)
// construida a mano

namespace App\Auth;

class CaptchaDrawing
{
    public const WIDTH = 150;

    public const HEIGHT = 50;

    // La "fuente": cada carácter es una lista de trazos, cada trazo una
    // secuencia de puntos x, y en una cuadrícula de 4 x 6 (y hacia abajo).
    // Caracteres demasiado fáciles de confundir entre sí: excluidos (0 O, 1 I L).
    private const FONT = [
        'A' => [[0, 6, 2, 0, 4, 6], [0.8, 3.8, 3.2, 3.8]],
        'B' => [[0, 0, 0, 6, 3, 6, 4, 5, 4, 4, 3, 3, 0, 3], [0, 0, 3, 0, 4, 1, 4, 2, 3, 3]],
        'C' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5]],
        'D' => [[0, 0, 0, 6, 2.5, 6, 4, 4.5, 4, 1.5, 2.5, 0, 0, 0]],
        'E' => [[4, 0, 0, 0, 0, 6, 4, 6], [0, 3, 3, 3]],
        'F' => [[4, 0, 0, 0, 0, 6], [0, 3, 3, 3]],
        'G' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5, 4, 3.5, 2.5, 3.5]],
        'H' => [[0, 0, 0, 6], [4, 0, 4, 6], [0, 3, 4, 3]],
        'J' => [[4, 0, 4, 5, 3, 6, 1, 6, 0, 5]],
        'K' => [[0, 0, 0, 6], [4, 0, 0, 3.5], [1.3, 2.6, 4, 6]],
        'M' => [[0, 6, 0, 0, 2, 3.5, 4, 0, 4, 6]],
        'N' => [[0, 6, 0, 0, 4, 6, 4, 0]],
        'P' => [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2, 3, 3, 0, 3]],
        'Q' => [[1, 0, 3, 0, 4, 1, 4, 5, 3, 6, 1, 6, 0, 5, 0, 1, 1, 0], [2.5, 4.5, 4, 6.3]],
        'R' => [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2, 3, 3, 0, 3], [2, 3, 4, 6]],
        'S' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 2, 1, 3, 3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
        'T' => [[0, 0, 4, 0], [2, 0, 2, 6]],
        'U' => [[0, 0, 0, 5, 1, 6, 3, 6, 4, 5, 4, 0]],
        'V' => [[0, 0, 2, 6, 4, 0]],
        'W' => [[0, 0, 1, 6, 2, 2.5, 3, 6, 4, 0]],
        'X' => [[0, 0, 4, 6], [4, 0, 0, 6]],
        'Y' => [[0, 0, 2, 3, 4, 0], [2, 3, 2, 6]],
        'Z' => [[0, 0, 4, 0, 0, 6, 4, 6]],
        '2' => [[0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 0, 6, 4, 6]],
        '3' => [[0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 3, 3, 1.5, 3], [3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
        '4' => [[3, 6, 3, 0, 0, 4, 4, 4]],
        '5' => [[4, 0, 0, 0, 0, 3, 3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
        '6' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5, 4, 4, 3, 3, 0, 3]],
        '7' => [[0, 0, 4, 0, 1.5, 6]],
        '8' => [[1, 3, 0, 2, 0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 3, 3, 1, 3, 0, 4, 0, 5, 1, 6, 3, 6, 4, 5,
            4, 4, 3, 3]],
        '9' => [[4, 3, 1, 3, 0, 2, 0, 1, 1, 0, 3, 0, 4, 1, 4, 5, 3, 6, 1, 6, 0, 5]],
    ];

    // algunos colores oscuros, fáciles de leer sobre el fondo claro
    private const COLORS = ['#1f4e79', '#7b2d26', '#2e6b30', '#5b2c83', '#8a5a00', '#23395d', '#9c2a5b'];

    // un texto aleatorio. random_int es un generador "criptográfico",
    // impredecible (a diferencia de rand o mt_rand, cuya secuencia podría adivinarse)
    public static function randomText(int $length): string
    {
        $alphabet = array_keys(self::FONT);
        $text = '';
        for ($i = 0; $i < $length; $i++) {
            $text .= $alphabet[random_int(0, count($alphabet) - 1)];
        }
        return $text;
    }

    // un número de punto flotante, al azar, entre $minimum y $maximum
    private static function random(float $minimum, float $maximum): float
    {
        return $minimum + ($maximum - $minimum) * random_int(0, PHP_INT_MAX) / PHP_INT_MAX;
    }

    private static function color(): string
    {
        return self::COLORS[random_int(0, count(self::COLORS) - 1)];
    }

    public static function svg(string $text): string
    {
        $l = self::WIDTH;
        $h = self::HEIGHT;
        $pieces = ["<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"$l\" height=\"$h\" viewBox=\"0 0 $l $h\">",
            '<rect width="100%" height="100%" fill="#f5f7fa"/>'];

        // los caracteres: cada uno ampliado, inclinado, desplazado, y cada punto
        // ligeramente movido al azar
        $step = ($l - 20) / strlen($text);
        foreach (str_split($text) as $i => $character) {
            $scale = self::random(4.6, 5.6);    // tamaño de una unidad de la cuadrícula, en píxeles
            $angle = self::random(-0.35, 0.35);   // rotación, en radianes (aproximadamente ±20°)
            $cx = 10 + $step * ($i + 0.5) + self::random(-3, 3);    // centro del carácter
            $cy = $h / 2 + self::random(-4, 4);
            foreach (self::FONT[$character] as $stroke) {
                $d = [];
                for ($k = 0; $k < count($stroke); $k += 2) {
                    // punto de la cuadrícula, centrado en (2, 3), distorsionado, rotado, colocado
                    $x = ($stroke[$k] - 2 + self::random(-0.2, 0.2)) * $scale;
                    $y = ($stroke[$k + 1] - 3 + self::random(-0.2, 0.2)) * $scale;
                    $px = $cx + $x * cos($angle) - $y * sin($angle);
                    $py = $cy + $x * sin($angle) + $y * cos($angle);
                    $d[] = sprintf('%s%.1f %.1f', $k === 0 ? 'M' : 'L', $px, $py);
                }
                $pieces[] = sprintf('<path d="%s" fill="none" stroke="%s" stroke-width="%.1f" '
                    .'stroke-linecap="round" stroke-linejoin="round"/>',
                    implode(' ', $d), self::color(), self::random(2.2, 3));
            }
        }

        // 3 líneas de interferencia: curvas que cruzan la imagen
        for ($n = 0; $n < 3; $n++) {
            $pieces[] = sprintf('<path d="M%.1f %.1f C%.1f %.1f %.1f %.1f %.1f %.1f" fill="none" '
                .'stroke="%s" stroke-width="1.3"/>',
                self::random(0, 20), self::random(5, 45), self::random(30, 60), self::random(0, 50),
                self::random(90, 120), self::random(0, 50), self::random(130, 150), self::random(5, 45),
                self::color());
        }
        $pieces[] = '</svg>';
        return implode('', $pieces);
    }
}

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

<?php
// app/Auth/CaptchaService.php: los captchas pendientes, conservados por el servidor,
// en la caché (véase el ejemplo 20)

namespace App\Auth;

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Str;

class CaptchaService
{
    // la vida útil de un captcha, en segundos
    private const LIFETIME = 600;

    public function generate(): Captcha
    {
        $text = CaptchaDrawing::randomText(5);
        // un identificador aleatorio, imposible de adivinar
        $id = Str::random(24);
        // la respuesta esperada, en la caché, durante 10 minutos: la caché la olvidará
        // sola después
        Cache::put("captcha:$id", $text, self::LIFETIME);
        return new Captcha($id, CaptchaDrawing::svg($text));
    }

    // el captcha se CONSUME en todos los casos: una imagen se usa una sola vez
    public function check(?string $id, ?string $answer): bool
    {
        // pull: lee el valor Y lo elimina de la caché (null si no existe o ha expirado)
        $expected = $id ? Cache::pull("captcha:$id") : null;
        if ($expected === null || $answer === null) {
            return false;
        }
        return strcasecmp($expected, trim($answer)) === 0;
    }
}
  • 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

<?php
// app/Http/Controllers/AuthController.php: inicio de sesión (con captcha y limitación de intentos) y cierre de sesión

namespace App\Http\Controllers;

use App\Auth\AuthService;
use App\Auth\CaptchaService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;
use Illuminate\View\View;

class AuthController
{
    // 3 fallos como máximo, durante 60 segundos
    private const MAX_FAILURES = 3;

    private const BLOCK_DURATION = 60;

    public function __construct(private AuthService $auth, private CaptchaService $captchas)
    {
    }

    public function home(): RedirectResponse
    {
        return redirect('/profile');
    }

    public function form(): View
    {
        return $this->loginPage();
    }

    public function login(Request $request): View|RedirectResponse
    {
        $login = $request->input('login');
        // la clave del contador de fallos: la dirección IP del cliente
        $key = 'login:'.$request->ip();

        // 1. una dirección bloqueada ni siquiera se atiende
        if (RateLimiter::tooManyAttempts($key, self::MAX_FAILURES)) {
            $seconds = RateLimiter::availableIn($key);
            return $this->loginPage($login, "Too many attempts: try again in $seconds s.");
        }
        // 2. primero el captcha (barato), después la contraseña (bcrypt, costoso)
        if (! $this->captchas->check($request->input('captchaId'), $request->input('captcha'))) {
            RateLimiter::hit($key, self::BLOCK_DURATION);
            return $this->loginPage($login, 'The image code is incorrect.');
        }
        $user = $this->auth->validate($login, $request->input('password'));
        if ($user === null) {
            RateLimiter::hit($key, self::BLOCK_DURATION);
            return $this->loginPage($login, 'Incorrect login or password.');
        }
        RateLimiter::clear($key);
        return redirect('/profile')->withCookie(cookie(config('jwt.cookie'),
            $this->auth->createToken($user), config('jwt.duration'),
            httpOnly: true, sameSite: 'lax'));
    }

    public function logout(): RedirectResponse
    {
        return redirect('/login')->withoutCookie(config('jwt.cookie'));
    }

    // cada visualización del formulario construye un captcha NUEVO
    private function loginPage(?string $login = null, ?string $error = null): View
    {
        return view('auth.login', ['login' => $login, 'error' => $error,
            'captcha' => $this->captchas->generate()]);
    }
}
  • 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

@extends('layout')

@section('content')
  <h1 class="h3">Login</h1>
  <form method="post" action="/login">
    @csrf
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ $login }}" required>
    </div>
    <div class="mb-2">
      <label class="form-label" for="password">Password</label>
      <input class="form-control" type="password" id="password" name="password" required>
    </div>
    <div class="mb-3">
      <label class="form-label" for="captcha">Copy the code of the image</label>
      {{-- la imagen SVG, construida por el servidor: insertada sin escapar --}}
      <div class="mb-1">{!! $captcha->svg !!}</div>
      {{-- el identificador del captcha viaja en un campo oculto; la respuesta se queda en el servidor --}}
      <input type="hidden" name="captchaId" value="{{ $captcha->id }}">
      <input class="form-control" id="captcha" name="captcha" autocomplete="off" required>
    </div>
    <button class="btn btn-primary" type="submit">Log in</button>
  </form>
  @if ($error)
    <div class="alert alert-danger mt-3">{{ $error }}</div>
  @endif
  <p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
@endsection
  • 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

Image

Un código copiado incorrectamente:

Image

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

Image

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):

curl -b cookies.txt -d "_token=...&login=marie&password=marie&captchaId=abc&captcha=XXXXX" http://localhost:8000/login
1
2
3
4
      <div class="alert alert-danger mt-3">The image code is incorrect.</div>
      <div class="alert alert-danger mt-3">The image code is incorrect.</div>
      <div class="alert alert-danger mt-3">The image code is incorrect.</div>
      <div class="alert alert-danger mt-3">Too many attempts: try again in 60 s.</div>

Incluso con la contraseña correcta, el cuarto intento es rechazado sin ser procesado.