API SafetyNet Verify Apps

L'API SafetyNet Verify Apps, une bibliothèque fournie par les services Google Play, permet à votre application d'interagir de façon programmatique avec la fonctionnalité Vérifier les applications sur un appareil, afin de protéger ce dernier contre les applications potentiellement dangereuses.

Si votre application traite des données utilisateur sensibles, telles que des informations financières, il est important de vérifier que l'appareil de l'utilisateur est protégé contre les applications malveillantes et qu'il n'existe aucune application qui pourrait se faire passer pour votre application ou effectuer d'autres actions malveillantes. Si la sécurité de l'appareil n'atteint pas le niveau de sécurité minimal, vous pouvez désactiver la fonctionnalité dans votre propre application afin de réduire les risques pour l'utilisateur.

Dans le cadre de son engagement continu visant à rendre l'écosystème Android aussi sûr que possible, Google surveille et profile le comportement des applications Android. Si la fonctionnalité Vérifier les applications détecte une application potentiellement dangereuse, tous les utilisateurs qui l'ont installée en sont informés et sont encouragés à la désinstaller rapidement. Ce processus assure la sécurité et la confidentialité de ces utilisateurs.

L'API SafetyNet Verify Apps vous permet d'exploiter cette fonctionnalité pour protéger les données de votre application. Avec cette API, vous pouvez déterminer si l'appareil d'un utilisateur est protégé par la fonctionnalité Vérifier les applications, encourager les utilisateurs qui n'utilisent pas encore cette fonctionnalité à activer sa protection et identifier toute application potentiellement dangereuse connue qui est installée sur l'appareil.

Conditions d'utilisation supplémentaires

En accédant aux API SafetyNet ou en les utilisant, vous acceptez les conditions d'utilisation des API Google et les conditions d'utilisation de l'API Verify Apps suivantes. Veuillez lire attentivement l'ensemble des conditions d'utilisation et des règles applicables avant d'accéder aux API.

Conditions d'utilisation de l'API Verify Apps

Les analyses qui identifient les applications potentiellement dangereuses peuvent générer à la fois des faux positifs et des faux négatifs. Les résultats renvoyés par cette suite d'API (ou l'absence de tels résultats) s'entendent au meilleur de notre compréhension. Vous reconnaissez et comprenez que l'exactitude des résultats renvoyés par cette suite d'API SafetyNet n'est pas garantie à tout moment.

Ajouter la dépendance de l'API SafetyNet

Avant d'utiliser l'API Verify Apps, ajoutez-la à votre projet. Si vous utilisez Android Studio, ajoutez cette dépendance à votre fichier Gradle au niveau de l'application. Pour en savoir plus, consultez Configuration de l'API SafetyNet.

Activer la vérification des applications

L'API SafetyNet Verify Apps propose deux méthodes d'activation de la fonctionnalité Vérifier les applications. Vous pouvez déterminer si la vérification des applications est activée à l'aide d'isVerifyAppsEnabled(), et vous pouvez demander l'activation de la vérification des applications à l'aide d'enableVerifyApps().

La différence entre ces deux méthodes est que même si isVerifyAppsEnabled() indique l'état actuel de la fonctionnalité Vérifier les applications, enableVerifyApps() demande explicitement à l'utilisateur l'autorisation d'utiliser cette fonctionnalité. Si vous souhaitez que votre application connaisse uniquement l'état de la fonctionnalité pour prendre une décision basée sur la sécurité, elle doit appeler isVerifyAppsEnabled(). Toutefois, pour vous assurer que votre application peut répertorier les applications installées potentiellement dangereuses, appelez plutôt enableVerifyApps().

Déterminer si la vérification des applications est activée

La méthode isVerifyAppsEnabled() asynchrone permet à votre application de déterminer si l'utilisateur a activé la fonctionnalité Vérifier les applications. Cette méthode renvoie un objet VerifyAppsUserResponse, qui contient des informations sur toutes les actions effectuées par l'utilisateur en lien avec la fonctionnalité Vérifier les applications, y compris son activation.

L'extrait de code suivant montre comment créer le rappel associé à cette méthode :

Kotlin

SafetyNet.getClient(this)
        .isVerifyAppsEnabled
        .addOnCompleteListener { task ->
            if (task.isSuccessful) {
                if (task.result.isVerifyAppsEnabled) {
                    Log.d("MY_APP_TAG", "The Verify Apps feature is enabled.")
                } else {
                    Log.d("MY_APP_TAG", "The Verify Apps feature is disabled.")
                }
            } else {
                Log.e("MY_APP_TAG", "A general error occurred.")
            }
        }

Java

SafetyNet.getClient(this)
    .isVerifyAppsEnabled()
    .addOnCompleteListener(new OnCompleteListener<VerifyAppsUserResponse>() {
        @Override
        public void onComplete(Task<VerifyAppsUserResponse> task) {
            if (task.isSuccessful()) {
                VerifyAppsUserResponse result = task.getResult();
                if (result.isVerifyAppsEnabled()) {
                    Log.d("MY_APP_TAG", "The Verify Apps feature is enabled.");
                } else {
                    Log.d("MY_APP_TAG", "The Verify Apps feature is disabled.");
                }
            } else {
                Log.e("MY_APP_TAG", "A general error occurred.");
            }
        }
    });

Demander l'activation de la vérification des applications

La méthode enableVerifyApps() asynchrone permet à votre application d'appeler une boîte de dialogue demandant à l'utilisateur d'activer la fonctionnalité Vérifier les applications. Cette méthode renvoie un objet VerifyAppsUserResponse, qui contient des informations sur toutes les actions effectuées par l'utilisateur en lien avec la fonctionnalité Vérifier les applications, y compris s'il a autorisé son activation.

L'extrait de code suivant montre comment créer le rappel associé à cette méthode :

Kotlin

SafetyNet.getClient(this)
        .enableVerifyApps()
        .addOnCompleteListener { task ->
            if (task.isSuccessful) {
                if (task.result.isVerifyAppsEnabled) {
                    Log.d("MY_APP_TAG", "The user gave consent to enable the Verify Apps feature.")
                } else {
                    Log.d(
                            "MY_APP_TAG",
                            "The user didn't give consent to enable the Verify Apps feature."
                    )
                }
            } else {
                Log.e("MY_APP_TAG", "A general error occurred.")
            }
        }

Java

SafetyNet.getClient(this)
    .enableVerifyApps()
    .addOnCompleteListener(new OnCompleteListener<VerifyAppsUserResponse>() {
        @Override
        public void onComplete(Task<VerifyAppsUserResponse> task) {
            if (task.isSuccessful()) {
                VerifyAppsUserResponse result = task.getResult();
                if (result.isVerifyAppsEnabled()) {
                    Log.d("MY_APP_TAG", "The user gave consent " +
                          "to enable the Verify Apps feature.");
                } else {
                    Log.d("MY_APP_TAG", "The user didn't give consent " +
                          "to enable the Verify Apps feature.");
                }
            } else {
                Log.e("MY_APP_TAG", "A general error occurred.");
            }
        }
    });

Lorsque vous utilisez cette méthode, votre application peut rencontrer une ou plusieurs conditions inhabituelles :

Si la fonctionnalité Vérifier les applications est déjà activée, la boîte de dialogue ne s'affiche pas et l'API se comporte comme si l'utilisateur avait autorisé l'activation de cette fonctionnalité.
Si l'utilisateur quitte la boîte de dialogue, celle-ci est détruite, et l'API suppose que l'utilisateur n'a pas autorisé l'activation de cette fonctionnalité.
Si votre application et une autre application appellent simultanément cette méthode, une seule boîte de dialogue s'affiche, et toutes les applications reçoivent des valeurs renvoyées identiques de la méthode.

Répertorier les applications installées potentiellement dangereuses

La méthode listHarmfulApps() asynchrone vous permet d'obtenir la liste de toutes les applications potentiellement dangereuses connues que l'utilisateur a installées sur son appareil. Cette liste inclut des catégories pour les applications potentiellement dangereuses identifiées afin que votre application puisse prendre les mesures appropriées.

L'extrait de code suivant montre comment créer le rappel associé à cette méthode :

Kotlin

SafetyNet.getClient(this)
        .listHarmfulApps()
        .addOnCompleteListener { task ->
            Log.d(TAG, "Received listHarmfulApps() result")

            if (task.isSuccessful) {
                val result = task.result
                val scanTimeMs = result.lastScanTimeMs

                val appList = result.harmfulAppsList
                if (appList?.isNotEmpty() == true) {
                    Log.e("MY_APP_TAG", "Potentially harmful apps are installed!")

                    for (harmfulApp in appList) {
                        Log.e("MY_APP_TAG", "Information about a harmful app:")
                        Log.e("MY_APP_TAG", "  APK: ${harmfulApp.apkPackageName}")
                        Log.e("MY_APP_TAG", "  SHA-256: ${harmfulApp.apkSha256}")

                        // Categories are defined in VerifyAppsConstants.
                        Log.e("MY_APP_TAG", "  Category: ${harmfulApp.apkCategory}")
                    }
                } else {
                    Log.d("MY_APP_TAG", "There are no known potentially harmful apps installed.")
                }
            } else {
                Log.d(
                        "MY_APP_TAG",
                        "An error occurred. Call isVerifyAppsEnabled() to ensure that the user "
                                + "has consented."
                )
            }
        }

Java

SafetyNet.getClient(this)
    .listHarmfulApps()
    .addOnCompleteListener(new OnCompleteListener<HarmfulAppsResponse>() {
        @Override
        public void onComplete(Task<HarmfulAppsResponse> task) {
            Log.d(TAG, "Received listHarmfulApps() result");

            if (task.isSuccessful()) {
                HarmfulAppsResponse result = task.getResult();
                long scanTimeMs = result.getLastScanTimeMs();

                List<HarmfulAppsData> appList = result.getHarmfulAppsList();
                if (appList.isEmpty()) {
                    Log.d("MY_APP_TAG", "There are no known " +
                          "potentially harmful apps installed.");
                } else {
                    Log.e("MY_APP_TAG",
                          "Potentially harmful apps are installed!");

                    for (HarmfulAppsData harmfulApp : appList) {
                        Log.e("MY_APP_TAG", "Information about a harmful app:");
                        Log.e("MY_APP_TAG",
                              "  APK: " + harmfulApp.apkPackageName);
                        Log.e("MY_APP_TAG",
                              "  SHA-256: " + harmfulApp.apkSha256);

                        // Categories are defined in VerifyAppsConstants.
                        Log.e("MY_APP_TAG",
                              "  Category: " + harmfulApp.apkCategory);
                    }
                }
            } else {
                Log.d("MY_APP_TAG", "An error occurred. " +
                      "Call isVerifyAppsEnabled() to ensure " +
                      "that the user has consented.");
            }
        }
    });