> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Découvrez comment mettre en œuvre des flux natifs de clés d’accès pour les applications Android et iOS
# Clés d’accès natives pour les applications mobiles
export const ReleaseStageNotice = ({feature, stage, plans, contact, terms}) => {
const stageTextMap = {
"beta": "Bêta",
"ea": "Accès anticipé"
};
const stageText = stageTextMap[stage] || "une étape du cycle de publication";
const prsLink = "/docs/troubleshoot/product-lifecycle/product-release-stages";
const linkify = (text, url) => {
return {text};
};
const includeDetails = (plans, contact, terms) => {
const hasDetails = terms || plans || contact;
if (!hasDetails) return null;
return
{plans && <>Cette fonctionnalité est offerte avec les {linkify(`${plans} forfaits`, "https://auth0.com/pricing")}. }
{contact && "Pour y participer, communiquez avec " + contact + ". "}
{terms && <>En utilisant cette fonctionnalité, vous acceptez les conditions applicables de l’essai gratuit énoncées dans le {linkify("Master Subscription Agreement", "https://www.okta.com/legal")} d’Okta.}
;
};
return
La fonctionnalité {feature} est en {linkify(stageText, prsLink)}.
{includeDetails(plans, contact, terms)}
;
};
Les clés d’accès sont une solution de rechange résistante à l’hameçonnage aux méthodes d’authentification traditionnelles (comme le nom d’utilisateur et le mot de passe) et offrent une expérience utilisateur plus simple et plus sécuritaire. Elles reposent sur les [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 Client to Authenticator Protocol (CTAP).
Auth0 prend actuellement en charge les clés d’accès comme méthode d’authentification pour les connexions de base de données et offre deux méthodes de mise en œuvre :
* [Clés d’accès dans Universal Login](/fr-CA/docs/authenticate/database-connections/passkeys) pour les applications Web.
* Clés d’accès natives pour les applications Android et iOS.
* [Connexion intégrée pour les applications Web et natives](/fr-CA/docs/authenticate/passwordless/implement-login/embedded-login)
## Fonctionnement
Les clés d’accès natives utilisent une combinaison de l’[API d’authentification Auth0](/fr-CA/docs/authenticate/database-connections/passkeys/native-passkeys-api) et des API natives d’iOS ou d’Android pour intégrer directement les flux de vérification à votre application mobile. Cela vous permet de créer, pour votre application, une expérience intégrée d’inscription et de connexion sans devoir rediriger les utilisateurs vers leur navigateur pour terminer l’authentification.
L’exemple suivant montre ce qu’un nouvel utilisateur peut vivre pendant le flux d’inscription avec clé d’accès :
1. Un nouvel utilisateur lance votre application mobile et accède à l’écran de connexion. Comme il s’agit d’un nouvel utilisateur, il sélectionne le bouton S’inscrire.
2. À l’écran suivant, l’utilisateur saisit son adresse courriel et sélectionne Créer un compte.
3. Ensuite, on demande à l’utilisateur s’il souhaite créer une clé d’accès pour votre application. Pour continuer, l’utilisateur sélectionne Continuer.
4. Pour générer une clé d’accès, l’utilisateur doit s’authentifier localement sur son appareil à l’aide de données biométriques ou d’une autre méthode d’authentification, comme la saisie d’un NIP.
5. Une fois l’authentification locale terminée, une nouvelle clé d’accès est enregistrée sur l’appareil de l’utilisateur et synchronisée avec son fournisseur de clés d’accès, comme iCloud ou Google.
6. Une fois la clé d’accès enregistrée, l’utilisateur poursuit le processus d’inscription afin de finaliser son compte.
Une fois ce processus terminé, l’utilisateur peut s’authentifier avec sa clé d’accès enregistrée la prochaine fois qu’il se connecte à votre application.
## Avant de commencer
### Configurer un domaine personnalisé
Les clés d’accès 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 [Custom Domains](/fr-CA/docs/customize/custom-domains).
### Configurer votre stratégie de clés d’accès
Avant de pouvoir implémenter des clés d’accès natives pour les applications Android ou iOS, vous devez configurer une stratégie de clés d’accès dans votre locataire Auth0. Pour préparer votre locataire, suivez les étapes de [Configurer la stratégie de clés d’accès](/fr-CA/docs/authenticate/database-connections/passkeys/configure-passkey-policy).
### Préparez votre application
Pour préparer votre application à l’utilisation de clés d’accès natives, vous devez configurer vos paramètres de l’appareil et ajouter le grant `Passkey`. Vous pouvez effectuer cette configuration dans votre Auth0 Dashboard ou au moyen de la Management API.
#### Domaines associés
Pour permettre aux utilisateurs finaux de s’authentifier à l’aide d’une seule clé d’accès dans différents types d’applications, ou dans des applications ayant des sous-domaines différents, définissez le Relying Party ID sur le domaine racine ou parent. Pour en savoir plus, consultez [Passkeys](/fr-CA/docs/authenticate/database-connections/passkeys).
### Configurer Auth0 Dashboard
1. Accédez à [Applications > Applications](https://manage.auth0.com/#/applications) et sélectionnez l’application à mettre à jour.
2. Au bas de l’onglet Settings, sélectionnez **Advanced Settings**. Ensuite, choisissez l’onglet **Device Settings**.
3. Remplissez les sections **iOS** et **Android** selon les besoins de votre application. Ensuite, cliquez sur **Save Changes**.
4. Dans la section **Advanced Settings**, sélectionnez l’onglet **Grant Types**.
5. Activez le type d’autorisation **Passkey**, puis sélectionnez **Save Changes**.
#### Management API
Appelez le point de terminaison [Mettre à jour une application](https://auth0.com/docs/api/management/v2/clients/patch-clients-by-id), puis :
* Mettez à jour `grant_types` pour y inclure `urn:okta:params:oauth:grant-type:webauthn`.
* Utilisez l’objet `mobile` pour définir, au besoin, les paramètres des appareils iOS et Android.
## Implémenter les flux de clés d’accès
Vous pouvez définir les flux de clés d’accès suivants pour votre application :
* [Flux d’inscription](#signup-flow) : permet aux nouveaux utilisateurs de générer et d’enregistrer une clé d’accès au cours du processus d’inscription.
* [Flux de connexion](#login-flow) : permet à un utilisateur existant, déjà inscrit aux clés d’accès, de s’authentifier avec sa clé d’accès enregistrée au cours du processus de connexion.
### Flux d’inscription
Un utilisateur lance le flux d’inscription par clé d’accès lorsqu’il tente de se connecter à votre application pour la première fois.
Si l’utilisateur fournit un identifiant qui existe déjà, il est recommandé de l’inviter à terminer le flux de connexion à la place. Sinon, l’opération échouera.
#### Étapes du flux
1. Un utilisateur accède à votre application et choisit de créer un nouveau compte. L’utilisateur fournit un identifiant demandé par votre application, comme son adresse courriel.
2. Votre application amorce ensuite le défi d’inscription en appelant le point de terminaison [Demander un défi d’inscription](/fr-CA/docs/authenticate/database-connections/passkeys/native-passkeys-api#request-signup-challenge) de l’API d’authentification d’Auth0 :
* Si vous ne précisez pas de `realm`, le répertoire par défaut de votre locataire est utilisé.
* Par défaut, `email` est l’identifiant requis. Si vous avez activé les [Identifiants flexibles](/fr-CA/docs/authenticate/database-connections/activate-and-configure-attributes-for-flexible-identifiers) pour votre connexion de base de données, vous pouvez plutôt utiliser une combinaison de `email`, `phone_number` ou `username`. Ces options peuvent être obligatoires ou facultatives et doivent correspondre à votre configuration des identifiants flexibles.
```text lines theme={null}
POST /passkey/register
Content-Type: application/json
{
"client_id": "{YOUR_CLIENT_ID}",
"realm": "{OPTIONAL_CONNECTION}",
"user_profile": {
"email": "{VALID_EMAIL_ADDRESS}",
"name": "{OPTIONAL_USER_DISPLAY_NAME}",
}
}
```
3. En réponse, Auth0 renvoie [`PublicKeyCredentialCreationOptions`](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialcreationoptions) avec un ID `auth_session` et `rpId` sous la forme de `rp.id` :
```text lines expandable theme={null}
HTTP/1.1 200 OK
Content-Type: application/json
{
"authn_params_public_key": {
"challenge": "{GENERATED_CHALLENGE_FOR_THIS_SESSION}",
"timeout": {MILLISECONDS},
"rp": {
"id": "{YOUR_CUSTOM_DOMAIN}",
"name": "{YOUR_CUSTOM_DOMAIN}"
},
"pubKeyCredParams": [
{ type: 'public-key', alg: -8 },
{ type: 'public-key', alg: -7 },
{ type: 'public-key', alg: -257 }
],
"authenticatorSelection": {
"residentKey": "required",
"userVerification": "preferred"
},
"user": {
"id": "{GENERATED_ID}",
"name": "{USER-ENTERED_IDENTIFIER}",
"displayName": "{USER-ENTERED_DISPLAY_NAME_OR_IDENTIFIER_IF_MISSING}"
}
},
"auth_session": "{SESSION_ID}"
}
```
Le `rpId` renvoyé dans la réponse correspond au domaine utilisé dans le flux Web afin que les clés d’accès fonctionnent dans les domaines associés.
4. Votre application termine ensuite le processus d’inscription de l’utilisateur à l’aide des API natives appropriées :
* Consultez la [documentation d’inscription pour Android](https://developer.android.com/identity/passkeys/create-passkeys).
* Consultez la [documentation d’inscription pour iOS](https://developer.apple.com/documentation/authenticationservices/supporting-passkeys#Register-a-new-account-on-a-service).
5. Votre application utilise ensuite les informations d’identification obtenues pendant le processus d’inscription, y compris les détails de `authn_response`, pour appeler le point de terminaison [Token](/fr-CA/docs/authenticate/database-connections/passkeys/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": "{YOUR_CLIENT_ID}",
"realm": "{OPTIONAL_CONNECTION}",
"scope": "{OPTIONAL_REQUESTED_SCOPE}",
"audience": "{OPTIONAL_REQUESTED_AUDIENCE}"
"auth_session": "{SESSION_ID_FROM_THE_FIRST_REQUEST}",
"authn_response": {
"id": "{BASE64URL_ID}",
"rawId": "{BASE64URL_RAWID}",
"type": "public-key",
"authenticatorAttachment": "platform|cross-platform",
"response": {
"clientDataJSON": "{BASE64URL_CLIENT_DATA_JSON}",
"attestationObject": "{BASE64URL_ATTESTATION_OBJECT}",
{OTHER_PROPERTIES}
},
},
}
```
6. Auth0 crée un nouveau compte d’utilisateur et renvoie les jetons demandés pour terminer le flux :
```text lines theme={null}
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "{BASE64_TOKEN}",
"refresh_token": "{BASE64_TOKEN}",
"id_token": "{BASE64_TOKEN}",
"token_type": "Bearer",
"expires_in": {SECONDS}
}
```
### Flux de connexion
Un utilisateur existant amorce le flux de connexion par clé d’accès lorsqu’il tente de se connecter à votre application. Ce flux s’applique uniquement aux utilisateurs existants qui ont enregistré des clés d’accès associées à leur compte 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 de connexion en appelant le point de terminaison [Request Login Challenge](/fr-CA/docs/authenticate/database-connections/passkeys/native-passkeys-api#request-login-challenge) de l’API d’authentification :
Si vous ne précisez pas de `realm`, l’annuaire par défaut de votre locataire est utilisé.
```text lines theme={null}
POST /passkey/challenge
Content-Type: application/json
{
"client_id": "{YOUR_CLIENT_ID}",
"realm": "{OPTIONAL_CONNECTION}"
}
```
2. En réponse, Auth0 renvoie [`PublicKeyCredentialRequestOptions`](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialrequestoptions) ainsi qu’un `auth_session` pour poursuivre le flux dans votre application :
```text lines theme={null}
HTTP/1.1 200 OK
Content-Type: application/json
{
"authn_params_public_key": {
"challenge": "{GENERATED_CHALLENGE_FOR_THIS_SESSION}",
"timeout": {AUTH_TIMEOUT_IN_MILLISECONDS},
"rpId": "{CUSTOM_DOMAIN}",
"userVerification": "preferred"
},
"auth_session": "{SESSION_ID}"
}
```
3. Votre application termine ensuite le processus de connexion à l’aide des API natives appropriées :
* Consultez la [documentation de connexion Android](https://developer.android.com/identity/passkeys/sign-in-with-passkeys)
* 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 données d’authentification obtenues pendant le processus de connexion, y compris les détails `authn_response`, pour appeler le point de terminaison [Token](/fr-CA/docs/authenticate/database-connections/passkeys/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": "{YOUR_CLIENT_ID}",
"realm": "{OPTIONAL_CONNECTION}",
"scope": "{OPTIONAL_REQUESTED_SCOPE}",
"audience": "{OPTIONAL_REQUESTED_AUDIENCE}"
"auth_session": "{SESSION_ID_FROM_THE_FIRST_REQUEST}",
"authn_response": {
"id": "{BASE64URL_ID}",
"rawId": "{BASE64URL_RAWID}",
"type": "public-key",
"authenticatorAttachment": "platform|cross-platform",
"response": {
"authenticatorData": "{BASE64URL_AUTHENTICATORDATA}",
"clientDataJSON": "{BASE64URL_CLIENTDATAJSON}",
"signature": "{BASE64URL_SIGNATURE}",
"userHandle": "{BASE64URL_USERHANDLE}"
},
"clientExtensionResults": {OPTIONAL_OBJECT}
}
}
```
5. Auth0 authentifie les informations d’identification et renvoie les jetons demandés pour terminer le flux :
```text lines theme={null}
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "{BASE64_TOKEN}",
"refresh_token": "{BASE64_TOKEN}",
"id_token": "{BASE64_TOKEN}",
"token_type": "Bearer",
"expires_in": {SECONDS}
}
```
## Références
Les ressources suivantes peuvent servir de référence pour la mise en œuvre de clés d’accès natives dans votre application mobile :
* API d’authentification Auth0
* [Demander un défi d’inscription](/fr-CA/docs/authenticate/database-connections/passkeys/native-passkeys-api#request-signup-challenge)
* [Authentifier un nouvel utilisateur](/fr-CA/docs/authenticate/database-connections/passkeys/native-passkeys-api#authenticate-new-user)
* [Demander un défi de connexion](/fr-CA/docs/authenticate/database-connections/passkeys/native-passkeys-api#request-login-challenge)
* [Authentifier un utilisateur existant](/fr-CA/docs/authenticate/database-connections/passkeys/native-passkeys-api#authenticate-existing-user)
* Ressources Android
* [Documentation d’inscription](https://developer.android.com/identity/passkeys/create-passkeys)
* [Documentation de connexion](https://developer.android.com/identity/passkeys/sign-in-with-passkeys)
* Ressources iOS
* [Documentation d’inscription](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)