Comparatif de 9 bibliothèques d'implémentation de serveurs WebAuthn

Aide-mémoire Passkeys. Conseils pratiques, modèles de déploiement et KPIs pour les programmes passkeys.

Obtenir l'aide-mémoire

Fournir une authentification utilisateur simple et sécurisée est une nécessité pour les entreprises numériques en 2024. Les clés d'accès, en tant que nouveau standard de connexion, sont la solution idéale pour répondre à ces besoins. Cependant, l'expérience utilisateur et la sécurité améliorées des clés d'accès pour l'utilisateur ont un prix lors de leur implémentation en tant que développeur. La difficulté d'implémentation vient du fait que les clés d'accès sont relativement nouvelles - pour les utilisateurs, mais aussi pour les développeurs, et que leur implémentation peut être assez complexe par rapport à l'authentification basée sur un mot de passe. En fait, vous avez besoin d'au moins quatre points de terminaison d'API pour l'authentification par clé d'accès contre un seul pour l'authentification par mot de passe.

L'un des composants centraux côté serveur pour fournir l'authentification par clé d'accès est le serveur WebAuthn (partie verte de la bibliothèque). Pour un guide complet sur la façon dont le serveur WebAuthn s'intègre dans l'intégration plus large de la pile d'entreprise, consultez notre article dédié.

Source : Yubico

Dans cet article de blog, nous comparons plusieurs bibliothèques / packages / SDK de serveur WebAuthn, analysons les différences et fournissons une recommandation pour les développeurs qui débutent dans l'implémentation des clés d'accès.

Pour mieux comprendre pourquoi une bibliothèque de serveur WebAuthn est nécessaire en premier lieu, regardons comment les clés d'accès peuvent être implémentées. En principe, il existe deux façons d'intégrer les clés d'accès dans les sites Web et les applications :

1. Utiliser une solution de clé d'accès tierce (par exemple Corbado)
2. Implémenter les clés d'accès vous-même en utilisant l'une des bibliothèques de serveur WebAuthn ci-dessous

Bien qu'une solution de clé d'accès tierce soit facile à intégrer et permette généralement d'économiser beaucoup de temps d'ingénierie (en particulier pour les cas limites, la maintenance, la récupération, les solutions de repli et l'amélioration de l'expérience utilisateur des clés d'accès), certains développeurs préfèrent tout implémenter eux-mêmes.

Testez les passkeys dans une démo en direct.

Tester les passkeys

Voyons comment fonctionne l'implémentation de clés d'accès à faire soi-même. Dans une configuration très basique, un mécanisme pour s'inscrire et s'authentifier (se connecter) est nécessaire. Les deux processus, également appelés cérémonies WebAuthn, sont gérés différemment, même si le flux global suit un schéma similaire :

1. Le front-end (le navigateur) initie une demande d'inscription ou de connexion et appelle un point de terminaison d'API back-end.
2. Le back-end génère les paramètres WebAuthn d'inscription ou de connexion. Ceux-ci sont appelés respectivement PublicKeyCredentialCreationOptions et PublicKeyCredentialRequestOptions. L'une des parties les plus importantes de ces paramètres WebAuthn est le défi. Les paramètres WebAuthn sont ensuite renvoyés au front-end.
3. Le front-end reçoit ces paramètres WebAuthn et les utilise pour vérifier l'identité de l'utilisateur à l'aide du système d'authentification de l'appareil local (par exemple via Face ID, Touch ID, Windows Hello). Lors des processus d'inscription, une nouvelle paire de clés publique-privée est créée, la clé privée est stockée localement, tandis que la clé publique est envoyée au serveur. Lors des processus de connexion, le défi est signé à l'aide de la clé privée de la clé d'accès et envoyé à un autre point de terminaison d'API back-end.
4. Lors des processus d'inscription, le back-end reçoit la clé publique et la stocke. Lors des connexions, le back-end reçoit le défi signé et vérifie son intégrité à l'aide du serveur WebAuthn.

Étant donné que chaque processus d'inscription / de connexion implique ces étapes, le back-end doit garder une trace des utilisateurs, des clés d'accès et des demandes d'inscription / de connexion.

Igor Gjorgjioski

Head of Digital Channels & Platform Enablement, VicRoads

We hit 80% mobile passkey activation across 5M+ users without replacing our IDP.

See how VicRoads scaled passkeys to 5M+ users — alongside their existing IDP.

Read the case study

Si vous souhaitez acquérir des connaissances plus approfondies sur le fonctionnement des clés d'accès et sur ce à quoi ressemble une implémentation simple (sans utiliser de solution de clé d'accès tierce), vous pouvez consulter notre article de blog ici.

Dans des scénarios réels, lorsque vous implémentez les clés d'accès vous-même, gardez à l'esprit qu'il ne s'agit pas seulement de fournir les points de terminaison d'API nécessaires et l'implémentation de base pour l'inscription et la connexion. En plus de cela, vous devez aborder les sujets et cas d'utilisation suivants :

• Gestion des appareils
• Flux de connexion multiplateformes et multi-appareils
• Gestion des utilisateurs
• Gestion des sessions
• Détection des appareils compatibles avec les clés d'accès
• Éducation des utilisateurs
• Options d'authentification de secours
• Mécanismes de récupération
• Options de partage de compte
• Flux de création de clés d'accès et flux de connexion par clé d'accès optimisés pour une forte adoption

Cependant, pour l'implémentation de base des clés d'accès, il vous suffit de respecter la norme WebAuthn. L'implémentation d'une bibliothèque de serveur WebAuthn bien connue et prise en charge est généralement suffisante. La bibliothèque génère les paramètres du serveur WebAuthn et vérifie les défis de connexion, prenant essentiellement en charge la partie cryptographique et la plus complexe pour vous.

Rejoignez notre communauté passkeys pour les mises à jour et le support.

Rejoindre

Toutes les bibliothèques de serveur WebAuthn analysées fournissent les fonctionnalités nécessaires pour proposer l'authentification par clé d'accès. Par conséquent, nous avons accordé une attention particulière aux critères suivants :

• Critères de sélection de l'authentificateur : Comment pouvez-vous définir des préférences pour certains comportements et fonctionnalités de sécurité (par exemple, forcer la création de clés résidentes) ?
• Paramètres globaux : Dans quelle mesure pouvez-vous centraliser la configuration nécessaire ?
• Documentation : Dans quelle mesure la bibliothèque de serveur WebAuthn est-elle bien documentée et facile à suivre ?
• Exemples : Existe-t-il des exemples d'implémentation que vous pouvez prendre comme référence ?

Les bibliothèques de serveur WebAuthn suivantes ont été analysées (classées par nombre décroissant d'étoiles GitHub en décembre 2023) :

Découvrez combien de personnes utilisent réellement les passkeys.

Voir les données d'adoption

• Langage de programmation : TypeScript
• Framework : Node.js
• Auteur : Matthew Miller (Duo Security / Cisco)
• Étoiles : 1 000
• Utilisé par : 781
• Contributeurs : 19
• Conformité FIDO : Oui
• Paramètres globaux : Non
• Critères de sélection de l'authentificateur : Tel que suggéré par le W3C (doit contenir les variables authenticatorAttachment, residentKey, requireResidentKey et userVerification qui sont également expliquées sur la page du W3C)
• Documentation : Bien structurée avec un accent sur la configuration rapide et la facilité d'utilisation, inclut des connaissances sur les clés d'accès, par exemple explique ce que sont les clés d'accès et comment elles fonctionnent
• Exemples : Projet d'exemple disponible dans la documentation
• Structures de données recommandées :

type UserModel = {
  id: string;
  username: string;
  currentChallenge?: string;
};
 
/**
 * It is strongly advised that authenticators get their own DB
 * table, ideally with a foreign key to a specific UserModel.
 *
 * "SQL" tags below are suggestions for column data types and
 * how best to store data received during registration for use
 * in subsequent authentications.
 */
type Authenticator = {
  // SQL: Encode to base64url then store as `TEXT`. Index this column
  credentialID: Uint8Array;
  // SQL: Store raw bytes as `BYTEA`/`BLOB`/etc...
  credentialPublicKey: Uint8Array;
  // SQL: Consider `BIGINT` since some authenticators return atomic timestamps as counters
  counter: number;
  // SQL: `VARCHAR(32)` or similar, longest possible value is currently 12 characters
  // Ex: 'singleDevice' | 'multiDevice'
  credentialDeviceType: CredentialDeviceType;
  // SQL: `BOOL` or whatever similar type is supported
  credentialBackedUp: boolean;
  // SQL: `VARCHAR(255)` and store string array as a CSV string
  // Ex: ['usb' | 'ble' | 'nfc' | 'internal']
  transports?: AuthenticatorTransport[];
};

• Autres caractéristiques : Excellent débogueur WebAuthn pour les réponses WebAuthn et ne propose pas seulement une bibliothèque back-end / serveur, mais aussi une bibliothèque pour le front-end (enveloppant essentiellement certaines des API d'authentification Web du client)
• Évaluation personnelle : La configuration la plus intuitive vue jusqu'à présent et très simple. De plus, c'est l'une des rares bibliothèques qui propose également une bibliothèque de navigateur pour aider avec les implémentations client, ce qui la rend assez remarquable. L'auteur de la bibliothèque est très actif dans la communauté WebAuthn / clés d'accès.
• Lien GitHub : https://github.com/MasterKale/SimpleWebAuthn

• Langage de programmation : C#
• Framework : .NET
• Auteurs : Anders Åberg, Alex Seigler
• Étoiles : 962
• Utilisé par : 200
• Contributeurs : 40
• Conformité FIDO : Oui
• Paramètres globaux : Oui
• Critères de sélection de l'authentificateur : Tel que suggéré par le W3C
• Documentation : Juste le fichier Readme avec quelques exemples, de l'intelligence sur les clés d'accès sur le site Web de la bibliothèque
• Exemples : Contrôleur de démonstration et magasin d'informations d'identification d'exemple disponibles pour montrer un exemple d'intégration
• Structure de données recommandée :

public class StoredCredential
{
    /// <summary>
    /// The Credential ID of the public key credential source.
    /// </summary>
    public byte[] Id { get; set; }
 
    /// <summary>
    /// The credential public key of the public key credential source.
    /// </summary>
    public byte[] PublicKey { get; set; }
 
    /// <summary>
    /// The latest value of the signature counter in the authenticator data from any ceremony using the public key credential source.
    /// </summary>
    public uint SignCount { get; set; }
 
    /// <summary>
    /// The value returned from getTransports() when the public key credential source was registered.
    /// </summary>
    public AuthenticatorTransport[] Transports { get; set; }
 
    /// <summary>
    /// The value of the BE flag when the public key credential source was created.
    /// </summary>
    public bool IsBackupEligible { get; set; }
 
    /// <summary>
    /// The latest value of the BS flag in the authenticator data from any ceremony using the public key credential source.
    /// </summary>
    public bool IsBackedUp { get; set; }
 
    /// <summary>
    /// The value of the attestationObject attribute when the public key credential source was registered.
    /// Storing this enables the Relying Party to reference the credent’al's attestation statement at a later time.
    /// </summary>
    public byte[] AttestationObject { get; set; }
 
    /// <summary>
    /// The value of the clientDataJSON attribute when the public key credential source was registered.
    /// Storing this in combination with the above attestationObject item enables the Relying Party to re-verify the attestation signature at a later time.
    /// </summary>
    public byte[] AttestationClientDataJson { get; set; }
 
    public List<byte[]> DevicePublicKeys { get; set; }
 
    public byte[] UserId { get; set; }
 
    public PublicKeyCredentialDescriptor Descriptor { get; set; }
 
    public byte[] UserHandle { get; set; }
 
    public string AttestationFormat { get; set; }
 
    public DateTimeOffset RegDate { get; set; }
 
    public Guid AaGuid { get; set; }
}

• Autres caractéristiques : Utilisée par Bitwarden (la startup passwordless.dev a été acquise par Bitwarden)
• Évaluation personnelle : Bibliothèque conviviale pour les développeurs avec une bonne quantité de matériel supplémentaire
• Lien GitHub : https://github.com/passwordless-lib/fido2-net-lib

• Langage de programmation : Python
• Framework : Aucun spécifique
• Auteur : Duo Labs
• Étoiles : 727
• Utilisé par : 912
• Contributeurs : 23
• Conformité FIDO : N/D
• Paramètres globaux : Non
• Critères de sélection de l'authentificateur : Tel que suggéré par le W3C
• Documentation : Très peu ou pas du tout, des connaissances préalables sur les clés d'accès sont requises
• Exemples : De petits exemples de code pour l'inscription et la connexion sont inclus
• Structure de données recommandée : N/D
• Autres caractéristiques : Nécessite Python >= 3.8
• Évaluation personnelle : Bibliothèque relativement compacte avec un petit nombre de fichiers, vous pouvez en avoir un aperçu en peu de temps.
• Lien GitHub : https://github.com/duo-labs/py_webauthn

• Langage de programmation : Ruby
• Framework : Ruby on Rails
• Auteur : Cedarcode
• Étoiles : 580
• Utilisé par : 679
• Téléchargements du Gem : 18 millions
• Contributeurs : 27
• Conformité FIDO : Oui
• Paramètres globaux : Oui
• Critères de sélection de l'authentificateur : Tel que suggéré par le W3C
• Documentation : Le fichier Readme est la seule source de documentation
• Exemples : N/D
• Structure de données recommandée : N/D
• Autres caractéristiques : Des wrappers pour cette bibliothèque sont également disponibles (warden-webauthn, devise-passkeys)
• Évaluation personnelle : Étant donné que le matériel supplémentaire est assez limité, nous ne recommanderions cette bibliothèque que si vous êtes familier avec Ruby et les clés d'accès
• Lien GitHub : https://github.com/cedarcode/webauthn-ruby

• Langage de programmation : Go
• Framework : Frameworks basés sur Go comme Gin, Echo, …
• Auteur : À l'origine Duo Labs / poursuivi par James Elliott
• Étoiles : 480
• Utilisé par : 280
• Contributeurs : 18
• Conformité FIDO : Oui
• Paramètres globaux : Oui
• Critères de sélection de l'authentificateur : Tel que suggéré par le W3C
• Documentation : Le fichier Readme avec quelques exemples est la seule source de documentation
• Exemples : Dépôt d'exemples disponible
• Structure de données recommandée : N/D
• Autres caractéristiques : Grand nombre de fichiers, obtenir une vue d'ensemble prend un certain temps
• Évaluation personnelle : Bibliothèque populaire qui est facile à utiliser une fois que vous vous y êtes familiarisé, cependant nous recommandons d'acquérir quelques connaissances sur les clés d'accès (comment elles fonctionnent, à quoi ressemblent les procédures, etc.) au préalable.
• Lien GitHub : https://github.com/go-webauthn/webauthn

• Langage de programmation : Java
• Framework : Maven / Gradle
• Auteur : Yubico
• Étoiles : 391
• Utilisé par : N/D
• Contributeurs : 27
• Conformité FIDO : N/D
• Paramètres globaux : Oui
• Critères de sélection de l'authentificateur : Tel que suggéré par le W3C.
• Documentation : Le fichier Readme est la seule documentation, mais il est plutôt détaillé
• Exemples : N/D
• Structure de données recommandée : N/D
• Autres caractéristiques : Livré avec une interface de référentiel d'informations d'identification, fournissant des indications claires sur les méthodes de récupération de base de données requises.
• Évaluation personnelle : Bien que vous deviez gérer la base de données vous-même, le référentiel d'informations d'identification aide considérablement dans le processus de conception de la base de données. Naturellement, les implémentations Java sont accompagnées d'un nombre important de fichiers car chaque attribut a besoin d'une classe qui est généralement stockée dans son propre fichier. Cela rend l'obtention d'une vue d'ensemble plus fastidieuse.
• Lien GitHub : https://github.com/Yubico/java-webauthn-server

• Langage de programmation : Rust
• Framework : Basé sur Rust (Rocket, Axum, …)
• Auteur : Projet de gestion des identités Kanidm
• Étoiles : 351
• Utilisé par : 617
• Contributeurs : 25
• Conformité FIDO : N/D
• Paramètres globaux : Oui
• Critères de sélection de l'authentificateur : Possibilités de configuration très limitées. Les autres bibliothèques sont implémentées exactement selon la norme W3C, affichant une plus grande configurabilité
• Documentation : Une documentation technique générée automatiquement existe, mais n'est pas très détaillée
• Exemples : Dépôt de tutoriels avec des exemples pour 3 frameworks web différents est disponible
• Structure de données recommandée : N/D
• Autres caractéristiques : La bibliothèque a passé un audit de sécurité réalisé par la sécurité des produits SUSE.
• Évaluation personnelle : En raison de la configurabilité et de la documentation limitées, nous ne recommanderions cette bibliothèque que si votre framework principal est basé sur Rust et que vous savez comment fonctionnent les clés d'accès
• Lien GitHub : https://github.com/kanidm/webauthn-rs

• Langage de programmation : PHP
• Framework : Symfony
• Auteur : Florent Morselli
• Étoiles : 347
• Utilisé par : N/D
• Contributeurs : 18
• Conformité FIDO : Oui
• Paramètres globaux : Oui
• Critères de sélection de l'authentificateur : Tel que suggéré par le W3C.
• Documentation : Documentation complète comprenant des détails techniques, mais expliquant également les clés d'accès de A à Z
• Exemples : Dépôt d'exemples disponible
• Structure de données recommandée :

<?php
 
declare(strict_types=1);
 
namespace App\Entity;
 
use App\Repository\PublicKeyCredentialSourceRepository;
use DateTimeImmutable;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Uid\AbstractUid;
use Symfony\Component\Uid\Uuid;
use Webauthn\PublicKeyCredentialSource as BasePublicKeyCredentialSource;
use Webauthn\TrustPath\TrustPath;
 
#[ORM\Table(name: 'pk_credential_sources')]
#[ORM\Entity(repositoryClass: PublicKeyCredentialSourceRepository::class)]
class PublicKeyCredentialSource extends BasePublicKeyCredentialSource
{
    #[ORM\Column(type: Types::DATETIME_IMMUTABLE)]
    public readonly DateTimeImmutable $createdAt;
 
    #[ORM\Id]
    #[ORM\Column(type: Types::STRING, length: 255)]
    #[ORM\GeneratedValue(strategy: 'NONE')]
    private string $id;
 
    public function __construct(
        string $publicKeyCredentialId,
        string $type,
        array $transports,
        string $attestationType,
        TrustPath $trustPath,
        AbstractUid $aaguid,
        string $credentialPublicKey,
        string $userHandle,
        int $counter
    ) {
        $this->id = Uuid::v4()->toRfc4122();
        $this->createdAt = new DateTimeImmutable();
        parent::__construct($publicKeyCredentialId, $type, $transports, $attestationType, $trustPath, $aaguid, $credentialPublicKey, $userHandle, $counter);
    }
 
    public function getId(): string
    {
        return $this->id;
    }
}

• Autres caractéristiques : N/D
• Évaluation personnelle : Idéal pour les personnes qui souhaitent se lancer dans les clés d'accès, mais qui n'ont pas de connaissances préalables
• Lien GitHub : https://github.com/web-auth/webauthn-framework

• Langage de programmation : Java
• Framework : Maven
• Auteur : WebAuthn4j
• Étoiles : 342
• Utilisé par : N/D
• Contributeurs : 19
• Conformité FIDO : Oui
• Paramètres globaux : Oui
• Critères de sélection de l'authentificateur : Au lieu du paramètre UserVerificationRequirement suggéré par le W3C avec les valeurs discouraged, preferred, required, webauthn4j propose verificationRequired et userPrecenseRequired comme variables booléennes
• Documentation : Une documentation aride mais complète avec quelques exemples de code est disponible
• Exemples : Dépôt d'exemples disponible
• Structure de données recommandée : N/D
• Autres caractéristiques : N/D
• Évaluation personnelle : La lecture de la documentation devient rapidement ennuyeuse et complexe, car il ne s'agit que d'une seule grande page qui se concentre uniquement sur les fonctionnalités, et non sur le concept sous-jacent des clés d'accès.
• Lien GitHub : https://github.com/webauthn4j/webauthn4j

Le tableau suivant donne un aperçu des bibliothèques de serveur WebAuthn :

Abonnez-vous à notre Substack passkeys pour les dernières actualités.

S'abonner

Étant donné que la plupart des bibliothèques sont tout aussi puissantes et implémentent la norme WebAuthn, nous recommandons l'arbre de décision suivant :

• Une bibliothèque de serveur WebAuthn dans votre framework et langage de programmation est disponible : Nous n'avons pas répertorié les bibliothèques de framework qui dépendent de l'une des bibliothèques ci-dessus (par exemple, il existe des personnalisations pour PHP disponibles pour Symfony et Laravel). S'il existe une implémentation de framework, choisissez celle-ci car elle vous permet d'implémenter les appels d'API WebAuthn de manière native dans la structure de votre framework actuel et d'utiliser l'abstraction de votre base de données pour implémenter le stockage.
• Une bibliothèque de serveur WebAuthn dans votre langage de programmation est disponible : Comme vous avez besoin de points de terminaison d'API back-end, choisissez la bibliothèque de serveur WebAuthn dans votre langage de programmation natif afin qu'elle puisse être intégrée nativement dans vos points de terminaison d'API actuels.
• Il n'y a pas de bibliothèque de serveur WebAuthn disponible dans votre langage de programmation : Dans ce cas, vous devriez envisager d'utiliser une solution de clé d'accès gérée comme Corbado. Si ce n'est pas une option, nous vous recommandons d'utiliser go-webauthn ou SimpleWebAuthn car ils ont la plus grande adoption, sont légers et sont également utilisés par de nombreux projets commerciaux et open source.

Si vous souhaitez simplement en savoir plus sur les serveurs WebAuthn en général sans avoir déjà de projet spécifique, nous pouvons faire quelques recommandations car il existe des différences entre les bibliothèques et leur matériel supplémentaire comme les documentations et les exemples d'implémentation. Ainsi, pour les développeurs de logiciels désireux de démarrer leur parcours d'implémentation de clés d'accès, nous conseillons de choisir les implémentations suivantes :

• Pour des tests rapides : Le package py_webauthn offre une implémentation instantanée avec des extraits de code prêts à l'emploi. Avec un seul appel de méthode, vous pouvez générer les options dont vous avez besoin pour l'authentification. Comme vous n'avez pas besoin d'intégrer la bibliothèque dans un framework et de la configurer, c'est idéal pour des tests rapides.
• Pour une implémentation intuitive : Le package SimpleWebauthn écrit en TypeScript est simple et convivial pour les développeurs. Comme py_webauthn, l'implémentation est très minimaliste, mais il est en outre accompagné d'une documentation qui vous guide tout au long du processus d'authentification. Contrairement à py_webauthn cependant, SimpleWebAuthn n'est pas livré avec un exemple clair qui fonctionne sans modification.
• Pour une compréhension approfondie : La bibliothèque webauthn-framework pour PHP se distingue par une documentation complète et structurée axée sur les concepts des clés d'accès. Les principales différences par rapport à d'autres bibliothèques bien documentées comme webauthn4j résident dans la conception et la vivacité de la documentation.

Pour une compréhension encore plus approfondie de la façon dont WebAuthn fonctionne côté serveur, vous pouvez lire la section très détaillée « WebAuthn Relying Party Operations » dans le RFC WebAuthn qui détaille chaque étape devant être implémentée pour l'enregistrement d'un nouvel identifiant (7.1) et la vérification d'une assertion d'authentification (7.2).

Évaluez vos besoins spécifiques en matière de clés d'accès et de WebAuthn. Dans cet article de blog, nous avons supposé que vous souhaitiez uniquement prendre en charge les clés d'accès en tant qu'informations d'identification découvrables (discoverable credentials). Lisez attentivement les paramètres PublicKeyCredentialCreationOptions et PublicKeyCredentialRequestOptions ainsi que les appels d'API WebAuthn côté client navigator.credentials.create() et navigator.credentials.get() pour configurer correctement les paramètres dans la configuration du SDK du serveur WebAuthn pour votre cas d'utilisation.

Pour toutes les bibliothèques de serveur WebAuthn, vous devrez fournir la structure de base de données appropriée pour conserver / accéder aux informations suivantes :

• Identifiants (Credentials)
• Utilisateurs (Users)
• Défis (Challenges)
• Authentificateurs (Authenticators)

Pour certaines bibliothèques, il existe des recommandations et des exemples spécifiques (si nous les avons trouvés utiles, nous les avons fournis ci-dessus). Il est essentiel de bien comprendre quels champs WebAuthn doivent être stockés et où. Accordez une attention particulière à l'identification de la valeur que vous souhaitez utiliser pour l'ID utilisateur (user.id). Nous avons une explication plus détaillée ici. Prenez également en considération ce qui se passe lorsqu'un utilisateur supprime une clé d'accès. En outre, vous pouvez éventuellement restreindre l'utilisation de certains authentificateurs. Une liste d'authentificateurs valides liés aux clés d'accès peut être trouvée ici. Si vous souhaitez également prendre en charge et vérifier les attestations des clés de sécurité, c'est une toute autre histoire. Vous trouverez plus d'informations ici.

Identifiez sur quels appareils vos utilisateurs utiliseront les clés d'accès et les méthodes d'authentification de secours. Si vous n'êtes pas sûr des appareils, navigateurs et systèmes d'exploitation qu'utilisent vos utilisateurs, consultez State of Passkeys pour obtenir les dernières données sur la compatibilité avec les clés d'accès sur toutes les plateformes, navigateurs et systèmes d'exploitation. Si vous avez des questions spécifiques sur l'adoption des clés d'accès et la part de compatibilité des clés d'accès sur certains appareils, n'hésitez pas à nous contacter. Nous serons heureux de vous fournir des informations supplémentaires et de vous aider sur ce sujet (voir également notre dernier article de blog concernant la compatibilité des clés d'accès). D'un point de vue de l'observabilité, conservez les échecs WebAuthn côté client et les rejets de vérification du serveur dans des flux distincts ; pour les définitions de compartiments côté client, utilisez les erreurs WebAuthn. De plus, vous devez garder à l'esprit que pour Windows 10 et Linux, vous devrez trouver des solutions dédiées car ces systèmes d'exploitation offrent le moins (voire aucune) prise en charge des clés d'accès.

Découvrez combien de personnes utilisent réellement les passkeys.

Voir les données d'adoption

Pour presque chaque langage ou framework, il existe aujourd'hui une bibliothèque de serveur WebAuthn bien établie. La comparaison de bibliothèques de différents langages ne montre aucune supériorité claire de certaines implémentations. Vous devriez plutôt utiliser le framework / langage de programmation avec lequel vous êtes le plus à l'aise. Alternativement, si vous ne souhaitez pas implémenter WebAuthn vous-même et vous occuper de tout ce qui l'accompagne, vous pouvez essayer une solution d'authentification par clé d'accès dédiée et pré-intégrée comme Corbado. Constituant une solution d'authentification tout-en-un centrée sur les clés d'accès, elle est dotée d'une excellente intelligence sur les clés d'accès, d'une gestion de session ainsi que de méthodes d'authentification de secours, afin que vous puissiez vous concentrer sur le développement de votre produit et lâcher prise sur l'authentification. Vous pouvez l'essayer gratuitement avec un nombre illimité d'utilisateurs ici.

À propos de Corbado

Corbado est la Authentication Intelligence Platform pour les équipes CIAM qui gèrent l'authentification client à grande échelle. Nous vous montrons ce que les logs IDP et les outils d'analytics génériques ne voient pas : quels appareils, versions d'OS, navigateurs et gestionnaires de credentials prennent en charge les passkeys, pourquoi les enrôlements ne deviennent pas des connexions, où le flux WebAuthn échoue et quand une mise à jour OS ou navigateur casse silencieusement la connexion — le tout sans remplacer Okta, Auth0, Ping, Cognito ni votre IDP interne. Deux produits : Corbado Observe ajoute l'observabilité pour les passkeys et toute autre méthode de connexion. Corbado Connect apporte des passkeys managés avec analytics intégrés (aux côtés de votre IDP). VicRoads gère les passkeys pour plus de 5M d'utilisateurs avec Corbado (+80 % d'activation passkey). Parler à un expert Passkey →

Vérifiez d'abord s'il existe une bibliothèque pour votre framework spécifique, puis pour votre langage de programmation. Étant donné que toutes les bibliothèques répertoriées implémentent la norme WebAuthn de manière équivalente, le choix doit prioriser la familiarité avec votre pile existante plutôt que les différences de fonctionnalités entre les bibliothèques.

Au minimum, vous devez conserver les identifiants, les utilisateurs, les défis et les authentificateurs. Faites particulièrement attention à la valeur que vous attribuez comme identifiant utilisateur (userHandle), et prévoyez les scénarios où les utilisateurs pourraient supprimer une clé d'accès de leur appareil.

Les bibliothèques de serveur WebAuthn gèrent les opérations cryptographiques les plus complexes : la génération des paramètres PublicKeyCredentialCreationOptions et PublicKeyCredentialRequestOptions, ainsi que la vérification des défis signés. Le faire correctement de zéro est beaucoup plus difficile que d'utiliser une bibliothèque conforme FIDO qui a déjà été testée et auditée.

Windows 10 et Linux offrent la moins bonne prise en charge des clés d'accès, des solutions de repli dédiées sont donc nécessaires pour les utilisateurs sur ces plateformes. La surveillance des échecs WebAuthn côté client et des rejets de vérification du serveur sous forme de flux distincts aide à identifier les problèmes spécifiques au système d'exploitation en production.