Authentification sur les accessoires connectés: Gestionnaire d'identifiants

Les applications Wear OS peuvent s'exécuter de manière autonome sans application associée. Cela signifie qu'une application Wear OS doit gérer elle-même l'authentification lorsqu'elle accède aux données depuis Internet. Le petit écran et les fonctionnalités de saisie réduites des montres connectées limitent les options d'authentification qu'une application Wear OS peut utiliser.

Ce guide fournit des instructions pour la méthode d'authentification recommandée pour les applications Wear OS, Credential Manager.

Pour en savoir plus sur la manière de concevoir une bonne expérience de connexion, consultez le guide de connexion de l'expérience utilisateur.

Considérations préliminaires

Avant de commencer l'implémentation, tenez compte des points suivants.

Mode Invité

N'exigez pas l'authentification pour toutes les fonctionnalités. Fournissez plutôt autant de fonctionnalités que possible à l'utilisateur, sans qu'il ait à se connecter.

Les utilisateurs peuvent découvrir et installer votre application Wear sans avoir utilisé l'application mobile. Ils peuvent donc ne pas avoir de compte et ne pas savoir quelles fonctionnalités sont disponibles. Assurez-vous que le mode Invité permette à l'utilisateur de découvrir avec précision les fonctionnalités de votre application.

Certains appareils peuvent rester déverrouillés plus longtemps

Sur les appareils compatibles équipés de Wear OS 5 ou version ultérieure, le système détecte si l'utilisateur porte l'appareil au poignet. Si l'utilisateur désactive la détection du poignet, puis retire l'appareil de son poignet, le système maintient l'appareil déverrouillé plus longtemps que d'habitude.

Si votre application nécessite un niveau de sécurité plus élevé (par exemple, lors de l'affichage de données potentiellement sensibles ou privées), vérifiez d'abord si la détection du poignet est activée :

fun isWristDetectionAutoLockingEnabled(context: Context): Boolean {
    // Use the keyguard manager to check for the presence of a lock mechanism
    val keyguardManager = context.getSystemService<KeyguardManager>()
    val isSecured = keyguardManager?.isDeviceSecure == true

    // Use OEM-specific system settings to verify that on-body autolock is enabled.
    val isWristDetectionOn = android.provider.Settings.Global.getInt(
        context.contentResolver, PIXEL_WRIST_AUTOLOCK_SETTING_STATE,
        0
    ) == 1

    return isSecured && isWristDetectionOn
}

Si la valeur renvoyée par cette méthode est false, invitez l'utilisateur à se connecter à un compte dans votre application avant d'afficher du contenu spécifique à l'utilisateur.

Gestionnaire d'identifiants

Credential Manager est l'API recommandée pour l'authentification sur Wear OS. Il offre un environnement plus sécurisé permettant aux utilisateurs de se connecter aux applications Wear OS de manière autonome, sans avoir besoin d'un téléphone associé connecté ni de mémoriser leur mot de passe.

Ce document présente les informations dont les développeurs ont besoin pour implémenter une solution Credential Manager avec les mécanismes d'authentification standards qu'elle héberge, à savoir :

  • Clés d'accès
  • Mots de passe
  • Identités fédérées (comme Se connecter avec Google)

Ce guide explique également comment migrer les autres méthodes d'authentification Wear OS acceptables (partage de jetons de couche de données et OAuth) en tant que sauvegardes pour Credential Manager, et fournit des instructions spéciales pour gérer la transition du bouton Se connecter avec Google autonome, désormais obsolète, vers la version intégrée de Credential Manager.

Limites et différences de Wear OS

Les développeurs doivent tenir compte des limites et différences suivantes sur Wear OS :

  • Le Credential Manager est disponible sur Wear OS 3 et versions ultérieures.
  • Impossible de créer des identifiants sur Wear OS
  • Ni la restauration des identifiants, ni les flux de connexion hybrides ne sont acceptés.
  • Seuls les fournisseurs d'identifiants avec intégration Wear OS peuvent être réutilisés depuis un mobile.

Clés d'accès sur Wear OS

Nous encourageons vivement les développeurs à implémenter des clés d'accès dans leurs implémentations de Credential Manager pour Wear OS. Les clés d'accès sont la nouvelle norme du secteur pour l'authentification des utilisateurs finaux. Elles offrent plusieurs avantages importants aux utilisateurs.

Les clés d'accès sont plus simples

  • Les utilisateurs peuvent sélectionner un compte avec lequel se connecter. Ils n'ont pas besoin de saisir de nom d'utilisateur.
  • Les utilisateurs peuvent s'authentifier à l'aide du verrouillage de l'écran de l'appareil.
  • Une fois qu'une clé d'accès est créée et enregistrée, l'utilisateur peut passer facilement à un nouvel appareil et l'utiliser immédiatement sans avoir à se réenregistrer.

Les clés d'accès sont plus sûres

  • Les développeurs n'enregistrent qu'une clé publique sur le serveur au lieu d'enregistrer un mot de passe. Cela signifie qu'un pirate informatique a beaucoup moins d'intérêt à pirater les serveurs et qu'il y a beaucoup moins de nettoyage à faire en cas de faille.
  • Les clés d'accès offrent une protection contre l'hameçonnage. Les clés d'accès ne fonctionnent que pour les applications et les sites Web enregistrés. Un utilisateur ne peut pas être amené à s'authentifier sur un site trompeur, car la validation est gérée par le navigateur ou l'OS.
  • Les clés d'accès réduisent la nécessité d'envoyer des SMS, ce qui rend l'authentification plus rentable.

Implémenter des clés d'accès

Inclut la configuration et des conseils pour tous les types d'implémentation.

Configuration

  1. Définissez le niveau d'API cible sur 35 dans le fichier build.gradle du module de votre application :

    android {
        defaultConfig {
            targetSdk(35)
        }
    }
    
  2. Ajoutez les lignes suivantes au fichier build.gradle de votre application ou module, en utilisant la dernière version stable de la documentation de référence sur les versions de androidx.credentials.

    androidx.credentials:credentials:1.6.0
    androidx.credentials:credentials-play-services-auth:1.6.0
    

Méthodes d'authentification intégrées

Comme Credential Manager est une API unifiée, les étapes d'implémentation pour Wear OS sont les mêmes que pour tout autre type d'appareil.

Utilisez les instructions pour mobile pour commencer et implémenter la compatibilité avec les clés d'accès et les mots de passe.

La procédure à suivre pour ajouter la compatibilité avec Se connecter avec Google à Credential Manager est axée sur le développement mobile, mais elle est identique sur Wear OS.

Notez que, comme les identifiants ne peuvent pas être créés sur Wear OS, vous n'avez pas besoin d'implémenter les méthodes de création d'identifiants mentionnées dans les instructions pour mobile.

Méthodes d'authentification de secours

Il existe deux autres méthodes d'authentification acceptables pour les applications Wear OS : OAuth 2.0 (l'une ou l'autre variante) et le partage de jetons d'authentification mobile via la couche de données. Bien que ces méthodes ne disposent pas de points d'intégration dans l'API Credential Manager, elles peuvent être incluses dans votre flux d'expérience utilisateur de Credential Manager en tant que solutions de secours si les utilisateurs ignorent l'écran Credential Manager.

Pour gérer l'action de l'utilisateur consistant à fermer l'écran du Credential Manager, interceptez une exception GetCredentialCancellationException dans votre logique GetCredential et accédez à votre propre UI d'authentification personnalisée.

try {
    val getCredentialResponse: GetCredentialResponse =
        credentialManager.getCredential(activity, createGetCredentialRequest())
    return authenticate(getCredentialResponse.credential)
} catch (_: GetCredentialCancellationException) {
    navigateToSecondaryAuthentication()
}

Votre UI d'authentification personnalisée peut ensuite fournir l'une des autres méthodes d'authentification acceptables décrites dans le guide de l'expérience utilisateur pour la connexion.

Partage de jetons de couche de données

L'application mobile associée peut transférer de manière sécurisée les données d'authentification vers l'application Wear OS à l'aide de l'API Wearable Data Layer. Transférez les identifiants sous forme de messages ou d'éléments de données.

Ce type d'authentification ne nécessite généralement aucune action de la part de l'utilisateur. Toutefois, évitez d'effectuer l'authentification sans informer l'utilisateur qu'il est en train de se connecter. Vous pouvez informer l'utilisateur que son compte est en cours de transfert depuis l'application mobile en lui affichant un écran qu'il pourra fermer ensuite.

Important : Votre application Wear OS doit proposer au moins une autre méthode d'authentification, car cette option ne fonctionne que sur les montres associées à un appareil Android sur lequel l'application mobile correspondante est installée. Fournissez une autre méthode d'authentification pour les utilisateurs qui ne disposent pas de l'application mobile correspondante ou pour les utilisateurs dont l'appareil Wear OS est associé à un appareil iOS.

Transmettez des jetons à l'aide de la couche de données de l'application mobile, comme illustré dans l'exemple suivant :

val token = "..." // Auth token to transmit to the Wear OS device.
val putDataReq: PutDataRequest = PutDataMapRequest.create("/auth").run {
    dataMap.putString("token", token)
    asPutDataRequest()
}
val putDataTask: Task<DataItem> = Wearable.getDataClient(this).putDataItem(putDataReq)

Écoutez les événements de changement des données sur l'application Wear OS, comme illustré dans l'exemple suivant :

class AuthDataListenerService : WearableListenerService() {
    override fun onDataChanged(dataEvents: DataEventBuffer) {
        dataEvents.forEach { event ->
            if (event.type == DataEvent.TYPE_CHANGED) {
                val dataItemPath = event.dataItem.uri.path ?: ""

                if (dataItemPath.startsWith("/auth")) {
                    val token = DataMapItem.fromDataItem(event.dataItem)
                        .dataMap
                        .getString("token")
                    // Display an interstitial screen to notify the user that they're being signed
                    // in. Then, store the token and use it in network requests.
                    handleSignInSequence(token)
                }
            }
        }
    }

    /** placeholder sign in handler. */
    fun handleSignInSequence(token: String?) {}
}

Pour en savoir plus sur l'utilisation de Wearable Data Layer, consultez la page Envoyer et synchroniser des données sur Wear OS.

Utiliser OAuth 2.0

Wear OS est compatible avec deux flux OAuth 2.0, décrits dans les sections ci-dessous :

  • Octroi du code d'autorisation avec clé de vérification pour l'échange de code (PKCE), comme défini dans le document RFC 7636
  • Autorisation via un appareil (DAG), tel que défini dans le document RFC 8628
Clé de vérification pour l'échange de code (PKCE)

Pour utiliser efficacement la PKCE, utilisez RemoteAuthClient. Ensuite, pour envoyer une requête d'authentification à un fournisseur OAuth à partir de votre application Wear OS, créez un objet OAuthRequest. Cet objet se compose d'une URL vers votre point de terminaison OAuth permettant d'obtenir un jeton et un objet CodeChallenge.

Le code suivant montre un exemple de création d'une requête d'authentification :

val oauthRequest = OAuthRequest.Builder(context)
    .setAuthProviderUrl(uri)
    .setCodeChallenge(codeChallenge)
    .setClientId(CLIENT_ID)
    .build()

Après avoir créé la requête d'authentification, envoyez-la à l'application associée à l'aide de la méthode sendAuthorizationRequest() :

RemoteAuthClient.create(context).sendAuthorizationRequest(
    request = oauthRequest,
    executor = { command -> command?.run() },
    clientCallback = object : RemoteAuthClient.Callback() {
        override fun onAuthorizationResponse(
            request: OAuthRequest,
            response: OAuthResponse
        ) {
            // Extract the token from the response, store it, and use it in requests.
            continuation.resume(parseCodeFromResponse(response))
        }
        override fun onAuthorizationError(request: OAuthRequest, errorCode: Int) {
            // Handle Errors
            continuation.resume(Result.failure(IOException("Authorization failed")))
        }
    }
)

Cette requête déclenche un appel à l'application associée, qui présente ensuite une interface d'autorisation dans le navigateur Web du téléphone mobile de l'utilisateur. Le fournisseur OAuth 2.0 authentifie l'utilisateur et obtient son consentement pour les autorisations demandées. La réponse est envoyée à l'URL de redirection, automatiquement générée.

Après l'échec ou la réussite de l'autorisation, le serveur OAuth 2.0 renvoie vers l'URL spécifiée dans la requête. Si l'utilisateur approuve la demande d'accès, la réponse contient un code d'autorisation. Si l'utilisateur n'approuve pas la requête, la réponse contient un message d'erreur.

La réponse se présente sous la forme d'une chaîne de requête et ressemble à l'un des exemples suivants :

  https://wear.googleapis.com/3p_auth/com.your.package.name?code=xyz
  https://wear.googleapis-cn.com/3p_auth/com.your.package.name?code=xyz

Une page qui redirige l'utilisateur vers l'application associée se charge. Celle-ci vérifie l'URL de la réponse et transmet la réponse à votre application Wear OS à l'aide de l'API onAuthorizationResponse.

L'application de la montre peut alors échanger le code d'autorisation contre un jeton d'accès.

Autorisation via un appareil

Avec l'autorisation via un appareil, l'utilisateur ouvre l'URI de vérification sur un autre appareil. Le serveur d'autorisation lui demande ensuite d'approuver ou de refuser la demande.

Pour faciliter ce processus, utilisez un RemoteActivityHelper pour ouvrir une page Web sur l'appareil mobile associé de l'utilisateur, comme illustré dans l'exemple suivant :

// Request access from the authorization server and receive Device Authorization Response.
private fun verifyDeviceAuthGrant(verificationUri: String) {
    RemoteActivityHelper(context).startRemoteActivity(
        Intent(Intent.ACTION_VIEW).apply {
            addCategory(Intent.CATEGORY_BROWSABLE)
            data = Uri.parse(verificationUri)
        },
        null
    )
}

Si vous disposez d'une application iOS, utilisez des liens universels pour intercepter cet intent dans votre application au lieu de compter sur le navigateur pour autoriser le jeton.