Integration der Zwei-Faktoren-Authentifizierung in Laravel mit Vonage

Einführung

Die Zwei-Faktor-Authentifizierung (2FA) ist ein wichtiger Bestandteil jeder Anwendung, bei der sich ein Benutzer anmelden muss. Sie fügt eine zusätzliche Sicherheitsebene hinzu, die dazu beitragen kann, unbefugten Zugriff zu verhindern und die Daten Ihrer Nutzer zu schützen.

In diesem Artikel werden wir einen Blick darauf werfen, wie wir unserer Laravel-Anwendung mithilfe der Vonage Verify API 2FA hinzufügen können. Wir werden auch die Vorteile von 2FA besprechen und wie es dazu beitragen kann, dass Ihre Benutzer mehr Vertrauen in Ihre App haben.

Was ist 2FA?

2FA ist eine Authentifizierungsmethode, bei der ein Benutzer zwei Informationen (oder Faktoren) angeben muss, um seine Identität zu verifizieren. Diese Faktoren fallen in der Regel in eine der folgenden Kategorien:

• Etwas, das Sie kennen - Dinge wie ein Passwort oder eine persönliche Identifikationsnummer (PIN).

• Etwas, das Sie haben - Dinge wie ein Token, der von einem physischen Gerät (z. B. einem PIN-Pad oder Telefon) oder einem YubiKey generiert wird.

• Etwas, das Sie sind - Dabei kann es sich um biometrische Daten wie Fingerabdrücke oder Gesichtserkennung handeln.

• Wo Sie sich befinden - Dabei kann es sich um einen Standort wie eine bestimmte IP-Adresse oder GPS-Koordinaten handeln. Sie haben dies vielleicht schon in Aktion erlebt, als Sie versucht haben, sich von einem anderen Ort als gewöhnlich bei Online-Konten anzumelden.

• Etwas, das Sie tun - Das kann z. B. eine Geste oder eine Aktion sein, die nur Sie kennen (z. B. Mausbewegungen auf der Seite).

Die gängigsten Formen der 2FA, die Sie bei der Anmeldung bei einer Webanwendung vorfinden, sind "etwas, das Sie wissen" und "etwas, das Sie haben". Sie müssen beispielsweise Ihre E-Mail-Adresse und Ihr Passwort eingeben (was Sie wissen) und dann einen Code eingeben, der an Ihr Telefon gesendet oder von diesem generiert wird (was Sie haben).

Im weiteren Verlauf dieses Artikels werden wir uns auf die Kategorien "etwas, das Sie wissen" und "etwas, das Sie haben" konzentrieren. Wir werden die Verify API von Vonage verwenden, um den Teil des 2FA-Prozesses zu implementieren, der "etwas, das Sie haben" betrifft.

Vorteile der Verwendung von 2FA

Nachdem wir nun besser verstanden haben, was 2FA ist, wollen wir einen Blick auf die Vorteile werfen, die sie sowohl für den Benutzer als auch für den Eigentümer der Anwendung bietet.

Verringern Sie die Wahrscheinlichkeit einer Account-Übernahme

Indem ein Nutzer die Möglichkeit hat, 2FA für seinen Account zu aktivieren, verringert sich die Wahrscheinlichkeit, dass ein böswilliger Akteur auf seinen Account zugreifen kann.

Listen mit Passwörtern, die bei Datenschutzverletzungen durchgesickert sind, lassen sich online relativ leicht finden. Diese Listen können von böswilligen Nutzern verwendet werden, um zu versuchen, auf Konten bei anderen Diensten zuzugreifen, die möglicherweise dasselbe Passwort verwenden. Stellen wir uns zum Beispiel vor, dass ein Benutzer ein Konto auf "Website A" und "Website B" hat und beide Konten dasselbe Passwort verwenden. Wenn bei Website A" eine Datenpanne auftritt und das Passwort des Benutzers bekannt wird, könnte ein Hacker versuchen, mit demselben Passwort auf das Konto des Benutzers bei Website B" zuzugreifen. Ohne 2FA wäre der Hacker in der Lage, auf das Konto des Benutzers auf "Website B" zuzugreifen und potenziell Schaden anzurichten. Dies könnte von der Änderung des Passworts des Benutzers bis hin zur vollständigen Löschung des Kontos oder sogar zu Einkäufen im Namen des Benutzers reichen.

Ein ähnliches Szenario könnte auch eintreten, wenn ein Benutzer ein schwaches oder leicht zu erratendes Passwort verwendet.

Durch die Aktivierung von 2FA könnte der Benutzer dies verhindern. Wenn der böswillige Benutzer einen Code eingeben müsste, der an sein Telefon gesendet wird, müsste er auch Zugriff auf das Telefon des Benutzers haben, um auf dessen Konto zuzugreifen.

Als Bonus für den Eigentümer der Anwendung kann dies auch die Anzahl der Supportanfragen reduzieren, die er von Benutzern erhält, deren Konten kompromittiert wurden.

Verbesserung von Vertrauen und Zuversicht

Durch die Implementierung von 2FA in Ihren Applications können Sie Ihren Nutzern zeigen, dass Sie ihre Sicherheit ernst nehmen. Dies kann dazu beitragen, ein gewisses Maß an Vertrauen in Ihre App aufzubauen, was zu mehr Verkäufen und Konversionen führen kann.

Reduzieren Sie betrügerische Benutzeraktivitäten und Anmeldungen

Wenn Sie 2FA als Teil eines Verifizierungs- oder Anmeldevorgangs verwenden, kann dies dazu beitragen, die Zahl der betrügerischen Aktivitäten zu verringern, die Sie erhalten.

Zum Beispiel können Sie Ihre Nutzer auffordern, bei der Registrierung eine Telefonnummer anzugeben. Sie könnten dann einen Verifizierungscode per SMS an den Nutzer senden und ihn auffordern, diesen in Ihre Anwendung einzugeben, um zu beweisen, dass er Zugang zu der angegebenen Telefonnummer hat. Dies könnte dazu beitragen, die Zahl der gefälschten Accounts zu verringern, die erstellt werden.

Es ist jedoch wichtig, daran zu denken, dass dies das Risiko der Erstellung gefälschter Accounts nicht vollständig ausschließt. Es wird lediglich ein Hindernis errichtet, das es böswilligen Nutzern erschwert, gefälschte Accounts zu erstellen. Wenn ein Bot eingerichtet wurde, um Konten zu erstellen, könnte ein böswilliger Akteur eine Reihe von Telefonnummern kaufen und sie dann zur Erstellung von Konten verwenden.

Was ist die Vonage Verify API?

Vonage ist eine Kommunikationsplattform, die eine Reihe von APIs zur Verfügung stellt, die Sie bei der Erstellung Ihrer App verwenden können. Sie bieten APIs für das Senden und Empfangen von SMS-Nachrichten, das Senden von WhatsApp-Nachrichten, das Tätigen von Anrufen und mehr.

Eine der APIs, die sie anbieten, ist die "Verify API". Mit dieser API können Sie einen Verifizierungscode per SMS, Telefonanruf, WhatsApp-Nachricht oder E-Mail an einen Benutzer senden. Sie bietet auch die Möglichkeit zu überprüfen, ob der von einem Nutzer eingegebene Code gültig ist.

Die Verwendung der Verify API ist eine großartige Möglichkeit, 2FA zu Ihrer Laravel-Anwendung hinzuzufügen, da Sie einen Teil der Funktionalität nicht mehr selbst erstellen müssen. Sie bietet beispielsweise die Möglichkeit, automatisierte Workflows zu erstellen (auf die wir später noch näher eingehen werden) und Dinge wie Betrugserkennung, automatisches Ablaufen des Codes und den tatsächlichen Versand von SMS-Nachrichten, WhatsApp-Nachrichten, E-Mails und Anrufen zu behandeln.

Weitere Informationen über die Verify API finden Sie in der vollständigen Dokumentation unter: https://developer.vonage.com/en/verify/overview

Vonage Verify Abläufe

Die Vonage Verify API bietet mehrere Kanäle, die Sie verwenden können, um die 2FA-Verifizierungscodes an Ihre Benutzer zu senden. Zum Zeitpunkt der Erstellung dieses Artikels sind die folgenden Kanäle verfügbar:

• SMS

• Voice-Anruf

• E-Mail

• WhatsApp

• WhatsApp (ohne Code)

Die Funktion "WhatsApp (ohne Code)" sendet dem Nutzer über WhatsApp eine Schaltfläche "Ja" oder "Nein". So kann sich der Nutzer authentifizieren, ohne sich einen Code merken oder eingeben zu müssen.

Mit der Vonage Verify API können Sie Verifizierungsworkflows erstellen. Diese ermöglichen es Ihnen, eine Reihe von Kanälen zu erstellen, an die Vonage versuchen soll, den Verifizierungscode zu senden. Sie könnten zum Beispiel einen Workflow erstellen, der den Code per SMS sendet. Wenn der Benutzer den Code dann nicht innerhalb eines bestimmten Zeitrahmens (z. B. 5 Minuten) verwendet, kann er stattdessen per Telefonanruf gesendet werden. Diese besondere Funktion kann nützlich sein, wenn der Nutzer kein Netz auf seinem Telefon hat (und daher die SMS nicht empfangen kann), aber einen Internetzugang hat, so dass er als Ausweichmöglichkeit E-Mails und WhatsApp-Nachrichten empfangen kann.

Im Folgenden finden Sie einige Beispiele für Arbeitsabläufe, die Sie möglicherweise verwenden möchten (unter der Annahme, dass zwischen den einzelnen Sendungen an den nächsten Kanal ein Abstand von 5 Minuten liegt):

1. SMS -> SMS -> SMS

2. SMS -> Sprachanruf -> SMS

3. SMS -> WhatsApp

4. E-Mail

5. Voice Call -> Voice Call -> Voice Call

Hinzufügen von 2FA zu Ihrer Laravel-Anwendung

Nachdem wir nun wissen, was die Verify API ist, schauen wir uns an, wie wir sie verwenden können, um 2FA zu unseren Laravel Applications hinzuzufügen.

Unser Ablauf wird folgendermaßen sein:

1. Senden eines Verifizierungscodes per SMS an den Benutzer

2. Erlauben Sie dem Benutzer, den Code in die Anwendung einzugeben.

3. Wenn der Benutzer den Code nicht innerhalb von fünf Minuten eingegeben hat, senden Sie den Code stattdessen per Telefonanruf.

Wir gehen von den folgenden Annahmen aus:

• Wir werden mit einem Feld interagieren phone_number Feld, das in der Tabelle users Tabelle. Das Feld ist ein Pflichtfeld und enthält die Telefonnummern der Benutzer. Damit wir uns ausschließlich auf den Verify API-Ablauf konzentrieren können, werden wir nicht darauf eingehen, wie dieses Feld zur Datenbank hinzugefügt wird.

• Wir gehen davon aus, dass 2FA für jeden Benutzer in der Anwendung dauerhaft aktiviert ist.

Erstellen Ihres Vonage Accounts

Bevor wir mit dem Schreiben von Code beginnen, müssen wir zunächst unsere API-Schlüssel von Vonage erhalten. Dazu müssen Sie sich für einen Vonage Account anmelden, wenn Sie noch keinen haben.

<sign-up>

Sie müssen Ihren API-Schlüssel und Ihr API-Geheimnis aufbewahren, damit wir sie zu unserer Laravel-Anwendung hinzufügen können.

Installieren des Vonage SDK

Da wir nun unsere API-Schlüssel haben, können wir das Laravel-Paket von Vonage installieren, das wir für die Interaktion mit der Verify API verwenden werden. Wir können dies über Composer tun, indem wir den folgenden Befehl in unserem Projektstamm ausführen:

composer require vonage/vonage-laravel

Das Paket sollte nun installiert sein. Danach können wir unseren API-Schlüssel und unser Geheimnis in unsere .env Datei hinzufügen:

Erstellen der Serviceklasse

Beginnen wir mit der Erstellung einer neuen Klasse, die wir für die Interaktion mit der Verify API verwenden werden. Wir nennen diese Klasse TwoFactorAuthService und speichern sie im Verzeichnis app/Services Verzeichnis.

Wir werden zwei Methoden zu dieser Klasse hinzufügen:

• sendVerification - Dieser wird verwendet, um den Verifizierungscode an den Benutzer zu senden.

• verify - Damit wird überprüft, ob der vom Benutzer eingegebene Code korrekt ist.

Die Klasse könnte etwa so aussehen:

declare(strict_types=1);

namespace App\Services;

use App\Models\User;
use Exception;
use Vonage\Client;
use Vonage\Verify2\Request\SMSRequest;
use Vonage\Verify2\VerifyObjects\VerificationWorkflow;

final class TwoFactorAuthService
{
    public function sendVerification(User $user): string
    {
        $smsRequest = (new SMSRequest(
            to: $user->phone_number,
            brand: 'Vonage Verify',
        ));

        $voiceWorkflow = new VerificationWorkflow(
            channel: VerificationWorkflow::WORKFLOW_VOICE,
            to: $user->phone_number,
        );

        $smsRequest->addWorkflow($voiceWorkflow);

        $result = app(Client::class)
            ->verify2()
            ->startVerification($smsRequest);

        return $result['request_id'];
    }

    public function verify(string $code, string $requestId): bool
    {
        try {
            return app(Client::class)
                ->verify2()
                ->check($requestId, $code);
        } catch (Exception) {
            return false;
        }
    }
}

Schauen wir uns das Geschehen in dieser Klasse etwas genauer an.

Die Methode sendVerification Methode akzeptiert eine User Modellinstanz als Argument. Dies ist der Benutzer, der versucht, sich mit 2FA zu authentifizieren. In dieser Methode erstellen wir einen Workflow, der den Verifizierungscode per SMS und anschließend per Telefonanruf an den Benutzer sendet (wenn der Benutzer den Code nicht innerhalb eines bestimmten Zeitrahmens verwendet). Wir verwenden dann das Vonage SDK, um den Verifizierungscode an den Benutzer zu senden. Die Methode startVerification Methode gibt ein Array zurück, das ein request_id Feld enthält. Dieses Feld wird verwendet, um den Fluss des Benutzers zu identifizieren und zu überprüfen, ob der vom Benutzer eingegebene Code korrekt ist. Wir werden diese ID innerhalb eines Controllers verwenden (auf den wir weiter unten eingehen werden), also geben wir die request_id von dieser Methode zurück.

Die Methode verify Methode akzeptiert einen code Parameter, der der Code ist, den der Benutzer beim Versuch, sich mit 2FA zu authentifizieren, eingegeben hat. Sie akzeptiert auch einen requestId Parameter. Dies ist normalerweise die Anfrage-ID, die von der sendVerification Methode zurückgegeben wurde. Wenn der vom Benutzer eingegebene Code korrekt ist, gibt die check Methode zurück true. Wenn der Code falsch ist, wird eine Ausnahme ausgelöst, die wir abfangen und zurückgeben false um dem Benutzer den Zugriff zu verweigern.

Erstellen der Middleware

Da wir nun unsere Klasse für die Erstellung unseres Workflows und die Interaktion mit der Verify API haben, müssen wir zwei Middleware-Klassen erstellen:

• VerifyTwoFactorAuth - Diese Middleware wird verwendet, um die Routen unserer Anwendung zu schützen. Wenn der Benutzer seinen 2FA-Code noch nicht eingegeben hat, wird er auf die 2FA-Verifizierungsseite weitergeleitet.

• PreventRequestsIfTwoFactorAuthVerified - Diese Middleware verhindert, dass der Benutzer auf die 2FA-Verifizierungsseite zugreifen kann, wenn er seinen 2FA-Code bereits eingegeben hat.

Beginnen wir mit der Erstellung der VerifyTwoFactorAuth Middleware. Dazu führen wir den folgenden Befehl in unserem Projektstamm aus:

php artisan make:middleware VerifyTwoFactorAuth

Sie sollten nun eine neue VerifyTwoFactorAuth Klasse im Verzeichnis app/Http/Middleware Verzeichnis haben. Lassen Sie uns diese Klasse aktualisieren und dann sehen wir uns an, was passiert:

declare(strict_types=1);

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

final class VerifyTwoFactorAuth
{
    public function handle(Request $request, Closure $next): Response
    {
        if ($this->shouldRedirectToTwoFactorAuthPage($request)) {
            return redirect()->route('auth.2fa.show');
        }

        return $next($request);
    }

    private function shouldRedirectToTwoFactorAuthPage(Request $request): bool
    {
        return !$request->session()->has('two_factor_auth_verified')
            && $request->route()->getName() !== 'auth.2fa.show'
            && $request->route()->getName() !== 'auth.2fa.verify';
    }
}

In der handle Methode überprüfen wir, ob der Benutzer mit 2FA verifiziert wurde. Dies geschieht durch die Überprüfung, ob der two_factor_auth_verified Schlüssel in der Sitzung des Benutzers existiert. Wenn dies der Fall ist, kann der Benutzer wie erwartet fortfahren. Ist dies nicht der Fall, wird der Benutzer auf die 2FA-Verifizierungsseite umgeleitet, es sei denn, er befindet sich bereits auf dieser Seite oder sendet das 2FA-Verifizierungsformular.

Wir können diese Middleware nun zum Schutz der Routen unserer Anwendung verwenden. Zum Beispiel kann unsere routes/web.php Routen-Datei etwa so aussehen:

use App\Http\Controllers\ProfileController;
use App\Http\Middleware\VerifyTwoFactorAuth;
use Illuminate\Support\Facades\Route;

Route::middleware(['auth', VerifyTwoFactorAuth::class])->group(function () {
    Route::get('/profile', [ProfileController::class, 'edit'])->name('profile.edit');
    Route::patch('/profile', [ProfileController::class, 'update'])->name('profile.update');
    Route::delete('/profile', [ProfileController::class, 'destroy'])->name('profile.destroy');
});

Die drei Routen im obigen Beispiel erfordern nun, dass der Benutzer authentifiziert ist und seinen 2FA-Code verifiziert hat, bevor er auf sie zugreifen kann.

Wir müssen auch eine PreventRequestsIfTwoFactorAuthVerified Middleware erstellen. Diese wird verwendet, um zu verhindern, dass der Benutzer zum 2FA-Verifizierungsbildschirm navigiert, wenn er bereits verifiziert ist. Wir erstellen diese Middleware, indem wir den folgenden Befehl ausführen:

php artisan make:middleware PreventRequestsIfTwoFactorAuthVerified

Sie sollten nun eine neue PreventRequestsIfTwoFactorAuthVerified Klasse im Verzeichnis app/Http/Middleware Verzeichnis haben. Lassen Sie uns diese Klasse aktualisieren und dann sehen wir uns an, was passiert:

declare(strict_types=1);

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

final class PreventRequestsIfTwoFactorAuthVerified
{
    public function handle(Request $request, Closure $next): Response
    {
        // If we have already verified the user's 2FA code, redirect them to the dashboard.
        // We don't want to keep allowing them to access the 2FA verification page.
        if ($request->session()->get('two_factor_auth_verified')) {
            return redirect()->route('dashboard');
        }

        return $next($request);
    }
}

Wie wir in der obigen Klasse sehen können, überprüfen wir, ob der Benutzer seine 2FA bereits verifiziert hat, indem wir die Existenz des two_factor_auth_verified Schlüssels in der Sitzung des Benutzers. Wenn dieser Schlüssel vorhanden ist, bedeutet dies, dass der Benutzer seinen 2FA-Code bereits verifiziert hat, sodass wir ihn zum Dashboard umleiten, damit er nicht auf die 2FA-Verifizierungsseite zugreifen kann. Wenn nicht, kann der Benutzer wie erwartet fortfahren.

Das war's! Wir haben jetzt unsere Middleware vorbereitet und sind bereit für den Einsatz. Wie diese spezielle Middleware verwendet wird, erfahren Sie im nächsten Abschnitt, wenn wir den 2FA-Verifizierungs-Controller und die Routen erstellen.

Erstellen des Controllers und der Routes

Nun, da wir unsere Serviceklasse und Middleware fertig haben, ist es an der Zeit, alles mit einem Controller und einigen Routen zusammenzufügen.

Wir beginnen damit, zwei neue Routen für unseren 2FA-Verifizierungsprozess zu erstellen:

• GET /auth/2fa - Über diesen Weg wird das 2FA-Verifizierungsformular angezeigt.

• POST /auth/2fa - Diese Route wird verwendet, wenn der Benutzer das Formular zur Verifizierung seines 2FA-Codes absendet.

Dazu fügen wir Folgendes in unsere routes/web.php Datei:

use App\Http\Controllers\Auth\TwoFactorAuthController;
use App\Http\Middleware\PreventRequestsIfTwoFactorAuthVerified;
use App\Http\Middleware\VerifyTwoFactorAuth;
use Illuminate\Support\Facades\Route;

Route::middleware(['auth', VerifyTwoFactorAuth::class])->group(function () {
    
    // ...

    Route::controller(TwoFactorAuthController::class)->middleware(PreventRequestsIfTwoFactorAuthVerified::class)->group(function () {
        Route::get('/auth/2fa', 'show')->name('auth.2fa.show');
        Route::post('/auth/2fa', 'verify')->name('auth.2fa.verify');
    });
});

Sie haben vielleicht bemerkt, dass wir die PreventRequestsIfTwoFactorAuthVerified Middleware (die wir zuvor erstellt haben) auf die TwoFactorAuthController Gruppe.

Wir können nun die TwoFactorAuthController (auf die wir in diesen beiden Routen verweisen) mit folgendem Befehl erstellen:

php artisan make:controller Auth/TwoFactorAuthController

Sie sollten nun eine neue TwoFactorAuthController Klasse im Verzeichnis app/Http/Controllers/Auth Verzeichnis haben. Lassen Sie uns diese Klasse aktualisieren und dann sehen wir uns an, was passiert:

declare(strict_types=1);

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Services\TwoFactorAuthService;
use Illuminate\Contracts\View\View;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

final class TwoFactorAuthController extends Controller
{
    /**
     * Show the two-factor authentication page.
     */
    public function show(Request $request, TwoFactorAuthService $twoFactorAuthService): View
    {
        // If the user hasn't already started the verification process, start it.
        // We check this here to prevent the user re-triggering the 2FA process
        // if the page is refreshed.
        if (! $request->session()->has('two_factor_auth_request_id')) {
            $requestId = $twoFactorAuthService->sendVerification($request->user());

            $request->session()->put('two_factor_auth_request_id', $requestId);
        }

        return view('auth.two-factor-auth');
    }

    /**
     * Verify the two-factor authentication code entered by the user.
     */
    public function verify(Request $request, TwoFactorAuthService $twoFactorAuthService): RedirectResponse
    {
        $validated = $request->validate([
            'two_factor_auth_code' => ['required', 'numeric'],
        ]);

        $isValidCode = $twoFactorAuthService->verify(
            code: $validated['two_factor_auth_code'],
            requestId: $request->session()->get('two_factor_auth_request_id')
        );

        if (! $isValidCode) {
            return back()->withErrors([
                'two_factor_auth_code' => 'The code you entered was invalid.',
            ]);
        }

        $request->session()->put('two_factor_auth_verified', true);

        return redirect()->route('dashboard');
    }
}

In der show Methode wird überprüft, ob der Benutzer den 2FA-Verifizierungsprozess bereits gestartet hat. Dies geschieht durch die Überprüfung auf die Existenz eines two_factor_auth_request_id Feldes in der Sitzung des Benutzers. In diesem Feld wird die Anfrage-ID gespeichert, die von der sendVerification Methode in der TwoFactorAuthService. Wenn das Feld nicht vorhanden ist, starten wir den Verifizierungsprozess (Senden des Codes per SMS und Telefonanruf), indem wir die sendVerification aufruft und die Anfrage-ID in der Sitzung speichert. Wenn der Benutzer den Verifizierungsprozess bereits gestartet hat, fahren wir wie gewohnt mit dem 2FA-Verifizierungsformular fort. Dies funktioniert auch, wenn der Benutzer die Seite aktualisiert oder von der Seite weg- und dann wieder zurücknavigiert.

In der verify Methode werden zunächst einige grundlegende Überprüfungen durchgeführt, um sicherzustellen, dass ein two_factor_auth_code Feld in der Anfrage übergeben wurde. Dann verwenden wir den vom Benutzer eingegebenen Code und das two_factor_auth_request_id Feld in der Sitzung des Benutzers, um den Code mit der verify Methode in der TwoFactorAuthService. Dadurch wird eine Anfrage an die Verify API gesendet, um sicherzustellen, dass der Code gültig ist. Wenn der Code gültig ist, speichern wir ein two_factor_auth_verified Feld in der Sitzung des Benutzers, um anzuzeigen, dass der Benutzer seinen 2FA-Code verifiziert hat. Dadurch wird verhindert, dass der Benutzer bei jeder nachfolgenden Anfrage zum 2FA-Verifizierungsformular weitergeleitet wird. Ist der Code ungültig, leiten wir den Benutzer mit einer Fehlermeldung zurück zum 2FA-Verifizierungsformular.

Erstellen des Formulars

In der show Methode der TwoFactorAuthControllergeben wir eine auth.two-factor-auth Ansicht an den Benutzer zurück. Diese Ansicht enthält das Formular, das der Benutzer zur Eingabe seines 2FA-Codes verwenden wird.

Für diesen Leitfaden erstellen wir ein einfaches Formular, das kein Styling enthält. Die Blade-Ansicht könnte etwa so aussehen:

<form method="POST" action="{{ route('auth.2fa.verify') }}">
    @csrf

    <!-- Two-factor Auth Code -->
    <div>
        <label for="two_factor_auth_code">Two Factor Auth Code')</label>
        <input id="two_factor_auth_code" type="text" name="two_factor_auth_code" required autofocus />

        @if ($errors->get('two_factor_auth_code'))
            <ul>
                @foreach ((array) $errors->get('two_factor_auth_code') as $error)
                    <li>{{ $error }}</li>
                @endforeach
            </ul>
        @endif
    </div>
    
    <button type="submit">Verify</button>
</form>

Wie wir in der Blade-Ansicht oben sehen können, haben wir ein einzelnes two_factor_auth_code Texteingabefeld, eine Beschriftung und eine Schaltfläche zum Absenden hinzugefügt. Wir haben auch eine Bedingung und eine Schleife hinzugefügt, die alle Fehlermeldungen ausgibt, die wir dem Benutzer anzeigen möchten (z. B. wenn er einen ungültigen Code eingibt).

Das war's! Sie sollten nun eine vollständig funktionierende 2FA-Implementierung in Ihrer Laravel-Anwendung haben!

Es geht weiter

Da wir nun wissen, wie wir 2FA in unseren Laravel-Applikationen implementieren können, wollen wir uns ansehen, wie wir diese Funktion weiter ausbauen können, um einen größeren Nutzen zu erzielen.

Hinzufügen eines Kippschalters zum Aktivieren/Deaktivieren von 2FA

In diesem Leitfaden gehen wir davon aus, dass alle Benutzer 2FA aktiviert haben und bei jeder Anmeldung einen Code eingeben müssen. Sie sollten Ihren Nutzern jedoch die Möglichkeit geben, 2FA für ihre Konten zu aktivieren und zu deaktivieren, damit sie selbst entscheiden können, ob sie es nutzen möchten. Wenn Sie diese Funktion jedoch anbieten, sollten Sie einen Hinweis oder eine Warnung in Ihre Benutzeroberfläche einfügen, um Ihre Benutzer auf die Sicherheitsauswirkungen der Deaktivierung von 2FA aufmerksam zu machen.

Darüber hinaus können Sie den Nutzern auch die Möglichkeit geben, die Kanäle zu wählen, über die die 2FA-Codes gesendet werden sollen. Zum Beispiel können sie die Codes per SMS und Voice-Anruf erhalten wollen. Oder sie möchten, dass sie nur über E-Mail und WhatsApp empfangen werden.

Diese Flexibilität ermöglicht es den Benutzern, einen für sie geeigneten Authentifizierungs-Workflow zu erstellen, der ein ausgewogenes Verhältnis zwischen Sicherheit und Komfort bietet.

Freundliche Weiterleitung hinzufügen

In unseren obigen Beispielen haben wir den Benutzer so kodiert, dass er immer zum Dashboard weitergeleitet wird, nachdem er seinen 2FA-Code erfolgreich verifiziert hat. Sie können jedoch eine "freundliche Weiterleitungsfunktion" bereitstellen, die den Benutzer auf die Seite umleitet, auf die er ursprünglich zugreifen wollte.

Wenn der Benutzer zum Beispiel ursprünglich versucht hat, direkt zu "https://my-app.com/orders" zu navigieren, könnten Sie eine freundliche Weiterleitung einrichten, so dass er zu dieser Seite weitergeleitet wird, nachdem er seinen 2FA-Code erfolgreich verifiziert hat.

Regelmäßige erneute Überprüfung von 2FA

In diesem Leitfaden haben wir 2FA nur für den Anmeldevorgang implementiert. Je nach Anwendung, die Sie erstellen, möchten Sie den 2FA-Code des Benutzers jedoch möglicherweise regelmäßig neu verifizieren. Sie können zum Beispiel verlangen, dass der Benutzer jede Stunde einen neuen Code eingibt. Dies kann dazu beitragen, das Konto des Benutzers zu schützen, wenn sein Gerät kompromittiert wird oder wenn er versehentlich an einem öffentlichen Computer angemeldet bleibt (z. B. in einer Bibliothek oder einem Café).

Darüber hinaus können Sie den Benutzer auch nach seinem Kennwort oder 2FA-Code fragen, bevor er bestimmte Aktionen durchführen kann. Dies können Sie zum Beispiel tun, bevor Sie einem Benutzer erlauben, sein Konto zu löschen oder seine E-Mail-Adresse zu ändern. Auf diese Weise können Sie verhindern, dass böswillige Benutzer potenziell zerstörerische Aktionen durchführen, wenn sie Zugang zu einem Account erhalten.

Bieten Sie eine Backup-Option

Wenn Sie Ihre Anwendung mit einer 2FA-Funktion ausstatten, sollten Sie auch eine Backup-Option vorsehen, mit der Benutzer im Notfall Zugriff auf ihre Konten erhalten. Ein Beispiel: Ein Nutzer könnte sein Telefon verlieren oder es wird ihm gestohlen. Infolgedessen kann er möglicherweise nicht mehr auf sein Konto zugreifen.

Aus diesem Grund besteht eine gängige Backup-Option darin, den Benutzern das Herunterladen einer Liste von Wiederherstellungscodes zu ermöglichen, die generiert werden, wenn sie 2FA für ihr Konto aktivieren. Diese Wiederherstellungscodes sind in der Regel einmalig und können verwendet werden, um Zugriff auf das Konto des Benutzers zu erhalten, ohne einen 2FA-Code eingeben zu müssen. Wenn Sie sich dafür entscheiden, diese Codes zu generieren, müssen Sie darauf achten, dass sie kryptografisch sicher sind, damit sie nicht einfach erraten oder geknackt werden können.

Schlussfolgerung

Wir hoffen, dass dieser Leitfaden Ihnen einen Einblick gegeben hat, wie Sie die Vonage Verify API verwenden können, um 2FA in Ihren Laravel-Anwendungen zu implementieren. Es sollte auch einige der Vorteile der Verwendung von 2FA hervorgehoben haben und wie es Ihnen und Ihren Benutzern helfen kann.