Web & Entwicklung

Passkeys und WebAuthn im Jahr 2026: Ein praktischer Implementierungsleitfaden für Webentwickler

Passkeys and WebAuthn in 2026: A Practical Implementation Guide for Web Developers

Passkeys versprechen passwortloses Einloggen ohne Speicherung von Passwortgeheimnissen, aber die korrekte Implementierung von WebAuthn erfordert mehr als das Aufrufen einer Browser-API. Erfahren Sie, wie Registrierung, Authentifizierung, serverseitige Verifizierung, auffindbare Anmeldeinformationen und Kontowiederherstellung zusammen in einer sicheren Webanwendung funktionieren.

Passwörter sind seit Jahrzehnten der Standard-Authentifizierungsmechanismus für Webanwendungen. Sie sind auch eine anhaltende Quelle von Sicherheitsproblemen.

Nutzer verwenden sie mehrfach. Angreifer stehlen sie durch Phishing. Server müssen Passwort-Hashes schützen, Zurücksetzungen verwalten und sich gegen Credential-Stuffing-Angriffe verteidigen.

Passkeys bieten einen grundlegend anderen Ansatz.

Anstatt Nutzer zu bitten, ein gemeinsames Geheimnis zu merken, verwenden Passkeys Public-Key-Kryptographie und einen vom Nutzer gesteuerten Authenticator. Der Browser stellt über WebAuthn eine Standardschnittstelle bereit, während der Server kryptografische Beweise verifiziert, dass die korrekte Anmeldeinformation verwendet wurde.

Die Technologie ist nicht mehr experimentell. WebAuthn ist in modernen Browsern weit verbreitet, und seine JSON-Komfortmethoden haben die Integration erheblich vereinfacht.

Der Aufbau eines sicheren Passkey-Logins erfordert dennoch eine sorgfältige Backend-Architektur.

Dieser Leitfaden erklärt die Architektur, demonstriert die browserseitigen Abläufe und identifiziert die serverseitigen Prüfungen, die Entwickler nicht übersehen dürfen.

1. Was genau ist ein Passkey?

Ein Passkey ist ein auffindbares FIDO-Credential, das zur Authentifizierung eines Benutzers mittels Public-Key-Kryptographie verwendet wird.

Während der Registrierung erstellt ein Authenticator ein kryptografisches Schlüsselpaar.

Der private Schlüssel bleibt durch den Authenticator oder dessen Credential-Management-Ökosystem geschützt. Die Website erhält den entsprechenden öffentlichen Schlüssel und verknüpft ihn mit dem Konto des Benutzers.

Während der Authentifizierung stellt der Server eine frische Herausforderung bereit. Der Authenticator signiert Daten, die mit dieser Herausforderung verknüpft sind, und der Server verifiziert die Signatur mithilfe des gespeicherten öffentlichen Schlüssels.

Es wird kein wiederverwendbares Passwort an die Website gesendet.

Ein Authenticator könnte ein Smartphone, ein Computer mit Windows Hello, ein Hardware-Sicherheitsschlüssel oder ein Credential-Manager sein, der synchronisierte Passkeys unterstützt.

Nicht jedes Passkey wird über Geräte hinweg synchronisiert. Manche Anmeldeinformationen bleiben gerätegebunden, während andere sicher gesichert und über einen Credential-Provider bereitgestellt werden können.

Die FIDO-Spezifikationen sind darauf ausgelegt, Phishing zu widerstehen, indem sie Anmeldeinformationen an die Domain der relying party binden. Biometrische Daten werden, wenn verwendet, lokal vom Gerät verarbeitet, anstatt an die Website gesendet zu werden.

2. WebAuthn ist die Browser-API hinter Passkeys

WebAuthn ist die Webplattform-API, die es Websites ermöglicht, Public-Key-Anmeldeinformationen zu erstellen und zu verwenden.

Zwei Browser-Methoden bilden die Grundlage:

navigator.credentials.create()
navigator.credentials.get()

Die erste erstellt eine Anmeldeinformation. Die zweite fordert Authentifizierung mithilfe einer bestehenden Anmeldeinformation an.

Beide Methoden arbeiten mit der publicKey-Option und erfordern einen sicheren Kontext, normalerweise HTTPS.

Wichtig ist, dass der Browser nicht entscheidet, ob der Benutzer authentifiziert ist. Er gibt Daten zurück, die das Backend verifizieren muss.

Ein erfolgreicher Browser-Prompt ist kein Beweis dafür, dass ein Login akzeptiert werden sollte.

Der Server bleibt verantwortlich für die Verifizierung der Herausforderung, des Ursprungs, der relying-party-Kennung und der kryptografischen Beweise.

3. Die vollständige Architektur verstehen

Eine typische Implementierung enthält vier Komponenten:

  • Das Webanwendungs-Frontend, das WebAuthn aufruft.
  • Das Anwendungs-Backend, das Herausforderungen generiert und Antworten verifiziert.
  • Der Authenticator oder der Passkey-Anbieter, der den privaten Schlüssel schützt.
  • Die Datenbank, die Anmeldeinformationen-Metadaten und öffentliche Schlüssel speichert.

Der Registrierungsablauf ist: Die Webanwendung fordert Registrierungsoptionen an; das Backend generiert eine Herausforderung und Benutzerdaten; der Browser und der Authenticator erstellen eine Anmeldeinformation und ein Schlüsselpaar; und das Backend verifiziert das Ergebnis und speichert den öffentlichen Schlüssel.

Der Server darf Registrierungsdaten niemals nur deshalb vertrauen, weil sie vom Browser zurückgegeben wurden.

Ein bösartiger Client kann beliebige HTTP-Anfragen einreichen, ohne überhaupt das erwartete Frontend zu verwenden.

Deshalb gehört die Verifizierung auf den Server.

4. Registrierungsoptionen auf dem Server generieren

Vor dem Aufruf von WebAuthn generiert das Backend eine Registrierungsherausforderung und Optionen.

Ein repräsentatives Optionsobjekt sieht wie folgt aus:

{
  "rp": {
    "name": "Example Application",
    "id": "example.com"
  },
  "user": {
    "id": "dXNlci0xMjM",
    "name": "alex@example.com",
    "displayName": "Alex"
  },
  "challenge": "SERVER_GENERATED_BASE64URL_CHALLENGE",
  "pubKeyCredParams": [
    {
      "type": "public-key",
      "alg": -7
    }
  ],
  "authenticatorSelection": {
    "residentKey": "required",
    "userVerification": "required"
  },
  "attestation": "none",
  "timeout": 300000
}

Dies ist beispielhaftes JSON, keine vollständige Produktionsantwort.

Mehrere Felder sind wichtig.

rp.id identifiziert die relying party. Zum Beispiel kann example.com für entsprechende Subdomänen dieser Domain verwendet werden, vorbehaltlich der RP-ID-Validierungsregeln von WebAuthn.

user.id sollte eine stabile, undurchsichtige Konto-Kennung sein, die als base64url für den JSON-Transport kodiert ist. Es sollte keine unnötigen persönlichen Informationen preisgeben.

challenge muss unter Verwendung einer kryptografisch sicheren Zufallsquelle auf dem Server generiert werden.

residentKey: "required" fordert eine auffindbare Anmeldeinformation an, die für die Passkey-Erfahrung erforderlich ist.

userVerification: "required" fordert lokale Nutzerverifizierung an, wie z. B. eine Geräte-PIN oder biometrische Authentifizierung. Das Backend muss später prüfen, dass die Verifizierung tatsächlich stattgefunden hat.

Der serverseitige Registrierungsleitfaden von Google beschreibt diese Felder und empfiehlt die Verwendung einer gepflegten WebAuthn-Bibliothek zum Generieren und Validieren von Registrierungsdaten.

5. Den Passkey in JavaScript erstellen

Moderne Browser stellen eine nützliche Methode bereit:

PublicKeyCredential.parseCreationOptionsFromJSON()

Sie konvertiert eine JSON-Darstellung, die base64url-kodierte Binärfelder enthält, in die von WebAuthn erwartete Struktur.

Dies vermeidet das Schreiben benutzerdefinierter base64url-zu-ArrayBuffer-Konvertierungslogik für jedes Feld.

Hier ist eine vereinfachte browserseitige Registrierungsfunktion:

async function registerPasskey() {
    const optionsResponse = await fetch(
        '/api/passkeys/register/options',
        {
            method: 'POST',
            credentials: 'same-origin',
            headers: {
                'Content-Type': 'application/json',
                'X-CSRF-Token': csrfToken
            }
        }
    );

    if (!optionsResponse.ok) {
        throw new Error('Unable to start registration');
    }

    const optionsJson = await optionsResponse.json();

    const publicKey =
        PublicKeyCredential.parseCreationOptionsFromJSON(
            optionsJson
        );

    const credential = await navigator.credentials.create({
        publicKey
    });

    if (!credential) {
        throw new Error('No credential was created');
    }

    const verifyResponse = await fetch(
        '/api/passkeys/register/verify',
        {
            method: 'POST',
            credentials: 'same-origin',
            headers: {
                'Content-Type': 'application/json',
                'X-CSRF-Token': csrfToken
            },
            body: JSON.stringify(credential.toJSON())
        }
    );

    if (!verifyResponse.ok) {
        throw new Error('Registration verification failed');
    }

    return await verifyResponse.json();
}

Die Variable csrfToken repräsentiert einen von der Anwendung bereitgestellten Anti-CSRF-Token. Der Server muss ihn validieren. Das Beispiel geht auch davon aus, dass die Seite bereits mit einem sicher authentisierten Benutzer verknüpft ist.

credential.toJSON() stellt eine JSON-freundliche Darstellung der zurückgegebenen Anmeldeinformation bereit und vermeidet eine weitere Ebene manueller Binärserialisierung.

Diese Komfortfunktionen sind in aktuellen Browsern verfügbar, obwohl Anwendungen, die ältere Browserversionen unterstützen, Kompatibilitätsbehandlung bereitstellen sollten.

Der obige Code ist nur die browserseitige Seite. Es ist keine vollständige Authentifizierungsimplementierung.

6. Was der Server während der Registrierung verifizieren muss

Wenn der Browser die neue Anmeldeinformation zurückgibt, muss das Backend sie validieren, bevor irgendetwas gespeichert wird.

Mindestens muss der Verifizierungsprozess sicherstellen, dass:

  1. Die zurückgegebene Herausforderung stimmt mit der für diesen Registrierungsversuch generierten überein.
  2. Die Herausforderung ist frisch und wurde nicht bereits verbraucht.
  3. Der gemeldete Ursprung stimmt mit einem explizit vertrauenswürdigen Anwendungsursprung überein.
  4. Die Authenticator-Daten entsprechen der erwarteten RP-ID.
  5. Die erforderlichen Bedingungen zur Nutzerpräsenz und Nutzerverifizierung sind erfüllt.
  6. Der öffentliche Schlüssel und die Kennung der Anmeldeinformation können extrahiert und validiert werden.
  7. Die Registrierung ist mit dem korrekt authentisierten Konto verknüpft.

Je nach Anwendungsrichtlinie können zusätzliche Prüfungen unterstützte Algorithmen, Einzigartigkeit von Anmeldeinformationen und Attestationsanforderungen umfassen.

Eine erfolgreiche Registrierung speichert typischerweise:

Feld Zweck
credential_id Identifiziert die Anmeldeinformation
user_id Verknüpft sie mit einem Konto
public_key Verifiziert zukünftige Signaturen
sign_count Verfolgt Authenticator-Zählerdaten
transports Optionale Authenticator-Transport-Hinweise
created_at Registrierungszeitstempel
last_used_at Kontoverwaltung und Auditing
backup_eligible / backup_state Optionale backup-bezogene Metadaten

Die genaue Datenbank-Darstellung hängt von der Verifizierungsbibliothek und der Anwendung ab.

Implementieren Sie CBOR-Parsing, Attestationsverifizierung oder kryptografische Signaturvalidierung nicht von Grund auf neu, es sei denn, Sie haben einen zwingenden Grund und die Expertise, es zu warten.

Die W3C-Spezifikation definiert detaillierte Registrierungs- und Authentifizierungsverifizierungsverfahren.

7. Einen bestehenden Benutzer authentifizieren

Die Authentifizierung folgt einer ähnlichen Struktur, erstellt jedoch kein neues Schlüsselpaar.

Der Server generiert eine neue Herausforderung und sendet Authentifizierungsoptionen an den Browser.

Für ein Passkey-Login mit auffindbarer Anmeldeinformation könnten diese Optionen Folgendes enthalten:

{
  "challenge": "NEW_SERVER_GENERATED_CHALLENGE",
  "rpId": "example.com",
  "userVerification": "required",
  "timeout": 300000
}

Der Browser kann dann eine Anmeldeinformation anfordern:

async function authenticateWithPasskey() {
    const optionsResponse = await fetch(
        '/api/passkeys/login/options',
        {
            credentials: 'same-origin'
        }
    );

    if (!optionsResponse.ok) {
        throw new Error('Unable to start authentication');
    }

    const optionsJson = await optionsResponse.json();

    const publicKey =
        PublicKeyCredential.parseRequestOptionsFromJSON(
            optionsJson
        );

    const credential = await navigator.credentials.get({
        publicKey
    });

    if (!credential) {
        throw new Error('Authentication was cancelled');
    }

    const verifyResponse = await fetch(
        '/api/passkeys/login/verify',
        {
            method: 'POST',
            credentials: 'same-origin',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(credential.toJSON())
        }
    );

    if (!verifyResponse.ok) {
        throw new Error('Authentication failed');
    }

    return await verifyResponse.json();
}

Dieses Beispiel geht davon aus, dass das Backend die ausgegebene Herausforderung mit einer kurzlebigen, anonymen Login-Transaktion verknüpft, geeignete Ratenbegrenzung anwendet und erst nach erfolgreicher Verifizierung eine neue authentifizierte Sitzung einrichtet.

Der Server muss die Anmeldeinformationen-ID nachschlagen, die signierte Aussage mit dem gespeicherten öffentlichen Schlüssel verifizieren, die Herausforderung und den Ursprung bestätigen und seine Nutzerverifizierungsrichtlinie durchsetzen.

Erst dann sollte er die Sitzung des Benutzers einrichten.

parseRequestOptionsFromJSON() ist Teil der modernen WebAuthn-API und entfernt die Notwendigkeit, Binärfelder bei häufigen browserseitigen Integrationen manuell zu dekodieren.

8. Passkeys zu bestehenden Login-Formularen mit bedingter Vermittlung hinzufügen

Eine der nützlichsten WebAuthn-Funktionen ist bedingte Vermittlung, manchmal auch Passkey-Autofill genannt.

Anstatt sofort einen separaten Passkey-Dialog anzuzeigen, kann der Browser ein verfügbares Passkey neben anderen gespeicherten Anmeldeinformationen anbieten, wenn der Nutzer mit einem Login-Feld interagiert.

Das HTML-Input-Element kann Folgendes verwenden:

<input
    type="text"
    name="username"
    autocomplete="username webauthn"
>

Die Anwendung kann auf Unterstützung prüfen:

const supported =
    await PublicKeyCredential.isConditionalMediationAvailable();

if (supported) {
    // Request authentication with mediation: 'conditional'.
}

Beim Aufruf von navigator.credentials.get() verwendet die Anwendung:

{
    publicKey,
    mediation: 'conditional'
}

Für die Autovervollständigung auffindbarer Anmeldeinformationen sollten die Optionen des Servers die Anfrage nicht auf eine bestimmte Liste von Anmeldeinformationen-IDs beschränken.

Bedingte Vermittlung ist besonders nützlich bei einer schrittweisen Migration von Passwörtern, da Nutzer sich nicht erinnern müssen, ob ein bestimmtes Konto ein Passkey hat.

Der Browser kann im vertrauten Login-Erlebnis geeignete Optionen präsentieren.

9. Warum Herausforderungs- und Ursprungsprüfungen unerlässlich sind

Passkeys sind phishing-resistent, aber das bedeutet nicht, dass eine Anwendung ihr Authentifizierungsprotokoll ignorieren kann.

Die Herausforderung schützt gegen Replay-Angriffe.

Ohne eine frische, unvorhersehbare Herausforderung könnte ein Angreifer versuchen, Authentifizierungsdaten aus einer vorherigen Sitzung wiederzuverwenden.

Die Ursprungs- und RP-ID-Prüfungen stellen sicher, dass Anmeldeinformationen im beabsichtigten Website-Kontext verwendet werden.

Zum Beispiel kann ein Passkey, das für example.com erstellt wurde, nicht einfach von einer täuschend echt aussehenden Phishing-Site wie examp1e.com wiederverwendet werden.

Der Browser und der Authenticator erzwingen wichtige Teile dieser Domain-Bindung, während das Backend die resultierenden Beweise unabhängig validiert.

Eine gute Implementierung verwendet kurzlebige Herausforderungen, verbraucht jede Herausforderung nur einmal und akzeptiert niemals beliebige Ursprünge nur deshalb, weil sie einen vertraut aussehenden Hostnamen teilen.

MDN empfiehlt, Herausforderungen in einer vertrauenswürdigen Umgebung zu generieren und sie nach einem kurzen Zeitraum ungültig zu machen, in der Regel nicht mehr als etwa zehn Minuten.

10. Signaturzähler nicht missverstehen

WebAuthn-Authenticator können einen Signaturzähler enthalten.

Historisch gesehen halfen Zähler dabei, möglicherweise geklonte Authenticator zu erkennen. Wenn ein Zähler unerwartet aufhört zu steigen, kann die relying party dies als Risikosignal betrachten.

Jedoch führt nicht jeder Authenticator einen aussagekräftigen Zähler.

Manche Anmeldeinformationen melden immer null. Synchronisierte Anmeldeinformationen können die Zählerinterpretation ebenfalls erschweren, da mehrere Geräte Kopien derselben Anmeldeinformation verwenden können.

Die W3C-Spezifikation behandelt unerwartetes Zählerverhalten ausdrücklich als mögliches Signal, nicht als endgültigen Beweis für Klonung.

Daher sollten Entwickler nicht blind jedes Login ablehnen, dessen Zähler null oder unverändert ist.

Verwenden Sie den Zähler gemäß dem Authenticator-Verhalten, der Anleitung der WebAuthn-Verifizierungsbibliothek und der Sicherheitsrichtlinie der Anwendung.

11. Konto-Wiederherstellung ist Teil der Passkey-Sicherheit

Eine Passkey-Implementierung ist unvollständig ohne eine Wiederherstellungsstrategie.

Was passiert, wenn ein Nutzer ein Gerät verliert?

Was ist, wenn sie ihren einzigen Passkey löschen?

Was ist, wenn sie den Anmeldeinformationen-Anbieter wechseln oder auf eine synchronisierte Anmeldeinformation nicht zugreifen können?

Ein sinnvolles Design erlaubt es Nutzern, mehrere Passkeys zu registrieren und über ihre Kontoeinstellungen zu verwalten.

Die Verwaltungsoberfläche sollte erkennbare Anmeldeinformationennamen, Erstellungsdaten und aktuelle Nutzung Informationen anzeigen, soweit verfügbar.

Nutzer sollten in der Lage sein, Anmeldeinformationen zu widerrufen, denen sie nicht mehr vertrauen.

Aber der Wiederherstellungsmechanismus erfordert besondere Sorgfalt.

Wenn ein Angreifer die Passkey-Authentifizierung mithilfe eines schwachen E-Mail-Wiederherstellungsprozesses umgehen kann, ist das gesamte Konto nur so sicher wie dieser Wiederherstellungspfad.

Für Konten mit höherem Risiko sollten Sie stärkere Wiederherstellungsverifizierung, Wiederherstellungscodes, zusätzliche registrierte Authenticator und Benachrichtigungen über sensible Kontoänderungen in Betracht ziehen.

Google's Passkey-UX-Richtlinie empfiehlt, eine Wiederherstellungsmethode festzulegen und wo angebracht mehrere Passkeys zu unterstützen.

12. Häufige Implementierungsfehler

Mehrere Fehler untergraben wiederholt sonst vielversprechende Passkey-Integrationen.

Browser-Erfolg als serverseitige Authentifizierung behandeln. Ein aufgelöstes navigator.credentials.get()-Versprechen ersetzt keine serverseitige kryptografische Verifizierung.

Herausforderungen in JavaScript generieren. Herausforderungen sollten von einem vertrauenswürdigen Server stammen und an die entsprechende Authentifizierungstransaktion gebunden sein.

Falsche RP-ID verwenden. Domain-Eingrenzung ist ein Sicherheitsfeature, keine kosmetische Einstellung. Produktions-, Staging- und lokale Entwicklungsumgebungen erfordern bewusste Konfiguration.

Annehmen, dass alle Passkeys synchronisieren. Gerätegebundene Anmeldeinformationen bleiben ein wichtiger Teil des Ökosystems.

Widerrufung von Anmeldeinformationen vergessen. Nutzer benötigen eine Möglichkeit, einen verlorenen oder kompromittierten Authenticator von ihrem Konto zu entfernen.

Eine schwache Fallback-Lösung erstellen. Ein phishing-resistentes Login verliert viel von seinem Wert, wenn die Konto-Wiederherstellung leicht ausgenutzt werden kann.

Alte Browser ignorieren. Moderne JSON-Komfortmethoden reduzieren die Komplexität, aber Anwendungen mit Anforderungen an ältere Browser benötigen möglicherweise dennoch Kompatibilitätscode.

CSRF- und Sitzungsschutz überspringen. Registrierungs- und Anmeldeinformationen-Verwaltungsvorgänge sind sensible Kontoänderungen. Sie benötigen denselben Schutz wie andere kontobezogene Aktionen mit hoher Wirkung.

Unnötig benutzerdefinierte kryptografische Verifizierung schreiben. Eine gewartete WebAuthn-Serverbibliothek ist normalerweise eine sicherere Wahl als die direkte Implementierung der Spezifikation.

13. Sollte jede Website Passwörter sofort ersetzen?

Nicht unbedingt.

Passkeys können sowohl Benutzerfreundlichkeit als auch Sicherheit verbessern, aber die Migrationsstrategie ist entscheidend.

Für eine neue Anwendung könnte passwortlose Registrierung eine vernünftige Standardeinstellung sein, wenn das Produkt einen gut gestalteten Wiederherstellungsfluss hat und seine Zielplattformen unterstützt.

Für eine bestehende Anwendung mit Tausenden von Nutzern ist inkrementelle Einführung oft sicherer.

Beginnen Sie damit, authentifizierten Nutzern zu erlauben, Passkeys in den Kontoeinstellungen zu registrieren.

Fügen Sie dann den Passkey-Login neben dem bestehenden Authentifizierungssystem hinzu.

Führen Sie bedingte Vermittlung dort ein, wo unterstützt.

Messen Sie Registrierungserfolg, Authentifizierungsfehler, Gerätekompatibilität und Wiederherstellungsanfragen.

Ziehen Sie schließlich in Betracht, Passkeys zur bevorzugten Authentifizierungsmethode zu machen, sobald die Benutzererfahrung und Wiederherstellungsmechanismen ausreichend ausgereift sind.

Ein schrittweiser Rollout erleichtert auch die Identifizierung browser-spezifischer Probleme, ohne legitime Nutzer auszusperren.

14. Eine Produktionsreife-Checkliste

Bevor Sie Passkeys in der Produktion aktivieren, verifizieren Sie Folgendes:

  • Alle WebAuthn-Operationen laufen in einem angemessenen sicheren Kontext.
  • RP-IDs und vertrauenswürdige Ursprünge sind explizit konfiguriert.
  • Herausforderungen sind kryptografisch zufällig, kurzlebig und einmalig verwendbar.
  • Registrierung erfordert angemessene Kontoautorisierung.
  • Serverseitige Verifizierung folgt der WebAuthn-Spezifikation.
  • Öffentliche Schlüssel und Anmeldeinformationen-Kennungen werden sicher gespeichert.
  • Login richtet eine Sitzung erst nach erfolgreicher Verifizierung ein.
  • Nutzerverifizierungsanforderungen werden auf dem Server durchgesetzt.
  • Entfernung von Anmeldeinformationen und Konto-Wiederherstellung sind geschützt.
  • Mehrere Anmeldeinformationen pro Konto werden wo angemessen unterstützt.
  • Authentifizierungsfehler und sicherheitsrelevante Kontoänderungen werden überwacht.
  • Mobile-, Desktop-, Cross-Device- und Hardware-Schlüssel-Szenarien werden getestet.

Diese Checks sind wichtiger als die Frage, ob das Frontend einen attraktiven biometrischen Login-Prompt anzeigen kann.

Fazit: Passkeys sind eine Authentifizierungsarchitektur, nicht nur ein Browser-Feature

WebAuthn macht Public-Key-Authentifizierung für gewöhnliche Webanwendungen zugänglich.

Moderne Browser-APIs haben einen Großteil der Serialisierungsarbeit entfernt, die die Passkey-Integration zuvor umständlich machte.

Aber der Browser ist nur ein Teil des Systems.

Die eigentliche Implementierungsarbeit liegt in Herausforderungsverwaltung, serverseitiger Verifizierung, Anmeldeinformationenspeicherung, Domain-Konfiguration, Konto-Wiederherstellung und sicheren Nutzerwegen.

Für Entwickler, die moderne Anwendungen in PHP, JavaScript, Python oder anderen Backend-Umgebungen erstellen, sind Passkeys zunehmend als praktische Alternative zu traditionellen Passwörtern eine Überlegung wert.

Der beste Ausgangspunkt ist nicht, ein ganzes Authentifizierungssystem über Nacht zu ersetzen.

Es ist, einen vollständigen, korrekt verifizierten Registrierungs- und Login-Flow zu implementieren und dann eine sichere Migrationsstrategie darum aufzubauen.