Kompleksowy przewodnik po uwierzytelnianiu Laravel

Uwierzytelnianie jest jedną z najważniejszych i najważniejszych funkcji aplikacji internetowych. Frameworki internetowe, takie jak Laravel, zapewniają użytkownikom wiele sposobów uwierzytelniania.

Możesz szybko i bezpiecznie wdrożyć funkcje uwierzytelniania Laravel. Jednak niewłaściwe wdrożenie tych funkcji uwierzytelniania może być ryzykowne, ponieważ złośliwe strony mogą je wykorzystać.

Ten przewodnik nauczy Cię wszystkiego, co musisz wiedzieć, aby zacząć korzystać z wybranych metod uwierzytelniania Laravel.

Czytaj!

Wprowadzenie do uwierzytelniania Laravel

Laravel wprowadza moduły, które składają się z „strażników” i „dostawców”. Strażnicy definiują uwierzytelnianie użytkownika dla każdego żądania, a dostawcy określają pobieranie użytkownika z pamięci trwałej (np. bazy danych MySQL).

Definiujemy nasze parametry uwierzytelniania w pliku o nazwie config/auth.php . Zawiera kilka opcji do dostosowywania i modyfikowania zachowania uwierzytelniania Laravel.

Najpierw musisz zdefiniować domyślne ustawienia uwierzytelniania. Ta opcja steruje domyślnymi opcjami uwierzytelniania aplikacji „strażnik” i resetowania hasła. W razie potrzeby możesz zmienić te ustawienia domyślne, ale są one idealnym początkiem dla większości aplikacji.

Następnie zdefiniuj zabezpieczenia uwierzytelniania dla swojej aplikacji. Tutaj nasza domyślna konfiguracja wykorzystuje przechowywanie sesji i dostawcę użytkownika Eloquent. Wszystkie sterowniki uwierzytelniania mają dostawcę użytkownika.

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

Później upewniamy się, że wszystkie sterowniki uwierzytelniania mają dostawcę użytkownika. Określa to, w jaki sposób użytkownicy są pobierani z bazy danych lub innych mechanizmów przechowywania w celu utrwalenia danych użytkownika. Możesz skonfigurować wiele źródeł reprezentujących każdy model lub tabelę, jeśli masz wiele tabel lub modeli użytkowników. Źródła te mogą być przypisane do dowolnych dodatkowych zabezpieczeń uwierzytelniania, które zdefiniowałeś.

Użytkownicy mogą również chcieć zresetować swoje hasła. W tym celu można określić wiele konfiguracji resetowania hasła, jeśli w aplikacji jest więcej niż jedna tabela lub model użytkownika i potrzebne są osobne ustawienia na podstawie określonych typów użytkowników. Czas wygaśnięcia to liczba minut, przez które każdy token resetowania będzie ważny. Ta funkcja bezpieczeństwa sprawia, że ​​tokeny są krótkotrwałe, więc mają mniej czasu na odgadnięcie. W razie potrzeby możesz to zmienić.

Ostatecznie musisz zdefiniować czas, po którym potwierdzenie hasła wygaśnie, a użytkownik zostanie poproszony o ponowne wprowadzenie hasła na ekranie potwierdzenia. Domyślnie limit czasu wynosi trzy godziny.

Rodzaje metod uwierzytelniania Laravel

Nie ma idealnego sposobu uwierzytelnienia każdego scenariusza, ale ich znajomość pomoże Ci podejmować lepsze decyzje. To i sposób, w jaki Laravel ewoluuje dzięki nowym funkcjom w Laravel 9. To znacznie ułatwia naszą pracę jako programistów przy przełączaniu trybów uwierzytelniania.

Uwierzytelnianie oparte na haśle

Jako podstawowy sposób uwierzytelniania użytkownika jest nadal używany przez tysiące organizacji, ale biorąc pod uwagę obecny rozwój, wyraźnie staje się przestarzały.

Dostawcy muszą egzekwować złożone implementacje haseł, zapewniając jednocześnie minimalne problemy dla użytkownika końcowego.

Działa to dość prosto, użytkownik wprowadza nazwę i hasło, a jeśli w Bazie Danych występuje zgodność między tymi dwoma, serwer decyduje się na uwierzytelnienie żądania i zezwolenie użytkownikowi na dostęp do zasobów na określony czas.

Uwierzytelnianie oparte na tokenach

Ta metodologia jest używana, gdy użytkownik otrzymuje unikalny token po weryfikacji.

Posiadając ten token, użytkownik ma teraz dostęp do odpowiednich zasobów. Uprawnienie jest aktywne do momentu wygaśnięcia tokena.

Podczas gdy token jest aktywny, użytkownik nie musi używać nazwy użytkownika ani hasła, ale przy pobieraniu nowego tokena te dwa są wymagane.

Tokeny są obecnie szeroko stosowane w wielu scenariuszach, ponieważ są jednostkami bezstanowymi, które zawierają wszystkie dane uwierzytelniające.

Zapewnienie sposobu oddzielenia generowania tokenów od weryfikacji tokenów zapewnia dostawcom dużą elastyczność.

Uwierzytelnianie wieloskładnikowe

Jak sama nazwa wskazuje, oznacza to użycie co najmniej dwóch czynników uwierzytelniających, podnoszących bezpieczeństwo, jakie zapewnia.

W przeciwieństwie do uwierzytelniania dwuskładnikowego, które obejmuje tylko dwa czynniki, ta metoda może obejmować dwa, trzy, cztery i więcej…

Typowa implementacja tej metody polega na użyciu hasła, po czym użytkownik otrzymuje na smartfona kod weryfikacyjny. Dostawcy wdrażający tę metodę powinni zwracać uwagę na fałszywe alarmy i awarie sieci, które mogą stać się dużymi problemami podczas szybkiego skalowania.

Jak zaimplementować uwierzytelnianie Laravel

W tej sekcji nauczysz się wielu sposobów uwierzytelniania użytkowników aplikacji. Niektóre biblioteki, takie jak Jetstream, Breeze i Socialite, mają bezpłatne samouczki dotyczące korzystania z nich.

Uwierzytelnianie ręczne

Rozpoczęcie od zarejestrowania użytkowników i utworzenia potrzebnych tras w routes/web.php .

Stworzymy dwie trasy, jedną do przeglądania formularza i jedną do rejestracji:

 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 utwórz kontroler potrzebny do tych:

 php artisan make controller Auth/RegisterController -r

Teraz zaktualizuj kod w następujący sposób:

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

Kontroler jest teraz pusty i zwraca widok do zarejestrowania. Zróbmy ten widok w resources/views/auth i nazwijmy go register.blade.php .

Teraz, gdy wszystko jest na swoim miejscu, powinniśmy odwiedzić naszą trasę /register i zobaczyć następujący formularz:

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

Teraz, gdy możemy wyświetlić formularz, który użytkownik może wypełnić i uzyskać do niego dane, powinniśmy pobrać dane użytkowników, zweryfikować je, a następnie zapisać w bazie danych, jeśli wszystko jest w porządku. W tym przypadku należy użyć transakcji bazy danych, aby upewnić się, że wprowadzane dane są kompletne.

Użyjemy funkcji sprawdzania poprawności żądań Laravel, aby upewnić się, że wszystkie trzy poświadczenia są wymagane. Musimy upewnić się, że e-mail ma format e-mail i jest unikalny w tabeli users oraz że hasło jest potwierdzone i ma minimum 8 znaków:

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

Teraz, gdy nasze dane wejściowe zostały zweryfikowane, wszystko, co jest sprzeczne z naszą weryfikacją, spowoduje błąd, który zostanie wyświetlony w postaci:

Zakładając, że założyliśmy konto użytkownika w metodzie store , chcemy również zalogować użytkownika. Możemy to zrobić na dwa sposoby. Możemy to zrobić ręcznie lub użyć fasady Auth .

Po zalogowaniu się użytkownika nie powinniśmy wracać do ekranu Rejestracja, ale do nowej strony, takiej jak pulpit nawigacyjny lub strona główna. Oto, co zamierzamy tutaj zrobić:

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

A teraz, gdy mamy zarejestrowanego i zalogowanego użytkownika -n , powinniśmy upewnić się, że może on bezpiecznie się wylogować.

Laravel sugeruje unieważnienie sesji i ponowne wygenerowanie tokena dla bezpieczeństwa po wylogowaniu. I to jest właśnie to, co zamierzamy zrobić. Zaczynamy od utworzenia nowej trasy /logout przy użyciu metody destroy kontrolera 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');

Przekazanie wylogowania przez oprogramowanie pośredniczące „auth” jest bardzo ważne. Użytkownicy nie powinni mieć dostępu do trasy, jeśli nie są zalogowani.

Teraz utwórz kontroler tak, jak zrobiliśmy to wcześniej:

 php artisan make:controller Auth/LogoutController -r

Możemy zapewnić, że otrzymamy żądanie jako parametr w metodzie destroy . Wylogowujemy użytkownika przez fasadę Auth, unieważniamy sesję i regenerujemy token, następnie przekierowujemy użytkownika na stronę główną:

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

Zapamiętywanie użytkowników

Większość, jeśli nie wszystkie, nowoczesnych aplikacji internetowych udostępnia pole wyboru „zapamiętaj mnie” w formularzu logowania.

Jeśli chcemy zapewnić funkcjonalność „zapamiętaj mnie”, możemy przekazać wartość logiczną jako drugi argument metody próbnej.

Gdy jest ważny, Laravel będzie utrzymywać uwierzytelnianie użytkownika przez czas nieokreślony lub do momentu ręcznego wylogowania. W tabeli user musi znaleźć się kolumna string remember_token (dlatego regenerujemy tokeny), w której będziemy przechowywać nasz token „zapamiętaj mnie”.

Domyślna migracja dla użytkowników już to obejmuje.

Po pierwsze, musisz dodać pole Zapamiętaj mnie do swojego formularza:

Następnie uzyskaj poświadczenia z żądania i użyj ich w metodzie próby na fasadzie Auth.

Jeśli użytkownik zostanie zapamiętany, zalogujemy go i przekierujemy na naszą stronę główną. W przeciwnym razie wyrzucimy błąd:

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

Resetowanie haseł

Większość dzisiejszych aplikacji internetowych umożliwia użytkownikom resetowanie haseł.

Zrobimy inną trasę dla zapomnianego hasła i utworzymy kontroler tak jak to zrobiliśmy. Dodatkowo dodamy trasę dla linku resetowania hasła, który zawiera token dla całego procesu:

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

W metodzie sklepu pobierzemy wiadomość e-mail z żądania i zweryfikujemy ją tak, jak to zrobiliśmy.

Następnie możemy użyć metody sendResetLink z fasady hasła.

A następnie w odpowiedzi chcemy zwrócić status, jeśli udało się wysłać link lub błędy w inny sposób:

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

Teraz, gdy link do resetowania został wysłany na adres e-mail użytkownika, powinniśmy zająć się logiką tego, co dzieje się później.

Otrzymamy token, adres e-mail i nowe hasło w żądaniu i zweryfikujemy je.

Następnie możemy użyć metody resetowania z fasady hasła, aby Laravel zajął się wszystkim innym za kulisami.

Zawsze będziemy haszować hasło, aby je zabezpieczyć.

Na koniec sprawdzimy, czy hasło zostało zresetowane, a jeśli tak, przekierujemy użytkownika do ekranu logowania z komunikatem o powodzeniu. W przeciwnym razie wyświetlamy błąd, że nie można go zresetować:

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

Bryza Laravela

Laravel Breeze to prosta implementacja funkcji uwierzytelniania Laravel: logowanie, rejestracja, resetowanie hasła, weryfikacja adresu e-mail i potwierdzenie hasła. Możesz go użyć do zaimplementowania uwierzytelniania w swojej nowej aplikacji Laravel.

Instalacja i konfiguracja

Po utworzeniu aplikacji Laravel wystarczy skonfigurować bazę danych, przeprowadzić migracje i zainstalować pakiet laravel/breeze za pośrednictwem kompozytora:

 composer require laravel/breeze –dev

Następnie uruchom następujące polecenie:

 php artisan breeze:install

Który opublikuje Twoje widoki uwierzytelniania, trasy, kontrolery i inne zasoby, z których korzysta. Po tym kroku masz pełną kontrolę nad wszystkim, co zapewnia Breeze.

Teraz musimy wyrenderować naszą aplikację do frontendu, więc zainstalujemy nasze zależności JS (które będą używać @vite):

 npm install

:

 npm run dev

Następnie linki do logowania i rejestracji powinny znajdować się na Twojej stronie głównej i wszystko powinno działać płynnie.

Laravel Jetstream

Laravel Jetstream rozszerza Laravel Breeze o przydatne funkcje i inne stosy frontendowe.

Zapewnia logowanie, rejestrację, weryfikację adresu e-mail, uwierzytelnianie dwuskładnikowe, zarządzanie sesjami, obsługę API za pośrednictwem Sanctum i opcjonalne zarządzanie zespołem.

Podczas instalacji Jetstream musisz wybrać między Livewire a Inertia na interfejsie użytkownika. Na zapleczu wykorzystuje Laravel Fortify, który jest agnostycznym, „bezgłowym” uwierzytelnianiem dla Laravel.

Instalacja i konfiguracja

Zainstalujemy go przez kompozytora w naszym projekcie Laravel:

 composer require laravel/jetstream

Następnie uruchomimy polecenie php artisan jetstream:install [stack] , które akceptuje argumenty [stack] Livewire lub Inertia . Możesz przekazać opcję –team , aby włączyć funkcję zespołów.

Spowoduje to również zainstalowanie Pest PHP do testowania.

Na koniec musimy wyrenderować frontend naszej aplikacji, korzystając z:

 npm install npm run dev

Wzmocnienie Laravela

Laravel Fortify to implementacja uwierzytelniania zaplecza, która jest niezależna od frontendu. Nie musisz używać Laravel Fortify, aby zaimplementować funkcje uwierzytelniania Laravel.

Jest również używany w zestawach startowych, takich jak Breeze i Jetstream. Możesz także użyć samodzielnej wersji Fortify, która jest tylko implementacją zaplecza. Jeśli używasz go samodzielnie, twój frontend musi wywoływać trasy Fortify.

Instalacja i konfiguracja

Możemy zainstalować Fortify przez kompozytora:

 composer require laravel/fortify

Teraz musimy opublikować zasoby Fortify:

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

Następnie utworzymy nowy katalog app/Actions oprócz nowego FortifyServiceProvider , pliku konfiguracyjnego i migracji bazy danych.

Na koniec uruchom:

 php artisan migrate

Lub:

 php artisan migrate:fresh

Twój Fortify jest gotowy do użycia.

Towarzystwo Laravela

Laravel zawiera prostą funkcję uwierzytelniania użytkownika opartą na OAuth. Obsługuje logowania społecznościowe za pośrednictwem Facebooka, Twittera, LinkedIn, Google, Bitbucket, GitHub i GitLab.

Instalacja

Możemy zainstalować go przez kompozytora:

 composer require laravel/socialite

Konfiguracja i użytkowanie

Po zainstalowaniu musimy dodać poświadczenia dla dostawcy OAuth, z którego korzysta nasza aplikacja. Dodamy je w config/services.php dla każdej usługi.

W konfiguracji powinniśmy dopasować klucz do poprzednich usług. Niektóre z tych kluczy to:

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

Jedna konfiguracja usługi może wyglądać tak:

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

Uwierzytelnianie użytkowników

Do tej akcji będziemy potrzebować dwóch tras, jednej do przekierowania użytkownika do dostawcy OAuth:

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

I jeden dla oddzwonienia od dostawcy po uwierzytelnieniu:

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

Socialite zapewnia metodę przekierowania, a fasada przekierowuje użytkownika do dostawcy OAuth, podczas gdy metoda użytkownika bada przychodzące żądanie i pobiera informacje o użytkowniku.

Po otrzymaniu naszego użytkownika musimy sprawdzić, czy istnieje on w naszej bazie danych i uwierzytelnić go. Jeśli nie istnieje, utworzymy nowy rekord reprezentujący użytkownika:

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

Jeśli chcemy ograniczyć zakresy dostępu użytkownika, możemy skorzystać z metody scopes , którą dołączymy do żądania uwierzytelnienia. Spowoduje to scalenie wszystkich wcześniej określonych zakresów z określonymi.

Alternatywą jest użycie metody setScopes , która nadpisuje każdy inny istniejący zakres:

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

Teraz, gdy wiemy już wszystko i jak zdobyć użytkownika po wywołaniu zwrotnym, spójrzmy na niektóre dane, które możemy z niego uzyskać.

Użytkownik OAuth1 ma token i tokenSecret :

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

OAuth2 zapewnia token , refreshToken i expiresIn :

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

Zarówno OAuth1, jak i OAuth2 zapewniają getId , getNickname , getName , getEmail i getAvatar :

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

A jeśli chcemy uzyskać dane użytkownika z tokena (OAuth 2) lub tokena i klucza tajnego (OAuth 1), sanctum udostępnia do tego dwie metody: userFromToken i userFromTokenAndSecret :

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

Sanktuarium Laravela

Laravel Sanctum to lekki system uwierzytelniania dla SPA (Single Page Applications) i aplikacji mobilnych. Pozwala użytkownikom generować wiele tokenów API o określonych zakresach. Te zakresy określają dozwolone akcje za pomocą tokenu.

zwyczaje

Sanctum może służyć do wydawania tokenów API użytkownikowi bez zawiłości OAuth. Te tokeny mają zwykle długi okres ważności, na przykład lata, ale mogą zostać odwołane i ponownie wygenerowane przez użytkownika w dowolnym momencie.

Instalacja i konfiguracja

Możemy go zainstalować za pomocą kompozytora:

 composer require laravel/sanctum

I musimy opublikować pliki konfiguracyjne i migracyjne:

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

Teraz, gdy wygenerowaliśmy nowe pliki migracji, musimy je przeprowadzić:

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

Jak wystawiać tokeny API

Przed wydaniem tokenów nasz model User powinien użyć cechy Laravel\Sanctum\HasApiTokens :

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

Gdy już mamy użytkownika, możemy wystawić token, wywołując metodę createToken , która zwraca instancję Laravel\Sanctum\NewAccessToken .

Możemy wywołać metodę plainTextToken w instancji NewAccessToken , aby zobaczyć wartość zwykłego tekstu SHA-256 tokena.

Wskazówki i najlepsze praktyki dotyczące uwierzytelniania Laravel

Unieważnianie sesji na innych urządzeniach

Jak omówiliśmy wcześniej, unieważnienie sesji jest kluczowe, gdy użytkownik się wylogowuje, ale powinno to być również dostępne jako opcja dla wszystkich posiadanych urządzeń.

Ta funkcja jest zwykle używana, gdy użytkownik zmienia lub aktualizuje swoje hasło, a my chcemy unieważnić jego sesję z dowolnego innego urządzenia.

Dzięki fasadzie Auth jest to łatwe do osiągnięcia. Biorąc pod uwagę, że trasa, której używamy, ma oprogramowanie pośredniczące auth i auth.session middleware , możemy użyć statycznej metody fasady logoutOtherDevices :

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

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

Konfiguracja za pomocą Auth::routes()

Metoda tras fasady Auth jest tylko pomocnikiem w generowaniu wszystkich tras wymaganych do uwierzytelnienia użytkownika.

Trasy obejmują Logowanie (Pobierz, Wyślij), Wyloguj (Pobierz), Zarejestruj się (Pobierz, Wyślij) i Resetowanie hasła/e-mail (Pobierz, Wyślij).

Kiedy wywołujesz metodę na fasadzie, wykonuje ona następujące czynności:

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

Interesuje nas, co się stanie, gdy metoda statyczna zostanie wywołana na routerze. Może to być trudne ze względu na fakt, jak działają fasady, ale następująca metoda jest następująca:

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

Domyślnie generuje wszystkie trasy oprócz weryfikacji adresu e-mail. Zawsze będziemy mieć trasy logowania i wylogowania, ale pozostałe możemy kontrolować za pomocą tablicy opcji.

Jeśli chcemy mieć tylko logowanie/wylogowanie i rejestrację, możemy przekazać następującą tablicę opcji:

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

Ochrona tras i straż celna

Chcemy mieć pewność, że dostęp do niektórych tras mają tylko uwierzytelnieni użytkownicy i można to szybko zrobić, dodając wywołanie metody oprogramowania pośredniczącego na fasadzie trasy lub łącząc metodę oprogramowania pośredniego:

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

Ten strażnik zapewnia uwierzytelnianie przychodzących żądań.

Potwierdzenie hasła

Aby zwiększyć bezpieczeństwo witryny, często chcesz potwierdzić hasło użytkownika przed wykonaniem jakiegokolwiek innego zadania.

Musimy zdefiniować trasę z widoku potwierdzenia hasła, aby obsłużyć żądanie. Zweryfikuje i przekieruje użytkownika do zamierzonego miejsca docelowego. Jednocześnie upewnimy się, że nasze hasło pojawiło się w sesji jako potwierdzone. Domyślnie hasło musi być potwierdzane co trzy godziny, ale można to zmienić w pliku konfiguracyjnym w 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']);

Autentyczność kontraktu

Uwierzytelnialna umowa znajdująca się w Illuminate\Contracts\Auth określa plan tego, co powinna wdrożyć fasada 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(); }

Interfejs umożliwia systemowi uwierzytelniania współpracę z dowolną klasą „użytkownika”, która go implementuje.

Dzieje się tak niezależnie od tego, jakie ORM lub warstwy pamięci są używane. Domyślnie Laravel ma App\Models\User, który implementuje ten interfejs, co można również zobaczyć w pliku konfiguracyjnym:

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

Zdarzenia uwierzytelniające

Istnieje wiele zdarzeń, które są wywoływane podczas całego procesu uwierzytelniania.

W zależności od swoich celów możesz dołączyć słuchaczy do tych wydarzeń w swoim EventServiceProvider .

Szybko twórz nowych użytkowników

Szybkie tworzenie nowego użytkownika można wykonać za pomocą App\User :

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

Lub za pomocą metody create static na fasadzie użytkownika:

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

Streszczenie

Ekosystem Laravel zawiera wiele zestawów startowych, dzięki którym Twoja aplikacja może działać z systemem uwierzytelniania, takim jak Breeze i Jetstream. Są wysoce konfigurowalne, ponieważ kod jest generowany po naszej stronie i możemy go dowolnie modyfikować, używając go jako planu, jeśli zajdzie taka potrzeba.

Istnieje wiele problemów związanych z bezpieczeństwem związanych z uwierzytelnianiem i jego zawiłościami, ale wszystkie z nich można łatwo rozwiązać za pomocą narzędzi udostępnianych przez Laravel. Narzędzia te są wysoce konfigurowalne i łatwe w użyciu.

Szybko i wydajnie wdrażaj swoje aplikacje Laravel dzięki naszej szybkiej usłudze hostingowej Laravel. Zobacz swoją aplikację w akcji dzięki bezpłatnemu okresowi próbnemu.