9 bibliotecas de implementación de servidor WebAuthn comparadas

Hoja de referencia de Passkeys. Guías prácticas, patrones de despliegue y KPIs para programas de passkeys.

Obtener cheat sheet

Proporcionar una autenticación de usuario segura y sencilla es imprescindible para las empresas digitales en 2024. Las claves de acceso, como el nuevo estándar de inicio de sesión, son la solución ideal para satisfacer estas necesidades. Sin embargo, la mejora en la experiencia del usuario y la seguridad de las claves de acceso para el usuario tiene un precio a la hora de implementarlas como desarrollador. La dificultad de implementación radica en el hecho de que las claves de acceso son relativamente nuevas, tanto para los usuarios como para los desarrolladores, y que su implementación puede ser bastante desafiante en comparación con la autenticación basada en contraseñas. De hecho, se necesitan al menos cuatro endpoints de API para la autenticación con claves de acceso en comparación con un endpoint de API para la autenticación con contraseñas.

Uno de los componentes principales en el lado del servidor para proporcionar autenticación con claves de acceso es el servidor WebAuthn (parte de biblioteca verde). Para obtener una guía completa sobre cómo encaja el servidor WebAuthn en la integración más amplia del stack empresarial, consulta nuestro artículo dedicado.

Fuente: Yubico

En esta publicación del blog, comparamos varias bibliotecas, paquetes y SDK de servidor WebAuthn, analizamos las diferencias y proporcionamos una recomendación para los desarrolladores que son nuevos en la implementación de claves de acceso.

Para comprender mejor por qué se necesita una biblioteca de servidor WebAuthn en primer lugar, echemos un vistazo a cómo se pueden implementar las claves de acceso. En principio, hay dos formas de integrar las claves de acceso en sitios web y aplicaciones:

1. Utilizar una solución de claves de acceso de terceros (por ejemplo, Corbado).
2. Implementar las claves de acceso por tu cuenta utilizando una de las bibliotecas de servidor WebAuthn a continuación.

Si bien una solución de claves de acceso de terceros es fácil de integrar y, por lo general, ahorra mucho tiempo de ingeniería (especialmente para casos extremos, mantenimiento, recuperación, métodos alternativos y UX mejorada de las claves de acceso), algunos desarrolladores simplemente prefieren implementarlo todo ellos mismos.

Prueba passkeys en una demo en vivo.

Probar passkeys

Echemos un vistazo a cómo funciona la implementación de claves de acceso de forma manual. En una configuración muy básica, se necesita un mecanismo para registrarse y autenticarse (iniciar sesión). Ambos procesos, también llamados ceremonias WebAuthn, se manejan de manera diferente, aunque el flujo general sigue un esquema similar:

1. El frontend (el navegador) inicia una solicitud de registro o inicio de sesión y llama a un endpoint de API en el backend.
2. El backend genera parámetros de registro o inicio de sesión de WebAuthn. Estos se denominan PublicKeyCredentialCreationOptions y PublicKeyCredentialRequestOptions, respectivamente. Una de las partes más importantes de estos parámetros de WebAuthn es el desafío (challenge). Los parámetros de WebAuthn se envían de vuelta al frontend.
3. El frontend recibe estos parámetros de WebAuthn y los utiliza para verificar la identidad del usuario utilizando el sistema de autenticación del dispositivo local (por ejemplo, a través de Face ID, Touch ID o Windows Hello). En los procesos de registro, se crea un nuevo par de claves pública-privada; la clave privada se almacena localmente, mientras que la clave pública se envía al servidor. En los procesos de inicio de sesión, el desafío se firma utilizando la clave privada de la clave de acceso y se envía a otro endpoint de API en el backend.
4. En los procesos de registro, el backend recibe la clave pública y la almacena. En los inicios de sesión, el backend recibe el desafío firmado y verifica su integridad utilizando el servidor WebAuthn.

Dado que cada proceso de registro e inicio de sesión implica estos pasos, el backend necesita realizar un seguimiento de los usuarios, las claves de acceso y las solicitudes de registro e inicio de sesión.

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 deseas obtener conocimientos más profundos sobre la forma en que funcionan las claves de acceso y cómo se ve una implementación simple (sin usar una solución de claves de acceso de terceros), puedes investigar en nuestro artículo del blog aquí.

En escenarios de la vida real, al implementar claves de acceso tú mismo, ten en cuenta que no se trata solo de proporcionar los endpoints de API necesarios y la implementación básica para registrarse e iniciar sesión. Además de eso, debes abordar los siguientes temas y casos de uso:

• Gestión de dispositivos.
• Flujos de inicio de sesión multiplataforma y multidispositivo.
• Gestión de usuarios.
• Gestión de sesiones.
• Detección de dispositivos compatibles con claves de acceso.
• Educación del usuario.
• Opciones de autenticación alternativas (fallbacks).
• Mecanismos de recuperación.
• Opciones para compartir cuentas.
• Flujos optimizados de creación de claves de acceso y de inicio de sesión para una alta adopción.

Sin embargo, para la implementación básica de claves de acceso, solo necesitas cumplir con el estándar WebAuthn. Implementar una biblioteca de servidor WebAuthn conocida y con soporte suele ser suficiente. La biblioteca genera los parámetros del servidor WebAuthn y verifica los desafíos de inicio de sesión, asumiendo esencialmente la parte criptográfica y más compleja por ti.

Forma parte de nuestra comunidad de passkeys para recibir novedades y soporte.

Unirse

Todas las bibliotecas de servidor WebAuthn analizadas proporcionan las funcionalidades necesarias para ofrecer autenticación con claves de acceso. Por lo tanto, prestamos especial atención a los siguientes criterios:

• Criterios de selección de autenticador: ¿Cómo puedes establecer preferencias para ciertos comportamientos y características de seguridad (por ejemplo, forzar la creación de claves residentes)?
• Configuraciones globales: ¿Cuánto puedes centralizar la configuración necesaria?
• Documentación: ¿Qué tan bien documentada y fácil de seguir es la biblioteca del servidor WebAuthn?
• Ejemplos: ¿Existen implementaciones de ejemplo que puedas tomar como referencia?

Se analizaron las siguientes bibliotecas de servidor WebAuthn (ordenadas de forma descendente por el número de estrellas en GitHub en diciembre de 2023):

Consulta cuántas personas usan passkeys realmente.

Ver datos de adopción

• Lenguaje de programación: TypeScript
• Framework: Node.js
• Autor: Matthew Miller (Duo Security / Cisco)
• Estrellas: 1.000
• Usado por: 781
• Colaboradores: 19
• Conformidad con FIDO: Sí
• Configuraciones globales: No
• Criterios de selección de autenticador: Tal como sugiere el W3C (debe contener las variables authenticatorAttachment, residentKey, requireResidentKey y userVerification, que también se explican en la página del W3C).
• Documentación: Bien estructurada con enfoque en una configuración rápida y facilidad de uso; incluye conocimientos sobre claves de acceso (por ejemplo, explica qué son las claves de acceso y cómo funcionan).
• Ejemplos: Proyecto de ejemplo disponible en la documentación.
• Estructuras de datos recomendadas:

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

• Otras características: Excelente WebAuthn Debugger para respuestas WebAuthn y no solo ofrece una biblioteca backend/servidor, sino también una biblioteca para el frontend (básicamente envolviendo algunas de las API de autenticación web del cliente).
• Evaluación personal: La configuración más intuitiva vista hasta ahora y muy sencilla. Además, es una de las pocas bibliotecas que también ofrece una biblioteca de navegador para ayudar con las implementaciones del cliente, lo que la hace bastante destacada. El autor de la biblioteca es muy activo en la comunidad de WebAuthn y claves de acceso.
• Enlace de GitHub: https://github.com/MasterKale/SimpleWebAuthn

• Lenguaje de programación: C#
• Framework: .NET
• Autores: Anders Åberg, Alex Seigler
• Estrellas: 962
• Usado por: 200
• Colaboradores: 40
• Conformidad con FIDO: Sí
• Configuraciones globales: Sí
• Criterios de selección de autenticador: Tal como sugiere el W3C.
• Documentación: Solo el archivo Readme con un par de ejemplos, algo de inteligencia de claves de acceso en el sitio web de la biblioteca.
• Ejemplos: Controlador de demostración y almacén de credenciales de ejemplo disponibles para mostrar una integración de ejemplo.
• Estructura de datos recomendada:

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

• Otras características: Utilizada por Bitwarden (la startup passwordless.dev fue adquirida por Bitwarden).
• Evaluación personal: Biblioteca amigable para los desarrolladores con una buena cantidad de material complementario.
• Enlace de GitHub: https://github.com/passwordless-lib/fido2-net-lib

• Lenguaje de programación: Python
• Framework: Ninguno en específico
• Autor: Duo Labs
• Estrellas: 727
• Usado por: 912
• Colaboradores: 23
• Conformidad con FIDO: N/A
• Configuraciones globales: No
• Criterios de selección de autenticador: Tal como sugiere el W3C.
• Documentación: Muy poca o ninguna, se requieren conocimientos previos sobre claves de acceso.
• Ejemplos: Se incluyen pequeños fragmentos de código de muestra para registrarse e iniciar sesión.
• Estructura de datos recomendada: N/A
• Otras características: Requiere Python >= 3.8.
• Evaluación personal: Biblioteca comparativamente compacta con una pequeña cantidad de archivos; puedes obtener una visión general en poco tiempo.
• Enlace de GitHub: https://github.com/duo-labs/py_webauthn

• Lenguaje de programación: Ruby
• Framework: Ruby on Rails
• Autor: Cedarcode
• Estrellas: 580
• Usado por: 679
• Descargas de gemas: 18 millones
• Colaboradores: 27
• Conformidad con FIDO: Sí
• Configuraciones globales: Sí
• Criterios de selección de autenticador: Tal como sugiere el W3C.
• Documentación: El archivo Readme es la única fuente de documentación.
• Ejemplos: N/A
• Estructura de datos recomendada: N/A
• Otras características: También hay envoltorios (wrappers) disponibles para esta biblioteca (warden-webauthn, devise-passkeys).
• Evaluación personal: Dado que el material complementario es bastante limitado, solo recomendaríamos esta biblioteca si estás familiarizado tanto con Ruby como con las claves de acceso.
• Enlace de GitHub: https://github.com/cedarcode/webauthn-ruby

• Lenguaje de programación: Go
• Framework: Frameworks basados en Go como Gin, Echo, etc.
• Autor: Originalmente de Duo Labs / continuado por James Elliott
• Estrellas: 480
• Usado por: 280
• Colaboradores: 18
• Conformidad con FIDO: Sí
• Configuraciones globales: Sí
• Criterios de selección de autenticador: Tal como sugiere el W3C.
• Documentación: El archivo Readme con algunos ejemplos es la única fuente de documentación.
• Ejemplos: Repositorio de ejemplo disponible.
• Estructura de datos recomendada: N/A
• Otras características: Gran cantidad de archivos, obtener una visión general lleva algo de tiempo.
• Evaluación personal: Biblioteca popular que es fácil de usar una vez que te familiarizas con ella; sin embargo, recomendamos adquirir algunos conocimientos sobre claves de acceso (cómo funcionan, cómo son los procedimientos, etc.) de antemano.
• Enlace de GitHub: https://github.com/go-webauthn/webauthn

• Lenguaje de programación: Java
• Framework: Maven / Gradle
• Autor: Yubico
• Estrellas: 391
• Usado por: N/A
• Colaboradores: 27
• Conformidad con FIDO: N/A
• Configuraciones globales: Sí
• Criterios de selección de autenticador: Tal como sugiere el W3C.
• Documentación: El archivo Readme es la única documentación, pero es bastante detallado.
• Ejemplos: N/A
• Estructura de datos recomendada: N/A
• Otras características: Viene con una interfaz de Repositorio de Credenciales, proporcionando una guía clara sobre los métodos requeridos de recuperación de la base de datos.
• Evaluación personal: Aunque debes administrar la base de datos tú mismo, el repositorio de credenciales ayuda significativamente en el proceso de diseño de la base de datos. Naturalmente, las implementaciones en Java vienen con una gran cantidad de archivos, ya que cada atributo necesita una clase que generalmente se almacena en su propio archivo. Esto hace que obtener una visión general sea una tarea que requiere más tiempo.
• Enlace de GitHub: https://github.com/Yubico/java-webauthn-server

• Lenguaje de programación: Rust
• Framework: Basados en Rust (Rocket, Axum, etc.)
• Autor: Kanidm Identity Management Project
• Estrellas: 351
• Usado por: 617
• Colaboradores: 25
• Conformidad con FIDO: N/A
• Configuraciones globales: Sí
• Criterios de selección de autenticador: Posibilidades de configuración muy limitadas. Las otras bibliotecas se implementan exactamente de acuerdo con el estándar del W3C, mostrando una mayor capacidad de configuración.
• Documentación: Existe documentación técnica autogenerada, pero no es muy detallada.
• Ejemplos: Repositorio de tutoriales con ejemplos para 3 frameworks web diferentes está disponible.
• Estructura de datos recomendada: N/A
• Otras características: La biblioteca ha pasado una auditoría de seguridad realizada por SUSE Product Security.
• Evaluación personal: Debido a la limitada capacidad de configuración y documentación, solo recomendaríamos esta biblioteca si tu framework principal está basado en Rust y sabes cómo funcionan las claves de acceso.
• Enlace de GitHub: https://github.com/kanidm/webauthn-rs

• Lenguaje de programación: PHP
• Framework: Symfony
• Autor: Florent Morselli
• Estrellas: 347
• Usado por: N/A
• Colaboradores: 18
• Conformidad con FIDO: Sí
• Configuraciones globales: Sí
• Criterios de selección de autenticador: Tal como sugiere el W3C.
• Documentación: Documentación extensa que incluye detalles técnicos, pero que también explica las claves de acceso desde cero.
• Ejemplos: Repositorio de ejemplo disponible.
• Estructura de datos recomendada:

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

• Otras características: N/A
• Evaluación personal: Buena para las personas que desean adentrarse en las claves de acceso, pero que no tienen conocimientos previos.
• Enlace de GitHub: https://github.com/web-auth/webauthn-framework

• Lenguaje de programación: Java
• Framework: Maven
• Autor: WebAuthn4j
• Estrellas: 342
• Usado por: N/A
• Colaboradores: 19
• Conformidad con FIDO: Sí
• Configuraciones globales: Sí
• Criterios de selección de autenticador: En lugar del parámetro UserVerificationRequirement sugerido por el W3C con valores discouraged, preferred o required, webauthn4j ofrece verificationRequired y userPrecenseRequired como variables booleanas.
• Documentación: Seca, pero hay documentación extensa con algunos fragmentos de código disponibles.
• Ejemplos: Repositorio de ejemplo disponible.
• Estructura de datos recomendada: N/A
• Otras características: N/A
• Evaluación personal: Leer la documentación se vuelve aburrido y complejo rápidamente, ya que es solo una página grande que se enfoca únicamente en la funcionalidad, no en el concepto detrás de las claves de acceso.
• Enlace de GitHub: https://github.com/webauthn4j/webauthn4j

La siguiente tabla proporciona una descripción general de las bibliotecas de servidor WebAuthn:

Suscríbete a nuestro Substack de passkeys para recibir las últimas noticias.

Suscribirse

Dado que la mayoría de las bibliotecas son igualmente potentes e implementan el estándar WebAuthn, recomendamos el siguiente árbol de decisiones:

• Si hay disponible una biblioteca de servidor WebAuthn en tu framework y lenguaje de programación: No hemos incluido bibliotecas de frameworks que dependan de una de las bibliotecas anteriores (por ejemplo, hay personalizaciones para PHP disponibles para Symfony y Laravel). En caso de que haya una implementación de framework, elige esa, ya que te permite implementar las llamadas a la API de WebAuthn de forma nativa en la estructura de tu framework actual y usar la abstracción de tu base de datos para implementar el almacenamiento.
• Si hay disponible una biblioteca de servidor WebAuthn en tu lenguaje de programación: Dado que necesitas endpoints de API en el backend, elige la biblioteca de servidor WebAuthn en tu lenguaje de programación nativo para que pueda integrarse de forma natural en tus endpoints de API actuales.
• Si no hay ninguna biblioteca de servidor WebAuthn disponible en tu lenguaje de programación: En este caso, deberías considerar utilizar una solución gestionada de claves de acceso como Corbado. Si esa no es una opción, recomendamos usar go-webauthn o SimpleWebAuthn, ya que tienen la mayor adopción, son ligeras y también las utilizan muchos proyectos comerciales y de código abierto.

Si simplemente quieres aprender más sobre los servidores WebAuthn en general sin tener todavía un proyecto específico, podemos hacerte algunas recomendaciones, ya que hay ciertas diferencias entre las bibliotecas y su material complementario (como la documentación y los ejemplos de implementación). Por lo tanto, a los desarrolladores de software que estén ansiosos por iniciar su viaje en la implementación de claves de acceso, les aconsejamos que elijan las siguientes implementaciones:

• Para pruebas rápidas: El paquete py_webauthn ofrece una implementación instantánea con fragmentos de código listos para usar. Con una sola llamada de método, puedes generar las opciones que necesitas para la autenticación. Dado que no necesitas integrar la biblioteca en un framework ni configurarla, es ideal para pruebas rápidas.
• Para una implementación intuitiva: El paquete SimpleWebAuthn, escrito en TypeScript, es directo y amigable para el desarrollador. Al igual que py_webauthn, la implementación es muy minimalista, pero además viene con documentación que te guía a través del proceso de autenticación. Sin embargo, a diferencia de py_webauthn, SimpleWebAuthn no incluye un ejemplo claro que se ejecute sin modificaciones.
• Para una comprensión profunda: La biblioteca webauthn-framework para PHP destaca por su documentación extensa y estructurada que se centra en los conceptos de las claves de acceso. Las principales diferencias con otras bibliotecas que tienen buena documentación, como webauthn4j, son el diseño y la claridad de la documentación.

Para comprender aún más a fondo cómo funciona WebAuthn en el lado del servidor, puedes leer la sección muy detallada sobre Operaciones de la Relying Party de WebAuthn en el RFC de WebAuthn, que detalla cada paso que debe implementarse para el registro de una nueva credencial (7.1) y la verificación de una afirmación de autenticación (7.2).

Evalúa los requisitos específicos de claves de acceso y WebAuthn que tienes. En esta publicación de blog, asumimos que solo deseas admitir claves de acceso como credenciales descubribles (discoverable credentials). Lee sobre PublicKeyCredentialCreationOptions y PublicKeyCredentialRequestOptions junto con las llamadas a la API WebAuthn del lado del cliente navigator.credentials.create() y navigator.credentials.get() para configurar correctamente los parámetros en la configuración del SDK del servidor WebAuthn para tu caso de uso.

Para todas las bibliotecas de servidor WebAuthn, deberás proporcionar la estructura de base de datos adecuada para persistir o acceder a la siguiente información:

• Credenciales
• Usuarios
• Desafíos (Challenges)
• Autenticadores

Para algunas bibliotecas, existen recomendaciones y ejemplos específicos (si los encontramos útiles, los proporcionamos anteriormente). Es esencial comprender completamente qué campos de WebAuthn deben almacenarse y dónde. Presta especial atención a identificar qué valor deseas usar para el ID de usuario (user.id). Tenemos una explicación más detallada aquí. También ten en cuenta qué sucede cuando un usuario puede eliminar una clave de acceso. Además de eso, opcionalmente puedes restringir el uso de ciertos autenticadores. Puedes encontrar una lista de autenticadores válidos relacionados con las claves de acceso aquí. En caso de que también desees admitir y verificar las atestaciones de las llaves de seguridad, esta es una historia completamente diferente. Puedes encontrar más información aquí.

Identifica en qué dispositivos utilizarán tus usuarios las claves de acceso y los métodos de autenticación alternativos. En caso de que no estés seguro de qué dispositivos, navegadores y sistemas operativos usan tus usuarios, consulta State of Passkeys para obtener los datos más recientes sobre la preparación para claves de acceso (passkey-readiness) en plataformas, navegadores y sistemas operativos. Si tienes preguntas específicas sobre la adopción de claves de acceso y la proporción de preparación para claves de acceso en determinados dispositivos, no dudes en comunicarte con nosotros. Estaremos encantados de proporcionarte más información y ayudarte con este tema (consulta también nuestra última publicación de blog sobre la preparación para claves de acceso). Desde una perspectiva de observabilidad, mantén las fallas de WebAuthn del lado del cliente y los rechazos de verificación del servidor como flujos separados; para las definiciones de buckets del lado del cliente, usa los errores de WebAuthn. Además, debes tener en cuenta que para Windows 10 y Linux deberás idear soluciones dedicadas, ya que estos sistemas operativos proporcionan la menor (si la hay) compatibilidad con claves de acceso.

Consulta cuántas personas usan passkeys realmente.

Ver datos de adopción

Para casi todos los lenguajes o frameworks que existen en la actualidad, hay una biblioteca de servidor WebAuthn bien establecida. Comparar bibliotecas de diferentes lenguajes no muestra una clara superioridad de ciertas implementaciones. Más bien, debes usar el framework o lenguaje de programación con el que estés más familiarizado. Alternativamente, si no quieres implementar WebAuthn tú mismo y ocuparte de todo lo que conlleva, puedes probar una solución dedicada y preconstruida de autenticación con claves de acceso como Corbado. Al ser una solución de autenticación todo en uno centrada en claves de acceso, viene con una excelente inteligencia de claves de acceso, gestión de sesiones y métodos de autenticación alternativos, para que puedas centrarte en desarrollar tu producto y olvidarte de la autenticación. Puedes probarla de forma gratuita con usuarios ilimitados aquí.

Acerca de Corbado

Corbado es la Authentication Intelligence Platform para equipos de CIAM que gestionan autenticación de consumidores a gran escala. Te ayudamos a ver lo que los logs de tu IDP y las herramientas de analytics genéricas no muestran: qué dispositivos, versiones de SO, navegadores y gestores de credenciales soportan passkeys, por qué los registros no se convierten en inicios de sesión, dónde falla el flujo de WebAuthn y cuándo una actualización de SO o navegador rompe el login en silencio — todo sin reemplazar Okta, Auth0, Ping, Cognito o tu IDP propio. Dos productos: Corbado Observe aporta observabilidad para passkeys y cualquier otro método de login. Corbado Connect añade passkeys gestionados con analytics integrado (junto a tu IDP). VicRoads ejecuta passkeys para más de 5M de usuarios con Corbado (+80 % de activación de passkey). Habla con un experto en Passkeys →

Primero verifica si existe una biblioteca para tu framework específico y luego para tu lenguaje de programación. Dado que todas las bibliotecas enumeradas implementan el estándar WebAuthn por igual, la elección debe priorizar la familiaridad con tu stack existente en lugar de las diferencias de características entre las bibliotecas.

Como mínimo, debes persistir credenciales, usuarios, desafíos y autenticadores. Presta mucha atención al valor que asignas como ID de usuario (userHandle) y planifica para escenarios en los que los usuarios puedan eliminar una clave de acceso de su dispositivo.

Las bibliotecas de servidor WebAuthn manejan las operaciones criptográficas más complejas: generar los parámetros PublicKeyCredentialCreationOptions y PublicKeyCredentialRequestOptions y verificar los desafíos firmados. Hacer esto correctamente desde cero es significativamente más difícil que usar una biblioteca conforme a FIDO que ya ha sido probada y auditada.

Windows 10 y Linux proporcionan el menor soporte para claves de acceso, por lo que se necesitan soluciones alternativas dedicadas para los usuarios en estas plataformas. Monitorear las fallas de WebAuthn del lado del cliente y los rechazos de verificación del servidor como flujos separados ayuda a identificar problemas específicos del sistema operativo en producción.