> ## Documentation Index > Fetch the complete documentation index at: https://docs-dev-docs-event-stream-action-templates.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Clés d’identification natives pour applications mobiles > Découvrez comment implémenter des flux de clés d’identification natives pour les applications Android et iOS Clés d’identification natives est actuellement proposé en accès anticipé limité. Pour en savoir plus sur les étapes de diffusion d’Auth0, consultez [Étapes de la diffusion du produit](/docs/fr-ca/troubleshoot/product-lifecycle/product-release-stages). Les clés d’identification sont une forme d’authentification résistante à l’hameçonnage et peuvent remplacer les formes traditionnelles d’authentification (telles que le nom d’utilisateur et le mot de passe); de plus, elles offrent à l’utilisateur une expérience plus facile et mieux sécurisée. Elles sont modélisées à partir des [spécifications](https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-errata-20220621.html#intro)) FIDO® W3C Web Authentication (WebAuthn) et du protocole client-authentificateur (CTAP). Auth0 prend actuellement en charge les clés d’identification comme méthode d’authentification pour les connexions de base de données et offre deux méthodes d’implémentation : * [Clés d’identification de connexion universelle](/docs/fr-ca/authenticate/database-connections/passkeys) pour les applications Web. * Clés d’identification natives pour les applications Android et iOS. Pour en savoir plus sur la mise en œuvre de clés d’identification pour les applications mobiles, consultez les informations ci-dessous. ## Fonctionnement Les clés d’identification natives utilisent une combinaison du [Auth0 Authentication API](/docs/fr-ca/native-passkeys-api) et des API iOS ou Android natives pour intégrer les flux de défis-réponse directement dans votre application mobile. Cela vous permet de créer une expérience d’inscription et de connexion intégrée pour votre application qui ne repose pas sur la redirection des utilisateurs par leur navigateur pour compléter l’authentification. L’exemple suivant montre ce qu’un nouvel utilisateur peut rencontrer pendant le flux d’inscription avec une clé d’identification : 1. Un nouvel utilisateur lance votre application mobile et accède à l’écran de connexion. Puisqu’il s’agit d’un nouvel utilisateur, il sélectionne le bouton Sign Up (Inscription). 2. Sur l’écran suivant, l’utilisateur saisit son adresse courriel et sélectionne Create Account (Créer un compte). 3. Ensuite, l’utilisateur est invité à créer une clé d’identification pour votre application. Il sélectionne donc Continue (Continuer). 4. Pour générer une clé d’identification, l’utilisateur doit s’authentifier localement sur son appareil à l’aide des données biométriques ou d’une autre méthode d’authentification, telle que la saisie d’un NIP. 5. Une fois l’authentification locale terminée, une nouvelle clé d’identification est enregistrée sur l’appareil de l’utilisateur et cette clé est synchronisée avec son fournisseur de clé d’identification, tel qu’iCloud ou Google. 6. Une fois la clé d’identification enregistrée, l’utilisateur poursuit le processus d’enregistrement du nouvel utilisateur pour finaliser son compte. Par la suite, l’utilisateur pourra s’authentifier avec sa clé d’identification enregistrée au moment de se connecter à votre application. ## Avant de commencer ### Configuration d’un domaine personnalisé Les clés d’identification natives nécessitent l’utilisation d’un domaine personnalisé. Avant de continuer, assurez-vous d’avoir configuré un domaine personnalisé pour votre locataire. Pour en savoir plus, consultez l’article [Domaines personnalisés](/docs/fr-ca/customize/custom-domains). ### Configuration de votre politique de clé d’identification Avant de pouvoir implémenter des clés d’identification natives pour les applications Android ou iOS, vous devez configurer une politique de clé d’identification dans votre locataire Auth0. Pour préparer votre locataire, suivez les étapes décrites dans l’article [Configurer la politique de clés d’identification](/docs/fr-ca/authenticate/database-connections/passkeys/configure-passkey-policy). ### Préparation de votre application Pour préparer votre application aux clés d’identification natives, vous devez configurer les paramètres de votre appareil et ajouter l’autorisation `Passkey (Clé d’identification)`. Vous pouvez terminer ces configurations dans votre Auth0 Dashboard ou en utilisant Management API. #### Auth0 Dashboard 1. Accédez à [Applications > Applications](https://manage.auth0.com/#/applications) et sélectionnez l’application que vous souhaitez mettre à jour. 2. En bas de l’onglet Settings (Réglages), sélectionnez **Advanced Settings (Réglages avancés)**. Choisissez ensuite l’onglet **Device Settings (Réglages de l’appareil)**. 3. Remplissez les sections **iOS** et **Android** nécessaires pour votre application. Cliquez ensuite sur **Save Change (Enregistrer les modifications)**. 4. Dans la section Réglages avancés, sélectionnez l’onglet **Types d’autorisation**. 5. Activez l’autorisation **Passkey (Clé d’identification)**, puis sélectionnez **Save Change (Enregistrer les modifications)**. #### Management API Appelez le point de terminaison [Update a Client (Mettre à jour un client)](/docs/fr-ca/api/management/v2/clients/patch-clients-by-id) et : * Mettez à jour `grant_types` pour inclure `urn:okta:params:oauth:grant-type:webauthn`. * Utilisez l’objet `mobile` pour spécifier les paramètres de l’appareil iOS et Android selon vos besoins. ## Implémentation des flux de clé d’identification Vous pouvez définir les flux de clé d’identification suivants pour votre application : * [Flux d’inscription](#signup-flow) : Permet aux nouveaux utilisateurs de générer et d’enregistrer une clé d’identification pendant le processus d’enregistrement de l’utilisateur. * [Flux de connexion](#login-flow) : Permet à un utilisateur existant qui s’est déjà inscrit avec la méthode de clé d’identification de se connecter en s’authentifiant avec sa clé d’identification enregistrée. ### Flux d’inscription Un utilisateur lance le flux d’inscription par clé d’identification lorsqu’il tente pour la première fois de se connecter à votre application. Si l’utilisateur fournit un identifiant qui existe déjà, il est recommandé de l’inviter à terminer le flux de connexion. Sinon, l’action échouera. #### Étapes du flux 1. Un utilisateur visite votre application et choisit d’enregistrer un nouveau compte. L’utilisateur fournit un identifiant demandé par votre application, tel que son adresse courriel. 2. Votre application lance ensuite le défi-réponse d’inscription en appelant le point de terminaison [Demander un défi-réponse d’inscription](/docs/fr-ca/native-passkeys-api#request-signup-challenge) d’Auth0 Authentication API : * Si vous ne spécifiez pas de `realm`, le répertoire par défaut de votre locataire est utilisé. * Par défaut, le courriel est l’identifiant requis. Si vous avez activé [Identifiants flexibles](/docs/fr-ca/authenticate/database-connections/activate-and-configure-attributes-for-flexible-identifiers) pour votre connexion de base de données, vous pouvez utiliser une combinaison de `email`, `phone_number`, ou `username` à la place. Ces options peuvent être obligatoires ou facultatives et doivent correspondre à votre configuration d’identificateur flexible. ```text lines theme={null} POST /passkey/register Content-Type: application/json { "client_id": "", "realm": "", "user_profile": { "email": "", "name": "", } } ``` 3. En réponse, Auth0 renvoie [PublicKeyCredentialCreationOptions](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialcreationoptions) avec un identifiant `auth_session` : ```text lines expandable theme={null} HTTP/1.1 200 OK Content-Type: application/json { "authn_params_public_key": { "challenge": "", "timeout": , "rp": { "id": "", "name": "" }, "pubKeyCredParams": [ { type: 'public-key', alg: -8 }, { type: 'public-key', alg: -7 }, { type: 'public-key', alg: -257 } ], "authenticatorSelection": { "residentKey": "required", "userVerification": "preferred" }, "user": { "id": "", "name": "", "displayName": "" } }, "auth_session": "" } ``` 4. Votre application termine ensuite le processus d’enregistrement de l’utilisateur à l’aide des API natives appropriées : * Consultez la [documentation d’enregistrement Android](https://developer.android.com/identity/sign-in/credential-manager#create-passkey). * Consultez la [documentation d’enregistrement iOS](https://developer.apple.com/documentation/authenticationservices/supporting-passkeys#Register-a-new-account-on-a-service). 5. Votre application utilise ensuite les identifiants obtenus lors du processus d’enregistrement, y compris les détails `authn_response`, pour appeler le point de terminaison [Jeton](/docs/fr-ca/native-passkeys-api#authenticate-new-user) : ```text lines theme={null} POST /oauth/token Content-Type: application/json { "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "", "realm": "", "scope": "", "audience": "" "auth_session": "", "authn_response": { "id": "", "rawId": "", "type": "public-key", "authenticatorAttachment": "platform|cross-platform", "response": { "clientDataJSON": "", "attestationObject": "", } } ``` 6. Auth0 crée un nouveau compte utilisateur et renvoie les jetons demandés pour compléter le flux : ```text lines theme={null} HTTP/1.1 200 OK Content-Type: application/json { "access_token": "", "refresh_token": "", "id_token": "", "token_type": "Bearer", "expires_in": } ``` ### Flux de connexion Un utilisateur existant lance le flux de connexion par clé d’identification lorsqu’il tente de se connecter à votre application. Ce flux s’applique uniquement aux utilisateurs existants qui ont enregistré une clé d’identification à leurs comptes lors de l’inscription initiale. #### Étapes du flux 1. Un utilisateur lance votre application et commence le processus de connexion. Votre application lance ensuite le défi-réponse de connexion en appelant le point de terminaison[Demander un défi-réponse de connexion](/docs/fr-ca/native-passkeys-api#request-login-challenge) d’Authentication API : Si vous ne spécifiez pas de `realm`, le répertoire par défaut de votre locataire est utilisé. ```text lines theme={null} POST /passkey/challenge Content-Type: application/json { "client_id": "", "realm": "" } ``` 2. En réponse, Auth0 renvoie [PublicKeyCredentialRequestOptions](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialrequestoptions) avec l’objet `auth_session` pour continuer le flux dans votre application : ```text lines theme={null} HTTP/1.1 200 OK Content-Type: application/json { "authn_params_public_key": { "challenge": "", "timeout": , "rpId": "", "userVerification": "preferred" }, "auth_session": "" } ``` 3. Votre application termine ensuite le processus de connexion en utilisant les API natives appropriées : * Consultez la [documentation de connexion Android](https://developer.android.com/identity/sign-in/credential-manager#sign-in). * Consultez la [documentation de connexion iOS](https://developer.apple.com/documentation/authenticationservices/supporting-passkeys#Connect-to-a-service-with-an-existing-account). 4. Votre application utilise ensuite les identifiants obtenus lors du processus de connexion, y compris les détails `authn_response`, pour appeler le point de terminaison[Jeton](/docs/fr-ca/native-passkeys-api#authenticate-existing-user) : ```text lines theme={null} POST /oauth/token Content-Type: application/json { "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "", "realm": "", "scope": "", "audience": "" "auth_session": "", "authn_response": { "id": "", "rawId": "", "type": "public-key", "authenticatorAttachment": "platform|cross-platform", "response": { "authenticatorData": "", "clientDataJSON": "", "signature": "", "userHandle": "" }, "clientExtensionResults": } ``` 5. Auth0 authentifie les identifiants de connexion et renvoie les jetons demandés pour compléter le flux : ```text lines theme={null} HTTP/1.1 200 OK Content-Type: application/json { "access_token": "", "refresh_token": "", "id_token": "", "token_type": "Bearer", "expires_in": } ``` ## Références Les ressources suivantes peuvent être référencées lors de l’implémentation de clés d’identification natives pour votre application mobile : * Auth0 Authentication API (API d’authentification Auth0) * [Demander un défi-réponse d’inscription](/docs/fr-ca/native-passkeys-api#request-signup-challenge) * [Authentifier un nouvel utilisateur](/docs/fr-ca/native-passkeys-api#authenticate-new-user) * [Demander un défi-réponse de connexion](/docs/fr-ca/native-passkeys-api#request-login-challenge) * [Authentifier un utilisateur existant](/docs/fr-ca/native-passkeys-api#authenticate-existing-user) * Ressources Android * [Documentation d’enregistrement](https://developer.android.com/identity/sign-in/credential-manager#create-passkey) * [Documentation de connexion](https://developer.android.com/identity/sign-in/credential-manager#sign-in) * Ressources iOS * [Documentation d’enregistrement](https://developer.apple.com/documentation/authenticationservices/supporting-passkeys#Register-a-new-account-on-a-service) * [Documentation de connexion](https://developer.apple.com/documentation/authenticationservices/supporting-passkeys#Connect-to-a-service-with-an-existing-account)