Authentification sécurisée des utilisateurs

Pour protéger votre système d'authentification sous Android, envisagez d'abandonner un modèle basé sur un mot de passe, en particulier pour les comptes sensibles tels que les comptes bancaires et de messagerie de vos utilisateurs. N'oubliez pas que certaines applications que vos utilisateurs installent peuvent ne pas avoir les meilleures intentions et essayer de les hameçonner.

De plus, ne partez pas du principe que seuls les utilisateurs autorisés se serviront de l'appareil. Le vol de téléphone est un problème courant, et les pirates informatiques ciblent les appareils déverrouillés pour tirer directement profit des données utilisateur ou des applications financières. Nous recommandons à toutes les applications sensibles d'implémenter un délai d'authentification raisonnable (15 minutes) avec la vérification biométrique et d'exiger une authentification supplémentaire avant les actions sensibles telles que les transferts d'argent.

Boîte de dialogue d'authentification biométrique

La bibliothèque Biometrics propose un ensemble de fonctions permettant d'afficher une requête demandant une authentification biométrique, telle que la reconnaissance faciale ou la reconnaissance d'empreintes digitales. Cependant, les invites biométriques peuvent être configurées pour se rabattre sur LSKF, qui présente des risques connus pour la planche d'épaule. Pour les applications sensibles, nous vous recommandons de ne pas utiliser l'authentification biométrique par code PIN. Après l'épuisement des tentatives biométriques, les utilisateurs peuvent attendre, se reconnecter avec un mot de passe ou réinitialiser les comptes. La réinitialisation du compte doit nécessiter des facteurs qui ne sont pas facilement accessibles sur l'appareil (bonne pratique ci-dessous).

En quoi cela permet-il de limiter la fraude et le vol de téléphone ?

Un cas d'utilisation particulier qui peut être utile pour éviter la fraude consiste à demander une authentification biométrique dans votre application avant une transaction. Lorsque vos utilisateurs souhaitent effectuer une transaction financière, la boîte de dialogue biométrique s'affiche afin de vérifier qu'il s'agit bien de l'utilisateur visé. Cette bonne pratique protège contre un pirate informatique qui vole un appareil, qu'il connaisse ou non la bibliothèque LSKF, car il devra vérifier qu'il est le propriétaire de l'appareil.

Pour renforcer la sécurité, nous recommandons aux développeurs d'applications de demander l'authentification biométrique de classe 3 et d'utiliser CryptoObject pour les transactions bancaires et financières.

Implémentation

  1. Veillez à inclure la bibliothèque androidx.biometric.
  2. Incluez la boîte de dialogue de connexion biométrique dans l'activité ou le fragment qui contient la logique d'authentification de l'utilisateur.

Kotlin


private var executor: Executor? = null
private var biometricPrompt: BiometricPrompt? = null
private var promptInfo: BiometricPrompt.PromptInfo? = null

fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  setContentView(R.layout.activity_login)
  executor = ContextCompat.getMainExecutor(this)
  biometricPrompt = BiometricPrompt(this@MainActivity,
    executor, object : AuthenticationCallback() {
      fun onAuthenticationError(
        errorCode: Int,
        @NonNull errString: CharSequence
      ) {
        super.onAuthenticationError(errorCode, errString)
        Toast.makeText(
          getApplicationContext(),
          "Authentication error: $errString", Toast.LENGTH_SHORT
        )
          .show()
      }

      fun onAuthenticationSucceeded(
        @NonNull result: BiometricPrompt.AuthenticationResult?
      ) {
        super.onAuthenticationSucceeded(result)
        Toast.makeText(
          getApplicationContext(),
          "Authentication succeeded!", Toast.LENGTH_SHORT
        ).show()
      }

      fun onAuthenticationFailed() {
        super.onAuthenticationFailed()
        Toast.makeText(
          getApplicationContext(), "Authentication failed",
          Toast.LENGTH_SHORT
        )
          .show()
      }
    })
  promptInfo = Builder()
    .setTitle("Biometric login for my app")
    .setSubtitle("Log in using your biometric credential")
    .setNegativeButtonText("Use account password")
    .build()

  // Prompt appears when user clicks "Log in".
  // Consider integrating with the keystore to unlock cryptographic operations,
  // if needed by your app.
  val biometricLoginButton: Button = findViewById(R.id.biometric_login)
  biometricLoginButton.setOnClickListener { view ->
    biometricPrompt.authenticate(
      promptInfo
    )
  }
}

Java


private Executor executor;
private BiometricPrompt biometricPrompt;
private BiometricPrompt.PromptInfo promptInfo;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_login);
    executor = ContextCompat.getMainExecutor(this);
    biometricPrompt = new BiometricPrompt(MainActivity.this,
            executor, new BiometricPrompt.AuthenticationCallback() {
        @Override
        public void onAuthenticationError(int errorCode,
                @NonNull CharSequence errString) {
            super.onAuthenticationError(errorCode, errString);
            Toast.makeText(getApplicationContext(),
                "Authentication error: " + errString, Toast.LENGTH_SHORT)
                .show();
        }

        @Override
        public void onAuthenticationSucceeded(
                @NonNull BiometricPrompt.AuthenticationResult result) {
            super.onAuthenticationSucceeded(result);
            Toast.makeText(getApplicationContext(),
                "Authentication succeeded!", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onAuthenticationFailed() {
            super.onAuthenticationFailed();
            Toast.makeText(getApplicationContext(), "Authentication failed",
                Toast.LENGTH_SHORT)
                .show();
        }
    });

    promptInfo = new BiometricPrompt.PromptInfo.Builder()
            .setTitle("Biometric login for my app")
            .setSubtitle("Log in using your biometric credential")
            .setNegativeButtonText("Use account password")
            .build();

    // Prompt appears when the user clicks "Log in".
    // Consider integrating with the keystore to unlock cryptographic operations,
    // if needed by your app.
    Button biometricLoginButton = findViewById(R.id.biometric_login);
    biometricLoginButton.setOnClickListener(view -> {
            biometricPrompt.authenticate(promptInfo);
    });
}

pour réussir votre lancement

Nous vous recommandons de commencer par l'atelier de programmation pour en savoir plus sur la biométrie.

Selon vos cas d'utilisation, vous pouvez implémenter la boîte de dialogue avec ou sans action explicite de l'utilisateur. Afin d'éviter les fraudes, nous vous recommandons d'ajouter la boîte de dialogue biométrique avec une action explicite de l'utilisateur pour chaque transaction. Nous comprenons que l'ajout d'une authentification peut introduire des frictions dans l'expérience utilisateur. Toutefois, en raison de la nature des informations traitées lors d'une transaction bancaire et du fait que l'authentification biométrique est plus fluide que d'autres méthodes d'authentification, nous pensons qu'il est nécessaire d'ajouter ce niveau de navigation.

En savoir plus sur l'authentification biométrique

Clés d'accès

Les clés d'accès offrent une alternative aux mots de passe, à la fois plus sécurisée et plus simple. Les clés d'accès utilisent la cryptographie à clé publique pour permettre aux utilisateurs de se connecter à des applications et à des sites Web à l'aide du mécanisme de verrouillage de l'écran de leur appareil, tel qu'une empreinte digitale ou la reconnaissance des visages. Cela évite à l'utilisateur de devoir mémoriser et gérer des mots de passe, et améliore considérablement la sécurité.

Les clés d'accès peuvent répondre aux exigences d'authentification multifacteur en une seule étape, en remplaçant un mot de passe et des codes OTP pour fournir une protection efficace contre les attaques par hameçonnage et éviter les problèmes liés aux mots de passe à usage unique envoyés par SMS ou par application. Étant donné que les clés d'accès sont standardisées, une seule implémentation permet une expérience sans mot de passe sur tous les appareils, navigateurs et systèmes d'exploitation des utilisateurs.

Sur Android, les clés d'accès sont compatibles avec la bibliothèque Jetpack Gestionnaire d'identifiants, qui unifie les principales méthodes d'authentification, y compris les clés d'accès, les mots de passe et la connexion fédérée (comme Se connecter avec Google).

En quoi cela permet-il de limiter la fraude ?

Les clés d'accès vous protègent contre les attaques par hameçonnage, car elles ne fonctionnent que sur les applications et sites Web que vous avez enregistrés.

Le composant principal d'une clé d'accès est une clé privée cryptographique. En règle générale, cette clé privée se trouve uniquement sur vos appareils, tels que les ordinateurs portables ou les téléphones mobiles, et est synchronisée entre eux par les fournisseurs d'identifiants (également appelés gestionnaires de mots de passe), tels que le Gestionnaire de mots de passe de Google. Seule la clé publique correspondante est enregistrée par le service en ligne lorsqu'une clé d'accès est créée. Lors de la connexion, le service utilise la clé privée pour signer une question d'authentification à partir de la clé publique. Elle ne peut provenir que d'un seul de vos appareils. De plus, pour cela, vous devez déverrouiller votre appareil ou votre magasin d'identifiants, ce qui empêche les connexions non autorisées (par exemple, à partir d'un téléphone volé).

Pour empêcher tout accès non autorisé en cas de vol et de déverrouillage d'appareil, les clés d'accès doivent être associées à un délai d'expiration d'authentification raisonnable. Un pirate qui vole un appareil ne devrait pas pouvoir utiliser une application simplement parce que l'utilisateur précédent était connecté. À la place, les identifiants doivent expirer à intervalles réguliers (par exemple, toutes les 15 minutes), et les utilisateurs doivent être tenus de valider leur identité via une réauthentification du verrouillage de l'écran.

En cas de vol de votre téléphone, les clés d'accès vous protègent, car des voleurs ne peuvent pas voler vos mots de passe pour les utiliser sur d'autres appareils. Les clés d'accès sont spécifiques à chaque appareil. Si vous utilisez le Gestionnaire de mots de passe de Google et que votre téléphone est volé, vous pouvez vous connecter à votre compte Google à partir d'un autre appareil (comme un ordinateur) et vous déconnecter à distance du téléphone volé. Cela rend le Gestionnaire de mots de passe de Google sur le téléphone volé inutilisable, y compris les clés d'accès enregistrées.

Dans le pire des cas, si l'appareil volé n'est pas récupéré, les clés d'accès sont synchronisées avec le nouvel appareil par le fournisseur d'identifiants qui a créé et synchronisé la clé d'accès. Par exemple, l'utilisateur peut avoir choisi le Gestionnaire de mots de passe de Google pour créer la clé d'accès. Il peut y accéder sur un nouvel appareil en se reconnectant à son compte Google et en fournissant le verrouillage de l'écran de l'appareil précédent.

Pour en savoir plus, consultez l'article Sécurité des clés d'accès dans le Gestionnaire de mots de passe de Google.

Implémentation

Les clés d'accès sont compatibles avec les appareils équipés d'Android 9 (niveau d'API 28) ou version ultérieure. Les mots de passe et la fonctionnalité Se connecter avec Google sont compatibles à partir d'Android 4.4. Pour commencer à utiliser les clés d'accès, procédez comme suit:

  1. Suivez l'atelier de programmation sur le Gestionnaire d'identifiants pour découvrir comment implémenter des clés d'accès.
  2. Consultez les consignes de conception de l'expérience utilisateur pour les clés d'accès. Ce document présente les flux recommandés pour votre cas d'utilisation.
  3. Étudiez le Gestionnaire d'identifiants en suivant ce guide.
  4. Planifiez l'implémentation du Gestionnaire d'identifiants et des clés d'accès pour votre application. Prévoyez d'ajouter la prise en charge de Digital Asset Links.

Consultez notre documentation destinée aux développeurs pour savoir comment créer, enregistrer et s'authentifier à l'aide de clés d'accès.

Réinitialisation sécurisée du compte

Un pirate informatique non autorisé ayant accès à un appareil déverrouillé (par exemple, en cas de vol d'un téléphone) tentera d'accéder à des applications sensibles, en particulier des applications bancaires ou de trésorerie. Si l'application met en œuvre la validation biométrique, le pirate informatique tentera de réinitialiser le compte pour y accéder. Il est essentiel que le flux de réinitialisation de compte ne s'appuie pas uniquement sur des informations facilement accessibles sur l'appareil, telles que les liens de réinitialisation OTP envoyés par e-mail ou par SMS.

Voici quelques bonnes pratiques courantes que vous pouvez intégrer au flux de réinitialisation de votre application:

  • Reconnaissance faciale, en plus de l'OTP
  • Questions secrètes
  • Facteur de connaissance (nom de jeune fille de la mère, ville de naissance ou chanson préférée)
  • Validation de l'identité

API SMS Retriever

L'API SMS Retriever vous permet d'effectuer automatiquement la validation des utilisateurs par SMS dans votre application Android. Ainsi, l'utilisateur n'a pas besoin de saisir manuellement les codes de validation. De plus, cette API ne demande pas à l'utilisateur d'autorisations d'application supplémentaires potentiellement dangereuses, telles que RECEIVE_SMS ou READ_SMS. Cependant, les SMS ne doivent pas être utilisés comme seule vérification de l'utilisateur pour se protéger contre tout accès local non autorisé à l'appareil.

En quoi cela permet-il de limiter la fraude ?

Certains utilisateurs utilisent les codes envoyés par SMS comme seul facteur d'authentification, ce qui constitue un point d'entrée facile en cas de fraude.

L'API SMS Retriever permet à l'application de récupérer directement le code SMS sans interaction de l'utilisateur et peut fournir un niveau de protection contre la fraude.

Implémentation

L'implémentation de l'API SMS Retriever s'effectue en deux parties: Android et Server.

Android: (guide)

  1. Obtenez le numéro de téléphone de l'utilisateur.
  2. Démarrez le client SMS Retriever.
  3. Envoyez le numéro de téléphone à votre serveur.
  4. Recevoir des messages de validation.
  5. Envoyez l'OTP à votre serveur.

Server (Serveur) : (guide)

  1. Rédigez un message de validation.
  2. Envoyez le message de validation par SMS.
  3. Vérifiez l'OTP lorsqu'il vous est renvoyé.

pour réussir votre lancement

Une fois l'application intégrée et le numéro de téléphone de l'utilisateur validé avec l'API SMS Retriever, celle-ci tente d'obtenir l'OTP. Si l'opération réussit, cela signifie que le SMS a été reçu automatiquement sur l'appareil. Si l'opération échoue et que l'utilisateur doit saisir manuellement le mot de passe à usage unique, cela peut être un signe d'avertissement indiquant que l'utilisateur est victime d'une fraude.

Le SMS ne doit pas être utilisé comme seul mécanisme de validation de l'utilisateur, car il laisse de la place à des attaques locales, telles qu'un pirate informatique qui dérobe un appareil déverrouillé ou par des attaques par clonage de carte SIM. Il est recommandé d'utiliser la biométrie autant que possible. Sur les appareils où les capteurs biométriques ne sont pas disponibles, l'authentification des utilisateurs doit s'appuyer sur au moins un facteur difficile à obtenir avec l'appareil actuel.

En savoir plus

Pour en savoir plus sur les bonnes pratiques, consultez les ressources suivantes: