Ein umfassender Leitfaden zur Laravel-Authentifizierung

Die Authentifizierung ist eine der kritischsten und wichtigsten Funktionen von Webanwendungen. Web-Frameworks wie Laravel bieten viele Möglichkeiten für die Authentifizierung von Nutzern.

Du kannst die Authentifizierungsfunktionen von Laravel schnell und sicher implementieren. Eine mangelhafte Implementierung dieser Authentifizierungsfunktionen kann jedoch riskant sein, da böswillige Parteien sie ausnutzen können.

In diesem Leitfaden erfährst du alles, was du wissen musst, um mit den von dir gewählten Laravel-Authentifizierungsmethoden loszulegen.

Los geht’s!

Eine Einführung in die Laravel-Authentifizierung

Laravel führt Module ein, die aus „Wächtern“ und „Anbietern“ bestehen Guards legen die Benutzerauthentifizierung für jede Anfrage fest, und Provider definieren den Abruf von Benutzerdaten aus einem dauerhaften Speicher (z. B. einer MySQL-Datenbank).

Wir legen unsere Authentifizierungsparameter in einer Datei namens config/auth.php fest. Sie enthält mehrere Optionen, um das Authentifizierungsverhalten von Laravel zu optimieren und zu ändern.

Zuerst musst du die Authentifizierungsvorgaben festlegen. Diese Option steuert die Standardoptionen für die Authentifizierung und das Zurücksetzen von Passwörtern in deiner Anwendung. Du kannst diese Voreinstellungen nach Bedarf ändern, aber für die meisten Anwendungen sind sie ein perfekter Start.

Als Nächstes legst du die Authentifizierungsgarantien für deine Anwendung fest. In unserer Standardkonfiguration verwenden wir den Sitzungsspeicher und den Eloquent User Provider. Alle Authentifizierungstreiber haben einen User Provider.

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

Später stellen wir sicher, dass alle Authentifizierungstreiber einen Benutzerprovider haben. Dieser legt fest, wie die Benutzer aus deiner Datenbank oder anderen Speichermechanismen abgerufen werden, um die Benutzerdaten zu erhalten. Du kannst mehrere Quellen für jedes Modell oder jede Tabelle konfigurieren, wenn du mehrere Benutzertabellen oder -modelle hast. Diese Quellen können allen zusätzlichen Authentifizierungsgarden zugewiesen werden, die du definiert hast.

Es kann auch sein, dass die Benutzer ihre Passwörter zurücksetzen wollen. Hierfür kannst du mehrere Konfigurationen für das Zurücksetzen von Passwörtern festlegen, wenn du mehr als eine Benutzertabelle oder ein Modell in der Anwendung hast und für die einzelnen Benutzertypen unterschiedliche Einstellungen vornehmen möchtest. Die Ablaufzeit ist die Anzahl der Minuten, die jedes Reset-Token gültig ist. Diese Sicherheitsfunktion sorgt dafür, dass die Token kurzlebig sind, damit sie weniger Zeit haben, erraten zu werden. Du kannst dies nach Bedarf ändern.

Schließlich musst du die Zeit festlegen, die vergeht, bevor eine Passwortbestätigung abläuft und der Nutzer aufgefordert wird, sein Passwort erneut über den Bestätigungsbildschirm einzugeben. In der Standardeinstellung dauert die Zeitüberschreitung drei Stunden.

Arten von Laravel-Authentifizierungsmethoden

Es gibt nicht für jedes Szenario die perfekte Authentifizierungsmethode, aber wenn du sie kennst, kannst du bessere Entscheidungen treffen. Dies und wie sich Laravel mit den neuen Funktionen in Laravel 9 weiterentwickelt. Das macht unsere Arbeit als Entwickler viel einfacher, wenn wir die Authentifizierungsmethoden wechseln.

Passwortbasierte Authentifizierung

Diese rudimentäre Art der Benutzerauthentifizierung wird immer noch von Tausenden von Unternehmen genutzt, aber wenn man die aktuelle Entwicklung betrachtet, ist sie eindeutig veraltet.

Die Anbieter müssen komplexe Passwörter durchsetzen und gleichzeitig dafür sorgen, dass die Reibung für den Endnutzer möglichst gering ist.

Die Funktionsweise ist ziemlich einfach: Der Nutzer gibt seinen Namen und sein Passwort ein, und wenn die Datenbank eine Übereinstimmung zwischen diesen beiden Daten feststellt, entscheidet der Server, die Anfrage zu authentifizieren und dem Nutzer für eine bestimmte Zeit Zugang zu den Ressourcen zu gewähren.

Token-basierte Authentifizierung

Bei dieser Methode erhält der/die Nutzer/in nach der Überprüfung ein eindeutiges Token.

Mit diesem Token kann der Nutzer nun auf die entsprechenden Ressourcen zugreifen. Die Berechtigung gilt so lange, bis das Token abläuft.

Solange der Token aktiv ist, muss der Nutzer weder einen Benutzernamen noch ein Passwort verwenden, aber wenn er einen neuen Token abruft, sind diese beiden erforderlich.

Token werden heute in vielen Szenarien eingesetzt, da sie zustandslose Einheiten sind, die alle Authentifizierungsdaten enthalten.

Die Möglichkeit, die Tokengenerierung von der Tokenüberprüfung zu trennen, gibt den Anbietern viel Flexibilität.

Multi-Faktor-Authentifizierung

Wie der Name schon sagt, müssen mindestens zwei Authentifizierungsfaktoren verwendet werden, um die Sicherheit zu erhöhen.

Im Gegensatz zur Zwei-Faktor-Authentifizierung, bei der nur zwei Faktoren zum Einsatz kommen, kann diese Methode zwei, drei, vier und mehr Faktoren umfassen..

Bei dieser Methode wird in der Regel ein Passwort verwendet, nach dem der/die Nutzer/in einen Verifizierungscode auf sein/ihr Smartphone geschickt bekommt. Anbieter, die diese Methode einsetzen, sollten auf Fehlalarme und Netzwerkausfälle achten, die bei einer schnellen Skalierung zu großen Problemen führen können.

Wie man die Laravel-Authentifizierung implementiert

In diesem Abschnitt lernst du mehrere Möglichkeiten kennen, wie du die Nutzer deiner Anwendung authentifizieren kannst. Für einige Bibliotheken wie Jetstream, Breeze und Socialite gibt es kostenlose Tutorials, die dir zeigen, wie du sie nutzen kannst.

Manuelle Authentifizierung

Beginne mit der Registrierung von Nutzern und der Erstellung der benötigten Routen in routes/web.php.

Wir werden zwei Routen erstellen, eine zum Anzeigen des Formulars und eine zur Registrierung:

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

Und erstellen den dafür benötigten Controller:

php artisan make controller Auth/RegisterController -r

Aktualisiere nun den Code wie folgt:

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

Der Controller ist jetzt leer und gibt einen View zum Registrieren zurück. Wir erstellen diese Ansicht in resources/views/auth und nennen sie register.blade.php.

Jetzt, wo alles eingerichtet ist, sollten wir unsere /register Route besuchen und das folgende Formular sehen:

Da wir nun ein Formular anzeigen können, das ein Nutzer ausfüllen kann, und die Daten dafür erhalten, sollten wir die Daten des Nutzers abrufen, validieren und dann in der Datenbank speichern, wenn alles in Ordnung ist. Hier solltest du eine Datenbanktransaktion verwenden, um sicherzustellen, dass die Daten, die du einfügst, vollständig sind.

Wir werden die Anfragevalidierung von Laravel nutzen, um sicherzustellen, dass alle drei Anmeldedaten erforderlich sind. Wir müssen sicherstellen, dass die E-Mail ein E-Mail-Format hat und in der Tabelle users eindeutig ist und dass das Passwort bestätigt ist und mindestens 8 Zeichen hat:

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

Da unsere Eingaben nun validiert sind, wird alles, was gegen unsere Validierung verstößt, einen Fehler auslösen, der im Formular angezeigt wird:

Angenommen, wir haben in der Methode store ein Benutzerkonto erstellt, wollen wir den Benutzer auch anmelden. Es gibt zwei Möglichkeiten, wie wir das tun können. Wir können es manuell tun oder die Auth-Fassade verwenden.

Nachdem sich der Nutzer angemeldet hat, sollten wir ihn nicht auf den Registrierungsbildschirm zurückbringen, sondern auf eine neue Seite, z. B. ein Dashboard oder eine Homepage. Genau das werden wir hier tun:

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

Jetzt, wo ein Nutzer registriert und angemeldet ist -n, sollten wir dafür sorgen, dass er sich sicher abmelden kann.

Laravel schlägt vor, die Sitzung ungültig zu machen und das Token zur Sicherheit nach einer Abmeldung neu zu generieren. Und genau das werden wir jetzt tun. Wir beginnen damit, eine neue /logout Route zu erstellen, indem wir die destroy Methode des LogoutControllers verwenden:

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

Die Weiterleitung des Logouts durch die auth-Middleware ist sehr wichtig. Die Nutzer sollen nicht auf die Route zugreifen können, wenn sie nicht angemeldet sind.

Erstelle nun einen Controller, wie wir es zuvor getan haben:

php artisan make:controller Auth/LogoutController -r

Wir können sicherstellen, dass wir die Anfrage als Parameter in der Methode destroy erhalten. Wir melden den Benutzer über die Auth-Fassade ab, machen die Sitzung ungültig, generieren das Token neu und leiten den Benutzer zur Homepage weiter:

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

Erinnerung an den Benutzer

Die meisten, wenn nicht sogar alle, modernen Webanwendungen bieten in ihrem Anmeldeformular ein Kontrollkästchen zur Erinnerung an den Benutzer.

Wenn wir eine Erinnerungsfunktion anbieten wollen, können wir einen booleschen Wert als zweites Argument an die Methode attempt übergeben.

Wenn dieser Wert gültig ist, behält Laravel den Benutzer auf unbestimmte Zeit oder so lange, bis er manuell abgemeldet wird, authentifiziert. Die Benutzertabelle muss die Spalte remember_token enthalten (deshalb werden die Token neu generiert), in der wir unser „Remember me“-Token speichern.

In der Standardmigration für Benutzer ist sie bereits enthalten.

Als Erstes musst du das Feld „Remember Me“ zu deinem Formular hinzufügen:

Danach holst du dir die Anmeldedaten aus der Anfrage und verwendest sie in der Methode attempt der Auth-Fassade.

Wenn der Benutzer erinnert werden soll, loggen wir ihn ein und leiten ihn auf unsere Homepage um. Andernfalls geben wir eine Fehlermeldung aus:

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

Passwörter zurücksetzen

Die meisten Webanwendungen bieten heute die Möglichkeit, Passwörter zurückzusetzen.

Wir erstellen eine weitere Route für das vergessene Passwort und erstellen den Controller wie zuvor. Außerdem fügen wir eine Route für den Link zum Zurücksetzen des Passworts hinzu, die das Token für den gesamten Prozess enthält:

Route::post('/forgot-password', [ForgotPasswordLinkController::class, 'store']);

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

In der Store-Methode nehmen wir die E-Mail aus der Anfrage und validieren sie, wie wir es bereits getan haben.

Danach können wir die Methode sendResetLink aus der Passwort-Fassade verwenden.

Und dann wollen wir als Antwort den Status zurückgeben, wenn der Link erfolgreich gesendet wurde, oder andernfalls einen Fehler:

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

Nachdem der Link zum Zurücksetzen des Passworts an die E-Mail des Nutzers gesendet wurde, sollten wir uns um die Logik kümmern, was danach passiert.

Wir erhalten das Token, die E-Mail und das neue Passwort in der Anfrage und überprüfen sie.

Danach können wir die Reset-Methode der Passwort-Fassade verwenden, damit Laravel sich um alles andere im Hintergrund kümmert.

Wir werden das Passwort immer mit einem Hash versehen, um es sicher zu machen.

Am Ende prüfen wir, ob das Passwort zurückgesetzt wurde. Wenn ja, leiten wir den Benutzer mit einer Erfolgsmeldung zum Anmeldebildschirm weiter. Andernfalls zeigen wir eine Fehlermeldung an, dass es nicht zurückgesetzt werden konnte:

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 Breeze

Laravel Breeze ist eine einfache Implementierung der Laravel-Authentifizierungsfunktionen: Anmeldung, Registrierung, Passwortzurücksetzung, E-Mail-Verifizierung und Passwortbestätigung. Du kannst es verwenden, um die Authentifizierung in deiner neuen Laravel-Anwendung zu implementieren.

Installation und Einrichtung

Nachdem du deine Laravel-Anwendung erstellt hast, musst du nur noch deine Datenbank konfigurieren, deine Migrationen durchführen und das Paket laravel/breeze über Composer installieren:

composer require laravel/breeze –dev

Danach führst du Folgendes aus:

php artisan breeze:install

Dadurch werden deine Authentifizierungsansichten, -routen, -controller und andere Ressourcen, die es verwendet, veröffentlicht. Nach diesem Schritt hast du die vollständige Kontrolle über alles, was Breeze bietet.

Jetzt müssen wir unsere Anwendung auf dem Frontend rendern, also installieren wir unsere JS-Abhängigkeiten (die @vite verwenden):

npm install

:

npm run dev

Danach sollten die Links zum Anmelden und Registrieren auf deiner Homepage zu finden sein und alles sollte reibungslos funktionieren.

Laravel Jetstream

Laravel Jetstream erweitert Laravel Breeze um nützliche Funktionen und andere Frontend-Stacks.

Es bietet Login, Registrierung, E-Mail-Verifizierung, Zwei-Faktor-Authentifizierung, Sitzungsmanagement, API-Unterstützung über Sanctum und optionales Team-Management.

Bei der Installation von Jetstream musst du im Frontend zwischen Livewire und Inertia wählen. Im Backend wird Laravel Fortify verwendet, ein frontend-unabhängiges, „headless“ Authentifizierungs-Backend für Laravel.

Installation und Einrichtung

Wir werden es über Composer in unserem Laravel-Projekt installieren:

composer require laravel/jetstream

Danach führen wir den Befehl php artisan jetstream:install [stack] aus, der die Argumente [stack] Livewire oder Inertia akzeptiert. Du kannst die Option –team übergeben, um die Teamfunktion zu aktivieren.

Dadurch wird auch Pest PHP zum Testen installiert.

Zum Schluss müssen wir das Frontend unserer Anwendung mit folgendem Befehl rendern:

npm install
npm run dev

Laravel Fortify

Laravel Fortify ist eine Backend-Authentifizierungs-Implementierung, die nicht an das Frontend gebunden ist. Du musst Laravel Fortify nicht verwenden, um die Authentifizierungsfunktionen von Laravel zu implementieren.

Es wird auch in Starter Kits wie Breeze und Jetstream verwendet. Du kannst Fortify auch eigenständig verwenden, was nur eine Backend-Implementierung ist. Wenn du es allein verwendest, muss dein Frontend die Fortify-Routen aufrufen.

Installation und Einrichtung

Wir können Fortify über Composer installieren:

composer require laravel/fortify

Jetzt müssen wir die Ressourcen von Fortify veröffentlichen:

php artisan vendor:publish –provider="LaravelFortifyFortifyServiceProvider"

Danach erstellen wir ein neues App/Actions-Verzeichnis sowie den neuen FortifyServiceProvider, die Konfigurationsdatei und die Datenbankmigrationen.

Zum Schluss führst du aus:

php artisan migrate

Oder:

php artisan migrate:fresh

Und schon ist dein Fortify einsatzbereit.

Laravel Socialite

Laravel enthält eine einfache OAuth-basierte Benutzerauthentifizierungsfunktion. Sie unterstützt soziale Logins über Facebook, Twitter, LinkedIn, Google, Bitbucket, GitHub und GitLab.

Installation

Wir können es über Composer installieren:

composer require laravel/socialite

Einrichtung und Nutzung

Nach der Installation müssen wir die Anmeldedaten für den OAuth-Anbieter hinzufügen, den unsere Anwendung verwendet. Wir fügen sie in config/services.php für jeden Dienst hinzu.

In der Konfiguration sollten wir den Schlüssel mit den vorherigen Diensten abgleichen. Einige dieser Schlüssel sind:

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

Eine Dienstkonfiguration kann wie folgt aussehen:

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

Benutzer authentifizieren

Für diese Aktion benötigen wir zwei Routen, eine für die Weiterleitung des Nutzers zum OAuth-Anbieter:

use Laravel\Socialite\Facades\Sociliate;

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

Und eine für den Callback vom Anbieter nach der Authentifizierung:

use Laravel\Socialite\Facades\Socialite;

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

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

Socialite stellt die Redirect-Methode zur Verfügung, und die Fassade leitet den Nutzer zum OAuth-Anbieter weiter, während die User-Methode die eingehende Anfrage untersucht und die Nutzerinformationen abruft.

Nachdem wir unseren Benutzer erhalten haben, müssen wir prüfen, ob er in unserer Datenbank existiert und ihn authentifizieren. Wenn er nicht existiert, legen wir einen neuen Datensatz an, um den Benutzer zu repräsentieren:

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

Wenn wir die Zugriffsbereiche des Benutzers einschränken wollen, können wir die Methode scopes verwenden, die wir der Authentifizierungsanfrage beifügen. Dadurch werden alle zuvor angegebenen Bereiche mit den angegebenen zusammengeführt.

Eine Alternative dazu ist die Methode setScopes, die alle anderen bestehenden Bereiche überschreibt:

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

Jetzt, wo wir alles wissen und wissen, wie wir einen Benutzer nach dem Callback bekommen, schauen wir uns einige der Daten an, die wir von ihm bekommen können.

OAuth1 User hat token und tokenSecret:

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

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

OAuth2 liefert token, refreshToken und expiresIn:

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

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

Sowohl OAuth1 als auch OAuth2 bieten getId, getNickname, getName, getEmail, und getAvatar:

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

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

Und wenn wir Benutzerdaten aus einem Token (OAuth 2) oder einem Token und einem Geheimnis (OAuth 1) abrufen wollen, bietet sanctum zwei Methoden dafür: userFromToken und userFromTokenAndSecret:

use Laravel\Socialite\Facades\Socialite;

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

Laravel Sanctum

Laravel Sanctum ist ein einfaches Authentifizierungssystem für SPAs (Single Page Applications) und mobile Apps. Es ermöglicht es Nutzern, mehrere API-Tokens mit bestimmten Geltungsbereichen zu erzeugen. Diese Bereiche legen die erlaubten Aktionen für ein Token fest.

Verwendungsmöglichkeiten

Sanctum kann verwendet werden, um API-Tokens an den Nutzer auszugeben, ohne die Feinheiten von OAuth. Diese Token haben in der Regel eine lange Gültigkeitsdauer, z. B. Jahre, können aber jederzeit vom Nutzer widerrufen und neu erstellt werden.

Installation und Einrichtung

Wir können es über Composer installieren:

composer require laravel/sanctum

Und wir müssen die Konfigurations- und Migrationsdateien veröffentlichen:

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

Jetzt, wo wir neue Migrationsdateien erstellt haben, müssen wir sie migrieren:

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

Wie man API-Tokens ausgibt

Bevor wir Token ausgeben, sollte unser Benutzermodell die Eigenschaft Laravel\Sanctum\HasApiTokens verwenden:

use Laravel\Sanctum\HasApiTokens;

class User extends Authenticable
{
    use HasApiTokens;
}

Wenn wir den Benutzer haben, können wir ein Token ausgeben, indem wir die Methode createToken aufrufen, die eine Laravel\Sanctum\NewAccessToken-Instanz zurückgibt.

Wir können die Methode plainTextToken für die Instanz NewAccessToken aufrufen, um den SHA-256-Klartextwert des Tokens zu sehen.

Tipps und Best Practices für die Laravel-Authentifizierung

Ungültig machen von Sitzungen auf anderen Geräten

Wie wir bereits besprochen haben, ist es wichtig, dass die Sitzung ungültig gemacht wird, wenn sich der Nutzer abmeldet, aber das sollte auch für alle anderen Geräte möglich sein.

Diese Funktion wird normalerweise verwendet, wenn der Nutzer sein Passwort ändert oder aktualisiert und wir seine Sitzung von einem anderen Gerät aus ungültig machen wollen.

Mit der Auth-Fassade ist das eine einfache Aufgabe. Da die Route, die wir verwenden, auth und auth.session middleware enthält, können wir die statische Methode logoutOtherDevices der Fassade verwenden:

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

use Illuminate\Support\Facades\Auth;

Auth::logoutOtherDevices($password);

Konfiguration mit Auth::routes()

Die routes-Methode der Auth-Fassade ist nur ein Hilfsmittel, um alle für die Benutzerauthentifizierung erforderlichen Routen zu erstellen.

Zu den Routen gehören Login (Get, Post), Logout (Post), Register (Get, Post) und Password Reset/Email (Get, Post).

Wenn du die Methode der Fassade aufrufst, macht sie Folgendes:

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

Uns interessiert, was passiert, wenn die statische Methode auf dem Router aufgerufen wird. Das kann aufgrund der Funktionsweise von Fassaden knifflig sein, aber die folgende Methode wird wie folgt aufgerufen:

/**
Register the typical authentication routes for an application.

@param array $options
@return void
*/
public function auth(array $options = [])
{
    // Authentication Routes...
    $this->get('login', 'AuthLoginController@showLoginForm')->name('login');
    $this->post('login', 'AuthLoginController@login');
    $this->post('logout', 'AuthLoginController@logout')->name('logout');

    // Registration Routes...
    if ($options['register'] ?? true) {
        $this->get('register', 'AuthRegisterController@showRegistrationForm')->name('register');
        $this->post('register', 'AuthRegisterController@register');
    }
   
    // Password Reset Routes...
    if ($options['reset'] ?? true) {
        $this->resetPassword();
    }

    // Email Verification Routes...
    if ($options['verify'] ?? false) {
        $this->emailVerification();
    }
}   

Standardmäßig werden alle Routen außer der E-Mail-Bestätigungsroute erzeugt. Wir haben immer die Login- und Logout-Routen, aber die anderen können wir über das Options-Array steuern.

Wenn wir nur Login/Logout und Registrierung haben wollen, können wir das folgende Options-Array übergeben:

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

Schutz von Routen und benutzerdefinierten Wächtern

Wir wollen sicherstellen, dass einige Routen nur von authentifizierten Nutzern aufgerufen werden können. Das geht schnell, indem wir entweder die Middleware-Methode auf der Route-Fassade aufrufen oder die Middleware-Methode mit ihr verketten:

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

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

Dieser Guard stellt sicher, dass eingehende Anfragen authentifiziert werden.

Passwort-Bestätigung

Um die Sicherheit der Website zu erhöhen, möchtest du oft das Passwort eines Benutzers bestätigen, bevor du mit einer anderen Aufgabe fortfährst.

Wir müssen eine Route von der Ansicht „Passwort bestätigen“ aus definieren, um die Anfrage zu bearbeiten. Sie prüft die Anfrage und leitet den Nutzer an das gewünschte Ziel weiter. Gleichzeitig stellen wir sicher, dass unser Passwort in der Sitzung bestätigt wird. Standardmäßig muss das Passwort alle drei Stunden neu bestätigt werden, aber das kann in der Konfigurationsdatei config/auth.php geändert werden:

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 Vertrag

Der Authenticable-Vertrag, der sich unter IlluminateContractsAuth befindet, legt fest, was die UserProvider-Fassade implementieren soll:

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

Die Schnittstelle ermöglicht es dem Authentifizierungssystem, mit jeder „User“-Klasse zu arbeiten, die sie implementiert.

Dies gilt unabhängig davon, welche ORM- oder Speicherschichten verwendet werden. Laravel verfügt standardmäßig über die Klasse AppModelsUser, die diese Schnittstelle implementiert, was auch in der Konfigurationsdatei zu sehen ist:

return [
    'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => AppModelsUser::class,
        ],
     ],
];

Authentifizierungsereignisse

Es gibt viele Ereignisse, die während des gesamten Authentifizierungsprozesses ausgelöst werden können.

Je nach deinen Zielen kannst du diesen Ereignissen in deiner EventServiceProvider einen Listener zuordnen.

Neue Benutzer schnell erstellen

Das schnelle Anlegen eines neuen Benutzers kann über den App\User erfolgen:

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

Oder über die statische Methode create in der User-Fassade:

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

Zusammenfassung

Das Laravel-Ökosystem bietet viele Starter-Kits, mit denen du deine App mit einem Authentifizierungssystem zum Laufen bringen kannst, wie Breeze und Jetstream. Sie sind in hohem Maße anpassbar, da der Code auf unserer Seite generiert wird und wir ihn nach Belieben verändern und bei Bedarf als Blaupause verwenden können.

Es gibt viele Sicherheitsbedenken in Bezug auf die Authentifizierung und ihre Feinheiten, aber all diese Probleme können mit den Tools, die Laravel bietet, leicht gelöst werden. Diese Tools sind in hohem Maße anpassbar und einfach zu bedienen.

Mit unserem schnellen Laravel-Hosting-Service kannst du deine Laravel-Anwendungen schnell und effizient bereitstellen. Teste deine App in Aktion mit einer kostenlosen Testversion.