Introducción a JWT (JSON Web Tokens)

Las JSON Web Tokens (JWT) son un estándar abierto (RFC 7519) que define una forma compacta y autónoma de transmitir información de forma segura entre dos partes como un objeto JSON. Esta información puede ser verificada y confiable porque está firmada digitalmente.

Un JWT se compone de tres partes separadas por puntos: el encabezado, la carga útil (payload) y la firma. El encabezado contiene el tipo de token y el algoritmo de cifrado utilizado, la carga útil incluye las claims o declaraciones sobre una entidad (normalmente el usuario), y la firma se utiliza para verificar que el mensaje no ha sido alterado.

La estructura básica de un JWT es la siguiente:

xxxxx.yyyyy.zzzzz

Donde cada segmento codifica, en Base64URL, el encabezado, el payload y la firma respectivamente. Por ejemplo:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
.
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6Ikp1YW4gUGVyZXoiLCJpYXQiOjE1MTYyMzkwMjJ9
.
TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

El uso de JWT es especialmente útil en el contexto de las APIs RESTful, donde se requiere un mecanismo de autenticación y autorización sin estado (stateless). Los tokens JWT permiten que el servidor valide la identidad del usuario y comparta información sin necesidad de mantener sesiones en el servidor.

En Laravel, la integración de JWT facilita la implementación de sistemas de autenticación para APIs. Al recibir una solicitud, la aplicación puede verificar el token incluido en los encabezados de la petición para autenticar al usuario y autorizar el acceso a recursos protegidos.

Una de las ventajas principales de utilizar JWT es su naturaleza autónoma; el token contiene toda la información necesaria, lo que reduce la necesidad de consultar bases de datos o almacenar sesiones en el servidor. Además, al estar firmado, garantiza la integridad y autenticidad de los datos transmitidos.

Es importante tener en cuenta aspectos de seguridad al trabajar con JWT. Aunque los tokens están firmados, el payload no está cifrado por defecto, lo que significa que la información puede ser leída si se intercepta el token. Por ello, es recomendable no incluir información sensible en el payload y utilizar HTTPS para las comunicaciones.

Otro aspecto a considerar es la caducidad de los tokens. Definir una expiración adecuada es crucial para minimizar riesgos de seguridad. Los tokens con una vida útil demasiado larga pueden ser vulnerables si son comprometidos, mientras que tokens con expiración muy corta pueden afectar la experiencia del usuario.

Instalación y configuración de un paquete JWT en Laravel

Para implementar autenticación JWT en una API REST con Laravel, es necesario instalar y configurar un paquete que facilite el manejo de tokens JWT. Uno de los paquetes más utilizados y mantenidos es php-open-source-saver/jwt-auth, un fork del paquete original tymon/jwt-auth, compatible con las versiones más recientes de Laravel.

Para instalar el paquete, se utiliza Composer, ejecutando el siguiente comando en la terminal dentro del directorio raíz del proyecto:

composer require php-open-source-saver/jwt-auth

Este comando instala el paquete y sus dependencias necesarias para su funcionamiento con Laravel.

Una vez instalado, es necesario publicar el archivo de configuración con el comando:

php artisan vendor:publish --provider="PHPOpenSourceSaver\JWTAuth\Providers\LaravelServiceProvider"

Este comando copia el archivo de configuración config/jwt.php a la aplicación, permitiendo personalizar los ajustes del paquete según las necesidades del proyecto.

A continuación, se debe generar una clave secreta para firmar los tokens JWT, utilizando:

php artisan jwt:secret

Este comando agrega una nueva entrada JWT_SECRET al archivo .env con una clave generada aleatoriamente. Es fundamental mantener esta clave confidencial, ya que garantiza la integridad y autenticidad de los tokens.

En el modelo de usuario, es necesario implementar la interfaz JWTSubject y agregar los métodos requeridos. En el archivo app/Models/User.php, modificar la clase User de la siguiente manera:

<?php

namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;
use PHPOpenSourceSaver\JWTAuth\Contracts\JWTSubject;

class User extends Authenticatable implements JWTSubject
{
    // ...

    public function getJWTIdentifier()
    {
        return $this->getKey();
    }

    public function getJWTCustomClaims()
    {
        return [];
    }
}

Esta implementación permite que el modelo User sea compatible con el paquete JWT y proporcione los métodos necesarios para obtener el identificador y las claims personalizadas del token.

Además, es necesario configurar el guard para que utilice el driver jwt. En el archivo config/auth.php, modificar la sección de guards de la siguiente forma:

'guards' => [
    // ...

    'api' => [
        'driver' => 'jwt',
        'provider' => 'users',
    ],
],

Esto indica a Laravel que para las autenticaciones realizadas a través del guard api, se utilizará el driver jwt proporcionado por el paquete.

Para garantizar que los cambios en la configuración sean efectivos, es recomendable limpiar la caché de configuración ejecutando:

php artisan config:clear
php artisan cache:clear

Finalmente, se deben registrar los middlewares relacionados con JWT. En el archivo app/Http/Kernel.php, dentro del array $middlewareAliases (o $routeMiddleware en versiones anteriores), agregar las siguientes entradas:

protected $middlewareAliases = [
    // ...

    'jwt.auth' => \PHPOpenSourceSaver\JWTAuth\Http\Middleware\Authenticate::class,
    'jwt.refresh' => \PHPOpenSourceSaver\JWTAuth\Http\Middleware\RefreshToken::class,
];

Esto permite utilizar los middlewares jwt.auth y jwt.refresh en las rutas que requieran autenticación JWT, lo cual es esencial para proteger las rutas de la API y manejar la renovación de tokens.

Generación y renovación de tokens

Para implementar la generación de tokens JWT en Laravel, es necesario crear un controlador que maneje la autenticación y emita los tokens al usuario. A continuación, se muestra cómo crear un método de inicio de sesión que autentica al usuario y devuelve un token.

En el controlador AuthController, se puede definir el método login de la siguiente manera:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use PHPOpenSourceSaver\JWTAuth\Facades\JWTAuth;
use Illuminate\Support\Facades\Validator;

class AuthController extends Controller
{
    public function login(Request $request)
    {
        // Validar las credenciales del usuario
        $credentials = $request->only('email', 'password');

        $validator = Validator::make($credentials, [
            'email' => 'required|email',
            'password' => 'required|string|min:6',
        ]);

        if ($validator->fails()) {
            return response()->json(['error' => 'Credenciales inválidas'], 400);
        }

        // Intentar autenticar y generar un token
        if (!$token = JWTAuth::attempt($credentials)) {
            return response()->json(['error' => 'No autorizado'], 401);
        }

        return response()->json([
            'message' => 'Inicio de sesión exitoso',
            'token' => $token,
            'user' => auth()->user(),
        ]);
    }
}

En este método se validan las credenciales recibidas y se utiliza JWTAuth::attempt para autenticar al usuario. Si las credenciales son correctas, se genera un token que se devuelve en la respuesta junto con la información del usuario.

Es necesario definir las rutas correspondientes en el archivo routes/api.php:

<?php

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

Route::post('login', [AuthController::class, 'login']);

Con esta configuración, la aplicación puede recibir solicitudes POST a la ruta /api/login, autenticar al usuario y proporcionar un token JWT.

Para proteger rutas y requerir autenticación, se utiliza el middleware jwt.auth. Por ejemplo:

Route::group(['middleware' => ['jwt.auth']], function () {
    Route::get('user-profile', function () {
        return response()->json(auth()->user());
    });
});

Este grupo de rutas exige que el usuario proporcione un token válido en la cabecera Authorization de la solicitud. El formato adecuado es:

Authorization: Bearer {token}

En cuanto a la renovación de tokens, es común que los tokens JWT tengan una expiración definida para mejorar la seguridad. Para permitir que los usuarios renueven su token antes de que expire, se puede implementar un método refresh en el AuthController:

public function refresh()
{
    try {
        $newToken = JWTAuth::refresh(JWTAuth::getToken());
        return response()->json([
            'message' => 'Token renovado',
            'token' => $newToken,
        ]);
    } catch (\PHPOpenSourceSaver\JWTAuth\Exceptions\TokenInvalidException $e) {
        return response()->json(['error' => 'Token inválido'], 401);
    }
}

Este método obtiene el token actual, lo refresca y devuelve un nuevo token al cliente. Es importante manejar las excepciones para casos en que el token no sea válido o haya expirado.

La ruta para este método se añade también en routes/api.php:

Route::post('refresh', [AuthController::class, 'refresh']);

De esta manera, el cliente puede enviar una solicitud POST a /api/refresh con el token antiguo, y recibir un token actualizado.

Además, se puede ajustar la configuración de expiración de los tokens en el archivo config/jwt.php, modificando el valor de ttl (time to live) que representa la duración del token en minutos:

'ttl' => env('JWT_TTL', 60),

Para controlar la expiración de los tokens de renovación, se puede configurar refresh_ttl:

'refresh_ttl' => env('JWT_REFRESH_TTL', 20160),

Es una buena práctica mantener los valores de expiración lo suficientemente cortos para minimizar riesgos de seguridad, pero sin comprometer la experiencia del usuario.

Mediante la implementación de estos métodos, se logra gestionar la generación y renovación de tokens, permitiendo que los usuarios autenticados accedan a recursos protegidos y mantengan sesiones seguras en la API.

Protección de rutas y middlewares JWT

Para asegurar que solo los usuarios autenticados accedan a ciertas rutas de la API, es esencial utilizar middlewares que verifiquen la validez de los tokens JWT. Laravel provee una forma sencilla de asignar middlewares a rutas individuales o grupos de rutas, garantizando la protección de recursos sensibles.

El paquete JWT instalado previamente incluye el middleware jwt.auth, que se encarga de verificar que la solicitud entrante contenga un token válido. Si el token es válido, el middleware permite el acceso a la ruta; de lo contrario, retorna una respuesta de error.

Para aplicar el middleware a una ruta específica, se puede utilizar el método middleware en la definición de la ruta. Por ejemplo:

Route::get('perfil', [UserController::class, 'perfil'])->middleware('jwt.auth');

En este caso, la ruta perfil estará protegida y solo los usuarios con un token válido podrán acceder a ella. Si el token falta o es inválido, el usuario recibirá una respuesta de error.

También es posible proteger múltiples rutas utilizando un grupo de rutas y aplicando el middleware a todo el grupo:

Route::group(['middleware' => ['jwt.auth']], function () {
    Route::get('perfil', [UserController::class, 'perfil']);
    Route::get('configuracion', [UserController::class, 'configuracion']);
    Route::post('actualizar-datos', [UserController::class, 'actualizarDatos']);
});

De esta manera, todas las rutas dentro del grupo estarán bajo la protección del middleware JWT, simplificando la asignación de middlewares a varias rutas.

El middleware jwt.auth no solo verifica la presencia del token, sino que también valida su integridad y vigencia. Esto significa que si el token ha expirado o ha sido manipulado, el middleware denegará el acceso y enviará una respuesta de error al cliente.

Además del middleware jwt.auth, el paquete proporciona otros middlewares útiles, como jwt.refresh. Este middleware intenta refrescar un token expirado y continuar con la solicitud. Si se desea implementar una renovación automática de tokens, se puede utilizar de la siguiente manera:

Route::group(['middleware' => ['jwt.auth', 'jwt.refresh']], function () {
    // Rutas protegidas que también renuevan el token automáticamente
});

Es importante mencionar que el middleware jwt.refresh debe colocarse después de jwt.auth en la lista de middlewares para que funcione correctamente. Esto asegura que el token sea validado primero y, si ha expirado pero es renovable, se genere un nuevo token.

Para manejar los errores que puedan surgir durante la autenticación, se pueden capturar las excepciones lanzadas por el middleware y personalizar las respuestas. Por ejemplo, se puede modificar el método unauthenticated en el manejador de excepciones App\Exceptions\Handler:

public function unauthenticated($request, AuthenticationException $exception)
{
    return response()->json(['error' => 'No autenticado'], 401);
}

Con esta modificación, las respuestas a solicitudes no autenticadas serán más coherentes y adecuadas para una API REST.

También es posible crear middlewares personalizados si se requiere una lógica adicional en la protección de rutas. Para generar un nuevo middleware, se puede utilizar el comando de Artisan:

php artisan make:middleware VerificarRol

Este comando crea una nueva clase de middleware en app/Http/Middleware/. En este middleware, se puede implementar lógica personalizada, como verificar el rol del usuario:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class VerificarRol
{
    public function handle(Request $request, Closure $next, $rol)
    {
        if (!auth()->user() || auth()->user()->rol !== $rol) {
            return response()->json(['error' => 'Acceso no autorizado'], 403);
        }

        return $next($request);
    }
}

Para registrar el middleware, se añade a $middlewareAliases en app/Http/Kernel.php:

protected $middlewareAliases = [
    // Otros middlewares
    'verificar.rol' => \App\Http\Middleware\VerificarRol::class,
];

Luego, se puede aplicar a las rutas de la siguiente manera:

Route::get('admin/panel', [AdminController::class, 'panel'])->middleware('jwt.auth', 'verificar.rol:admin');

En este ejemplo, solo los usuarios con rol admin podrán acceder a la ruta admin/panel, fortaleciendo aún más la seguridad de la API.

Es crucial considerar que los middlewares se ejecutan en el orden en que se definen. Por ello, para garantizar que el usuario esté autenticado antes de verificar su rol, se debe colocar primero el middleware jwt.auth.

Para mantener una buena práctica en el manejo de rutas y middlewares, es recomendable organizar las rutas en archivos separados si la aplicación crece en complejidad. Laravel permite cargar rutas adicionales desde otros archivos, facilitando la modularidad y el mantenimiento del código.

Ejemplos de uso en controladores

En esta sección se presentan ejemplos prácticos de cómo utilizar la autenticación JWT en controladores de Laravel para gestionar las operaciones de una API REST. Estos ejemplos ilustran cómo interactuar con el sistema de autenticación, acceder a los datos del usuario autenticado y manejar respuestas adecuadas para distintas situaciones.

Para acceder a la información del usuario autenticado dentro de un controlador, se puede utilizar el helper auth() después de que la solicitud haya pasado por el middleware jwt.auth. Por ejemplo, para obtener los datos del usuario y responder con su perfil:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class UsuarioController extends Controller
{
    public function perfil()
    {
        $usuario = auth()->user();

        return response()->json([
            'mensaje' => 'Perfil del usuario',
            'usuario' => $usuario,
        ]);
    }
}

En este ejemplo, el método perfil devuelve un objeto JSON con la información del usuario actualmente autenticado. La función auth()->user() proporciona una instancia del modelo User, facilitando el acceso a sus atributos sin necesidad de realizar consultas adicionales a la base de datos.

Si se desea proteger métodos específicos dentro de un controlador, se puede aplicar el middleware directamente en el constructor de la clase. Esto permite mayor control sobre qué métodos requieren autenticación y cuáles están disponibles públicamente. Por ejemplo:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ProductoController extends Controller
{
    public function __construct()
    {
        $this->middleware('jwt.auth', ['except' => ['index', 'mostrar']]);
    }

    public function index()
    {
        // Lista todos los productos disponibles
        $productos = Producto::all();

        return response()->json($productos);
    }

    public function mostrar($id)
    {
        // Muestra un producto específico
        $producto = Producto::find($id);

        if (!$producto) {
            return response()->json(['error' => 'Producto no encontrado'], 404);
        }

        return response()->json($producto);
    }

    public function crear(Request $request)
    {
        // Crea un nuevo producto (requiere autenticación)
        $datos = $request->only('nombre', 'precio', 'descripcion');

        $producto = Producto::create($datos);

        return response()->json([
            'mensaje' => 'Producto creado exitosamente',
            'producto' => $producto,
        ], 201);
    }
}

En este caso, el constructor del ProductoController aplica el middleware jwt.auth a todos los métodos excepto index y mostrar, permitiendo que usuarios no autenticados puedan ver la lista y detalles de productos, pero restringiendo la creación y modificación a usuarios autenticados.

Es común verificar permisos o roles dentro de los controladores para implementar autorización adicional. Accediendo al usuario autenticado, se pueden comprobar sus atributos antes de permitir ciertas acciones. Por ejemplo, para restringir la eliminación de productos solo a usuarios con rol de administrador:

public function eliminar($id)
{
    $usuario = auth()->user();

    if ($usuario->rol !== 'admin') {
        return response()->json(['error' => 'Acceso no autorizado'], 403);
    }

    $producto = Producto::find($id);

    if (!$producto) {
        return response()->json(['error' => 'Producto no encontrado'], 404);
    }

    $producto->delete();

    return response()->json(['mensaje' => 'Producto eliminado correctamente']);
}

Aquí, antes de eliminar el producto, se verifica que el usuario tenga el rol adecuado. Esto añade una capa de seguridad en el controlador y garantiza que solo usuarios autorizados puedan realizar ciertas operaciones.

Para permitir que un usuario autenticado actualice su propia información, se puede implementar un método en el controlador que gestione dicha acción. Por ejemplo:

public function actualizarPerfil(Request $request)
{
    $usuario = auth()->user();

    $datos = $request->only('nombre', 'email', 'password');

    $validator = Validator::make($datos, [
        'nombre' => 'string|max:255',
        'email' => 'email|unique:users,email,' . $usuario->id,
        'password' => 'string|min:6|confirmed',
    ]);

    if ($validator->fails()) {
        return response()->json(['error' => 'Datos inválidos', 'errores' => $validator->errors()], 422);
    }

    if (isset($datos['password'])) {
        $datos['password'] = Hash::make($datos['password']);
    } else {
        unset($datos['password']);
    }

    $usuario->update($datos);

    return response()->json([
        'mensaje' => 'Perfil actualizado correctamente',
        'usuario' => $usuario,
    ]);
}

En este método, se validan los datos proporcionados por el usuario y se actualiza su perfil. Es esencial utilizar Hash::make para cifrar la nueva contraseña si se proporciona, manteniendo así las buenas prácticas de seguridad.

Para gestionar el cierre de sesión y anular el token JWT del usuario, se puede agregar un método logout en el controlador:

public function logout()
{
    try {
        auth()->logout();

        return response()->json(['mensaje' => 'Sesión cerrada exitosamente']);
    } catch (\Exception $e) {
        return response()->json(['error' => 'Error al cerrar sesión'], 500);
    }
}

Este método invalida el token actual mediante auth()->logout(), lo que impide su uso posterior. Proporcionar una ruta de cierre de sesión es una práctica recomendada para manejar el ciclo de vida de la sesión del usuario en la API.

En algunos casos, es útil que el servidor envíe un nuevo token en cada respuesta para mantener la sesión activa sin requerir acciones adicionales por parte del cliente. Esto se puede lograr generando un nuevo token y añadiéndolo a los encabezados de la respuesta:

public function algunaAccion(Request $request)
{
    // Lógica del método

    // Generar un nuevo token
    $nuevoToken = auth()->refresh();

    return response()->json([
        'datos' => $datosResultado,
    ])->header('Authorization', 'Bearer ' . $nuevoToken);
}

Así, el cliente recibe un token actualizado con cada solicitud, manteniendo la sesión sin interrupciones y mejorando la experiencia del usuario.

Es importante gestionar adecuadamente las excepciones que puedan surgir al utilizar autenticación JWT en los controladores. Por ejemplo, si se intenta acceder al usuario autenticado y el token es inválido o ha expirado, se puede capturar la excepción correspondiente:

public function accionProtegida()
{
    try {
        $usuario = auth()->userOrFail();

        // Lógica del método con el usuario autenticado

    } catch (\PHPOpenSourceSaver\JWTAuth\Exceptions\UserNotDefinedException $e) {
        return response()->json(['error' => 'Usuario no autenticado'], 401);
    }
}

Al utilizar userOrFail(), se lanza una excepción si no hay un usuario autenticado, lo que permite manejar el error y proporcionar una respuesta coherente al cliente.

Si en el token JWT se han incluido claims personalizadas, estas pueden ser utilizadas en el controlador para tomar decisiones basadas en esa información. Por ejemplo:

public function accesoPersonalizado()
{
    $payload = auth()->payload();

    if ($payload->get('clave_especial') !== 'valor_permitido') {
        return response()->json(['error' => 'Acceso denegado por clave especial'], 403);
    }

    // Lógica del método si la clave especial coincide

    return response()->json(['mensaje' => 'Acceso concedido']);
}

Mediante auth()->payload(), se accede a las claims del token, permitiendo verificar valores personalizados y controlar el flujo de la aplicación en función de ellos.

Estos ejemplos demuestran cómo integrar la autenticación JWT en los controladores de Laravel para gestionar operaciones comunes en una API REST. Al aprovechar las funcionalidades proporcionadas por el paquete JWT y las herramientas nativas de Laravel, es posible construir aplicaciones seguras y eficientes.

Manejo de la caducidad y buenas prácticas

El manejo de la caducidad de los tokens JWT es un aspecto crítico para garantizar tanto la seguridad como la experiencia del usuario en una API REST. Establecer un tiempo de vida adecuado para los tokens es fundamental para minimizar el riesgo de accesos no autorizados en caso de que un token sea comprometido.

En Laravel, la configuración de la expiración de los tokens se realiza en el archivo config/jwt.php, donde la clave ttl (time to live) determina la duración del token en minutos. Por ejemplo, para establecer una caducidad de una hora:

'ttl' => env('JWT_TTL', 60),

Es recomendable encontrar un equilibrio entre un tiempo de vida corto, que aumenta la seguridad al reducir la ventana de oportunidad para el uso indebido de un token, y un tiempo de vida más largo, que mejora la usabilidad al reducir la frecuencia con la que el usuario debe autenticarse de nuevo.

Para manejar la expiración de tokens sin afectar negativamente la experiencia del usuario, es común implementar mecanismos de renovación automática. Una estrategia es utilizar el middleware jwt.refresh, que intenta refrescar el token expirado y proporciona uno nuevo en la respuesta. Esto permite mantener sesiones de usuario sin interrupciones, siempre y cuando el token no haya excedido el tiempo máximo de renovación definido por refresh_ttl.

El parámetro refresh_ttl en config/jwt.php especifica el periodo máximo, en minutos, durante el cual un token puede ser renovado:

'refresh_ttl' => env('JWT_REFRESH_TTL', 20160), // 14 días por defecto

Una buena práctica es establecer un ttl relativamente corto, como 15 minutos, y un refresh_ttl más largo, como varios días. De esta manera, si el token actual expira, el usuario no se ve obligado a iniciar sesión nuevamente siempre y cuando el periodo de renovación no haya expirado.

Es fundamental también considerar la seguridad en el almacenamiento y transmisión de los tokens JWT. Algunas recomendaciones incluyen:

• Almacenar el token de forma segura en el cliente, por ejemplo, en la memoria de la aplicación o en Almacenamiento Seguro en dispositivos móviles. Evitar el almacenamiento en localStorage o sessionStorage, ya que pueden ser susceptibles a ataques XSS.
• Utilizar siempre HTTPS para todas las comunicaciones, garantizando que los tokens no sean interceptados por terceros a través de ataques de tipo Man-in-the-Middle.
• Evitar incluir información sensible en el payload del token, ya que, aunque el token esté firmado, su contenido no está cifrado y puede ser decodificado fácilmente.
• Implementar control de origen con CORS apropiadamente configurado, permitiendo únicamente solicitudes desde dominios de confianza.

En caso de que se requiera invalidar un token antes de su expiración natural, por ejemplo, al detectar actividad sospechosa, es necesario implementar un mecanismo adicional. Como JWT es sin estado por naturaleza, el servidor no almacena información sobre tokens emitidos o revocados. Una solución es mantener una lista negra (blacklist) de tokens invalidos, o bien usar un enfoque de listas blancas (whitelists).

Para implementar una lista negra, se puede utilizar la configuración blacklist_enabled en config/jwt.php:

'blacklist_enabled' => env('JWT_BLACKLIST_ENABLED', true),

Al habilitar esta opción, el paquete JWT almacenará en caché los tokens que se invalidan al realizar operaciones como logout o invalidate. Es importante configurar adecuadamente el sistema de caché de Laravel para que funcione de manera eficiente.

Otra práctica recomendada es rotar las claves secretas utilizadas para firmar los tokens de manera periódica. Esto aumenta la seguridad al limitar la cantidad de tokens que podrían ser válidos en caso de que una clave sea comprometida. Sin embargo, la rotación de claves debe manejarse cuidadosamente para evitar invalidar todos los tokens activos inesperadamente.

Adicionalmente, es esencial manejar correctamente los errores relacionados con la caducidad de los tokens en la API. Cuando un token ha expirado, la API debe responder con un código de estado HTTP adecuado, como 401 Unauthorized, y un mensaje claro que indique que el token es inválido o ha expirado.

Implementar la funcionalidad de logout es otra consideración importante. Al permitir que el usuario cierre su sesión, se debe invalidar el token actual para prevenir su uso posterior. Esto se logra utilizando el método invalidate del paquete JWT:

public function logout()
{
    try {
        auth()->invalidate();

        return response()->json(['mensaje' => 'Sesión cerrada correctamente']);
    } catch (\Exception $e) {
        return response()->json(['error' => 'No se pudo cerrar la sesión'], 500);
    }
}

Es crucial manejar las excepciones y proporcionar retroalimentación útil al cliente en caso de fallos.