Una guía completa para la autenticación de Laravel

La autenticación es una de las características más críticas y esenciales de las aplicaciones web. Los marcos web como Laravel brindan muchas formas para que los usuarios se autentiquen.

Puede implementar las funciones de autenticación de Laravel de forma rápida y segura. Sin embargo, la implementación deficiente de estas funciones de autenticación puede ser riesgosa, ya que las partes malintencionadas pueden explotarlas.

Esta guía le enseñará todo lo que necesita saber para comenzar con los métodos de autenticación de Laravel elegidos.

¡Sigue leyendo!

Una introducción a la autenticación de Laravel

Laravel presenta módulos que se componen de "guardias" y "proveedores". Los guardias definen la autenticación del usuario para cada solicitud y los proveedores definen la recuperación del usuario desde el almacenamiento persistente (por ejemplo, la base de datos MySQL).

Definimos nuestros parámetros de autenticación en un archivo llamado config/auth.php . Incluye varias opciones para ajustar y modificar el comportamiento de autenticación de Laravel.

Primero, debe definir los valores predeterminados de autenticación. Esta opción controla las opciones de "protección" y restablecimiento de contraseña de autenticación predeterminada de su aplicación. Puede cambiar estos valores predeterminados según sea necesario, pero son un comienzo perfecto para la mayoría de las aplicaciones.

A continuación, defina protecciones de autenticación para su aplicación. Aquí, nuestra configuración predeterminada utiliza el almacenamiento de sesiones y el proveedor de usuarios de Eloquent. Todos los controladores de autenticación tienen un proveedor de usuarios.

 return [ /* Defining Authentication Defaults */ 'defaults' => [ 'guard' => 'web', 'passwords' => 'users', ], /* Defining Authentication Guards Supported: "session" */ 'guards' => [ 'web' => [ 'driver' => 'session', 'provider' => 'users', ], ], /* Defining User Providers Supported: "database", "eloquent" */ 'providers' => [ 'users' => [ 'driver' => 'eloquent', 'model' => App\Models\User::class, ], // 'users' => [ // 'driver' => 'database', // 'table' => 'users', // ], ], /* Defining Password Resetting */ 'passwords' => [ 'users' => [ 'provider' => 'users', 'table' => 'password_resets', 'expire' => 60, 'throttle' => 60, ], ], /* Defining Password Confirmation Timeout */ 'password_timeout' => 10800, ];

Más tarde, nos aseguramos de que todos los controladores de autenticación tengan un proveedor de usuarios. Esto define cómo se recuperan los usuarios de su base de datos u otros mecanismos de almacenamiento para conservar los datos de su usuario. Puede configurar varias fuentes que representen cada modelo o tabla si tiene varias tablas o modelos de usuario. Estas fuentes se pueden asignar a cualquier guardia de autenticación adicional que haya definido.

Los usuarios también pueden querer restablecer sus contraseñas. Para esto, puede especificar múltiples configuraciones de restablecimiento de contraseña si tiene más de una tabla o modelo de usuario en la aplicación y desea configuraciones separadas basadas en tipos de usuarios específicos. El tiempo de caducidad es la cantidad de minutos que cada token de reinicio será válido. Esta característica de seguridad hace que los tokens duren poco tiempo, por lo que tienen menos tiempo para ser adivinados. Puede cambiar esto según sea necesario.

En última instancia, debe definir el tiempo antes de que se agote el tiempo de confirmación de la contraseña, y se le pedirá al usuario que vuelva a ingresar su contraseña a través de la pantalla de confirmación. De forma predeterminada, el tiempo de espera dura tres horas.

Tipos de métodos de autenticación de Laravel

No existe una manera perfecta de autenticar todos los escenarios, pero conocerlos lo ayudará a tomar mejores decisiones. Esto y cómo Laravel está evolucionando con las nuevas funciones en Laravel 9. Esto hace que nuestro trabajo como desarrolladores sea mucho más fácil al cambiar los modos de autenticación.

Autenticación basada en contraseña

Como una forma rudimentaria de autenticar a un usuario, todavía lo utilizan miles de organizaciones, pero considerando el desarrollo actual, claramente se está volviendo obsoleto.

Los proveedores deben hacer cumplir implementaciones de contraseñas complejas al tiempo que garantizan una fricción mínima para el usuario final.

Funciona bastante sencillo, el usuario ingresa el nombre y la contraseña, y si en la base de datos hay una coincidencia entre esos dos, el servidor decide autenticar la solicitud y permitir que el usuario acceda a los recursos durante un tiempo predefinido.

Autenticación basada en token

Esta metodología se utiliza cuando al usuario se le emite un token único tras la verificación.

Con este token, ahora el usuario puede acceder a los recursos relevantes. El privilegio está activo hasta que caduca el token.

Mientras el token está activo, el usuario no tiene que usar ningún nombre de usuario o contraseña, pero al recuperar un nuevo token, se requieren esos dos.

Los tokens se usan ampliamente en múltiples escenarios hoy en día, ya que son entidades sin estado que contienen todos los datos de autenticación.

Proporcionar una forma de separar la generación de tokens de la verificación de tokens brinda a los proveedores mucha flexibilidad.

Autenticación de múltiples factores

Como sugiere el nombre, implica usar al menos dos factores de autenticación, elevando la seguridad que brinda.

A diferencia de la autenticación de dos factores que involucra solo dos factores, este método puede involucrar dos, tres, cuatro y más...

La implementación típica de este método implica el uso de una contraseña, después de lo cual se envía al usuario un código de verificación en su teléfono inteligente. Los proveedores que implementen este método deben buscar falsos positivos e interrupciones de la red, que pueden convertirse en grandes problemas mientras se amplían rápidamente.

Cómo implementar la autenticación de Laravel

Esta sección le enseñará varias formas de autenticar a los usuarios de su aplicación. Algunas bibliotecas como Jetstream, Breeze y Socialite tienen tutoriales gratuitos sobre cómo usarlas.

Autenticación manual

Comenzando con el registro de usuarios y la creación de las rutas necesarias en routes/web.php .

Crearemos dos rutas, una para ver el formulario y otra para registrarse:

 use App\Http\Contrllers\Auth\RegisterController; use Illuminate\Support\Facades\Route; /* Web Routes Register web routes for your app's RouteServiceProvider in a group containing the "web" middleware */ Route::get('/register', [RegisterController::class], 'create']); Route::post('/register', [RegisterController::class], 'store']);

Y cree el controlador necesario para esos:

 php artisan make controller Auth/RegisterController -r

Ahora actualice el código de la siguiente manera:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use illuminate\Htpp\Request; class RegisterController extends Controller { public function create() { return view('auth.register'); } public function store(Request $request) { } }

El controlador está vacío ahora y devuelve una vista para registrarse. Hagamos esa vista en resources/views/auth y llamémosla register.blade.php .

Ahora con todo en su lugar, debemos visitar nuestra ruta /register y ver el siguiente formulario:

 public function store(Request $request) { $credentials = $request->only('email', 'password'); if (Auth::attempt($credentials, $request->filled('remember'))) { $request->session()->regenerate(); return redirect()->intended('/'); } return back()->withErrors([ 'email' => 'The provided credentials do not match our records.', ]); }

Ahora que podemos mostrar un formulario que un usuario puede completar y obtener los datos, debemos obtener los datos de los usuarios, validarlos y luego almacenarlos en la base de datos si todo está bien. Aquí debe usar una transacción de base de datos para asegurarse de que los datos que inserte estén completos.

Usaremos la función de validación de solicitudes de Laravel para garantizar que se requieran las tres credenciales. Tenemos que asegurarnos de que el correo electrónico tenga un formato de correo electrónico y sea único en la tabla users y que la contraseña esté confirmada y tenga un mínimo de 8 caracteres:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use Illuminate\Foundation\Auth\User; use Illuminate\Http\Request; use Illuminate\Support\Facades\Hash; class RegisterController extends Controller { public function store(Request $request) { /* Validation */ $request->validate([ 'name' => 'required', 'email' => 'required|email|unique:users', 'password' => 'required|confirmed|min:8', ]); /* Database Insert */ $user = User:;create([ 'name' => $request->name, 'email' => $request->email, 'password' => Hash::make($request->password), ]); return back(); } public function create() { return view('auth.register'); } }

Ahora que nuestra entrada está validada, cualquier cosa que vaya en contra de nuestra validación generará un error que se mostrará en el formulario:

Suponiendo que hemos creado una cuenta de usuario en el método store , también queremos iniciar sesión en el usuario. Hay dos formas en las que podemos hacerlo. Podemos hacerlo manualmente o usar la fachada Auth .

Después de que el usuario inicie sesión, no deberíamos regresarlo a la pantalla de registro, sino a una nueva página, como un tablero o una página de inicio. Eso es lo que vamos a hacer aquí:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use App\Providers\RouteServiceProvider; use Illuminate\Foundation\Auth\User; use Illuminate\Http\Request; use Illuminate\Support\Facades\Auth; use Illuminate\Support\Facades\Hash; class RegisterController extends Controller { public function store(Request $request) { /* Validation */ $request->validate([ 'name' => 'required', 'email' => 'required|email|unique:users', 'password' => 'required|confirmed|min:8', ]); /* Database Insert */ $user = User:;create([ 'name' => $request->name, 'email' => $request->email, 'password' => Hash::make($request->password), ]); Auth::login($user): return redirect(RouteServiceProvider::HOME); } public function create() { return view('auth.register'); } }

Y ahora que tenemos un usuario registrado y conectado -n , debemos asegurarnos de que pueda cerrar sesión de forma segura.

Laravel sugiere que invalidemos la sesión y regeneremos el token por seguridad después de cerrar sesión. Y esto es precisamente lo que vamos a hacer. Comenzamos creando una nueva ruta /logout usando el método destroy de LogoutController :

 use App\Http\Controllers\Auth\RegisterController; use App\Http\Controllers\Auth\LogoutController; use Illuminate\Support\Facades\Route; /* Web Routes Here is where you can register web routes for your application. These routes are loaded by the RrouteServiceProvider with a group which contains the "web" middleware group. Now create something great! */ Route::get('/register', [RegisterController::class, 'create']); Route::post('/register', ['RegisterController::class, 'store']); Route::post('/logout', [Logoutcontroller::class, 'destroy']) ->middleware('auth');

Pasar el cierre de sesión a través del middleware "auth" es muy importante. Los usuarios no deberían poder acceder a la ruta si no han iniciado sesión.

Ahora, crea un controlador como lo hicimos antes:

 php artisan make:controller Auth/LogoutController -r

Podemos asegurarnos de obtener la solicitud como parámetro en el método destroy . Cerramos la sesión del usuario a través de la fachada Auth, invalidamos la sesión y, regeneramos el token, luego redirigimos al usuario a la página de inicio:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use Illuminate\Http\Request; use Illuminate\Support\Facades\Auth; class LogoutController extends Controller { public function destroy(Request $request) { Auth::logout(); $request->session()->invalidate(); $request->session()->regenerateToken(); return redirect('/'); } }

Recordando Usuarios

La mayoría de las aplicaciones web modernas, si no todas, proporcionan una casilla de verificación "recordarme" en su formulario de inicio de sesión.

Si queremos proporcionar una funcionalidad de "recuérdame", podemos pasar un valor booleano como segundo argumento al método de intento.

Cuando sea válido, Laravel mantendrá al usuario autenticado indefinidamente o hasta que se desconecte manualmente. La tabla de usuario debe incluir la columna de la cadena de texto remember_token (es por eso que regeneramos los tokens), donde almacenaremos nuestro token de "recordarme".

La migración por defecto para usuarios ya lo incluye.

Lo primero es lo primero, debe agregar el campo Recordarme a su formulario:

Y después de esto, obtenga las credenciales de la solicitud y utilícelas en el método de intento en la fachada Auth.

Si se debe recordar al usuario, lo iniciaremos y lo redirigiremos a nuestra página de inicio. De lo contrario, arrojaremos un error:

 public function store(Request $request) { $credentials = $request->only('email', 'password'); if (Auth::attempt($credentials, $request->filled('remember'))) { $request->session()->regenerate(); return redirect()->intended('/'); } return back()->withErrors([ 'email' =>

Restablecimiento de contraseñas

La mayoría de las aplicaciones web actuales brindan formas para que los usuarios restablezcan sus contraseñas.

Haremos otra ruta para la contraseña olvidada y crearemos el controlador como lo hicimos. Además, agregaremos una ruta para el enlace de restablecimiento de contraseña que contiene el token para todo el proceso:

 Route::post('/forgot-password', [ForgotPasswordLinkController::class, 'store']); Route::post('/forgot-password/{token}', [ForgotPasswordController::class, 'reset']);

Dentro del método de la tienda, tomaremos el correo electrónico de la solicitud y lo validaremos como lo hicimos.

Después de esto, podemos usar el método sendResetLink desde la fachada de la contraseña.

Y luego, como respuesta, queremos devolver el estado si tuvo éxito al enviar el enlace o errores de lo contrario:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use Illuminate\Http\Request; use Illuminate\Support\Facades\Password; class ForgotPasswordLinkController extends Controller { public function store(Request $request) { $request->validate([ 'email' => 'required|email', ]); $status = Password::sendResetLink( $request->only('email'); ); return $status === Password::RESET_LINK_SENT ? back()->with('status', __($status)) : back()->withInput($request->only('email'))->withErrors(['email' => __($status)]); } }

Ahora que el enlace de reinicio se ha enviado al correo electrónico del usuario, debemos ocuparnos de la lógica de lo que sucede después de eso.

Obtendremos el token, el correo electrónico y la nueva contraseña en la solicitud y los validaremos.

Después de esto, podemos usar el método de reinicio desde la fachada de la contraseña para dejar que Laravel se encargue de todo lo demás detrás de escena.

Siempre vamos a codificar la contraseña para mantenerla segura.

Al final, comprobaremos si se ha restablecido la contraseña y, en caso afirmativo, redirigiremos al usuario a la pantalla de inicio de sesión con un mensaje de éxito. De lo contrario, mostramos un error que no se pudo restablecer:

 namespace App\Http\Controllers\Auth; use App\Http\Controllers\Controller; use Illuminate\Http\Request; use Illuminate\Support\Facades\Hash; use Illuminate\Support\Facades\Password; use Illuminate\Support\Str; class ForgotPasswordController extends Controller { public function store(Request $request) { $request->validate([ 'token' => 'required', 'email' => 'required|email', 'password' => 'required|string|confirmed|min:8', ]); $status = Password::reset( $request->only('email', 'password', 'password_confirmation', 'token'), function ($user) use ($request) { $user->forceFill( 'password' => Hash::make($request->password), 'remember_token' => Str::random(60) ])->save(); } ); return $status == Password::PASSWORD_RESET ? redirect()->route('login')->with('status', __($status)) : back()->withInput($request->only('email'))->withErrors(['email' => __($status)]); } }

Brisa de Laravel

Laravel Breeze es una implementación simple de las funciones de autenticación de Laravel: inicio de sesión, registro, restablecimiento de contraseña, verificación de correo electrónico y confirmación de contraseña. Puede usarlo para implementar la autenticación en su nueva aplicación Laravel.

Instalación y configuración

Después de crear su aplicación Laravel, todo lo que tiene que hacer es configurar su base de datos, ejecutar sus migraciones e instalar el paquete laravel/breeze a través de composer:

 composer require laravel/breeze –dev

Después de esto, ejecuta lo siguiente:

 php artisan breeze:install

Que publicará sus vistas de autenticación, rutas, controladores y otros recursos que utiliza. Después de este paso, tienes el control total de todo lo que ofrece Breeze.

Ahora tenemos que renderizar nuestra aplicación en la interfaz, por lo que instalaremos nuestras dependencias JS (que usarán @vite):

 npm install

:

 npm run dev

Después de esto, los enlaces de inicio de sesión y registro deberían estar en su página de inicio, y todo debería funcionar sin problemas.

Corriente de chorro de Laravel

Laravel Jetstream amplía Laravel Breeze con características útiles y otras pilas de interfaz.

Proporciona inicio de sesión, registro, verificación de correo electrónico, autenticación de dos factores, gestión de sesiones, soporte de API a través de Sanctum y gestión de equipos opcional.

Debe elegir entre Livewire e Inertia en la interfaz al instalar Jetstream. En el backend, utiliza Laravel Fortify, que es un backend de autenticación "sin cabeza" independiente de la interfaz de usuario para Laravel.

Instalación y configuración

Lo instalaremos a través de composer en nuestro Proyecto Laravel:

 composer require laravel/jetstream

Después de esto, ejecutaremos el comando php artisan jetstream:install [stack] , que acepta los argumentos [stack] Livewire o Inertia . Puede pasar la opción –team para habilitar la función de equipos.

Esto también instalará Pest PHP para realizar pruebas.

Y finalmente, tenemos que renderizar la interfaz de nuestra aplicación usando lo siguiente:

 npm install npm run dev

Laravel Fortificar

Laravel Fortify es una implementación de autenticación de backend que es agnóstica de frontend. No tiene que usar Laravel Fortify para implementar las funciones de autenticación de Laravel.

También se usa en kits de inicio como Breeze y Jetstream. También puede usar Fortify independiente, que es solo una implementación de back-end. Si lo usa de forma independiente, su interfaz debe llamar a las rutas de Fortify.

Instalación y configuración

Podemos instalar Fortify a través de composer:

 composer require laravel/fortify

Ahora tenemos que publicar los recursos de Fortify:

 php artisan vendor:publish –provider="Laravel\Fortify\FortifyServiceProvider"

Después de esto, crearemos un nuevo directorio de aplicaciones/acciones además del nuevo FortifyServiceProvider , el archivo de configuración y las migraciones de bases de datos.

Finalmente, ejecuta:

 php artisan migrate

O:

 php artisan migrate:fresh

Y su Fortify está listo para usar.

Socialité de Laravel

Laravel incluye una sencilla función de autenticación de usuario basada en OAuth. Admite inicios de sesión sociales a través de Facebook, Twitter, LinkedIn, Google, Bitbucket, GitHub y GitLab.

Instalación

Podemos instalarlo a través de composer:

 composer require laravel/socialite

Configuración y uso

Después de haberlo instalado, debemos agregar las credenciales para el proveedor de OAuth que utiliza nuestra aplicación. Los agregaremos en config/services.php para cada servicio.

En la configuración, debemos hacer coincidir la clave con los servicios anteriores. Algunas de esas claves incluyen:

• Facebook
• Twitter (para OAuth 1.0)
• twitter-oauth-2 (para OAuth 2.0)
• Linkedin
• Google
• github
• gitlab
• bitbucket

Una configuración de servicio puede verse así:

 'google' => [ 'client_id' => env("GOOGLE_CLIENT_ID"), 'client_secret' => env("GOOGLE_CLIENT_SECRET"), 'redirect' => "http://example.com/callback-url", ],

Autenticación de usuarios

Para esta acción necesitaremos dos rutas, una para redirigir al usuario al proveedor de OAuth:

 use Laravel\Socialite\Facades\Sociliate; Route::get('/auth/redirect', function () { return Socialite:;driver('google')->redirect(); });

Y uno para la devolución de llamada del proveedor después de la autenticación:

 use Laravel\Socialite\Facades\Socialite; Route:;get('/auht/callback', function () { $user = Socialite:;driver('google')->user(); // Getting the user data $user->token; });

Socialite proporciona el método de redireccionamiento y la fachada redirige al usuario al proveedor de OAuth, mientras que el método de usuario examina la solicitud entrante y recupera la información del usuario.

Después de haber recibido nuestro usuario, debemos verificar si existe en nuestra base de datos y autenticarlo. Si no existe, crearemos un nuevo registro para representar al usuario:

 use App\Models\User; use Illuminate\Support\Facades\Auth; use Laravel\Socialite\Facades\Socialite; Route::get('/auth/callback', function () { /* Get the user */ $googleUser = Socialite::driver('google')->user(); /* Create the user if it does not exist Update the user if it exists Check for google_id in database */ $user = User::updateOrCreate([ 'google_id' => $googleUser->id, ], [ 'name' => $googleUser->name, 'email' => $googleUser->email, 'google_token' => $googleUser->token, 'google_refresh_token' => $googleUser->refreshToken, ]); /* Authenticates the user using the Auth facade */ Auth::login($user); return redirect('/dashboard'); });

Si queremos limitar los ámbitos de acceso del usuario, podemos utilizar el método scopes , que incluiremos con la solicitud de autenticación. Esto combinará todos los ámbitos especificados previamente con los especificados.

Una alternativa a esto es usar el método setScopes que sobrescribe cualquier otro ámbito existente:

 use Laravel\Socialite\Facades\Socialite; return Socialite::driver('google') ->scopes(['read:user', 'write:user', 'public_repo']) ->redirect(); return Socialite::driver('google') ->setScopes(['read:user', 'public_repo') ->redirect();

Ahora que sabemos todo y cómo obtener un usuario después de la devolución de llamada, veamos algunos de los datos que podemos obtener de él.

El usuario de OAuth1 tiene token y tokenSecret :

 $user = Socialite::driver('google')->user(); $token = $user->token; $tokenSecret = $user->tokenSecret;

OAuth2 proporciona token , refreshToken y expiresIn :

 $user = Socialite::driver('google')->user(); $token = $user->token; $refreshToken = $user->refreshToken; $expiresIn = $user->expiresIn;

Tanto OAuth1 como OAuth2 proporcionan getId , getNickname , getName , getEmail y getAvatar :

 $user = Socialite::driver('google')->user(); $user->getId(); $user->getNickName(); $user->getName(); $user->getEmail(); $user->getAvatar();

Y si queremos obtener los detalles del usuario de un token (OAuth 2) o un token y un secreto (OAuth 1), sanctum proporciona dos métodos para esto: userFromToken y userFromTokenAndSecret :

 use Laravel\Socialite\Facades\Socialite; $user = Socialite:;driver('google')->userFromToken($token); $user = Socialite::driver('twitter')->userFromTokenAndSecret($token, $secret);

Santuario de Laravel

Laravel Sanctum es un sistema de autenticación ligero para SPA (aplicaciones de una sola página) y aplicaciones móviles. Permite a los usuarios generar múltiples tokens de API con alcances específicos. Estos ámbitos especifican las acciones permitidas por un token.

usos

Sanctum se puede utilizar para emitir tokens API al usuario sin las complejidades de OAuth. Esos tokens suelen tener tiempos de vencimiento prolongados, como años, pero el usuario puede revocarlos y regenerarlos en cualquier momento.

Instalación y configuración

Podemos instalarlo a través de composer:

 composer require laravel/sanctum

Y tenemos que publicar los archivos de configuración y migración:

 php artisan vendor:publish –provider="Laravel\Sanctum\SanctumServiceProvider"

Ahora que hemos generado nuevos archivos de migración, tenemos que migrarlos:

 php artisan migrate </code> or <code> php artisan migrate:fresh

Cómo emitir tokens API

Antes de emitir tokens, nuestro modelo de usuario debe usar el rasgo Laravel\Sanctum\HasApiTokens :

 use Laravel\Sanctum\HasApiTokens; class User extends Authenticable { use HasApiTokens; }

Cuando tenemos el usuario, podemos emitir un token llamando al método createToken , que devuelve una instancia de Laravel\Sanctum\NewAccessToken .

Podemos llamar al método plainTextToken en la instancia de NewAccessToken para ver el valor de texto sin formato SHA-256 del token.

Consejos y mejores prácticas para la autenticación de Laravel

Invalidación de sesiones en otros dispositivos

Como hemos discutido anteriormente, la invalidación de la sesión es crucial cuando el usuario cierra la sesión, pero eso también debería estar disponible como una opción para todos los dispositivos de propiedad.

Esta característica se suele utilizar cuando el usuario cambia o actualiza su contraseña, y queremos invalidar su sesión desde cualquier otro dispositivo.

Con la fachada Auth, esta es una tarea fácil de lograr. Teniendo en cuenta que la ruta que estamos usando tiene el auth.session middleware auth y auth.session, podemos usar el método estático logoutOtherDevices de la fachada:

 Route::get('/logout', [LogoutController::class, 'invoke']) ->middleware(['auth', 'auth.session']);

 use Illuminate\Support\Facades\Auth; Auth::logoutOtherDevices($password);

Configuración con Auth::routes()

El método de rutas de la fachada Auth es solo una ayuda para generar todas las rutas requeridas para la autenticación del usuario.

Las rutas incluyen Inicio de sesión (Obtener, Publicar), Cerrar sesión (Publicar), Registrarse (Obtener, Publicar) y Restablecimiento de contraseña/Correo electrónico (Obtener, Publicar).

Cuando llama al método en la fachada, hace lo siguiente:

 public static fucntion routes(array $options = []) { if (!static::$app->providerIsLoaded(UiServiceProvider::class)) { throw new RuntimeException('In order to use the Auth:;routes() method, please install the laravel/ui package.'); } static::$app->make('router')->auth($options); }

Estamos interesados ​​en lo que sucede cuando se llama al método estático en el enrutador. Esto puede ser complicado debido al hecho de cómo funcionan las fachadas, pero el siguiente método llamado es así:

 /** Register the typical authentication routes for an application. @param array $options @return void */ public function auth(array $options = []) { // Authentication Routes... $this->get('login', 'Auth\[email protected]')->name('login'); $this->post('login', 'Auth\[email protected]'); $this->post('logout', 'Auth\[email protected]')->name('logout'); // Registration Routes... if ($options['register'] ?? true) { $this->get('register', 'Auth\[email protected]')->name('register'); $this->post('register', 'Auth\[email protected]'); } // Password Reset Routes... if ($options['reset'] ?? true) { $this->resetPassword(); } // Email Verification Routes... if ($options['verify'] ?? false) { $this->emailVerification(); } }

De forma predeterminada, genera todas las rutas además de la de verificación de correo electrónico. Siempre tendremos las rutas de inicio y cierre de sesión, pero las otras las podemos controlar a través de la matriz de opciones.

Si queremos tener solo iniciar/cerrar sesión y registrarse, podemos pasar la siguiente matriz de opciones:

 $options = ["register" => true, "reset" => false, "verify" => false];

Protección de Rutas y Guardias Aduaneros

Queremos asegurarnos de que solo los usuarios autenticados puedan acceder a algunas rutas y que se pueda hacer rápidamente agregando una llamada al método de middleware en la fachada de la ruta o encadenando el método de middleware en él:

 Route::middleware('auth')->get('/user', function (Request $request) { return $request->user(); }); Route::get('/user', function (Request $request) { return $request->user(); })->middleware('auth');

Esta protección garantiza que las solicitudes entrantes se autentiquen.

Confirmación de contraseña

Para mayor seguridad del sitio web, a menudo desea confirmar la contraseña de un usuario antes de continuar con cualquier otra tarea.

Debemos definir una ruta desde la vista de confirmación de contraseña para manejar la solicitud. Validará y redirigirá al usuario a su destino previsto. Al mismo tiempo, nos aseguraremos de que nuestra contraseña aparezca confirmada en la sesión. De forma predeterminada, la contraseña debe volver a confirmarse cada tres horas, pero esto se puede cambiar en el archivo de configuración en config/auth.php :

 use Illuminate\Http\Request; use Illuminate\Support\Facades\Hash; use Illuminate\Support\Facades\Redirect; Route::post('/confirm-password', function (Request $request) { if (!Hash::check($request->password, $request->user()->password)) { return back()->withErrors([ 'password' => ['The provided password does not match our records.'] ]); } $request->session()->passwordConfirmed(); return redirect()->intended(); })->middleware(['auth']);

Contrato Autenticable

El contrato autenticable ubicado en Illuminate\Contracts\Auth define un modelo de lo que debe implementar la fachada UserProvider:

 namespace Illuminate\Contracts\Auth; interface Authenticable { public function getAuthIdentifierName(); public function getAuthIdentifier(); public function getAuthPassord(); public function getRememberToken(); public function setRememberToken($value); public function getrememberTokenName(); }

La interfaz permite que el sistema de autenticación funcione con cualquier clase de "usuario" que lo implemente.

Esto se mantiene independientemente de qué ORM o capas de almacenamiento se utilicen. Por defecto, Laravel tiene App\Models\User que implementa esta interfaz, y esto también se puede ver en el archivo de configuración:

 return [ 'providers' => [ 'users' => [ 'driver' => 'eloquent', 'model' => App\Models\User::class, ], ], ];

Eventos de autenticación

Hay muchos eventos que se envían durante todo el proceso de autenticación.

Dependiendo de sus objetivos, puede adjuntar oyentes a esos eventos en su EventServiceProvider .

Crear rápidamente nuevos usuarios

La creación de un nuevo usuario rápidamente se puede hacer a través de App\User :

 $user = new App\User(); $user->password = Hash::make('strong_password'); $user->email = '[email protected]'; $user->name = 'Username'; $user->save();

O a través del método crear estático en la fachada del Usuario:

 User::create([ 'password' => Hash::make('strong-password'), 'email' => '[email protected]', 'name' => 'username' ]);

Resumen

El ecosistema de Laravel tiene muchos kits de inicio para poner en marcha su aplicación con un sistema de autenticación, como Breeze y Jetstream. Son altamente personalizables ya que el código se genera de nuestra parte, y podemos modificarlo tanto como queramos, usándolo como modelo si es necesario.

Hay muchas preocupaciones de seguridad con respecto a la autenticación y sus complejidades, pero todas pueden resolverse fácilmente a través de las herramientas que proporciona Laravel. Estas herramientas son altamente personalizables y fáciles de usar.

Implemente sus aplicaciones Laravel de manera rápida y eficiente con nuestro rápido servicio de alojamiento Laravel. Vea su aplicación en acción con una prueba gratuita.