Utiliser App Check pour sécuriser le SDK Navigation pour Android

La compatibilité avec App Check pour le SDK Navigation pour Android sera déployée au cours des prochains jours. Si vous ne voyez pas encore cette fonctionnalité dans la console Firebase, réessayez dans quelques jours.

Firebase App Check protège les appels de votre application vers Google Maps Platform en bloquant le trafic provenant de sources autres que vos applications légitimes. Pour ce faire, il demande à un fournisseur d'attestation, tel que Play Integrity, d'évaluer l'authenticité de l'application ou de l'appareil. Lorsque vous intégrez votre application à App Check, vous ajoutez une protection contre les requêtes malveillantes et non autorisées, ce qui protège votre facturation contre les frais non autorisés. App Check améliore également considérablement la création de rapports sur les perturbations en temps réel dans l'écosystème de votre application de flotte, ce qui profite à tous les conducteurs qui l'utilisent. Pour en savoir plus, consultez Création de rapports sur les perturbations.

Important : App Check ne bloque pas le trafic non autorisé par défaut. Vous devez activer manuellement l'application après avoir vérifié les métriques de votre application (voir Étape 6 : Surveiller les requêtes de votre application et décider de l'application).

Pourquoi utiliser App Check ?

App Check protège deux zones distinctes du SDK Navigation pour Android : la fonctionnalité de navigation principale et la création de rapports sur les perturbations.

Navigation

App Check permet de bloquer les requêtes principales du SDK Navigation pour Android provenant de sources malveillantes ou non autorisées. Cela vous est directement bénéfique, car votre projet est protégé contre la fraude à la facturation et l'épuisement des quotas.

Création de rapports sur les perturbations

App Check est fortement recommandé si votre application est compatible avec la création de rapports sur les perturbations et les fonctionnalités de vote en temps réel. L'activation d'App Check permet de s'assurer que vos conducteurs bénéficient des itinéraires les plus précis, en tenant compte de tous les commentaires en temps réel.

Pourquoi App Check est important pour la création de rapports :

• Le niveau de confiance élevé pour les fermetures : les événements ayant un impact sur l'itinéraire, tels que les fermetures de routes, peuvent modifier considérablement le comportement de routage pour tous les conducteurs. Pour protéger la carte contre le vandalisme, le spam ou les rapports inexacts potentiels, l'infrastructure de modération de Google pour les perturbations liées aux fermetures de routes repose sur des signaux d'intégrité de l'appareil et de l'application fiables.
• Comment App Check valide les rapports : les rapports et les votes des utilisateurs envoyés depuis le SDK Navigation pour Android incluent le jeton App Check, qui est utilisé par le backend de Google pour valider la légitimité des commentaires, ce qui augmente son niveau de confiance et permet de l'évaluer pour l'impact sur la carte en direct.
• L'impact de l'omission d'App Check : les rapports envoyés sans jeton App Check valide sont évalués selon un modèle de confiance plus faible et peuvent être traités uniquement comme des signaux silencieux. Cela signifie que même si vos utilisateurs peuvent toujours signaler et voter, leurs rapports sont moins susceptibles d'être visibles sur la carte ou d'affecter les itinéraires des autres conducteurs, et qu'ils nécessiteront une validation supplémentaire.

App Check est-il adapté à mes besoins ?

App Check est recommandé dans la plupart des cas. Toutefois, il n'est pas nécessaire ou n'est pas compatible dans les cas suivants :

• Applications privées ou expérimentales : si votre application n'est pas accessible au public, App Check n'est pas nécessaire.
• Appareils dont la sécurité est compromise : les fournisseurs d'attestation recommandés empêchent le SDK Navigation pour Android de s'exécuter sur des appareils non fiables, tels que les téléphones rootés ou jailbreakés. Pour prendre en charge ces appareils, déployez un fournisseur d'attestation personnalisé.
• Appareils Android non GMS : les appareils Android doivent exécuter les services Google Mobile (GMS) pour Play Integrity. Si vous prévoyez de prendre en charge les appareils Android non GMS, déployez un fournisseur d'attestation personnalisé.

Présentation des étapes d'implémentation

En règle générale, vous devez suivre ces étapes pour intégrer votre application à App Check :

1. Ajoutez Firebase à votre application.
2. Ajoutez la bibliothèque App Check et initialisez App Check.
3. Ajoutez un fournisseur de jetons. Cette étape appelle le fournisseur d'attestation de votre choix pour vérifier l'intégrité de l'appareil ou de l'application.
4. Initialisez les API Navigation et App Check.
5. Activez le débogage. Cela est utile lors du développement ou dans des environnements d'intégration continue (CI).
6. Surveillez les requêtes de votre application avant d'activer l'application. De cette façon, vous appliquez App Check de manière transparente sans perturber vos utilisateurs.

Éléments à prendre en compte lors de la planification d'une intégration App Check

• Quotas des fournisseurs d'attestation : le fournisseur d'attestation que nous recommandons, Play Integrity, est soumis à une limite d'appels quotidienne pour son niveau d'utilisation de l'API standard. Pour en savoir plus sur les limites d'appels, consultez la page Configuration de la documentation pour les développeurs Google Play Integrity.
• Latence au démarrage : dans la plupart des cas, vos utilisateurs ne rencontreront pas de latence lors d'une utilisation normale, car les jetons App Check sont mis en cache sur l'appareil. Le système actualise automatiquement les jetons App Check en arrière-plan avant leur expiration pour maintenir des performances fluides. Toutefois, si aucun jeton App Check valide n'est présent, les utilisateurs de votre application rencontreront une certaine latence au démarrage. Par exemple, cette latence se produit lors des démarrages à froid lorsqu'un jeton mis en cache a expiré ou est manquant.
• TTL des jetons : la valeur TTL (Time To Live) détermine la durée de validité du jeton App Check avant qu'il ne soit nécessaire de l'actualiser. Vous pouvez configurer cette durée entre 30 minutes et 7 jours dans la console Firebase. Une durée d'une heure est recommandée comme base sécurisée, mais le SDK tente automatiquement d'actualiser en arrière-plan environ la moitié de la durée de vie. Pour obtenir des instructions détaillées dans la console, consultez la documentation Firebase App Check.

Intégrer votre application à App Check

Conditions préalables et exigences

• Une application sur laquelle le SDK Navigation pour Android version 7.9 ou ultérieure est installé.
• L'empreinte du certificat SHA-256 de votre application.
• Nom du package de votre application.
• Vous devez être le propriétaire de l'application dans la console Google Cloud.
• L'ID du projet de votre application dans la console Google Cloud.

Étape 1 : Ajouter Firebase à votre application

Suivez les instructions de la documentation pour les développeurs Firebase afin d'ajouter Firebase à votre application. Ajoutez votre google-services.json fichier au répertoire de niveau application de votre projet.

Étape 2 : Ajouter la bibliothèque App Check et initialiser App Check

Ajoutez la dépendance App Check au fichier build.gradle de votre application :

Groovy (build.gradle)

dependencies {
    // Import the Firebase BoM
    implementation platform('com.google.firebase:firebase-bom:34.17.0')
    // Add the dependency for the App Check library with Play Integrity
    implementation 'com.google.firebase:firebase-appcheck-playintegrity'
}

Initialisez App Check dans votre classe Application ou votre activité principale :

Java

import com.google.firebase.FirebaseApp;
import com.google.firebase.appcheck.FirebaseAppCheck;
import com.google.firebase.appcheck.playintegrity.PlayIntegrityAppCheckProviderFactory;

// Initialize Firebase App
FirebaseApp.initializeApp(/* context= */ this);

// Initialize App Check
FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance();
firebaseAppCheck.installAppCheckProviderFactory(
    PlayIntegrityAppCheckProviderFactory.getInstance());

Kotlin

import com.google.firebase.Firebase
import com.google.firebase.appcheck.appCheck
import com.google.firebase.appcheck.playintegrity.PlayIntegrityAppCheckProviderFactory
import com.google.firebase.initialize

// Initialize Firebase App
Firebase.initialize(context = this)

// Initialize App Check
Firebase.appCheck.installAppCheckProviderFactory(
    PlayIntegrityAppCheckProviderFactory.getInstance(),
)

Étape 3 : Ajouter le fournisseur de jetons

Remarque : Si votre application utilise également d'autres SDK Google Maps Platform compatibles avec App Check (tels que le SDK Places), vous pouvez utiliser la même configuration Firebase App Check, mais vous devez implémenter et enregistrer l'interface du fournisseur de jetons spécifique à chaque SDK.

Créez une implémentation de l'interface MapsAppCheckTokenProvider. Ce fournisseur récupère de manière asynchrone les jetons App Check à partir de Firebase App Check et les transmet à la pile réseau du SDK Navigation pour Android à l'aide de MapsAppCheckTokenCallback :

Java

import com.google.android.gms.maps.MapsAppCheckTokenCallback;
import com.google.android.gms.maps.MapsAppCheckTokenProvider;
import com.google.firebase.appcheck.FirebaseAppCheck;

public class NavigationTokenProvider implements MapsAppCheckTokenProvider {
  @Override
  public void fetchToken(MapsAppCheckTokenCallback callback) {
    FirebaseAppCheck.getInstance()
        .getAppCheckToken(false) // forcingRefresh = false
        .addOnSuccessListener(
            tokenResult -> {
              String token = tokenResult.getToken();
              callback.onSuccess(token);
            })
        .addOnFailureListener(
            e -> {
              callback.onFailure();
            });
  }
}

Kotlin

import com.google.android.gms.maps.MapsAppCheckTokenCallback
import com.google.android.gms.maps.MapsAppCheckTokenProvider
import com.google.firebase.appcheck.FirebaseAppCheck

class NavigationTokenProvider : MapsAppCheckTokenProvider {
    override fun fetchToken(callback: MapsAppCheckTokenCallback) {
        FirebaseAppCheck.getInstance()
            .getAppCheckToken(false)
            .addOnSuccessListener { tokenResult ->
                callback.onSuccess(tokenResult.token)
            }
            .addOnFailureListener {
                callback.onFailure()
            }
    }
}

Étape 4 : Initialiser les API Navigation et App Check

Initialisez le SDK Navigation pour Android et enregistrez votre instance de fournisseur de jetons unifiée à l'aide de MapsApiSettings.setAppCheckTokenProvider() :

Java

import com.google.android.gms.maps.MapsApiSettings;

// Register your App Check token provider before initializing Navigation SDK for Android
MapsApiSettings.setAppCheckTokenProvider(context, new NavigationTokenProvider());

Kotlin

import com.google.android.gms.maps.MapsApiSettings

// Register your App Check token provider before initializing Navigation SDK for Android
MapsApiSettings.setAppCheckTokenProvider(context, NavigationTokenProvider())

Étape 5 : Activer le débogage (facultatif)

Une fois App Check appliqué au SDK Navigation pour Android, les fonctionnalités de votre application qui dépendent du SDK Navigation pour Android ne s'exécuteront pas dans un simulateur ni à partir d'un environnement d'intégration continue (CI), car ces environnements ne sont pas considérés comme des appareils valides. Pour exécuter votre application dans ces environnements lors du développement et des tests, vous devez créer une version de débogage de votre application qui utilise le fournisseur de débogage App Check au lieu d'un fournisseur d'attestation de production.

1. Ajoutez la dépendance du fournisseur de débogage au fichier build.gradle de votre application :

   Groovy (build.gradle)

   dependencies {
       implementation 'com.google.firebase:firebase-appcheck-debug'
   }

2. Configurez App Check pour qu'il utilise la fabrique de fournisseurs de débogage dans vos builds de débogage :

   Java

   import com.google.firebase.appcheck.debug.DebugAppCheckProviderFactory;
   import com.google.firebase.appcheck.playintegrity.PlayIntegrityAppCheckProviderFactory;
   
   if (BuildConfig.DEBUG) {
       firebaseAppCheck.installAppCheckProviderFactory(
           DebugAppCheckProviderFactory.getInstance()
       );
   } else {
       firebaseAppCheck.installAppCheckProviderFactory(
           PlayIntegrityAppCheckProviderFactory.getInstance()
       );
   }

   Kotlin

   import com.google.firebase.Firebase
   import com.google.firebase.appcheck.appCheck
   import com.google.firebase.appcheck.debug.DebugAppCheckProviderFactory
   import com.google.firebase.appcheck.playintegrity.PlayIntegrityAppCheckProviderFactory
   
   if (BuildConfig.DEBUG) {
       Firebase.appCheck.installAppCheckProviderFactory(
           DebugAppCheckProviderFactory.getInstance(),
       )
   } else {
       Firebase.appCheck.installAppCheckProviderFactory(
           PlayIntegrityAppCheckProviderFactory.getInstance(),
       )
   }

3. Lancez votre application sur un émulateur ou un appareil de débogage. App Check imprimera un jeton de débogage local dans la sortie logcat.
4. Copiez et enregistrez ce jeton de débogage dans la console Firebase. Pour en savoir plus, consultez la documentation du fournisseur de débogage Firebase App Check.

Étape 6 : Surveiller les requêtes de votre application et décider de l'application

Remarque : L'application n'est pas strictement nécessaire pour que les rapports sur les perturbations en temps réel bénéficient de la vérification de l'intégrité de l'appareil. Toutefois, une protection complète contre la fraude à la facturation, l'usurpation d'identité et l'utilisation abusive des quotas nécessite l'activation de l'application au niveau du projet.

Avant d'activer la mesure d'application, surveillez les requêtes de votre application pour vous assurer que vous ne perturbez pas les utilisateurs légitimes.

1. Accédez à l'écran des métriques App Check dans la console Firebase pour afficher le pourcentage de trafic validé par rapport au trafic non validé.
2. Une fois que vous êtes sûr que la majorité de votre trafic est validée et que les utilisateurs légitimes sont passés à une version de votre application contenant votre implémentation App Check, activez l'application.
3. Une fois l'application activée, App Check refusera tout le trafic sans jeton App Check valide.