Un ghid cuprinzător pentru autentificarea Laravel

Autentificarea este una dintre cele mai critice și esențiale caracteristici ale aplicațiilor web. Cadrele web precum Laravel oferă utilizatorilor multe modalități de autentificare.

Puteți implementa funcțiile de autentificare Laravel rapid și în siguranță. Cu toate acestea, implementarea slabă a acestor caracteristici de autentificare poate fi riscantă, deoarece părțile rău intenționate le pot exploata.

Acest ghid vă va învăța tot ce trebuie să știți pentru a începe cu metodele de autentificare Laravel alese.

Citește mai departe!

O introducere în autentificarea Laravel

Laravel introduce module care sunt formate din „gărzi” și „furnizori”. Gardienii definesc autentificarea utilizatorului pentru fiecare cerere, iar furnizorii definesc recuperarea utilizatorului din stocarea persistentă (de exemplu, baza de date MySQL).

Noi definim parametrii noștri de autentificare într-un fișier numit config/auth.php . Include mai multe opțiuni pentru a modifica și modifica comportamentul de autentificare al lui Laravel.

În primul rând, trebuie să definiți valorile implicite de autentificare. Această opțiune controlează opțiunile implicite de „protecție” de autentificare și de resetare a parolei ale aplicației dvs. Puteți modifica aceste valori implicite după cum este necesar, dar sunt un început perfect pentru majoritatea aplicațiilor.

Apoi, definiți gardieni de autentificare pentru aplicația dvs. Aici, configurația noastră implicită folosește stocarea sesiunii și furnizorul de utilizatori Eloquent. Toate driverele de autentificare au un furnizor de utilizator.

 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, ];

Mai târziu, ne asigurăm că toți driverele de autentificare au un furnizor de utilizator. Aceasta definește modul în care utilizatorii sunt preluați din baza de date sau din alte mecanisme de stocare pentru a păstra datele utilizatorului. Puteți configura mai multe surse reprezentând fiecare model sau tabel dacă aveți mai multe tabele sau modele de utilizatori. Aceste surse pot fi atribuite oricăror gardieni de autentificare suplimentari pe care i-ați definit.

De asemenea, utilizatorii pot dori să-și resetați parolele. Pentru aceasta, puteți specifica mai multe configurații de resetare a parolei dacă aveți mai mult de un tabel sau model de utilizatori în aplicație și doriți setări separate pe baza anumitor tipuri de utilizatori. Timpul de expirare este numărul de minute în care fiecare jeton de resetare va fi valabil. Această caracteristică de securitate menține jetoanele de scurtă durată, astfel încât acestea au mai puțin timp pentru a fi ghicite. Puteți modifica acest lucru după cum este necesar.

În cele din urmă, trebuie să definiți timpul înainte de expirarea timpului de confirmare a parolei, iar utilizatorului i se solicită să-și introducă din nou parola prin intermediul ecranului de confirmare. În mod implicit, expirarea durează trei ore.

Tipuri de metode de autentificare Laravel

Nu există o modalitate perfectă de a autentifica fiecare scenariu, dar cunoașterea lor vă va ajuta să luați decizii mai bune. Aceasta și cum evoluează Laravel cu noile funcții din Laravel 9. Acest lucru ne face munca de dezvoltatori mult mai ușoară atunci când comutăm modurile de autentificare.

Autentificare bazată pe parolă

Ca modalitate rudimentară de a autentifica un utilizator, este încă folosit de mii de organizații, dar având în vedere dezvoltarea actuală, este în mod clar depășit.

Furnizorii trebuie să impună implementări complexe de parole, asigurând în același timp frecare minimă pentru utilizatorul final.

Funcționează destul de simplu, utilizatorul introduce numele și parola, iar dacă în baza de date există o potrivire între cele două, serverul decide să autentifice cererea și să lase utilizatorul să acceseze resursele pentru un timp predefinit.

Autentificare bazată pe token

Această metodologie este utilizată în cazul în care utilizatorului i se emite un simbol unic la verificare.

Având acest simbol, acum utilizatorul poate accesa resursele relevante. Privilegiul este activ până la expirarea simbolului.

În timp ce token-ul este activ, utilizatorul nu trebuie să folosească niciun nume de utilizator sau parolă, dar la preluarea unui nou token, cele două sunt necesare.

Tokenurile sunt utilizate pe scară largă în mai multe scenarii astăzi, deoarece sunt entități apatride care conțin toate datele de autentificare.

Oferirea unei modalități de a separa generarea token-ului de verificarea token-ului oferă vânzătorilor multă flexibilitate.

Autentificare cu mai mulți factori

După cum sugerează și numele, implică utilizarea a cel puțin doi factori de autentificare, sporind securitatea pe care o oferă.

Spre deosebire de autentificarea cu doi factori care implică doar doi factori, această metodă poate implica doi, trei, patru și mai mult...

Implementarea tipică a acestei metode implică utilizarea unei parole, după care utilizatorului i se trimite un cod de verificare pe smartphone-ul său. Furnizorii care implementează această metodă ar trebui să caute false pozitive și întreruperi ale rețelei, care pot deveni probleme mari în timp ce se extind rapid.

Cum se implementează autentificarea Laravel

Această secțiune vă va învăța mai multe moduri de a autentifica utilizatorii aplicației dvs. Unele biblioteci precum Jetstream, Breeze și Socialite au tutoriale gratuite despre cum să le folosești.

Autentificare manuală

Începând cu înregistrarea utilizatorilor și crearea rutelor necesare în routes/web.php .

Vom crea două rute, unul pentru vizualizarea formularului și unul pentru înregistrare:

 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']);

Și creați controlerul necesar pentru cei:

 php artisan make controller Auth/RegisterController -r

Acum actualizați codul după cum urmează:

 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) { } }

Controlerul este gol acum și returnează o vizualizare pentru înregistrare. Să facem acea vizualizare în resources/views/auth și să o numim register.blade.php .

Acum, cu totul în loc, ar trebui să ne vizităm traseul /register și să vedem următorul formular:

 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.', ]); }

Acum că putem afișa un formular pe care un utilizator îl poate completa și obține datele pentru acesta, ar trebui să obținem datele utilizatorilor, să le validăm și apoi să îl stocăm în baza de date dacă totul este în regulă. Aici ar trebui să utilizați o tranzacție de bază de date pentru a vă asigura că datele pe care le introduceți sunt complete.

Vom folosi funcția de validare a cererii Laravel pentru a ne asigura că toate cele trei acreditări sunt necesare. Trebuie să ne asigurăm că e-mailul are un format de e-mail și este unic în tabelul users și că parola este confirmată și are minim 8 caractere:

 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'); } }

Acum că intrarea noastră este validată, orice contravine validării noastre va genera o eroare care va fi afișată sub forma:

Presupunând că am creat un cont de utilizator în metoda store , dorim, de asemenea, să ne logăm utilizatorul. Există două moduri în care o putem face. O putem face manual sau folosi Fațada Auth .

După ce utilizatorul se conectează, nu ar trebui să-l returnăm la ecranul Înregistrare, ci pe o pagină nouă, cum ar fi un tablou de bord sau o pagină de pornire. Asta vom face aici:

 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'); } }

Și acum că avem un utilizator înregistrat și conectat -n , ar trebui să ne asigurăm că se poate deconecta în siguranță.

Laravel sugerează să invalidăm sesiunea și să regenerăm jetonul pentru securitate după o deconectare. Și tocmai asta vom face. Începem prin a crea o nouă rută /logout folosind metoda destroy a 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');

Trecerea deconectarii prin middleware-ul „auth” este foarte importantă. Utilizatorii ar trebui să nu poată accesa ruta dacă nu sunt autentificați.

Acum, creați un controler așa cum am făcut înainte:

 php artisan make:controller Auth/LogoutController -r

Ne putem asigura că primim cererea ca parametru în metoda destroy . Deconectam utilizatorul prin fațada Auth, invalidăm sesiunea și regenerăm jetonul, apoi redirecționăm utilizatorul către pagina de pornire:

 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('/'); } }

Amintirea utilizatorilor

Majoritatea, dacă nu toate, aplicațiile web moderne oferă o casetă de selectare „Ține-mă minte” în formularul lor de conectare.

Dacă dorim să oferim o funcționalitate „ține minte”, putem trece o valoare booleană ca al doilea argument la metoda de încercare.

Când este valabil, Laravel va păstra utilizatorul autentificat pe o perioadă nedeterminată sau până când acesta este deconectat manual. Tabelul de utilizator trebuie să includă coloana șirul remember_token (de aceea regenerăm jetoanele), unde vom stoca jetonul nostru „remember me”.

Migrarea implicită pentru utilizatori o include deja.

În primul rând, trebuie să adăugați câmpul Reține-mă în formularul tău:

Și după aceasta, obțineți acreditările de la cerere și utilizați-le pe metoda de încercare pe fațada Auth.

Dacă utilizatorul trebuie reținut, îl vom conecta și îl vom redirecționa către pagina noastră de pornire. În caz contrar, vom arunca o eroare:

 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' =>

Resetarea parolelor

Majoritatea aplicațiilor web de astăzi oferă utilizatorilor modalități de a-și reseta parolele.

Vom face o altă rută pentru parola uitată și vom crea controlerul așa cum am făcut-o. În plus, vom adăuga o rută pentru linkul de resetare a parolei care conține simbolul pentru întregul proces:

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

În cadrul metodei de magazin, vom lua e-mailul din cerere și îl vom valida așa cum am făcut.

După aceasta, putem folosi metoda sendResetLink din fațada parolei.

Și apoi, ca răspuns, vrem să returnăm starea dacă a reușit să trimită linkul sau erori în caz contrar:

 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)]); } }

Acum că linkul de resetare a fost trimis către e-mailul utilizatorului, ar trebui să avem grijă de logica a ceea ce se întâmplă după aceea.

Vom primi jetonul, e-mailul și noua parolă în cerere și le vom valida.

După aceasta, putem folosi metoda de resetare de pe fațada parolei pentru a-l lăsa pe Laravel să se ocupe de orice altceva în culise.

Întotdeauna vom hash parola pentru a o păstra în siguranță.

La final, vom verifica dacă parola a fost resetată, iar dacă a fost, vom redirecționa utilizatorul către ecranul de autentificare cu un mesaj de succes. În caz contrar, afișăm o eroare că nu a putut fi resetat:

 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)]); } }

Laravel Briza

Laravel Breeze este o implementare simplă a caracteristicilor de autentificare Laravel: autentificare, înregistrare, resetare a parolei, verificare e-mail și confirmare a parolei. Îl poți folosi pentru a implementa autentificarea în noua ta aplicație Laravel.

Instalare și configurare

După ce ați creat aplicația Laravel, tot ce trebuie să faceți este să vă configurați baza de date, să rulați migrațiile și să instalați pachetul laravel/breeze prin composer:

 composer require laravel/breeze –dev

După aceasta, rulați următoarele:

 php artisan breeze:install

Care va publica vizualizările de autentificare, rutele, controlerele și alte resurse pe care le utilizează. După acest pas, aveți control complet asupra a tot ceea ce oferă Breeze.

Acum trebuie să redăm aplicația noastră la frontend, așa că vom instala dependențele noastre JS (care vor folosi @vite):

 npm install

:

 npm run dev

După aceasta, linkurile de autentificare și înregistrare ar trebui să fie pe pagina ta de pornire și totul ar trebui să funcționeze fără probleme.

Laravel Jetstream

Laravel Jetstream extinde Laravel Breeze cu funcții utile și alte stive frontale.

Oferă autentificare, înregistrare, verificare e-mail, autentificare în doi factori, gestionare a sesiunii, suport API prin Sanctum și management opțional al echipei.

Trebuie să alegeți între Livewire și Inertia pe front-end atunci când instalați Jetstream. Pe backend, folosește Laravel Fortify, care este un backend de autentificare agnostic, „fără cap” pentru Laravel.

Instalare și configurare

Îl vom instala prin compozitor în proiectul nostru Laravel:

 composer require laravel/jetstream

După aceasta, vom rula comanda php artisan jetstream:install [stack] , care acceptă argumentele [stack] Livewire sau Inertia . Puteți trece opțiunea –team pentru a activa funcția echipe.

Acest lucru va instala și Pest PHP pentru testare.

Și, în sfârșit, trebuie să redăm interfața aplicației noastre folosind următoarele:

 npm install npm run dev

Laravel Fortify

Laravel Fortify este o implementare de autentificare backend care este agnostică de frontend. Nu trebuie să utilizați Laravel Fortify pentru a implementa caracteristicile de autentificare ale Laravel.

Este, de asemenea, folosit în kituri de pornire precum Breeze și Jetstream. De asemenea, puteți utiliza Fortify independent, care este doar o implementare backend. Dacă îl utilizați independent, front-end-ul dvs. trebuie să apeleze rutele Fortify.

Instalare și configurare

Putem instala Fortify prin compozitor:

 composer require laravel/fortify

Acum trebuie să publicăm resursele Fortify:

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

După aceasta, vom crea un nou director aplicație/Acțiuni în plus față de noul FortifyServiceProvider , fișierul de configurare și migrarea bazei de date.

În sfârșit, rulați:

 php artisan migrate

Sau:

 php artisan migrate:fresh

Și Fortify dvs. este gata de utilizare.

Laravel Socialite

Laravel include o funcție simplă de autentificare a utilizatorului, bazată pe OAuth. Acceptă conectări sociale prin Facebook, Twitter, LinkedIn, Google, Bitbucket, GitHub și GitLab.

Instalare

Îl putem instala prin compozitor:

 composer require laravel/socialite

Configurare și utilizare

După ce l-am instalat, trebuie să adăugăm acreditările pentru furnizorul OAuth pe care îl folosește aplicația noastră. Le vom adăuga în config/services.php pentru fiecare serviciu.

În configurație, ar trebui să potrivim cheia cu serviciile anterioare. Unele dintre aceste chei includ:

• Facebook
• twitter (pentru OAuth 1.0)
• twitter-oauth-2 (pentru OAuth 2.0)
• linkedin
• Google
• github
• gitlab
• bitbucket

O configurație de serviciu poate arăta astfel:

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

Autentificarea utilizatorilor

Pentru această acțiune, vom avea nevoie de două rute, una pentru redirecționarea utilizatorului către furnizorul OAuth:

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

Și unul pentru apel invers de la furnizor după autentificare:

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

Socialite oferă metoda de redirecționare, iar fațada redirecționează utilizatorul către furnizorul OAuth, în timp ce metoda utilizatorului examinează cererea primită și preia informațiile despre utilizator.

După ce ne-am primit utilizatorul, trebuie să verificăm dacă acesta există în baza noastră de date și să-l autentificăm. Dacă nu există, vom crea o nouă înregistrare care să reprezinte utilizatorul:

 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'); });

Dacă dorim să limităm domeniile de acces ale utilizatorului, putem folosi metoda scopes , pe care o vom include cu cererea de autentificare. Aceasta va îmbina toate domeniile specificate anterior cu cele specificate.

O alternativă la aceasta este utilizarea metodei setScopes care suprascrie orice alt domeniu existent:

 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();

Acum că știm totul și cum să obținem un utilizator după apel invers, să ne uităm la unele dintre datele pe care le putem obține din acesta.

Utilizatorul OAuth1 are token și tokenSecret :

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

OAuth2 oferă token , refreshToken și expiresIn :

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

Atât OAuth1, cât și OAuth2 oferă getId , getNickname , getName , getEmail și getAvatar :

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

Și dacă dorim să obținem detalii despre utilizator de la un token (OAuth 2) sau un token și secret (OAuth 1), sanctum oferă două metode pentru aceasta: userFromToken și userFromTokenAndSecret :

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

Laravel Sanctum

Laravel Sanctum este un sistem de autentificare ușor pentru SPA-uri (aplicații cu o singură pagină) și aplicații mobile. Permite utilizatorilor să genereze mai multe jetoane API cu domenii specifice. Aceste domenii specifică acțiunile permise printr-un simbol.

Utilizări

Sanctum poate fi folosit pentru a emite jetoane API utilizatorului fără complicațiile OAuth. Aceste jetoane au, de obicei, perioade lungi de expirare, cum ar fi ani, dar pot fi revocate și regenerate de utilizator în orice moment.

Instalare și configurare

Îl putem instala prin compozitor:

 composer require laravel/sanctum

Și trebuie să publicăm fișierele de configurare și migrare:

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

Acum că am generat noi fișiere de migrare, trebuie să le migrăm:

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

Cum se emit jetoane API

Înainte de a emite jetoane, modelul nostru de utilizator ar trebui să folosească trăsătura Laravel\Sanctum\HasApiTokens :

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

Când avem utilizatorul, putem emite un token apelând metoda createToken , care returnează o instanță Laravel\Sanctum\NewAccessToken .

Putem apela metoda plainTextToken pe instanța NewAccessToken pentru a vedea valoarea de text simplu SHA-256 a jetonului.

Sfaturi și bune practici pentru autentificarea Laravel

Invalidarea sesiunilor pe alte dispozitive

După cum am discutat anterior, invalidarea sesiunii este crucială atunci când utilizatorul se deconectează, dar aceasta ar trebui să fie disponibilă și ca opțiune pentru toate dispozitivele deținute.

Această caracteristică este de obicei folosită atunci când utilizatorul își schimbă sau își actualizează parola și dorim să îi invalidăm sesiunea de pe orice alt dispozitiv.

Prevăzută cu fațada Auth, aceasta este o sarcină ușor de realizat. Având în vedere că ruta pe care o folosim are auth.session middleware -ul auth și auth.session, putem folosi metoda statică logoutOtherDevices a fațadei:

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

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

Configurare cu Auth::routes()

Metoda rutelor fațadei Auth este doar un ajutor pentru a genera toate rutele necesare pentru autentificarea utilizatorului.

Rutele includ Autentificare (Obținere, Postare), Deconectare (Postare), Înregistrare (Obținere, Postare) și Resetare parolă/E-mail (Obținere, Postare).

Când apelați metoda pe fațadă, aceasta face următoarele:

 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); }

Suntem interesați de ce se întâmplă atunci când metoda statică este apelată pe router. Acest lucru poate fi dificil din cauza modului în care funcționează fațadele, dar următoarea metodă numită este astfel:

 /** 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(); } }

În mod implicit, generează toate rutele, în afară de cea de verificare a e-mailului. Vom avea întotdeauna rutele Login și Logout, dar pe celelalte le putem controla prin matricea de opțiuni.

Dacă dorim să avem doar autentificare/delogare și înregistrare, putem trece următoarea matrice de opțiuni:

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

Protejarea rutelor și a gardienilor vamale

Dorim să ne asigurăm că unele rute pot fi accesate numai de utilizatori autentificați și pot fi făcute rapid adăugând fie apelarea metodei middleware pe fațada Route, fie înlănțuirea metodei middleware pe aceasta:

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

Acest gard se asigură că cererile primite sunt autentificate.

Confirmarea parolei

Pentru o securitate sporită a site-ului, deseori doriți să confirmați parola unui utilizator înainte de a continua cu orice altă sarcină.

Trebuie să definim o rută din vizualizarea de confirmare a parolei pentru a gestiona cererea. Acesta va valida și redirecționa utilizatorul către destinația dorită. În același timp, ne vom asigura că parola noastră apare confirmată în sesiune. În mod implicit, parola trebuie reconfirmată la fiecare trei ore, dar aceasta poate fi schimbată în fișierul de configurare la 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']);

Contract autentic

Contractul Authenticable situat la Illuminate\Contracts\Auth definește o schiță a ceea ce ar trebui să implementeze fațada 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(); }

Interfața permite sistemului de autentificare să funcționeze cu orice clasă „utilizator” care o implementează.

Acest lucru este valabil indiferent de ce ORM sau straturile de stocare sunt utilizate. Implicit, Laravel are App\Modeles\Utilizator care implementează această interfață, iar acest lucru poate fi văzut și în fișierul de configurare:

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

Evenimente de autentificare

Există o mulțime de evenimente care sunt trimise pe parcursul întregului proces de autentificare.

În funcție de obiectivele dvs., puteți atașa ascultătorii la acele evenimente din dvs EventServiceProvider .

Creați rapid utilizatori noi

Crearea rapidă a unui utilizator nou se poate face prin aplicația\Utilizator :

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

Sau prin metoda de creare statică pe fațada utilizatorului:

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

rezumat

Ecosistemul Laravel are o mulțime de kituri de pornire pentru a vă pune în funcțiune aplicația cu un sistem de autentificare, cum ar fi Breeze și Jetstream. Ele sunt extrem de personalizabile, deoarece codul este generat de partea noastră și îl putem modifica atât cât vrem, folosindu-l ca model, dacă este necesar.

Există multe probleme de securitate în ceea ce privește autentificarea și complexitățile sale, dar toate acestea pot fi rezolvate cu ușurință prin instrumentele pe care Laravel le oferă. Aceste instrumente sunt extrem de personalizabile și ușor de utilizat.

Implementează-ți aplicațiile Laravel rapid și eficient cu serviciul nostru rapid de găzduire Laravel. Vedeți-vă aplicația în acțiune cu o încercare gratuită.