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ć funkcję App Check w aplikacji Apple przy użyciu niestandardowego dostawcy App Check . Po włączeniu Kontroli aplikacji zapewniasz, że tylko Twoja aplikacja ma dostęp do zasobów Firebase projektu.

Jeśli chcesz korzystać z funkcji App Check z wbudowanymi dostawcami, zapoznaj się z dokumentacją dotyczącą App Check with App Attest i App Check with DeviceCheck .

Zanim zaczniesz

1. Dodaj bibliotekę Sprawdzanie aplikacji do swojej aplikacji

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

    pod 'FirebaseAppCheck'

    Ewentualnie możesz zamiast tego użyć Swift Package Manager .

    Upewnij się też, że korzystasz z najnowszej wersji dowolnych bibliotek klienta usługi Firebase, na których polegasz.

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

2. Implementuj protokoły App Check

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

Klasa AppCheckProvider musi mieć getToken(completion:) , która zbiera wszelkie informacje wymagane przez niestandardowy dostawca sprawdzania aplikacji jako dowód autentyczności i wysyła je do usługi pozyskiwania tokenów w zamian za token sprawdzania aplikacji. Pakiet App Check SDK obsługuje buforowanie tokenów, więc zawsze pobieraj 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 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

Po zainstalowaniu biblioteki Sprawdzanie aplikacji w Twojej aplikacji zacznij rozpowszechniać zaktualizowaną aplikację wśród użytkowników.

Zaktualizowana aplikacja kliencka zacznie wysyłać tokeny sprawdzania aplikacji wraz z każdym żądaniem wysłanym 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łącz egzekwowanie

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

Aby pomóc w podjęciu tej decyzji, możesz przyjrzeć się wskaźnikom Kontroli aplikacji dla usług, z których korzystasz:

Włącz wymuszanie sprawdzania aplikacji

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

Użyj sprawdzania aplikacji w środowiskach debugowania

Jeśli po zarejestrowaniu aplikacji do sprawdzania aplikacji chcesz uruchomić aplikację w środowisku, którego Sprawdzanie aplikacji normalnie nie klasyfikuje jako prawidłowe, takim jak symulator podczas tworzenia lub ze środowiska ciągłej integracji (CI), możesz utwórz kompilację debugowania swojej aplikacji, która używa dostawcy debugowania sprawdzania aplikacji zamiast rzeczywistego dostawcy poświadczania.

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