Commencez à utiliser App Check avec un fournisseur personnalisé sur les plates-formes Apple

Cette page vous montre comment activer l'application à cocher dans une application Apple, en utilisant votre fournisseur de vérification d'application personnalisé . Lorsque vous activez la vérification de l'application, vous contribuez à vous assurer que seule votre application peut accéder aux ressources de Firebase de votre projet.

Si vous souhaitez utiliser l'application Vérifiez avec les fournisseurs intégrés, consultez les documents pour vérifier l'application avec App ATTEST et Vérifier l'application avec DeviceCheck .

Avant que tu commences

1. Ajoutez la bibliothèque de vérification de l'application à votre application

  1. Ajoutez la dépendance de la vérification des applications au Podfile de votre projet:

    pod 'FirebaseAppCheck'

    Ou, alternativement, vous pouvez utiliser Swift Package Manager à la place.

    Assurez-vous également que vous utilisez la dernière version de toutes les bibliothèques clients de service Firebase sur lesquelles vous dépendez.

  2. Exécutez pod install et ouvrez le fichier .xcworkspace créé.

2. Implémentez les protocoles de vérification des applications

Tout d'abord, vous devez créer des classes qui implémentent les protocoles AppCheckProvider et AppCheckProviderFactory .

Votre classe AppCheckProvider doit avoir une méthode getToken(completion:) qui recueille les informations dont votre fournisseur de vérification d'application personnalisé a besoin comme preuve d'authenticité, et l'envoie à votre service d'acquisition de jeton en échange d'un jeton de vérification d'application. L'application vérifie le SDK gère la mise en cache des jetons, alors obtenez toujours un nouveau jeton dans votre implémentation de getToken(completion:) .

Rapide

class YourCustomAppCheckProvider: NSObject, AppCheckProvider {
  var app: FirebaseApp

  init(withFirebaseApp app: FirebaseApp) {
    self.app = app
    super.init()
  }

  func getToken() async throws -> AppCheckToken {
    let getTokenTask = Task { () -> AppCheckToken in
      // ...

      // Create AppCheckToken object.
      let exp = Date(timeIntervalSince1970: expirationFromServer)
      let token = AppCheckToken(
        token: tokenFromServer,
        expirationDate: exp
      )

      if Date() > exp {
        throw NSError(domain: "ExampleError", code: 1, userInfo: nil)
      }

      return token
    }

    return try await getTokenTask.value
  }

}

Objectif c

@interface YourCustomAppCheckProvider : NSObject <FIRAppCheckProvider>

@property FIRApp *app;

- (id)initWithApp:(FIRApp *)app;

@end

@implementation YourCustomAppCheckProvider

- (id)initWithApp:app {
    self = [super init];
    if (self) {
        self.app = app;
    }
    return self;
}

- (void)getTokenWithCompletion:(nonnull void (^)(FIRAppCheckToken * _Nullable,
                                                 NSError * _Nullable))handler {
    dispatch_async(dispatch_get_main_queue(), ^{
        // Logic to exchange proof of authenticity for an App Check token.
        // ...

        // Create FIRAppCheckToken object.
        NSTimeInterval exp = expirationFromServer;
        FIRAppCheckToken *token
            = [[FIRAppCheckToken alloc] initWithToken:tokenFromServer
                                       expirationDate:[NSDate dateWithTimeIntervalSince1970:exp]];

        // Pass the token or error to the completion handler.
        handler(token, nil);
    });
}

@end

Implémentez également une classe AppCheckProviderFactory qui crée des instances de votre implémentation AppCheckProvider :

Rapide

class YourCustomAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
  func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
    return YourCustomAppCheckProvider(withFirebaseApp: app)
  }
}

Objectif c

@interface YourCustomAppCheckProviderFactory : NSObject <FIRAppCheckProviderFactory>
@end

@implementation YourCustomAppCheckProviderFactory

- (nullable id<FIRAppCheckProvider>)createProviderWithApp:(FIRApp *)app {
    return [[YourCustomAppCheckProvider alloc] initWithApp:app];
}

@end

3. Initialiser la vérification de l'application

Ajoutez le code d'initialisation suivant à votre délégué d'application ou à l'initialisateur de l'application:

Rapide

let providerFactory = YourAppCheckProviderFactory()
AppCheck.setAppCheckProviderFactory(providerFactory)

FirebaseApp.configure()

Objectif c

YourAppCheckProviderFactory *providerFactory =
        [[YourAppCheckProviderFactory alloc] init];
[FIRAppCheck setAppCheckProviderFactory:providerFactory];

[FIRApp configure];

Prochaines étapes

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

L'application client mise à jour commencera à envoyer des jetons de vérification de l'application avec chaque demande qu'il fait à Firebase, mais les produits Firebase ne nécessiteront pas que les jetons soient valides jusqu'à ce que vous activez l'application dans la section Vérification de l'application de la console Firebase.

Surveiller les mesures et activer l'application

Avant d'activer l'application, cependant, vous devez vous assurer que cela ne perturbera pas vos utilisateurs légitimes existants. D'un autre côté, si vous voyez une utilisation suspecte des ressources de votre application, vous voudrez peut-être permettre l'application plus tôt.

Pour aider à prendre cette décision, vous pouvez consulter les mesures de vérification des applications pour les services que vous utilisez:

Activer l'application de vérification des applications

Lorsque vous comprenez comment l'application Vérification affectera vos utilisateurs et que vous êtes prêt à continuer, vous pouvez activer l'application de vérification de l'application:

Utiliser la vérification des applications dans les environnements de débogage

Si, après avoir enregistré votre application pour la vérification des applications, vous souhaitez exécuter votre application dans un environnement que la vérification de l'application ne classerait normalement pas comme valide, comme un simulateur pendant le développement, ou à partir d'un environnement d'intégration continue (CI), vous pouvez Créez une génération de débogage de votre application qui utilise le fournisseur de débogage de vérification de l'application au lieu d'un véritable fournisseur d'attestation.

Voir Utiliser l'application Vérifier avec le fournisseur de débogage sur les plateformes Apple .