En omfattande guide till Laravel-autentisering

Autentisering är en av webbapplikationernas mest kritiska och viktiga funktioner. Webbramverk som Laravel erbjuder många sätt för användare att autentisera sig.

Du kan dessutom implementera autentiserings-funktioner i Laravel snabbt och säkert. Att implementera dessa autentiserings-funktioner på ett dåligt sätt kan dock vara riskabelt, eftersom skadliga parter kan utnyttja dem.

I den här guiden så får du lära dig allt som du behöver veta för att komma igång med de autentiserings-metoder som du valt i Laravel.

Läs vidare!

Introduktion till Laravel-autentisering

Laravel introducerar moduler som består av ”guards” och ”providers”. Guards definierar användar-autentisering för varje begäran, och providers definierar användarhämtning från beständig lagring (exempelvis MySQL-databasen).

Vi definierar våra autentiserings-parametrar i en fil som heter config/auth.php. Den inkluderar flera alternativ för att justera och ändra Laravels autentiserings-beteende.

Först så måste du definiera standardvärdena för autentisering. Det här alternativet styr sedan din applikations standardalternativ för autentiseringen ”guards” och återställning av lösenord. Du kan ändra dessa standardvärden efter behov, men de är en perfekt start för de flesta applikationer.

Därefter så definierar du autentiserings-vakter för din applikation. Här använder vår standard-konfiguration sessionslagring och Elokvent user provider. Alla autentiserings-drivrutiner har en användarleverantör.

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

Se till att alla autentiserings-drivrutiner har en användarleverantör

Senare så ser vi till att alla autentiserings-drivrutiner har en användarleverantör. Denna definierar hur användarna hämtas från din databas eller andra lagrings-mekanismer för att bevara användardata. Du kan dessutom konfigurera flera källor som representerar varje modell eller tabell om du har flera användartabeller eller modeller. Dessa källor kan sedan tilldelas alla extra autentiserings-vakter som du har definierat.

Användare kan även vilja återställa sina lösenord. För detta ändamål så kan du ange flera konfigurationer för återställning av lösenord. Detta gäller om du har mer än en användartabell eller modell i applikationen och vill ha separata inställningar som är baserade på de specifika användartyperna. Utgångstiden är det antal minuter som varje återställnings-token kommer att vara giltig. Med den här säkerhetsfunktionen så hålls dina tokens kortvariga, så att de har mindre tid att gissa sig till. Du kan ändra detta vid behov.

I slutändan så måste du dessutom definiera den tid som ska gå innan en bekräftelse av lösenordet tar slut. Då kommer användaren uppmanas att ange sitt lösenord på nytt via bekräftelse-skärmen. Som standard så varar timeout-tiden i tre timmar.

Typer av Laravel-autentiseringsmetoder

Det finns inget perfekt sätt att autentisera varje scenario. Om du känner till dem så kan du dock fatta bättre beslut. Du kommer även att få lära dig hur Laravel utvecklas med de nya funktionerna i Laravel 9. Detta gör vårt jobb som utvecklare mycket enklare när vi byter autentiserings-metoder.

Lösenordsbaserad autentisering

Det är ett rudimentärt sätt att autentisera en användare och används fortfarande av tusentals organisationer. Med tanke på den nuvarande utvecklingen så börjar det dock helt klart bli föråldrat.

Leverantörerna måste tvinga fram komplexa implementeringar av lösenord samtidigt som de säkerställer minimal friktion för slutanvändaren.

Det fungerar ganska enkelt, användaren anger namn och lösenord. Om det finns en matchning mellan dessa två i databasen så bestämmer sig servern för att autentisera begärandet och låta användaren få tillgång till resurserna under en fördefinierad tid.

Tokenbaserad autentisering

Denna metod används när användaren får en unik token efter verifiering.

Med denna token så kan användaren nu få tillgång till relevanta resurser. Privilegiet är aktivt tills denna token löper ut.

Under tiden som denna token är aktiv så behöver användaren inte använda något användarnamn eller lösenord. När han/hon hämtar en ny token så krävs dock dessa två.

Tokens används i stor utsträckning i flera scenarier i dag eftersom de är tillståndslösa enheter som innehåller alla autentiserings-uppgifter.

Att tillhandahålla ett sätt att separera token-generering från token-verifiering ger leverantörerna en stor flexibilitet.

Autentisering med flera faktorer

Som namnet antyder så innebär detta att man använder minst två autentiserings-faktorer. Som ett resultat så ökar säkerheten.

Till skillnad från tvåfaktorsautentisering som endast innefattar två faktorer så kan denna metod innefatta två, tre, fyra eller fler…

Den här metodens typiska genomförande innebär att man använder ett lösenord, varefter användaren får en verifieringskod på sin smartphone. Leverantörer som implementerar den här metoden bör hålla utkik efter falska positiva resultat och nätverksavbrott, vilket kan bli stora problem när man skalar upp snabbt.

Hur man implementerar Laravel-autentisering

I det här avsnittet så lär du dig flera olika sätt att autentisera användarna i din applikation. Vissa bibliotek som Jetstream, Breeze och Socialite har kostnadsfria handledningar om hur man använder dem.

Manuell autentisering

Börja med att registrera användare och skapa de nödvändiga routerna i routes/web.php.

Vi kommer att skapa två router, en för att visa formuläret och en för att registrera:

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

Och skapa den kontrollant som behövs för dessa:

php artisan make:controller Auth/RegisterController -r

Uppdatera nu koden på följande sätt:

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

Kontrollanten är tom nu och returnerar en vy som ska registreras. Vi skapar den vyn i resources/views/auth och kallar den register.blade.php.

Besök /register-route

Nu när allt är på plats så bör vi besöka vår /register-route och se följande formulär:

Nu när vi kan visa ett formulär som en användare kan fylla i och få data för det, bör vi hämta användarnas data. Vi bör sedan validera dem och därefter lagra dem i databasen om allt är bra. Här bör du använda en databas-transaktion för att se till att de data som du lägger in är fullständiga.

Vi kommer att använda Laravel’s funktion för validering av begäranden för att se till att alla tre autentiserings-uppgifter krävs. Vi måste dessutom se till att e-postmeddelandet har ett e-postformat och är unikt i tabellen users och att lösenordet är bekräftat och har minst 8 tecken:

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

Allt som strider mot valideringen ger upphov till fel

Nu när vår inmatning är validerad så kommer allt som strider mot valideringen att ge upphov till ett fel som visas i formuläret:

Om vi antar att vi har skapat ett användarkonto i metoden store så bör vi även logga in användaren. Det finns två sätt att göra detta på. Vi kan göra det manuellt eller använda Auth-fasaden.

När användaren har loggat in så ska vi inte skicka tillbaka honom eller henne till skärmen Registrering. Användaren ska istället skickas till en ny sida, exempelvis en instrumentpanel eller en hemsida. Detta görs med denna kod:

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

Nu när vi har registrerat en användare och loggat in på -n så ska vi se till att han kan logga ut på ett säkert sätt.

Ogiltigförklara sessionen

Laravel föreslår att vi ogiltigförklarar sessionen och återskapar en token för säkerheten efter en utloggning. Och det är precis vad vi ska göra. Vi börjar med att skapa en ny /logout-route med hjälp av LogoutControllers destroy-metoden:

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

Att skicka utloggningen genom auth-middleware är mycket viktigt. Användarna ska inte kunna komma åt routen om de inte är inloggade.

Skapa nu en kontrollant som vi gjorde tidigare:

php artisan make:controller Auth/LogoutController -r

Logga ut användaren

Vi kan se till att vi får begäran som en parameter i destroy-metoden. Vi loggar ut användaren via Auth-fasaden, ogiltigförklarar sessionen och återskapar vår token och omdirigerar sedan användaren till hemsidan:

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

Att komma ihåg användare

De flesta, om inte alla, moderna webbapplikationer har en kryssruta för ”kom ihåg mig” i inloggningsformuläret.

Om vi vill tillhandahålla en funktion för att komma ihåg en användare så kan vi skicka ett boolsk värde som andra argument till metoden attempt.

När det är giltigt så kommer Laravel att hålla användaren autentiserad på en obestämd tid eller tills de loggas ut manuellt. Användartabellen måste inkludera kolumnen string remember_token (det är därför som vi förnyar våra tokens), där vi kommer att lagra vår ”kom ihåg mig”-token.

Standard-migreringen för användare inkluderar redan denna.

Först och främst så måste du lägga till fältet Remember Me i ditt formulär:

Du hämtar sedan autentiserings-uppgifterna från begärandet och använder dem i försöks-metoden på Auth-fasaden.

Om användaren blir ihågkommen så kommer vi att logga in honom och omdirigera honom till vår hemsida. I annat fall så kommer vi att visa ett felmeddelande:

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

Återställning av lösenord

De flesta webbapplikationer erbjuder idag sätt för användarna att återställa sina lösenord.

Vi kommer att skapa en annan route för det glömda lösenordet och skapa kontrollanten på samma sätt som tidigare. Dessutom så lägger vi till en route för länken för återställning av lösenordet som inkluderar en token för hela processen:

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

I butiksmetoden så tar vi e-postmeddelandet från begärandet och validerar det som vi gjorde.

Därefter så kan vi använda sendResetLink-metoden från lösenords-fasaden.

Som svar så bör vi sedan returnera statusen om vi lyckades skicka länken, annars ett felmeddelande:

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 när återställningslänken har skickats till användarens e-post så bör vi ta hand om logiken för vad som händer därefter.

Vi hämtar token, e-post och nytt lösenord i begärandet och validerar dem.

Nyttja återställ-metoden

Därefter så kan vi använda återställ-metoden från password-fassaden för att låta Laravel ta hand om allt annat bakom kulisserna.

Vi kommer alltid att hash-behandla lösenordet för att hålla det säkert.

I slutet så kommer vi att kontrollera om lösenordet har återställts. Om så är fallet så kommer vi att omdirigera användaren till inloggningsskärmen med ett meddelande om framgång. I annat fall så visar vi ett felmeddelande om att det inte kunde återställas:

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 är en enkel implementering av Laravel’s autentiserings-funktioner: inloggning, registrering, återställning av lösenord, e-postverifiering och bekräftelse av lösenord. Du kan använda den för att implementera autentisering i din nya Laravel-applikation.

Installation och inställning

När du har skapat din Laravel-applikation så behöver du bara konfigurera din databas, köra dina migreringar och installera paketet laravel/breeze via composer:

composer require laravel/breeze --dev

Efter detta så kör du följande:

php artisan breeze:install

Detta kommer sedan att publicera dina autentiserings-vyer, router, styrenheter och andra resurser som används. Efter detta steg så har du fullständig kontroll över allt som Breeze tillhandahåller.

Nu måste vi återge vår applikation till frontend, så vi kommer att installera våra JS-beroenden (som kommer att använda @vite):

npm install

:

npm run dev

Därefter så bör länkarna för inloggning och registrering finnas på din hemsida och allt bör fungera smidigt.

Laravel Jetstream

Laravel Jetstream utökar Laravel Breeze med användbara funktioner och andra frontend-stackar.

Den tillhandahåller inloggning, registrering, e-postverifiering, tvåfaktorsautentisering, sessionshantering, API-stöd via Sanctum och valfri team-hantering.

Du måste välja mellan Livewire och Inertia på frontend när du installerar Jetstream. På backend så används Laravel Fortify, som är en frontend agnostisk, ”huvudlös” autentiserings-backend för Laravel.

Installation och inställning

Vi kommer att installera den genom composer i vårt Laravel-projekt:

composer require laravel/jetstream

Därefter så kör vi kommandot php artisan jetstream:install [stack], som accepterar [stack] -argumenten Livewire eller Inertia. Du kan skicka alternativet –-teams för att aktivera teamfunktionen.

Detta kommer även att installera Pest PHP för testning.

Och slutligen så måste vi rendera frontend av vår applikation med hjälp av följande:

npm install
npm run dev

Laravel Fortify

Laravel Fortify är en autentiserings-implementering för backend som är oberoende av frontend. Du behöver inte använda Laravel Fortify för att implementera Laravels autentiserings-funktioner.

Den används även i startpaket som Breeze och Jetstream. Du kan dessutom använda Fortify standalone, som endast är en backend-implementering. Om du använder den fristående så måste din frontend anropa Fortify-vägarna.

Installation och inställning

Vi kan installera Fortify genom composer:

composer require laravel/fortify

Nu måste vi publicera Fortifys resurser:

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

Därefter så kommer vi att skapa en ny app/Actions-katalog utöver den nya FortifyServiceProvider, konfigurationsfilen och databas-migreringen.

Slutligen så ska du köra:

php artisan migrate

Eller:

php artisan migrate:fresh

Sen är Fortify är redo att användas.

Laravel Socialite

Laravel inkluderar dessutom en enkel OAuth-baserad funktion för användar-autentisering. Den stöder exempelvis sociala inloggningar via Facebook, Twitter, LinkedIn, Google, Bitbucket, GitHub och GitLab.

Installation

Vi kan installera den via composer:

composer require laravel/socialite

Installation och användning

När vi har installerat den så måste vi sedan lägga till autentiserings-uppgifter för den OAuth-provider som vår applikation använder. Vi lägger till dem i config/services.php för varje tjänst.

I konfigurationen så ska vi matcha nyckeln med de tidigare tjänsterna. Några av dessa nycklar är exempelvis:

• facebook
• twitter (för OAuth 1.0)
• twitter-oauth-2 (För OAuth 2.0)
• linkedin
• google
• github
• gitlab
• bitbucket

En tjänstekonfiguration kan se ut så här:

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

Autentisering av användare

För den här åtgärden så behöver vi två router, en för att omdirigera användaren till OAuth-leverantören:

use Laravel\Socialite\Facades\Sociliate;

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

och en för callback från leverantören efter autentisering:

use Laravel\Socialite\Facades\Socialite;

Route:;get('/auht/callback', function () {
    $user = Socialite::driver('google')->user();

    // Getting the user data
    $user->token;
});

Socialite tillhandahåller omdirigeringsmetoden, och fasaden omdirigerar användaren till OAuth-leverantören. Användarmetoden undersöker sedan det inkommande begärandet och hämtar användarinformationen.

Kontrollera om användaren finns i databasen

När vi har fått vår användare så måste vi dessutom kontrollera om den finns i vår databas och autentisera den. Om den inte finns, så skapar vi en ny post för att representera användaren:

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

Om vi vill begränsa användarens åtkomstområden så kan vi använda metoden scopes, som vi inkluderar i autentiserings-begärandet. Detta kommer sedan att slå samman alla tidigare angivna områden med de angivna.

Ett alternativ till detta är att använda metoden setScopes som skriver över alla andra befintliga router:

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

Låt oss titta på lite data

Nu när vi vet allt om hur vi får en användare efter callbacken, låt oss titta på några av de data som vi kan få från detta.

OAuth1-användaren har token och tokenSecret:

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

$token = $user->token;
$tokenSecret = $user->tokenSecret;

OAuth2 ger token, refreshToken och expiresIn:

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

$token = $user->token;
$refreshToken = $user->refreshToken;
$expiresIn = $user->expiresIn;

Både OAuth1 och OAuth2 tillhandahåller getId, getNickname, getName, getEmail och getAvatar:

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

$user->getId();
$user->getNickName();
$user->getName();
$user->getEmail();
$user->getAvatar();

Och om vi vill få fram användaruppgifter från en token (OAuth 2) eller en token och en hemlighet (OAuth 1), så tillhandahåller Socialite två metoder för detta: userFromToken och userFromTokenAndSecret:

use Laravel\Socialite\Facades\Socialite;

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

Laravel Sanctum

Laravel Sanctum är ett lättviktigt autentiserings-system för SPAs (Single Page Applications) och mobilappar. Det låter användare generera flera API-tokens med specifika router. Dessa scopes anger tillåtna åtgärder för en token.

Användningsområden

Sanctum kan användas för att utfärda API-tokens till användaren utan OAuth’s invecklade system. Dessa tokens har vanligtvis långa utgångstider, exempelvis år, men kan återkallas och återskapas av användaren när som helst.

Installation och inställning

Vi kan installera detta via composer:

composer require laravel/sanctum

Och vi måste publicera konfigurations- och migrerings-filerna:

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

Nu när vi har genererat nya migrerings-filer så måste vi migrera dem:

php artisan migrate:fresh

Hur man utfärdar API-tokens

Innan vi utfärdar tokens så bör vår användarmodell använda Laravel\Sanctum\HasApiTokens-egenskapen:

use Laravel\Sanctum\HasApiTokens;

class User extends Authenticable
{
    use HasApiTokens;
}

När vi har användaren så kan vi utfärda en token genom att anropa metoden createToken. Som ett resultat så returneras en instans av Laravel\Sanctum\NewAccessToken.

Vi kan anropa metoden plainTextToken på instansen NewAccessToken för att se tokens SHA-256-värde i klartext.

Tips och bästa praxis för Laravel-autentisering

Invalidering av sessioner på andra enheter

Som vi har diskuterat tidigare så är det viktigt att ogiltigförklara sessionen när användaren loggar ut. Detta bör dock även finnas tillgängligt som ett alternativ för alla ägda enheter.

Den här funktionen används vanligtvis när användaren ändrar eller uppdaterar sitt lösenord och vi vill ogiltigförklara deras session från någon annan enhet.

Med Auth-fasaden så är detta en enkel uppgift att utföra. Med tanke på att den route som vi använder har auth och auth.session middleware så kan vi använda den statiska metoden logoutOtherDevices i fasaden:

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-fasaden är endast en hjälpreda för att generera alla de router som krävs för användar-autentisering.

Routerna omfattar inloggning (hämta, skicka), utloggning (skicka), registrering (hämta, skicka) och återställning av lösenord/e-post (hämta, skicka).

När du anropar metoden på fasaden så gör den följande:

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 är intresserade av vad som händer när den statiska metoden anropas på routen. Detta kan vara knepigt på grund av hur fasader fungerar, men följande metod kan lösa detta:

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

Genererar inte router för e-postverifiering

Som standard så genererar den alla router förutom den för e-postverifiering. Vi kommer alltid att ha routerna Login och Logout, men de andra rutterna kan vi styra via options-matrisen.

Om vi endast vill ha inloggning/utloggning och registrering så kan vi skicka följande options-matris:

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

Skydda router och anpassade vakter

Vi vill sedan försäkra oss om att vissa router endast kan nås av autentiserade användare. Detta kan snabbt göras genom att lägga till antingen anrop av middleware-metoden på Route-fasaden eller kedja 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');

Denna vakt säkerställer att inkommande begäranden är autentiserade.

Bekräftelse av lösenord

För att öka säkerheten på webbplatsen så vill man ofta bekräfta en användares lösenord innan man går vidare med någon annan uppgift.

Vi måste definiera en route från vyn Bekräfta lösenord för att hantera begärandet. Den kommer att validera och omdirigera användaren till den avsedda destinationen. Samtidigt så ser vi till att vårt lösenord visas bekräftat i sessionen. Som standard så måste lösenordet dessutom bekräftas på nytt var tredje timme, men detta kan ändras i konfigurationsfilen i 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-kontraktet

Authenticable-kontraktet som finns på Illuminate\Contracts\Auth definierar en plan för vad UserProvider-fasaden ska implementera:

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änssnittet gör det möjligt för autentiserings-systemet att arbeta med alla ”användar”-klasser som implementerar detta.

Detta gäller oavsett vilken ORM eller vilket lagrings-arkiv som används. Som standard så har Laravel App\Models\User som implementerar det här gränssnittet, och detta kan även ses i konfigurationsfilen:

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

Autentiseringshändelser

Det finns många händelser som skickas ut under hela autentiserings-processen.

Beroende på dina mål så kan du koppla lyssnare till dessa händelser i din EventServiceProvider.

Skapa snabbt nya användare

Du kan snabbt skapa en ny användare via App\User:

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

Eller genom den statiska metoden create på Användar-fasaden:

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

Sammanfattning

Laravel-ekosystemet har många startpaket för att få igång din app med ett autentiserings-system, som Breeze och Jetstream. De är väldigt anpassningsbara eftersom koden genereras på vår sida. Vi kan dessutom ändra den så mycket som vi vill, och använda den som en blåkopia om det krävs.

Det finns många säkerhetsproblem när det gäller autentisering och dess intrikat. Alla dessa kan dock enkelt lösas med hjälp av de verktyg som Laravel tillhandahåller. Dessa verktyg är mycket anpassningsbara och lätta att använda.

Distribuera dina Laravel-appar snabbt och effektivt med vår snabba hosting-tjänst för Laravel. Se din app i aktion med en kostnadsfri provperiod.