Autentifikation er en af webapplikationernes mest kritiske og vigtige funktioner. Webframeworks som Laravel giver brugerne mange måder at autentificere sig på.
Du kan implementere Laravel-godkendelsesfunktioner hurtigt og sikkert. Det kan dog være risikabelt at implementere disse autentificeringsfunktioner dårligt, da ondsindede parter kan udnytte dem.
I denne vejledning lærer du alt det, du skal vide for at komme i gang med de valgte Laravel-godkendelsesmetoder.
Læs videre!
En introduktion til Laravel-autentifikation
Laravel introducerer moduler, der består af “vagter” og “udbydere“. Guards definerer brugergodkendelse for hver forespørgsel, og providers definerer brugerhentning fra vedvarende lagring (f.eks. MySQL-database).
Vi definerer vores autentificeringsparametre i en fil ved navn config/auth.php. Den indeholder flere muligheder for at justere og ændre Laravels autentifikationsadfærd.
Først skal du definere standardindstillingerne for autentificering. Denne indstilling styrer din applikations standardgodkendelses “vagt” og indstillinger for nulstilling af adgangskode. Du kan ændre disse standardindstillinger efter behov, men de er en perfekt start for de fleste applikationer.
Dernæst skal du definere godkendelsesvagter for din applikation. Her bruger vores standardkonfiguration sessionsopbevaring og Eloquent-brugerudbyderen. Alle godkendelsesdrivere har en brugerudbyder.
<?php
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,
];Senere sørger vi for, at alle godkendelsesdrivere har en brugerudbyder. Dette definerer, hvordan brugerne hentes fra din database eller andre lagringsmekanismer for at bevare dine brugerdata. Du kan konfigurere flere kilder, der repræsenterer hver model eller tabel, hvis du har flere brugertabeller eller modeller. Disse kilder kan tildeles alle ekstra godkendelsesvagter, som du har defineret.
Brugere kan også ønske at nulstille deres passwords. I den forbindelse kan du angive flere konfigurationer for nulstilling af adgangskoder, hvis du har mere end én brugertabel eller -model i programmet og ønsker separate indstillinger baseret på de specifikke brugertyper. Udløbstiden er det antal minutter, som hvert nulstillingstoken er gyldigt. Denne sikkerhedsfunktion holder tokens med kort levetid, så de har mindre tid til at blive gættet. Du kan ændre dette efter behov.
I sidste ende skal du definere den tid, før en password-bekræftelse udløber, og brugeren bliver bedt om at indtaste sit password igen via bekræftelsesskærmen. Som standard varer timeoutet tre timer.
Typer af Laravel autentifikationmetoder
Der er ikke nogen perfekt måde at autentificere alle scenarier på, men hvis du kender dem, kan du træffe bedre beslutninger. Dette og hvordan Laravel udvikler sig med de nye funktioner i Laravel 9. Dette gør vores arbejde som udviklere langt nemmere, når vi skifter autentifikationsmetoder.
Passwordbaseret autentificering
Som en rudimentær måde at autentificere en bruger på, bruges den stadig af tusindvis af organisationer, men i betragtning af den nuværende udvikling er den helt klart ved at være forældet.
Leverandørerne skal håndhæve komplekse password-implementeringer og samtidig sikre minimal friktion for slutbrugeren.
Det fungerer ret ligetil, brugeren indtaster navn og adgangskode, og hvis der i databasen er et match mellem de to, beslutter serveren at godkende anmodningen og give brugeren adgang til ressourcerne i et foruddefineret tidsrum.
Tokenbaseret autentificering
Denne metode anvendes, hvor brugeren får udstedt et unikt token efter verifikation.
Med dette token kan brugeren nu få adgang til de relevante ressourcer. Rettigheden er aktiv, indtil tokenet udløber.
Mens tokenet er aktivt, behøver brugeren ikke at bruge noget brugernavn eller password, men når han/hun henter et nyt token, skal disse to ting anvendes.
Tokens anvendes i vid udstrækning i flere scenarier i dag, da de er tilstandsløse enheder, der indeholder alle autentificeringsdata.
Hvis man kan adskille tokengenerering fra tokenverificering, giver det leverandørerne stor fleksibilitet.
Multifaktor-autentificering
Som navnet antyder, indebærer det, at der anvendes mindst to autentifikationsfaktorer, hvilket øger den sikkerhed, der opnås.
I modsætning til to-faktor-autentificering, som kun involverer to faktorer, kan denne metode involvere to, tre, fire og flere faktorer…
Den typiske implementering af denne metode indebærer, at man bruger en adgangskode, hvorefter brugeren får tilsendt en bekræftelseskode på sin smartphone. Leverandører, der implementerer denne metode, bør være opmærksomme på falske positiver og netværksafbrydelser, som kan blive store problemer, når de skalerer hurtigt op.
Sådan implementeres Laravel-autentificering
Dette afsnit vil lære dig flere måder at autentificere din applikations brugere på. Nogle biblioteker som Jetstream, Breeze og Socialite har gratis tutorials om, hvordan du bruger dem.
Manuel autentificering
Begynder med at registrere brugere og oprette de nødvendige ruter i routes/web.php.
Vi vil oprette to ruter, en til at se formularen og en til at registrere:
use App\Http\Controllers\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']);Og oprette den controller, der er nødvendig for disse:
php artisan make controller Auth/RegisterController -rOpdater nu koden som følger:
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)
{
}
}Nu er controlleren tom og returnerer en visning, der skal registreres. Lad os lave denne visning i resources/views/auth og kalde den register.blade.php.
Nu hvor alt er på plads, bør vi besøge vores /register rute og se følgende formular:
Nu hvor vi kan vise en formular, som en bruger kan udfylde og få data til den, skal vi hente brugernes data, validere dem og derefter gemme dem i databasen, hvis alt er i orden. Her bør du bruge en databasetransaktion for at sikre, at de data, du indsætter, er komplette.
Vi vil bruge Laravels funktion til validering af forespørgsler for at sikre, at alle tre legitimationsoplysninger er påkrævet. Vi skal sikre os, at e-mailen har et e-mail-format og er unik i tabellen users, og at adgangskoden er bekræftet og har mindst otte tegn:
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');
}
}Nu hvor vores input er valideret, vil alt, der strider mod vores validering, give en fejl, der vises i formularen:
[ccaption id=”attachment_162751″ align=”alignnone” width=”960″]
Eksempel på ugyldigt input til registrering.[/caption]
Hvis vi antager, at vi har oprettet en brugerkonto i metoden store, vil vi også logge brugeren ind. Der er to måder, hvorpå vi kan gøre det. Vi kan gøre det manuelt eller bruge Auth-facade.
Når brugeren logger ind, skal vi ikke sende ham/hende tilbage til Registrer-skærmen, men i stedet til en ny side, f.eks. et dashboard eller en hjemmeside. Det er det, vi vil gøre her:
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');
}
}Og nu hvor vi har en bruger registreret og logget ind -n, skal vi sikre os, at de sikkert kan logge ud.
Laravel foreslår, at vi ugyldiggør sessionen og regenererer tokenet for sikkerhed efter en logout. Og det er netop det, vi skal gøre. Vi starter med at oprette en ny /logout rute ved hjælp af LogoutController’s destroy metode:
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');Det er meget vigtigt at sende logout gennem auth middleware. Brugerne skal ikke kunne få adgang til ruten, hvis de ikke er logget ind.
Opret nu en controller, som vi gjorde før:
php artisan make:controller Auth/LogoutController -rVi kan sikre, at vi får anmodningen som en parameter i destroy-metoden. Vi logger brugeren ud via Auth-facaden, ugyldiggør sessionen og regenererer tokenet, hvorefter vi omdirigerer brugeren til hjemmesiden:
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('/');
}
}Huskning af brugere
De fleste, hvis ikke alle, moderne webapplikationer har et afkrydsningsfelt “remember me” i deres loginformular.
Hvis vi ønsker at levere en “husk mig”-funktionalitet, kan vi sende en boolsk værdi som det andet argument til forsøgsmetoden.
Når den er gyldig, vil Laravel holde brugeren autentificeret på ubestemt tid, eller indtil de bliver logget ud manuelt. Brugertabellen skal indeholde kolonnen string remember_token (det er derfor, vi regenererer tokens), hvor vi gemmer vores “husk mig”-token.
Standardmigrationen for brugere indeholder den allerede.
Først og fremmest skal du tilføje feltet Remember Me til din formular:
Og efter dette skal du hente legitimationsoplysningerne fra anmodningen og bruge dem på forsøgsmetoden på Auth-facaden.
Hvis brugeren skulle blive husket, logger vi ham ind og omdirigerer ham til vores hjemmeside. Ellers kaster vi en fejl:
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.',
]);
}Nulstilling af passwords
De fleste webapplikationer i dag giver brugerne mulighed for at nulstille deres passwords.
Vi laver en anden rute til den glemte adgangskode og opretter controlleren som vi gjorde. Derudover vil vi tilføje en rute til linket til nulstilling af password, der indeholder tokenet for hele processen:
Route::post('/forgot-password', [ForgotPasswordLinkController::class, 'store']);
Route::post('/forgot-password/{token}', [ForgotPasswordController::class, 'reset']);Inde i butiksmetoden vil vi tage e-mailen fra anmodningen og validere den som vi gjorde.
Herefter kan vi bruge sendResetLink-metoden fra password-facaden.
Og derefter vil vi som svar returnere status, hvis det lykkedes at sende linket eller fejl ellers:
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)]);
}
}Nu hvor linket til nulstilling er blevet sendt til brugerens e-mail, skal vi tage os af logikken for, hvad der sker derefter.
Vi får token, e-mail og nyt password i anmodningen og validerer dem.
Herefter kan vi bruge reset-metoden fra password-facaden for at lade Laravel tage sig af alt andet bag kulisserne.
Vi vil altid hash’e passwordet for at holde det sikkert.
Til sidst vil vi kontrollere, om passwordet blev nulstillet, og hvis det var tilfældet, vil vi omdirigere brugeren til login-skærmen med en succesbesked. Ellers viser vi en fejlmeddelelse om, at det ikke kunne nulstilles:
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 reset(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 Breeze
Laravel Breeze er en simpel implementering af Laravel-authentificationssfunktioner: login, registrering, nulstilling af password, e-mailbekræftelse og passwordbekræftelse. Du kan bruge den til at implementere autentificering i din nye Laravel-applikation.
Installation og opsætning
Når du har oprettet din Laravel-applikation, skal du blot konfigurere din database, køre dine migreringer og installere laravel/breeze-pakken via composer:
composer require laravel/breeze --devHerefter skal du køre følgende:
php artisan breeze:installDette vil offentliggøre dine autentifikationsvisninger, ruter, controllere og andre ressourcer, som den bruger. Efter dette trin har du fuld kontrol over alt det, som Breeze tilbyder.
Nu skal vi rendere vores applikation til frontend, så vi vil installere vores JS-afhængigheder (som vil bruge @vite):
npm install:
npm run devHerefter bør links til login og registrering være på din hjemmeside, og alt bør fungere uden problemer.
Laravel Jetstream
Laravel Jetstream udvider Laravel Breeze med nyttige funktioner og andre frontend stacks.
Det giver login, registrering, e-mailbekræftelse, to-faktor-godkendelse, sessionshåndtering, API-understøttelse via Sanctum og valgfri teamadministration.
Du skal vælge mellem Livewire og Inertia på frontend’en, når du installerer Jetstream. På backend bruger den Laravel Fortify, som er en frontend agnostisk, “headless” autentifikationsbackend til Laravel.
Installation og opsætning
Vi installerer det gennem composer i vores Laravel-projekt:
composer require laravel/jetstreamHerefter kører vi kommandoen php artisan jetstream:install [stack], som accepterer [stack] argumenter Livewire eller Inertia. Du kan videregive indstillingen --teams for at aktivere holdfunktionen.
Dette vil også installere Pest PHP til test.
Og til sidst skal vi rendere frontend af vores applikation ved hjælp af følgende:
npm install
npm run devLaravel Fortify
Laravel Fortify er en backend autentificeringsimplementering, der er frontend agnostisk. Du behøver ikke at bruge Laravel Fortify for at implementere Laravels autentifikationsfunktioner.
Det bruges også i startpakker som Breeze og Jetstream. Du kan også bruge Fortify standalone, som blot er en backend-implementering. Hvis du bruger det standalone, skal din frontend kalde Fortify-ruterne.
Installation og opsætning
Vi kan installere Fortify gennem composer:
composer require laravel/fortifyNu skal vi udgive Fortify’s ressourcer:
php artisan vendor:publish --provider="Laravel\Fortify\FortifyServiceProvider"Herefter opretter vi en ny app/Actions-mappe ud over den nye FortifyServiceProvider, konfigurationsfilen og databasemigrationerne.
Til sidst skal du køre:
php artisan migrateEller:
php artisan migrate:freshOg din Fortify er klar til brug.
Laravel Socialite
Laravel indeholder en ukompliceret OAuth-baseret brugergodkendelsesfunktion. Den understøtter sociale logins via Facebook, Twitter, LinkedIn, LinkedIn, Google, Bitbucket, GitHub og GitLab.
Installation
Vi kan installere det gennem composer:
composer require laravel/socialiteOpsætning og brug
Når vi har installeret det, skal vi tilføje legitimationsoplysningerne for den OAuth-udbyder, som vores program bruger. Vi vil tilføje dem i config/services.php for hver tjeneste.
I konfigurationen skal vi matche nøglen med de tidligere tjenester. Nogle af disse nøgler omfatter:
- twitter (til OAuth 1.0)
- twitter-oauth-2 (til OAuth 2.0)
- github
- gitlab
- bitbucket
En tjenestekonfiguration kan se således ud:
'google' => [
'client_id' => env("GOOGLE_CLIENT_ID"),
'client_secret' => env("GOOGLE_CLIENT_SECRET"),
'redirect' => "http://example.com/callback-url",
],Autentificering af brugere
Til denne handling har vi brug for to ruter, en til at omdirigere brugeren til OAuth-udbyderen:
use Laravel\Socialite\Facades\Sociliate;
Route::get('/auth/redirect', function () {
return Socialite::driver('google')->redirect();
});Og en til callback fra udbyderen efter godkendelse:
use Laravel\Socialite\Facades\Socialite;
Route:;get('/auht/callback', function () {
$user = Socialite::driver('google')->user();
// Getting the user data
$user->token;
});Socialite leverer redirect-metoden, og facaden omdirigerer brugeren til OAuth-udbyderen, mens brugermetoden undersøger den indgående anmodning og henter brugeroplysningerne.
Når vi har modtaget vores bruger, skal vi kontrollere, om den findes i vores database, og autentificere den. Hvis den ikke findes, opretter vi en ny post for at repræsentere brugeren:
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');
});Hvis vi ønsker at begrænse brugerens adgangsintervaller, kan vi bruge metoden scopes, som vi inkluderer i godkendelsesanmodningen. Dette vil sammenføje alle tidligere angivne anvendelsesområder med de angivne anvendelsesområder.
Et alternativ til dette er at bruge metoden setScopes, som overskriver alle andre eksisterende områder:
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();Nu hvor vi ved alt, og hvordan vi får en bruger efter callbacken, lad os se på nogle af de data, vi kan få fra den.
OAuth1 User har token og tokenSecret:
$user = Socialite::driver('google')->user();
$token = $user->token;
$tokenSecret = $user->tokenSecret;OAuth2 giver token, refreshToken og expiresIn:
$user = Socialite::driver('google')->user();
$token = $user->token;
$refreshToken = $user->refreshToken;
$expiresIn = $user->expiresIn;Både OAuth1 og OAuth2 leverer getId, getNickname, getName, getEmail og getAvatar:
$user = Socialite::driver('google')->user();
$user->getId();
$user->getNickName();
$user->getName();
$user->getEmail();
$user->getAvatar();Og hvis vi ønsker at få brugeroplysninger fra et token (OAuth 2) eller et token og en hemmelighed (OAuth 1), tilbyder Socialite to metoder til dette: userFromToken og userFromTokenAndSecret:
use Laravel\Socialite\Facades\Socialite;
$user = Socialite::driver('google')->userFromToken($token);
$user = Socialite::driver('twitter')->userFromTokenAndSecret($token, $secret);Laravel Sanctum
Laravel Sanctum er et let autentificeringssystem til SPA’er (Single Page Applications) og mobilapps. Det giver brugerne mulighed for at generere flere API-tokens med specifikke scopes. Disse scopes specificerer tilladte handlinger af et token.
Anvendelser
Sanctum kan bruges til at udstede API-tokens til brugeren uden de indviklede OAuth-metoder. Disse tokens har typisk lange udløbstider, f.eks. år, men kan til enhver tid tilbagekaldes og genereres på ny af brugeren.
Installation og opsætning
Vi kan installere det via composer:
composer require laravel/sanctumOg vi skal udgive konfigurations- og migrationsfilerne:
php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"Nu hvor vi har genereret nye migreringsfiler, skal vi migrere dem:
php artisan migrate:freshSådan udsteder du API-tokens
Før vi udsteder tokens, skal vores brugermodel bruge Laravel\Sanctum\HasApiTokens-trækket:
use Laravel\Sanctum\HasApiTokens;
class User extends Authenticable
{
use HasApiTokens;
}Når vi har brugeren, kan vi udstede et token ved at kalde createToken-metoden, som returnerer en Laravel\Sanctum\NewAccessToken-instans.
Vi kan kalde plainTextToken-metoden på NewAccessToken-instansen for at se SHA-256-værdien i ren tekst for tokenet.
Tips og bedste praksis for Laravel-authentification
Invalidering af sessioner på andre enheder
Som vi har diskuteret tidligere, er det afgørende at invalidere sessionen, når brugeren logger ud, men det bør også være tilgængeligt som en mulighed for alle de ejede enheder.
Denne funktion bruges normalt, når brugeren ændrer eller opdaterer sit password, og vi ønsker at invalidere deres session fra enhver anden enhed.
Med Auth-facaden er dette en let opgave at udføre. I betragtning af at den rute, vi bruger, har auth og auth.session middleware, kan vi bruge den statiske metode logoutOtherDevices i facaden:
Route::get('/logout', [LogoutController::class, 'invoke'])
->middleware(['auth', 'auth.session']);
use Illuminate\Support\Facades\Auth;
Auth::logoutOtherDevices($password);Konfiguration med Auth::routes()
Metoden routes i Auth-facaden er blot en hjælper til at generere alle de ruter, der er nødvendige for brugergodkendelse.
Ruterne omfatter Login (Get, Post), Logout (Post), Register (Get, Post) og Password Reset/Email (Get, Post).
Når du kalder metoden på facaden, gør den følgende:
public static function 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);
}Vi er interesseret i, hvad der sker, når den statiske metode kaldes på routeren. Dette kan være tricky på grund af hvordan facaderne fungerer, men følgende metode kaldes sådan her:
/**
Register the typical authentication routes for an application.
@param array $options
@return void
*/
public function auth(array $options = [])
{
// Authentication Routes...
$this->get('login', 'Auth\LoginController@showLoginForm')->name('login');
$this->post('login', 'Auth\LoginController@login');
$this->post('logout', 'Auth\LoginController@logout')->name('logout');
// Registration Routes...
if ($options['register'] ?? true) {
$this->get('register', 'Auth\RegisterController@showRegistrationForm')->name('register');
$this->post('register', 'Auth\RegisterController@register');
}
// Password Reset Routes...
if ($options['reset'] ?? true) {
$this->resetPassword();
}
// Email Verification Routes...
if ($options['verify'] ?? false) {
$this->emailVerification();
}
} Som standard genererer den alle ruter ud over den til e-mailbekræftelse. Vi vil altid have ruterne Login og Logout, men de andre ruter kan vi styre via options arrayet.
Hvis vi kun vil have login/logout og register, kan vi sende følgende options array:
$options = ["register" => true, "reset" => false, "verify" => false];Beskyttelse af ruter og brugerdefinerede vagter
Vi ønsker at sikre, at nogle ruter kun kan tilgås af autentificerede brugere, og det kan hurtigt gøres ved at tilføje enten at kalde middleware-metoden på Route-facaden eller kæde middleware-metoden på den:
Route::middleware('auth')->get('/user', function (Request $request) {
return $request->user();
});
Route::get('/user', function (Request $request) {
return $request->user();
})->middleware('auth');Denne vagt sikrer, at indgående anmodninger er autentificeret.
Bekræftelse af password
For at øge sikkerheden på webstedet ønsker man ofte at bekræfte en brugers adgangskode, før man går videre med en anden opgave.
Vi skal definere en rute fra visningen Bekræft adgangskode for at håndtere anmodningen. Den vil validere og omdirigere brugeren til den ønskede destination. Samtidig vil vi sørge for, at vores password vises bekræftet i sessionen. Som standard skal adgangskoden genbekræftes hver tredje time, men dette kan ændres i konfigurationsfilen på 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']);Authenticable kontrakt
Authenticable-kontrakten, der findes på Illuminate\Contracts\Auth, definerer et blueprint af, hvad UserProvider-facaden skal implementere:
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();
}Grænsefladen gør det muligt for autentificeringssystemet at arbejde med enhver “bruger”-klasse, der implementerer den.
Dette gælder uanset hvilke ORM- eller lagringslag der anvendes. Som standard har Laravel App\Models\User, der implementerer denne grænseflade, og dette kan også ses i konfigurationsfilen:
return [
'providers' => [
'users' => [
'driver' => 'eloquent',
'model' => App\Models\User::class,
],
],
];Authentication Events
Der er masser af begivenheder, der sendes i løbet af hele autentifikationsprocessen.
Afhængigt af dine mål kan du knytte lyttere til disse hændelser i din EventServiceProvider.
Hurtigt oprette nye brugere
Oprettelse af en ny bruger hurtigt kan gøres gennem App\User:
$user = new App\User();
$user->password = Hash::make('strong_password');
$user->email = '[email protected]';
$user->name = 'Username';
$user->save();Eller gennem den statiske metode create static metode på User facaden:
User::create([
'password' => Hash::make('strong-password'),
'email' => '[email protected]',
'name' => 'username'
]);Opsummering
Laravel-økosystemet har en masse startpakker til at få din app op at køre med et autentifikationssystem, som Breeze og Jetstream. De kan i høj grad tilpasses, da koden genereres på vores side, og vi kan ændre den så meget som vi vil, og bruge den som et blueprint, hvis det er nødvendigt.
Der er mange sikkerhedsmæssige bekymringer vedrørende autentificering og dens snørklede detaljer, men alle disse kan nemt løses gennem de værktøjer, som Laravel tilbyder. Disse værktøjer kan i høj grad tilpasses og er nemme at bruge.
Implementer dine Laravel-apps hurtigt og effektivt med vores hurtige Laravel-hostingtjeneste. Se din app i aktion med en gratis prøveperiode.
Cosmin Coman er en teknologiskribent- og udvikler med over 3 års erfaring. Udover at skrive for Kinsta, har han assisteret i forskning på nuklearfysiske faciliteter og universiteter. Han er teknisk kyndig og integreret i fællesskabet og kommer altid med innovative løsninger.
Skriv et svar