Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Zacznij korzystać z App Check u niestandardowego dostawcy na platformach Apple, Zacznij korzystać z App Check u niestandardowego dostawcy na platformach Apple

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Na tej stronie pokazano, jak włączyć Sprawdzanie aplikacji w aplikacji Apple przy użyciu niestandardowego dostawcy Sprawdzanie aplikacji . Włączając Sprawdzanie aplikacji, pomagasz upewnić się, że tylko Twoja aplikacja ma dostęp do zasobów Firebase Twojego projektu.

Jeśli chcesz używać sprawdzania aplikacji z wbudowanymi dostawcami, zapoznaj się z dokumentacją sprawdzania aplikacji za pomocą zaświadczenia o aplikacji i sprawdzania aplikacji za pomocą DeviceCheck .

Zanim zaczniesz

1. Dodaj bibliotekę App Check do swojej aplikacji

  1. Dodaj zależność dla sprawdzania aplikacji do Podfile swojego projektu:

    pod 'FirebaseAppCheck'

    Lub, alternatywnie, możesz zamiast tego użyć Swift Package Manager .

    Upewnij się też, że używasz najnowszej wersji bibliotek klienta usługi Firebase, od których zależysz.

  2. Uruchom pod install i otwórz utworzony plik .xcworkspace .

2. Zaimplementuj protokoły sprawdzania aplikacji

Najpierw musisz utworzyć klasy, które implementują protokoły AppCheckProvider i AppCheckProviderFactory .

Twoja klasa AppCheckProvider musi mieć getToken(completion:) , która zbiera wszelkie informacje wymagane przez niestandardowego dostawcę sprawdzania aplikacji jako dowód autentyczności i wysyła je do usługi pozyskiwania tokenów w zamian za token sprawdzania aplikacji. Zestaw App Check SDK obsługuje buforowanie tokenów, więc zawsze uzyskaj nowy token w swojej implementacji getToken(completion:) .

Szybki

class YourCustomAppCheckProvider: NSObject, AppCheckProvider {
    var app: FirebaseApp

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

    func getToken(completion handler: @escaping (AppCheckToken?, Error?) -> Void) {
        DispatchQueue.main.async {
            // Logic to exchange proof of authenticity for an App Check token.
            // ...

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

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

Cel 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

Zaimplementuj również klasę AppCheckProviderFactory , która tworzy instancje twojej implementacji AppCheckProvider :

Szybki

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

Cel C

@interface YourCustomAppCheckProviderFactory : NSObject <FIRAppCheckProviderFactory>
@end

@implementation YourCustomAppCheckProviderFactory

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

@end

3. Zainicjuj sprawdzanie aplikacji

Dodaj następujący kod inicjujący do delegata aplikacji lub inicjatora aplikacji:

Szybki

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

FirebaseApp.configure()

Cel C

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

[FIRApp configure];

Następne kroki

Gdy biblioteka sprawdzania aplikacji zostanie zainstalowana w Twojej aplikacji, rozpocznij dystrybucję zaktualizowanej aplikacji do użytkowników.

Zaktualizowana aplikacja kliencka zacznie wysyłać tokeny sprawdzania aplikacji wraz z każdym żądaniem skierowanym do Firebase, ale produkty Firebase nie będą wymagać, aby tokeny były ważne, dopóki nie włączysz wymuszania w sekcji Sprawdzanie aplikacji w konsoli Firebase.

Monitoruj metryki i włączaj egzekwowanie

Zanim jednak włączysz wymuszanie, upewnij się, że nie zakłóci to działania Twoich obecnych legalnych użytkowników. Z drugiej strony, jeśli zauważysz podejrzane użycie zasobów aplikacji, warto wcześniej włączyć wymuszanie.

Aby pomóc w podjęciu tej decyzji, możesz przejrzeć dane Sprawdzania aplikacji dotyczące usług, z których korzystasz:

Włącz wymuszanie sprawdzania aplikacji

Gdy zrozumiesz, w jaki sposób Sprawdzanie aplikacji wpłynie na Twoich użytkowników i będziesz gotowy do kontynuowania, możesz włączyć wymuszanie Sprawdzania aplikacji:

Użyj sprawdzania aplikacji w środowiskach debugowania

Jeśli po zarejestrowaniu aplikacji do kontroli aplikacji chcesz uruchomić ją w środowisku, którego kontrola aplikacji normalnie nie sklasyfikowałaby jako ważne, na przykład na symulatorze podczas opracowywania lub w środowisku ciągłej integracji (CI), możesz utwórz kompilację debugowania swojej aplikacji, która używa dostawcy debugowania sprawdzania aplikacji zamiast prawdziwego dostawcy zaświadczeń.

Zobacz Używanie sprawdzania aplikacji z dostawcą debugowania na platformach Apple .