Join us for Firebase Summit on November 10, 2021. Tune in to learn how Firebase can help you accelerate app development, release with confidence, and scale with ease. Register

Activer App Check avec un fournisseur personnalisé sur Android

Cette page vous montre comment activer App Check dans une application Android, utilisant votre commande fournisseur App Check . Lorsque vous activez App Check, vous vous assurez que seule votre application peut accéder aux ressources Firebase de votre projet.

Si vous souhaitez utiliser App Check avec le fournisseur par défaut SafetyNet, voir Activer App Check avec SafetyNet sur Android .

Avant que tu commences

1. Ajoutez la bibliothèque App Check à votre application

Dans votre module (app-niveau) de fichier Gradle (généralement app/build.gradle ), déclarer la dépendance pour l'App Check bibliothèque Android:

Java

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

Kotlin+KTX

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

2. Implémenter les interfaces App Check

Tout d' abord, vous devez créer des classes qui mettent en œuvre la AppCheckProvider et AppCheckProviderFactory interfaces.

Votre AppCheckProvider classe doit avoir un getToken() méthode, qui recueille toutes les informations de votre commande App fournisseur de vérification exige comme preuve d'authenticité, et l' envoie pour une application Vérifiez votre jeton service d'acquisition de jetons en échange. Les poignées SDK Check App mise en cache jeton, il faut donc toujours obtenir un nouveau jeton dans votre implémentation de getToken() .

Java

public class YourCustomAppCheckToken extends AppCheckToken {
    private String token;
    private long expiration;

    YourCustomAppCheckToken(String token, long expiration) {
        this.token = token;
        this.expiration = expiration;
    }

    @NonNull
    @Override
    public String getToken() {
        return token;
    }

    @Override
    public long getExpireTimeMillis() {
        return expiration;
    }
}

public class YourCustomAppCheckProvider implements AppCheckProvider {
    @Override
    public Task<AppCheckToken> getToken() {
        // Logic to exchange proof of authenticity for an App Check token and
        //   expiration time.
        // ...

        // Refresh the token early to handle clock skew.
        long expMillis = expirationFromServer * 1000 - 60000;

        // Create AppCheckToken object.
        AppCheckToken appCheckToken =
                YourCustomAppCheckToken(tokenFromServer, expMillis);

        return appCheckToken;
    }
}

Kotlin+KTX

class YourCustomAppCheckToken(
    private val token: String,
    private val expiration: Long
) : AppCheckToken() {
    override fun getToken(): String {
        return token
    }

    override fun getExpireTimeMillis(): Long {
        return expiration
    }
}

class YourCustomAppCheckProvider : AppCheckProvider {
    val token: Task<AppCheckToken>
        get() {
            // Logic to exchange proof of authenticity for an App Check token.
            // ...

            // Refresh the token early to handle clock skew.
            val expMillis: Long = expirationFromServer * 1000 - 60000

            // Create AppCheckToken object.
            val appCheckToken: AppCheckToken =
                    YourCustomAppCheckToken(tokenFromServer, expMillis)

            return appCheckToken!
        }
}

En outre, mettre en œuvre une AppCheckProviderFactory classe qui crée des instances de votre AppCheckProvider mise en œuvre:

Java

public class YourCustomAppCheckProviderFactory implements AppCheckProviderFactory {
  @Override
  public AppCheckProvider create(FirebaseApp firebaseApp) {
    // Create and return an AppCheckProvider object.
    return new YourCustomAppCheckProvider(firebaseApp);
  }
}

Kotlin+KTX

class YourCustomAppCheckProviderFactory : AppCheckProviderFactory {
    fun create(firebaseApp: FirebaseApp): AppCheckProvider {
        // Create and return an AppCheckProvider object.
        return YourCustomAppCheckProvider(firebaseApp)
    }
}

3. Initialiser App Check

Ajoutez le code d'initialisation suivant à votre application pour qu'elle s'exécute avant d'utiliser d'autres SDK Firebase :

Java

FirebaseApp.initializeApp(/*context=*/ this);
FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance();
firebaseAppCheck.installAppCheckProviderFactory(
    YourCustomAppCheckProviderFactory.getInstance());

Kotlin+KTX

FirebaseApp.initializeApp(/*context=*/ this)
val firebaseAppCheck = FirebaseAppCheck.getInstance()
firebaseAppCheck.installAppCheckProviderFactory(
    YourCustomAppCheckProviderFactory.getInstance())

Une fois la bibliothèque App Check installée dans votre application, commencez à distribuer l'application mise à jour à vos utilisateurs.

L'application cliente mise à jour commencera à envoyer des jetons App Check avec chaque demande qu'elle fait à Firebase, mais les produits Firebase n'exigeront pas que les jetons soient valides jusqu'à ce que vous activiez l'application dans la section App Check de la console Firebase. Voir les deux sections suivantes pour plus de détails.

4. Surveiller les métriques de demande

Maintenant que votre application mise à jour est entre les mains des utilisateurs, vous pouvez activer l'application de la vérification des applications pour les produits Firebase que vous utilisez. Avant de le faire, cependant, vous devez vous assurer que cela ne perturbera pas vos utilisateurs légitimes existants.

Base de données en temps réel et stockage cloud

Un outil important que vous pouvez utiliser pour prendre cette décision pour la base de données en temps réel et le stockage dans le cloud est l'écran des métriques de demande App Check.

Pour afficher les paramètres de demande de vérification App pour un produit, ouvrez le Paramètres du projet> App Vérifiez la section de la console Firebase. Par exemple:

Capture d'écran de la page des métriques App Check

Les métriques de demande pour chaque produit sont réparties en quatre catégories :

  • Demandes vérifiées sont celles qui ont une application valide Vérifier jeton. Après avoir activé l'application App Check, seules les demandes de cette catégorie aboutiront.

  • Les demandes des clients sont ceux qui obsolètes manquent un jeton de vérification App. Ces demandes peuvent provenir d'une ancienne version du SDK Firebase avant qu'App Check ne soit inclus dans l'application.

  • Demandes d'origine inconnue sont ceux qui manquent une application Vérifiez jeton et ne regardent pas comme ils viennent du SDK Firebase. Il peut s'agir de demandes effectuées avec des clés API volées ou de demandes falsifiées effectuées sans le SDK Firebase.

  • Demandes non valides sont celles qui ont une application non valide Vérifiez jeton, ce qui pourrait provenir d' un client inauthentique essayant d'usurper l' identité de votre application, ou des environnements émulés.

La distribution de ces catégories pour votre application doit vous informer lorsque vous décidez d'activer l'application. Voici quelques lignes directrices :

  • Si presque toutes les demandes récentes proviennent de clients vérifiés, envisagez d'activer l'application pour commencer à protéger vos ressources principales.

  • Si une partie importante des demandes récentes proviennent de clients probablement obsolètes, pour éviter de perturber les utilisateurs, envisagez d'attendre que davantage d'utilisateurs mettent à jour votre application avant d'activer l'application. L'application d'App Check sur une application publiée annulera les versions d'application précédentes qui ne sont pas intégrées au SDK App Check.

  • Si votre application n'a pas encore été lancée, vous devez activer l'application App Check immédiatement, car aucun client obsolète n'est utilisé.

Fonctions Cloud

Pour Cloud Functions, vous pouvez obtenir des métriques App Check en examinant les journaux de vos fonctions. Chaque invocation d'une fonction appelable émet une entrée de journal structurée comme dans l'exemple suivant :

{
  "severity": "INFO",    // INFO, WARNING, or ERROR
  "logging.googleapis.com/labels": {"firebase-log-type": "callable-request-verification"},
  "jsonPayload": {
    "message": "Callable header verifications passed.",
    "verifications": {
      // ...
      "app": "MISSING",  // VALID, INVALID, or MISSING
    }
  }
}

Vous pouvez analyser ces paramètres dans la console Google Cloud en créant un logs-basé compteur métrique avec le filtre métrique suivante:

resource.type="cloud_function"
resource.labels.function_name="YOUR_CLOUD_FUNCTION"
resource.labels.region="us-central1"
labels.firebase-log-type="callable-request-verification"

Étiquette de jsonPayload.verifications.appCheck la métrique en utilisant le champ jsonPayload.verifications.appCheck .

5. Activer l'application

Pour activer l'application, suivez les instructions pour chaque produit ci-dessous. Une fois que vous avez activé l'application pour un produit, toutes les demandes non vérifiées concernant ce produit seront rejetées.

Base de données en temps réel et stockage cloud

Pour activer l'application de la base de données en temps réel et de Cloud Storage :

  1. Ouvrez le Paramètres du projet> App Vérifiez la section de la console Firebase.

  2. Développez la vue des métriques du produit pour lequel vous souhaitez activer l'application.

  3. Cliquez sur Appliquer et confirmez votre choix.

Notez que cela peut prendre jusqu'à 10 minutes après l'activation de l'application pour qu'elle prenne effet.

Fonctions Cloud

Voir Activer App Vérifier l' application des fonctions de Cloud .