Wybierz platformę: Android iOS JavaScript

Zabezpieczanie klucza interfejsu API za pomocą Sprawdzania aplikacji

Sprawdzanie aplikacji Firebase chroni połączenia z Twojej aplikacji z platformą Google Maps, blokując ruch pochodzący z innych źródeł niż legalne aplikacje. W tym celu sprawdza token od dostawcy potwierdzenia, takiego jak App Attest. Integracja aplikacji ze Sprawdzaniem aplikacji pomaga chronić przed złośliwymi żądaniami, dzięki czemu nie ponosisz opłat za nieautoryzowane wywołania interfejsu API.

Czy Sprawdzanie aplikacji jest dla mnie odpowiednie?

W większości przypadków zalecamy korzystanie ze Sprawdzania aplikacji. Nie jest ono jednak potrzebne lub nie jest obsługiwane w tych przypadkach:

  • Używasz oryginalnego pakietu SDK Miejsc. Sprawdzanie aplikacji jest obsługiwane tylko w przypadku pakietu SDK Miejsc (nowego).
  • Aplikacje prywatne lub eksperymentalne. Jeśli Twoja aplikacja nie jest dostępna publicznie, Sprawdzanie aplikacji nie jest potrzebne.
  • Jeśli Twoja aplikacja jest używana tylko w komunikacji między serwerami, Sprawdzanie aplikacji nie jest potrzebne. Jeśli jednak serwer, który komunikuje się z platformą Google Maps, jest używany przez klientów publicznych (np. aplikacje mobilne), rozważ użycie Sprawdzania aplikacji do ochrony tego serwera zamiast platformy Google Maps.
  • Zalecani przez nas dostawcy potwierdzenia, czyli Device Check lub App Attest, nie będą działać na urządzeniach, które dostawca uzna za naruszone lub niewiarygodne. Jeśli musisz obsługiwać takie urządzenia, możesz wdrożyć niestandardową usługę potwierdzania. Więcej informacji znajdziesz w instrukcjach.

Omówienie etapów wdrożenia

Aby zintegrować aplikację ze Sprawdzaniem aplikacji, wykonaj te czynności:

  1. Dodaj Firebase do aplikacji.
  2. Dodaj i zainicjuj bibliotekę Sprawdzania aplikacji.
  3. Dodaj dostawcę tokena do aplikacji.
  4. Zainicjuj interfejsy API Miejsc i Sprawdzania aplikacji.
  5. Włącz debugowanie.
  6. Monitoruj żądania aplikacji i zdecyduj, czy chcesz włączyć wymuszanie.

Po zintegrowaniu ze Sprawdzaniem aplikacji możesz wyświetlać dane o ruchu w backendzie w konsoli Firebase. Te dane zawierają podział żądań na te, które są powiązane z prawidłowym tokenem Sprawdzania aplikacji, i te, które nie są. Więcej informacji znajdziesz w dokumentacji Sprawdzania aplikacji Firebase.

Gdy będziesz mieć pewność, że większość żądań pochodzi z legalnych źródeł i że użytkownicy zaktualizowali aplikację do najnowszej wersji, która zawiera implementację Sprawdzania aplikacji, możesz włączyć wymuszanie. Gdy wymuszanie jest włączone, Sprawdzanie aplikacji będzie odrzucać cały ruch bez prawidłowego tokena Sprawdzania aplikacji.

Kwestie do rozważenia podczas planowania integracji ze Sprawdzaniem aplikacji

Oto kilka kwestii, które warto rozważyć podczas planowania integracji:

  • Zalecani przez nas dostawcy potwierdzenia, czyli Device Check lub App Attest, podlegają limitom i ograniczeniom określonym przez Apple.

    Możesz użyć niestandardowego dostawcy potwierdzenia, ale jest to zaawansowany przypadek użycia. Więcej informacji znajdziesz w dokumentacji Sprawdzania aplikacji Firebase.

  • Użytkownicy Twojej aplikacji będą odczuwać pewne opóźnienie podczas uruchamiania. Jednak później wszelkie okresowe ponowne potwierdzenia będą wykonywane w tle i użytkownicy nie powinni już odczuwać żadnych opóźnień. Dokładna wielkość opóźnienia podczas uruchamiania zależy od wybranego dostawcy potwierdzenia.

    Czas ważności tokena Sprawdzania aplikacji (czyli czas życia danych lub TTL) określa częstotliwość ponownych potwierdzeń. Ten czas można skonfigurować w konsoli Firebase. Ponowne potwierdzenie następuje po upływie około połowy czasu TTL. Więcej informacji znajdziesz w dokumentacji Firebase dotyczącej dostawcy potwierdzenia.

Integracja aplikacji ze Sprawdzaniem aplikacji

Wymagania wstępne

  • Aplikacja z zainstalowanym pakietem SDK Miejsc w wersji 9.2 lub nowszej.
  • Identyfikator pakietu aplikacji.
  • Identyfikator zespołu w Apple Member Center w sekcji Membership (Członkostwo).
  • Jeśli planujesz używać Device Check, twój plik klucza prywatnego i identyfikator klucza.
  • Musisz być właścicielem aplikacji w konsoli Cloud.
  • Będziesz potrzebować identyfikatora projektu aplikacji z konsoli Cloud.

Krok 1. Dodaj Firebase do aplikacji

Aby dodać Firebase do aplikacji, postępuj zgodnie z instrukcjami w dokumentacji dla deweloperów Firebase.

Gdy zarejestrujesz aplikację, otrzymasz plik konfiguracyjny GoogleService-Info.plist. Dodaj ten plik w niezmienionej postaci do katalogu głównego aplikacji.

Pakiet Places Swift SDK na iOS

import FirebaseCore
import FirebaseAppCheck
import GooglePlacesSwift

Swift

import FirebaseCore
import FirebaseAppCheck
import GooglePlaces

Objective-C

@import FirebaseCore;      
@import FirebaseAppCheck;
@import GooglePlaces;

Krok 2. Dodaj bibliotekę Sprawdzania aplikacji i zainicjuj Sprawdzanie aplikacji

Firebase zawiera instrukcje dotyczące każdego domyślnego dostawcy potwierdzenia. Te instrukcje pokazują, jak skonfigurować projekt w Firebase i dodać bibliotekę Sprawdzania aplikacji do aplikacji. Aby zainicjować Sprawdzanie aplikacji, postępuj zgodnie z podanymi przykładami kodu.

  1. Aby dodać bibliotekę Sprawdzania aplikacji, postępuj zgodnie z instrukcjami Firebase:
  2. Zainicjuj Sprawdzanie aplikacji.
    • Jeśli używasz App Attest, postępuj zgodnie z dokumentacją dla deweloperów Firebase dotyczącą App Attest..

      Aby utworzyć implementację AppCheckProviderFactory i dodać ją do pliku AppDelegate, postępuj zgodnie z instrukcjami Sprawdzania aplikacji Firebase.

      Pakiet Places Swift SDK na iOS

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

      Swift

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

      Objective-C

      YourAppCheckProviderFactory *providerFactory =
    [[YourAppCheckProviderFactory alloc] init];
[FIRAppCheck setAppCheckProviderFactory:providerFactory];
    • Jeśli używasz Device Check, dodaj do pliku AppDelegate te elementy:

      Pakiet Places Swift SDK na iOS

      AppCheck.setAppCheckProviderFactory(DeviceCheckProviderFactory())

      Swift

      AppCheck.setAppCheckProviderFactory(DeviceCheckProviderFactory())

      Objective-C

      [FIRAppCheck setAppCheckProviderFactory:providerFactory];

Krok 3. Dodaj dostawcę tokena

Utwórz w katalogu głównym aplikacji plik o nazwie AppCheckTokenProvider (lub, jeśli używasz Objective-C, 2 pliki o nazwach AppCheckTokenProvider.h i AppCheckTokenProvider.m). Dodaj te instrukcje importu i definicję klasy:

Pakiet Places Swift SDK na iOS

// AppCheckTokenProvider.swift

import FirebaseAppCheck
import Foundation
import GooglePlacesSwift
      
struct TokenProvider: AppCheckTokenProvider {
  func fetchAppCheckToken() async throws -> String {
    return try await AppCheck.appCheck().token(forcingRefresh: false).token
  }
}

Swift

// AppCheckTokenProvider.swift

import FirebaseAppCheck
import Foundation
import GooglePlaces

class AppCheckTokenProvider: NSObject, GMSPlacesAppCheckTokenProvider {
  func fetchAppCheckToken() async throws -> String {
    return try await AppCheck.appCheck().token(forcingRefresh: false).token
  }
}

Objective-C

// AppCheckTokenProvider.h

@import Foundation;
@import GooglePlaces;

@interface AppCheckTokenProvider : NSObject <GMSPlacesAppCheckTokenProvider>
@end

// AppCheckTokenProvider.m

#import "AppCheckTokenProvider.h"

@import FirebaseAppCheck;

@implementation AppCheckTokenProvider

- (void)fetchAppCheckTokenWithCompletion:(nonnull GMSAppCheckTokenCompletion)completion {
  [[FIRAppCheck appCheck]
      tokenForcingRefresh:NO
               completion:^(FIRAppCheckToken *_Nullable token, NSError *_Nullable error) {
                 if (token) {
                   completion(token.token, nil);
                 } else {
                   completion(nil, error);
                 }
               }];
}

@end

Krok 4. Zainicjuj interfejsy API Miejsc i Sprawdzania aplikacji

  1. W pliku AppDelegate zainicjuj interfejs Places API:

    Pakiet Places Swift SDK na iOS

    PlacesClient.provideAPIKey("YOUR_API_KEY")

    Swift

    GMSPlacesClient.provideAPIKey("YOUR_API_KEY")

    Objective-C

    [GMSPlacesClient provideAPIKey:@"YOUR_API_KEY"];
  2. Następnie zainicjuj interfejs App Check API:

    Pakiet Places Swift SDK na iOS

    PlacesClient.setAppCheckTokenProvider(AppCheckTokenProvider())

    Swift

    GMSPlacesClient.setAppCheckTokenProvider(AppCheckTokenProvider())

    Objective-C

    [GMSPlacesClient setAppCheckTokenProvider:[[AppCheckTokenProvider alloc] init]];

Krok 5. Włącz debugowanie (opcjonalny)

Jeśli chcesz programować i testować aplikację lokalnie lub uruchamiać ją w trybie ciągłej integracji (CI), możesz utworzyć kompilację do debugowania aplikacji, która używa tajnego klucza debugowania do uzyskiwania prawidłowych tokenów Sprawdzania aplikacji. Dzięki temu w kompilacji do debugowania nie musisz używać prawdziwych dostawców potwierdzenia.

Aby przetestować aplikację w symulatorze lub na urządzeniu testowym:

  • Utwórz i ustaw fabrykę dostawcy debugowania Sprawdzania aplikacji.

    Ten przykładowy kod obsługuje zarówno scenariusze debugowania, jak i produkcyjne:

    Pakiet Places Swift SDK na iOS

    #if targetEnvironment(simulator)
      let providerFactory = AppCheckDebugProviderFactory()
#else
      let providerFactory = YourAppCheckProviderFactory()
#endif

    Swift

    #if targetEnvironment(simulator)
      let providerFactory = AppCheckDebugProviderFactory()
#else
      let providerFactory = YourAppCheckProviderFactory()
#endif

    Objective-C

    if (targetEnvironment == simulator){

FIRAppCheckDebugProviderFactory *providerFactory =
      [[FIRAppCheckDebugProviderFactory alloc] init];
[FIRAppCheck setAppCheckProviderFactory:providerFactory];
}

else {

YourAppCheckProviderFactory *providerFactory =
      [[YourAppCheckProviderFactory alloc] init];
[FIRAppCheck setAppCheckProviderFactory:providerFactory];
}
  • Włącz logowanie w projekcie Xcode, uruchom aplikację i znajdź lokalny token debugowania w logu.
  • Dodaj ten token do konsoli Firebase.
  • Więcej informacji i instrukcji znajdziesz w dokumentacji Sprawdzania aplikacji.

Aby uruchomić aplikację w środowisku CI:

  • Utwórz token debugowania w konsoli Firebase i dodaj go do bezpiecznego magazynu kluczy systemu CI.
  • W Xcode dodaj do schematu testowania zmienną środowiskową o nazwie FIRAAppCheckDebugToken i wartości $(APP_CHECK_DEBUG_TOKEN) (lub podobnej).
  • W scenariuszu testowania CI przekaż token debugowania jako środowisko.

  • Utwórz i ustaw fabrykę dostawcy debugowania Sprawdzania aplikacji.

    Ten przykładowy kod obsługuje zarówno scenariusze debugowania, jak i produkcyjne:

    Pakiet Places Swift SDK na iOS

    #if DEBUG
  let providerFactory = AppCheckDebugProviderFactory()
#else
  let providerFactory = YourAppCheckProviderFactory()
#endif
AppCheck.setAppCheckProviderFactory(providerFactory)

    Swift

    #if DEBUG
  let providerFactory = AppCheckDebugProviderFactory()
#else
  let providerFactory = YourAppCheckProviderFactory()
#endif
AppCheck.setAppCheckProviderFactory(providerFactory)

    Objective-C

    #if DEBUG
id<FIRAppCheckProviderFactory> providerFactory =
    [[FIRAppCheckDebugProviderFactory alloc] init];
#else  // DEBUG
id<FIRAppCheckProviderFactory> providerFactory =
    [[YourAppCheckProviderFactory alloc] init];
#endif  // DEBUG
AppCheck.setAppCheckProviderFactory(providerFactory)
  • Więcej informacji i instrukcji znajdziesz w dokumentacji Sprawdzania aplikacji.

Krok 6. Monitoruj żądania aplikacji i zdecyduj, czy chcesz włączyć wymuszanie

Zanim zaczniesz wymuszać, upewnij się, że nie zakłócisz działania legalnych użytkowników aplikacji. Aby to zrobić, otwórz ekran danych Sprawdzania aplikacji i sprawdź, jaki odsetek ruchu w aplikacji jest zweryfikowany, nieaktualny lub nielegalny. Gdy zobaczysz, że większość ruchu jest zweryfikowana, możesz włączyć wymuszanie.

Więcej informacji i instrukcji znajdziesz w dokumentacji Sprawdzania aplikacji Firebase.