# Autenticación

# Introducción

TIP

¿Quieres comenzar rápido? Instala el paquete de Composer laravel/ui y ejecuta php artisan ui vue --auth en una nueva aplicación de Laravel. Luego de migrar tu base de datos, dirígete en tu navegador a http://tu-app.test/register o cualquier otra URL asignada a tu aplicación. ¡Estos dos comandos se encargarán de generar todo el sistema de autenticación!

Laravel hace la implementación de la autenticación algo muy sencillo. De hecho, casi todo se configura para ti por defecto. El archivo de configuración de la autenticación está localizado en config/auth.php, el cual contiene varias opciones bien documentadas para ajustar el comportamiento de los servicios de autenticación.

En esencia, las características de la autenticación de Laravel están compuestas de "guards" (guardias) y "providers" (proveedores). Los Guards definen cómo los usuarios son autenticados para cada petición. Por ejemplo, Laravel contiene un guard session el cual mantiene el estado utilizando el almacenamiento de sesión y las cookies.

Los proveedores definen cómo se retornan los usuarios de tu almacenamiento persistente. Laravel cuenta con soporte para recuperar los usuarios utilizando Eloquent y el constructor de consultas de la base de datos. Sin embargo, eres libre de definir los proveedores adicionales que requiera tu aplicación.

¡No te preocupes si esto suena confuso por el momento! Muchas aplicaciones nunca necesitarán modificar la configuración predeterminada de la autenticación.

# Consideraciones de la base de datos

De manera predeterminada, Laravel incluye un Modelo de Eloquent App\User en tu directorio app. Este modelo puede ser utilizado por el controlador de autenticación predeterminado de Eloquent. Si tu aplicación no utiliza Eloquent, deberás utilizar el controlador de autenticación database el cual utiliza el constructor de consultas (query builder) de Laravel.

Al crear el esquema de la base de datos para el modelo App\User, asegúrate de que la columna password sea de al menos 60 caracteres de longitud. Mantener una longitud de columna de cadena predeterminada a 255 caracteres sería una buena opción.

Además, debes verificar que tu tabla users (o equivalente) contenga un campo nulo de tipo cadena llamado remember_token de 100 caracteres. Esta columna se usará para almacenar un token para los usuarios que seleccionen la opción "remember me" (recuérdame) cuando inicien sesión en tu aplicación.

# Inicio rápido de autenticación

Laravel viene con varios controladores de autenticación preconstruidos, los cuales están localizados en el nombre de espacio App\Http\Controllers\Auth. RegisterController maneja el registro de usuarios nuevos, LoginController maneja la autenticación, ForgotPasswordController maneja el envío de correos electrónicos para restablecer la contraseña y el ResetPasswordController contiene la lógica para reiniciar contraseñas. Cada uno de estos controladores utiliza un trait para incluir los métodos necesarios. En la mayoría de los casos no tendrás que modificar estos controladores en lo absoluto.

# Enrutamiento

El paquete de Laravel laravel/ui proporciona una manera rápida de generar todas las rutas y vistas que necesitas para la autenticación con unos simples comando:

composer require laravel/ui --dev
php artisan ui vue --auth

Este comando debe ser utilizado en aplicaciones nuevas e instalará vistas de diseño, registro e inicio de sesión, así como todas las rutas necesarias para la autenticación. También será generado un HomeController que se encargará de manejar las peticiones posteriores al login, como mostrar el dashboard de la aplicación.

TIP

Si tu aplicación no necesita registro, puedes desactivarlo eliminando el recién creado RegisterController y modificando tu declaración de ruta: Auth::routes(['register' => false]);.

# Vistas

Como se mencionó en la sección anterior, el comando php artisan ui vue --auth del paquete laravel/ui creará todas las vistas que se necesiten para la autenticación y las colocará en el directorio resources/views/auth.

El comando ui también creará el directorio resources/views/layouts, el cual contendrá la plantilla base para tu aplicación. Todas estas vistas usan el framework de CSS Bootstrap, pero eres libre de modificarlo en base a tus preferencias.

# Autenticación

Ahora que ya tienes tus rutas y vistas configuradas para los controladores de autenticación incluidos con el framework, ¡estás listo para registrar y autenticar usuarios nuevos para tu aplicación! Puedes acceder a tu aplicación en el navegador ya que los controladores de autenticación contienen la lógica (a través de traits) para autenticar usuarios existentes y almacenar usuarios nuevos en la base de datos.

# Personalizar rutas

Cuando un usuario se ha autenticado exitosamente, será redirigido a la URI /home. Puedes personalizar la ubicación de redireccionamiento post-autenticación definiendo una propiedad redirectTo en LoginController, RegisterController, ResetPasswordController y VerificationController:

protected $redirectTo = '/';

Luego, debes modificar el método handle del middleware RedirectIfAuthenticated para usar tu nueva URI al redirigir al usuario.

Si la ruta de redireccionamiento necesita generar lógica personalizada puedes definir un método redirectTo en lugar de una propiedad redirectTo:

protected function redirectTo()
{
    return '/path';
}

TIP

El método redirectTo toma precedencia sobre la propiedad redirectTo.

# Personalizar usuario

Por defecto, Laravel utiliza el campo email para la autenticación. Si deseas modificar esto, puedes definir un método username en LoginController:

public function username()
{
    return 'username';
}

# Personalizar guard

También puedes personalizar el "guard" que es utilizado para autenticar y registrar usuarios. Para empezar, define un método guard en LoginController, RegisterController y ResetPasswordController. Este método debe devolver una instancia de guard:

use Illuminate\Support\Facades\Auth;

protected function guard()
{
    return Auth::guard('guard-name');
}

# Validación / Personalizar almacenamiento

Para modificar los campos del formulario que son requeridos cuando se registren usuarios nuevos en tu aplicación, o para personalizar cómo los nuevos usuarios son almacenados en tu base de datos, puedes modificar la clase RegisterController. Esta clase es responsable de validar y crear usuarios nuevos en tu aplicación.

El método validator de RegisterController contiene las reglas de validación para los usuarios nuevos de tu aplicación. Eres libre de modificar este método según te convenga.

El método create de RegisterController es responsable de crear registros nuevos de App\User en tu base de datos usando el ORM Eloquent. Eres libre de modificar este método de acuerdo a las necesidades de tu base de datos.

# Retornando el usuario autenticado

Puedes acceder al usuario autenticado por medio del facade Auth:

use Illuminate\Support\Facades\Auth;

// Get the currently authenticated user...
$user = Auth::user();

// Get the currently authenticated user's ID...
$id = Auth::id();

Alternativamente, una vez que el usuario haya sido autenticado, puedes aceder al usuario autenticado mediante una instancia de Illuminate\Http\Request. Recuerda que las clases a las cuales se le declaren el tipo serán inyectadas automáticamente en los métodos de tu controlador:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ProfileController extends Controller
{
    /**
        * Update the user's profile.
        *
        * @param  Request  $request
        * @return Response
        */
    public function update(Request $request)
    {
        // $request->user() returns an instance of the authenticated user...
    }
}

# Determinar si el usuario actual está autenticado

Para determinar si el usuario actual está loggeado en tu aplicación, puedes usar el método check del facade Auth, el cual devolverá true si el usuario está autenticado:

use Illuminate\Support\Facades\Auth;

if (Auth::check()) {
    // The user is logged in...
}

TIP

Aún cuando es posible determinar si un usuario está autenticado utilizando el método check, típicamente deberás usar un middleware para verificar que el usuario está autenticado antes de permitir al usuario acceder a ciertas rutas / controladores. Para aprender más acerca de esto, echa un vistazo a la documentación para proteger rutas.

# Proteger rutas

Puedes utilizar middleware de rutas para permitir acceder a ciertas rutas a los usuarios autenticados. Laravel incluye un middleware auth, el cual está definido en Illuminate\Auth\Middleware\Authenticate. Ya que este middleware está registrado en tu kernel HTTP, todo lo que necesitas hacer es adjuntar el middleware a la definición de la ruta:

Route::get('profile', function () {
    // Only authenticated users may enter...
})->middleware('auth');

Si estás utilizando controladores, puedes hacer una llamada al método middleware desde el constructor de tu controlador en lugar de adjuntarlo a la definición de la ruta:

public function __construct()
{
    $this->middleware('auth');
}

# Redireccionar usuarios no autenticados

Cuando el middleware auth detecta un usuario no autorizado, redirigirá al usuario a la ruta nombrada login. Puedes modificar este comportamiento actualizando la función redirectTo en tu archivo app/Http/Middleware/Authenticate.php:

/**
* Get the path the user should be redirected to.
*
* @param  \Illuminate\Http\Request  $request
* @return string
*/
protected function redirectTo($request)
{
    return route('login');
}

# Especificar un guard

Cuando adjuntes el middleware auth a una ruta, también puedes especificar cuál guard deberá ser utilizado para autenticar al usuario. El guard especificado deberá corresponder a una de las llaves en el arreglo guards del archivo de configuración auth.php:

public function __construct()
{
    $this->middleware('auth:api');
}

# Regulación De Inicio De Sesión

Si estás utilizando la clase LoginController incorporada en Laravel, el trait Illuminate\Foundation\Auth\ThrottlesLogins se encontrará incluído en tu controlador. De manera predeterminada, el usuario no será capaz de iniciar sesión durante un minuto si falla al proveer las credenciales correctas después de varios intentos. El regulador (o throttle) es único para el nombre de usuario / dirección de correo electrónico del usuario y su dirección IP.

# Autenticar usuarios manualmente

Nota que no estás obligado a utilizar los controladores de autenticación incluidos en Laravel. Si deseas eliminar estos controladores, tendrás que encargarte de administrar la autenticación de usuarios utilizando las clases de autenticación de Laravel directamente. No te preocupes, ¡es algo sencillo!.

Vamos a acceder a los servicios de autenticación de Laravel por medio del facade, así que hay que asegurarnos de importar el facade Auth al inicio de la clase. Después, veamos el método attempt:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class LoginController extends Controller
{
    /**
    * Handle an authentication attempt.
    *
    * @param  \Illuminate\Http\Request $request
    *
    * @return Response
    */
    public function authenticate(Request $request)
    {
        $credentials = $request->only('email', 'password');

        if (Auth::attempt($credentials)) {
            // Authentication passed...
            return redirect()->intended('dashboard');
        }
    }
}

El método attempt acepta un arreglo de pares llave / valor como primer argumento. Los valores en el arreglo serán utilizados para encontrar el usuario en la tabla de tu base de datos. Así que, en el ejemplo anterior, el usuario se obtiene por el valor de la columna email. Si se encuentra el usuario, la contraseña encriptada obtenida de la base de datos será comparada con el valor password pasado al método en el arreglo. No debes encriptar la contraseña especificada para el valor password, ya que el framework automáticamente va a encriptarlo antes de compararlo con la contraseña almacenada en la base de datos. Si dos contraseñas encriptadas coinciden, se iniciará una sesión autenticada para el usuario.

El método attempt va a devolver true si la autenticación fue exitosa. De otra forma, devolverá false.

El método intended del redireccionador va a redirigir al usuario a la URL que intentaba acceder antes de ser interceptado por el middleware de autenticación. Una URI de fallback puede ser proporcionada al método en caso de que el destino solicitado no esté disponible.

# Especificar condiciones adicionales

Si lo deseas, puedes agregar condiciones extras a la consulta de autenticación además del correo electrónico del usuario y su contraseña. Por ejemplo, podemos verificar que un usuario esté marcado como "active":

if (Auth::attempt(['email' => $email, 'password' => $password, 'active' => 1])) {
    // The user is active, not suspended, and exists.
}

Nota

En estos ejemplos, email no es una opción requerida, solamente es utilizado como ejemplo. Debes utilizar cualquier columna que corresponda a "username" en tu base de datos.

# Acceso a instancias específicas de guard

Puedes especificar qué instancia de guard deseas usar utilizando el método guard en el facade Auth. Esto te permitirá administrar la autentincación para partes separadas de tu aplicación utilizando modelos autenticables o tablas de usuarios independientes.

El nombre del guard pasado al método guard deberá corresponder a uno de los guards configurados en tu archivo de configuración auth.php:

if (Auth::guard('admin')->attempt($credentials)) {
    //
}

# Cerrar sesión

Para desconectar usuarios de tu aplicación, debes utilizar el método logout del facade Auth. Esto va a borrar la información de autenticación en la sesión del usuario:

Auth::logout();

# Recordar usuarios

Si desea proporcionar la funcionalidad de "recordarme" en tu aplicación, puedes pasar un valor booleano como segundo argumento al método attempt, que mantendrá al usuario autenticado indefinidamente, o hasta que cierre su sesión manualmente. Tu tabla users deberá incluir una columna de tipo string llamada remember_token, que será utilizada para almacenar el token de "recordarme".

if (Auth::attempt(['email' => $email, 'password' => $password], $remember)) {
    // The user is being remembered...
}

TIP

Si estás utilizando el LoginController integrado en tu instalación de Laravel, la lógica apropiada para "recordar" usuarios ya se encontrará implementada por los traits utilizados por el controlador.

Si estás "recordando" usuarios, puedes utilizar el método viaRemember para determinar si el usuario se ha autenticado utilizando la cookie "recordarme":

if (Auth::viaRemember()) {
    //
}

# Otros métodos de autenticación

# Autenticar una instancia de usuario

Si necesitas registrar una instancia de usuario existente en tu aplicación, puedes llamar al método login con la instancia de usuario. El objeto proporcionado deberá ser una implementación de la interfaz Illuminate\Contracts\Auth\Authenticatable. El modelo App\User incluido en Laravel ya implementa esta interfaz:

Auth::login($user);

// Login and "remember" the given user...
Auth::login($user, true);

Puedes especificar la instancia de guard que desees utilizar:

Auth::guard('admin')->login($user);

# Autenticar un usuario por ID

Para autenticar un usuario en tu aplicación por su ID, debes usar el método loginUsingId. Este método acepta la clave primaria del usuario que deseas autenticar:

Auth::loginUsingId(1);

// Login and "remember" the given user...
Auth::loginUsingId(1, true);

# Autenticar un usuario una vez

Puedes utilizar el método once para autenticar un usuario en tu aplicación para una única solicitud. No se utilizarán sesiones o cookies, lo que significa que este método puede ser bastante útil al construir una API sin estado:

if (Auth::once($credentials)) {
    //
}

# Autenticación HTTP básica

La autenticación HTTP básica proporciona una manera rápida de autenticar usuarios en tu aplicación sin configurar una página de "login" dedicada. Para iniciar, adjunta el middleware auth.basic a tu ruta. El middleware auth.basic está incluido en el framework de Laravel, por lo que no hay necesidad de definirlo:

Route::get('profile', function () {
    // Only authenticated users may enter...
})->middleware('auth.basic');

Una vez que el middleware haya sido adjuntado a la ruta, se preguntará automáticamente por las credenciales al acceder a la ruta desde tu navegador. Por defecto, el middleware auth.basic va a usar la columna email en el registro del usuario como "nombre de usuario".

# Una nota sobre FastCGI

Si estás usando PHP FastCGI, la Autentincación Básica HTTP podría no funcionar correctamente por defecto. Las siguientes líneas deberán ser agregadas a tu archivo .htaccess:

RewriteCond %{HTTP:Authorization} ^(.+)$
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

# Autenticación HTTP básica sin estado

También puedes utilizar la Autenticación HTTP Básica sin establecer una cookie de identificación en la sesión, esto es particularmente útil para la autenticacíon API. Para hacer esto define un middleware que llame al método onceBasic. Si el método no devuelve ninguna respuesta, la petición puede pasarse a la aplicación:

<?php

namespace App\Http\Middleware;

use Illuminate\Support\Facades\Auth;

class AuthenticateOnceWithBasicAuth
{
    /**
    * Handle an incoming request.
    *
    * @param  \Illuminate\Http\Request  $request
    * @param  \Closure  $next
    * @return mixed
    */
    public function handle($request, $next)
    {
        return Auth::onceBasic() ?: $next($request);
    }

}

A continuación registra el middleware de ruta y adjúntalo a la ruta:

Route::get('api/user', function () {
    // Only authenticated users may enter...
})->middleware('auth.basic.once');

# Logging Out

Para cerrar manualmente la sesión de un usuario en tu aplicación, puedes usar el método logout en el facade Auth. Esto limpiará la información de autenticación en la sesión del usuario:

use Illuminate\Support\Facades\Auth;

Auth::logout();

# Invalidando sesiones en otros dispositivos

Laravel también proporciona un mecanismo para invalidar y "sacar" las sesiones de un usuario que están activas en otros dispositivos sin invalidar la sesión en el dispositivo actual. Antes de comenzar, debes asegurarte de que el middleware Illuminate\Session\Middleware\AuthenticateSession está presente y no está comentado en tu clase app/Http/Kernel.php del grupo de middleware web:

'web' => [
    // ...
    \Illuminate\Session\Middleware\AuthenticateSession::class,
    // ...
]

Luego, puedes usar el método logoutOtherDevices en el facade Auth. Este método requiere que el usuario proporcione su contraseña actual, que tu aplicación debe aceptar mediante un campo de formulario:

use Illuminate\Support\Facades\Auth;

Auth::logoutOtherDevices($password);

Nota

Cuando el método logoutOtherDevices es invocado, las otras sesiones del usuario serán invalidadas completamente, lo que quiere decir que serán "sacadas" de todos los guards en los que previamente estaban autenticadas.

# Agregar guards personalizados

Puedes definir tu propio guard de autenticación utilizando el método extend en el facade Auth. Debes colocar la llamada a este método extend en el proveedor de servicios. Ya que Laravel cuenta con un AuthServiceProvider, puedes colocar el código en ese proveedor:

<?php

namespace App\Providers;

use App\Services\Auth\JwtGuard;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Auth;

class AuthServiceProvider extends ServiceProvider
{
    /**
    * Register any application authentication / authorization services.
    *
    * @return void
    */
    public function boot()
    {
        $this->registerPolicies();

        Auth::extend('jwt', function ($app, $name, array $config) {
            // Return an instance of Illuminate\Contracts\Auth\Guard...

            return new JwtGuard(Auth::createUserProvider($config['provider']));
        });
    }
}

Como puedes ver en el ejemplo anterior, el callback pasado al método extend deberá retornar una implementación de Illuminate\Contracts\Auth\Guard. Esta interfaz contiene algunos métodos que tendrás que implementar para definir un guard personalizado. Una vez que tu guard personalizado haya sido definido, podrás utilizar este guard en la configuración guards de tu archivo de configuración auth.php:

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

# Guards de closures de peticiones

La forma más sencilla de implementar un sistema de autenticación basado en peticiones HTTP es usando el método Auth:viaRequest. Este método te permite definir rápidamente tu proceso de autenticación usando sólo un Closure.

Para comenzar, llama al método Auth::viaRequest dentro del método boot de tu AuthServiceProvider. El método viaRequest acepta el nombre de un driver de autenticación como su primer argumento. Este nombre puede ser cualquier cadena que describa tu guard personalizado. El segundo argumento pasado al método debe ser un Closure que reciba la petición HTTP entrante y retorne una instancia de usuario o, si la autenticación falla, null:

use App\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

/**
* Register any application authentication / authorization services.
*
* @return void
*/
public function boot()
{
    $this->registerPolicies();

    Auth::viaRequest('custom-token', function ($request) {
        return User::where('token', $request->token)->first();
    });
}

Una vez que tu driver de autenticación personalizado ha sido definido, úsalo como un driver dentro de la configuración de guards de tu archivo de configuración auth.php:

'guards' => [
    'api' => [
        'driver' => 'custom-token',
    ],
],

# Agregar proveedores de usuario personalizados

Si no estás utilizando una base de datos relacional tradicional para almacenar a tus usuarios, deberás extender Laravel con tu propio proveedor de autenticación. Usaremos el método provider en el facade Auth para definir un proveedor de usuarios personalizado:

<?php

namespace App\Providers;

use App\Extensions\RiakUserProvider;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Auth;

class AuthServiceProvider extends ServiceProvider
{
    /**
    * Register any application authentication / authorization services.
    *
    * @return void
    */
    public function boot()
    {
        $this->registerPolicies();

        Auth::provider('riak', function ($app, array $config) {
            // Return an instance of Illuminate\Contracts\Auth\UserProvider...

            return new RiakUserProvider($app->make('riak.connection'));
        });
    }
}

Después de haber registrado el proveedor utilizando el método provider, puedes cambiar al nuevo proveedor de usuarios en tu archivo de configuración auth.php. Primero, define un provider que utilice tu nuevo controlador:

'providers' => [
    'users' => [
        'driver' => 'riak',
    ],
],

Finalmente, puedes utilizar este proveedor en tu configuración de guards:

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
],

# La interfaz UserProvider

Las implementaciones Illuminate\Contracts\Auth\UserProvider son responsables solamente de obtener una implementación de Illuminate\Contracts\Auth\Authenticatable desde un sistema de almacenamiento persistente, como MySQL, Riak, etc. Estas dos interfaces permiten a los mecanismos de autenticación de Laravel continuar funcionando independientemente de cómo esté almacenada la información del usuario o qué tipo de clase es utilizado para representarlo.

Echemos un vistaso a la interfaz Illuminate\Contracts\Auth\UserProvider:

<?php

namespace Illuminate\Contracts\Auth;

interface UserProvider 
{
    public function retrieveById($identifier);
    public function retrieveByToken($identifier, $token);
    public function updateRememberToken(Authenticatable $user, $token);
    public function retrieveByCredentials(array $credentials);
    public function validateCredentials(Authenticatable $user, array $credentials);
}

La función retrieveById generalmente recibe una clave que representa al usuario, como un ID auto-incrementable de una base de datos MySQL. La implementación Authenticatable que coincida con el ID deberá ser recuperado y retornado por el método.

La función retireveByToken recupera un usuario por su $identifier único y su $token "recordar datos", almacenados en el campo remember_token. Como en el método anterior, la implementación Authenticatable deberá ser retornado.

El método updateRememberToken actualiza el campo $user y remember_token con el nuevo $token. Un nuevo token es asignado en un inicio de sesión con "recordar datos" o cuando el usuario cierre su sesión.

El método retrieveByCredentials recupera el arreglo de credenciales pasadas al método Auth::attempt cuando intenta loguearse a la aplicación. El método "consulta" el almacenamiento persistente en busca de las credenciales que coincidan con las del usuario. Típicamente, este método va a ejecutar una consulta con una condición "where" en $credentials['username']. El método deberá retornar una implementación de Authenticatable. Este método no debe intentar realizar ninguna validación o autenticación por contraseña.

El método validateCredentials deberá comparar el $user proporcionado con sus $credentials para autenticar el usuario. Por ejemplo, este método puede utilizar Hash::check para comparar los valores de $user->getAuthPassword() al valor de $credentials['password']. Este método deberá retornar true o false indicando si la contraseña es válida o no.

# La interfaz Authenticatable

Ahora que hemos explorado cada uno de los métodos en UserProvider, vamos a echar un vistazo a la interfaz Authenticatable. Recuerda, el proveedor deberá retornar implementaciones de esta interfaz desde los métodos retrieveById, retrieveByToken y retrieveByCredentials:

<?php

namespace Illuminate\Contracts\Auth;

interface Authenticatable 
{
    public function getAuthIdentifierName();
    public function getAuthIdentifier();
    public function getAuthPassword();
    public function getRememberToken();
    public function setRememberToken($value);
    public function getRememberTokenName();
}

Esta interfaz es simple. El método getAuthIdentifierName debe retornar el nombre del campo "clave primaria" del usuario y el método getAuthIdentifier deberá retornar la "clave primaria" del usuario. En un backend MySQL, nuevamente, esto deberá ser la clave auto-incrementable. El método getAuthPassword deberá retornar la contraseña encriptada del usuario. Esta interfaz permite que el sistema de autenticación funcione con cualquier clase de usuario, independientemente de qué capa de abstracción o qué ORM se está utilizando. Por defecto, Laravel incluye una clase User en el directorio app que implementa esta interfaz, por lo que puedes consultar esta clase para obtener un ejemplo de implementación.

# Eventos

Laravel genera una variedad de eventos durante el proceso de autenticación. Puedes adjuntar listeners a estos eventos en tu EventServiceProvider:

/**
* The event listener mappings for the application.
*
* @var array
*/
protected $listen = [
    'Illuminate\Auth\Events\Registered' => [
        'App\Listeners\LogRegisteredUser',
    ],

    'Illuminate\Auth\Events\Attempting' => [
        'App\Listeners\LogAuthenticationAttempt',
    ],

    'Illuminate\Auth\Events\Authenticated' => [
        'App\Listeners\LogAuthenticated',
    ],

    'Illuminate\Auth\Events\Login' => [
        'App\Listeners\LogSuccessfulLogin',
    ],

    'Illuminate\Auth\Events\Failed' => [
        'App\Listeners\LogFailedLogin',
    ],

    'Illuminate\Auth\Events\Logout' => [
        'App\Listeners\LogSuccessfulLogout',
    ],

    'Illuminate\Auth\Events\Lockout' => [
        'App\Listeners\LogLockout',
    ],

    'Illuminate\Auth\Events\PasswordReset' => [
        'App\Listeners\LogPasswordReset',
    ],
];