Zabezpieczanie pakietu Navigation SDK na iOS za pomocą Sprawdzania aplikacji

Obsługa Sprawdzania aplikacji w pakiecie Navigation SDK na iOS będzie wdrażana w ciągu najbliższych kilku dni. Jeśli nie widzisz jeszcze tej funkcji w konsoli Firebase, sprawdź ponownie za kilka dni.

Sprawdzanie aplikacji Firebase chroni połączenia z Twojej aplikacji z Google Maps Platform, blokując ruch pochodzący z innych źródeł niż Twoje legalne aplikacje. W tym celu prosi o ocenę autentyczności aplikacji lub urządzenia dostawcę potwierdzenia, takiego jak App Attest. Gdy zintegrujesz aplikację ze Sprawdzaniem aplikacji, zyskasz ochronę przed złośliwymi i nieautoryzowanymi żądaniami, co z kolei zabezpieczy Cię przed nieautoryzowanymi obciążeniami. Sprawdzanie aplikacji znacznie poprawia też raportowanie zakłóceń w czasie rzeczywistym w ekosystemie aplikacji dla kierowców, co przynosi korzyści wszystkim kierowcom korzystającym z Twojej aplikacji. Więcej informacji znajdziesz w sekcji Raportowanie zakłóceń.

Ważne: Sprawdzanie aplikacji domyślnie nie blokuje nieautoryzowanego ruchu. Po sprawdzeniu danych aplikacji musisz ręcznie włączyć wymuszanie (patrz Krok 6. Monitorowanie próśb aplikacji i decydowanie o wymuszaniu).

Dlaczego warto korzystać ze Sprawdzania aplikacji?

Sprawdzanie aplikacji chroni 2 różne obszary pakietu Navigation SDK na iOS: główną funkcję nawigacji i raportowanie zakłóceń.

Nawigacja

Sprawdzanie aplikacji pomaga blokować główne żądania pakietu Navigation SDK na iOS pochodzące ze złośliwych lub nieautoryzowanych źródeł. Dzięki temu chronisz swój projekt przed oszustwami związanymi z płatnościami i wyczerpaniem limitu.

Raportowanie zakłóceń

Jeśli Twoja aplikacja obsługuje raportowanie zakłóceń i głosowanie w czasie rzeczywistym, zdecydowanie zalecamy korzystanie ze Sprawdzania aplikacji. Włączenie Sprawdzania aplikacji zapewnia kierowcom najdokładniejsze trasy, które uwzględniają wszystkie opinie w czasie rzeczywistym.

Dlaczego Sprawdzanie aplikacji jest ważne w przypadku raportowania:

• Wysoki poziom zaufania w przypadku zamknięć: zdarzenia wpływające na trasę, takie jak zamknięcia dróg, mogą znacząco zmienić zachowanie routingu u wszystkich kierowców. Aby chronić mapę przed potencjalnym wandalizmem, spamem lub niedokładnymi zgłoszeniami, infrastruktura moderacji Google w przypadku zakłóceń związanych z zamknięciem dróg opiera się na silnych sygnałach integralności urządzenia i integralności aplikacji.
• Jak Sprawdzanie aplikacji weryfikuje raporty: raporty i głosy użytkowników wysyłane z pakietu Navigation SDK na iOS zawierają token Sprawdzania aplikacji, który jest używany przez backend Google do weryfikowania wiarygodności opinii, zwiększania jej poziomu zaufania i umożliwiania oceny wpływu na mapę publiczną.
• Wpływ pominięcia Sprawdzania aplikacji: raporty przesyłane bez prawidłowego tokena Sprawdzania aplikacji są oceniane w ramach modelu o niższym poziomie zaufania i mogą być przetwarzane wyłącznie jako ciche sygnały. Oznacza to, że użytkownicy nadal mogą zgłaszać problemy i głosować, ale ich raporty będą mniej widoczne na mapie i będą miały mniejszy wpływ na trasy innych kierowców. Będą też wymagać dodatkowej weryfikacji.

Czy Sprawdzanie aplikacji jest dla mnie odpowiednie?

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

• Aplikacje prywatne lub eksperymentalne: jeśli Twoja aplikacja nie jest publicznie dostępna, Sprawdzanie aplikacji nie jest potrzebne.
• Zhakowane urządzenia: zalecani dostawcy potwierdzenia uniemożliwiają uruchamianie pakietu Navigation SDK na iOS na niezaufanych urządzeniach, takich jak telefony z dostępem do roota lub po jailbreaku. Aby obsługiwać te urządzenia, wdróż niestandardowego dostawcę potwierdzenia.

Omówienie czynności związanych z wdrożeniem

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

1. Dodaj Firebase do swojej aplikacji.
2. Dodaj bibliotekę Sprawdzania aplikacji i zainicjuj Sprawdzanie aplikacji.
3. Dodaj dostawcę tokenów. Ten krok powoduje wywołanie wybranego dostawcy potwierdzenia w celu zweryfikowania integralności urządzenia lub aplikacji.
4. Zainicjuj interfejsy API nawigacji i Sprawdzania aplikacji.
5. Włącz debugowanie. Jest to przydatne podczas programowania lub w środowiskach trybu ciągłej integracji (CI).
6. Zanim włączysz wymuszanie, monitoruj żądania aplikacji. Dzięki temu możesz bezproblemowo wymusić Sprawdzanie aplikacji bez zakłócania pracy użytkowników.

Kwestie do rozważenia podczas planowania integracji ze Sprawdzaniem aplikacji

• Limity dostawcy potwierdzenia: zalecani przez nas dostawcy potwierdzenia, DeviceCheck lub App Attest, podlegają limitom i ograniczeniom określonym przez Apple.
• Opóźnienie przy uruchamianiu: w większości sytuacji użytkownicy nie będą odczuwać opóźnień podczas normalnego użytkowania, ponieważ tokeny Sprawdzania aplikacji są zapisywane w pamięci podręcznej urządzenia. System automatycznie odświeża tokeny Sprawdzania aplikacji w tle przed ich wygaśnięciem, aby zapewnić płynne działanie. Jeśli jednak prawidłowy token Sprawdzania aplikacji nie jest dostępny, użytkownicy aplikacji będą odczuwać pewne opóźnienie przy uruchamianiu. Opóźnienie występuje na przykład podczas zimnego startu, gdy token w pamięci podręcznej wygasł lub nie jest dostępny.
• TTL tokena: czas życia (TTL) określa, jak długo token Sprawdzania aplikacji jest ważny, zanim trzeba go odświeżyć. W konsoli Firebase możesz skonfigurować ten czas od 30 minut do 7 dni. Zalecamy ustawienie 1 godziny jako bezpiecznej wartości bazowej, ale pakiet SDK automatycznie próbuje odświeżyć token w tle po upływie około połowy czasu TTL. Szczegółowe instrukcje dotyczące konsoli znajdziesz w dokumentacji Sprawdzania aplikacji Firebase.

Integracja aplikacji ze Sprawdzaniem aplikacji

Wymagania wstępne i kryteria

• Aplikacja z zainstalowanym pakietem Navigation SDK na iOS w wersji 11.0 lub nowszej.
• Identyfikator pakietu aplikacji.
• Identyfikator zespołu na karcie Membership (Członkostwo) w konsoli Apple Developer.
• Jeśli planujesz używać DeviceCheck, plik klucza prywatnego i identyfikator klucza.
• Musisz być właścicielem aplikacji w konsoli Google Cloud.
• Identyfikator projektu aplikacji w konsoli Google Cloud.

Krok 1. Dodaj Firebase do swojej aplikacji

Aby dodać Firebase do swojej aplikacji, postępuj zgodnie z instrukcjami w dokumentacji dla deweloperów Firebase. Dodaj plik GoogleService-Info.plist w niezmienionej postaci do katalogu głównego projektu.

W pliku AppDelegate zaimportuj te moduły:

Swift

import FirebaseCore
import FirebaseAppCheck
import GoogleNavigation

Objective-C

@import FirebaseCore;
@import FirebaseAppCheck;
@import GoogleNavigation;

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

Firebase udostępnia 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:
   • Instrukcje dotyczące App Attest.
   • Instrukcje dotyczące DeviceCheck.
2. Zainicjuj Sprawdzanie aplikacji w pliku AppDelegate:
   • Jeśli używasz App Attest, utwórz implementację AppCheckProviderFactory i zarejestruj ją przed wywołaniem FirebaseApp.configure():

     Swift

     class YourAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
         func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
             return AppAttestProvider(app: app)
         }
     }
     // In application(_:didFinishLaunchingWithOptions:)
     let providerFactory = YourAppCheckProviderFactory()
     AppCheck.setAppCheckProviderFactory(providerFactory)
     FirebaseApp.configure()

     Objective-C

     #import <FirebaseCore/FirebaseCore.h>
     #import <FirebaseAppCheck/FirebaseAppCheck.h>
     
     @interface YourAppCheckProviderFactory : NSObject <FIRAppCheckProviderFactory>
     @end
     
     @implementation YourAppCheckProviderFactory
     - (nullable id<FIRAppCheckProvider>)createProviderWithApp:(FIRApp *)app {
         return [[FIRAppAttestProvider alloc] initWithApp:app];
     }
     @end
     
     // In application:didFinishLaunchingWithOptions:
     YourAppCheckProviderFactory *providerFactory = [[YourAppCheckProviderFactory alloc] init];
     [FIRAppCheck setAppCheckProviderFactory:providerFactory];
     [FIRApp configure];

   • Jeśli zamiast tego używasz DeviceCheck, ustaw fabrykę w ten sposób:

     Swift

     AppCheck.setAppCheckProviderFactory(DeviceCheckProviderFactory())

     Objective-C

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

Krok 3. Dodaj dostawcę tokenów

Uwaga: jeśli Twoja aplikacja korzysta też z innych pakietów SDK Google Maps Platform, które obsługują Sprawdzanie aplikacji (np. Places SDK), możesz użyć tej samej konfiguracji Sprawdzania aplikacji Firebase, ale musisz zaimplementować i zarejestrować interfejs dostawcy tokenów specyficzny dla każdego pakietu SDK.

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

Ta klasa musi być zgodna z protokołem GMSAppCheckTokenProvider i implementować metodę fetchAppCheckTokenWithCompletion.

Swift

import Foundation
import FirebaseAppCheck
import GoogleNavigation

class AppCheckTokenProvider: NSObject, GMSAppCheckTokenProvider {
    func fetchAppCheckToken(completion: @escaping (String?, Error?) -> Void) {
        AppCheck.appCheck().token(forcingRefresh: false) { token, error in
            if let error = error {
                print("App Check Error: \(error)")
                completion(nil, error)
                return
            }
            guard let token = token else {
                completion(nil, NSError(domain: "AppCheck", code: -1, userInfo: [NSLocalizedDescriptionKey: "Token is nil"]))
                return
            }
            print("App Check Token: \(token.token)")
            completion(token.token, nil)
        }
    }
}

Objective-C

// AppCheckTokenProvider.h
#import <Foundation/Foundation.h>
#import <GoogleNavigation/GoogleNavigation.h>

NS_ASSUME_NONNULL_BEGIN

@interface AppCheckTokenProvider : NSObject <GMSAppCheckTokenProvider>
@end

NS_ASSUME_NONNULL_END

// AppCheckTokenProvider.m
#import "AppCheckTokenProvider.h"
#import <FirebaseAppCheck/FirebaseAppCheck.h>

@implementation AppCheckTokenProvider
- (void)fetchAppCheckTokenWithCompletion:(void (^)(NSString * _Nullable token, NSError * _Nullable error))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 nawigacji i Sprawdzania aplikacji

Zainicjuj pakiet Navigation SDK na iOS (za pomocą GMSServices) i zarejestruj instancję dostawcy tokenów, rzutując wspólny nieprzezroczysty uchwyt usług na GMSServices:

Swift

// In application(_:didFinishLaunchingWithOptions:)
GMSServices.provideAPIKey("YOUR_API_KEY")

// Register your App Check token provider before initializing Navigation SDK for iOS
if let services = GMSServices.sharedServices() as? GMSServices {
    services.appCheckTokenProvider = AppCheckTokenProvider()
}

Objective-C

// In application:didFinishLaunchingWithOptions:
[GMSServices provideAPIKey:@"YOUR_API_KEY"];

// Register your App Check token provider before initializing Navigation SDK for iOS
((GMSServices *)[GMSServices sharedServices]).appCheckTokenProvider = [[AppCheckTokenProvider alloc] init];

Krok 5. Włącz debugowanie (opcjonalny)

Gdy wymusisz Sprawdzanie aplikacji w pakiecie Navigation SDK na iOS, funkcje aplikacji, które zależą od tego pakietu SDK, nie będą działać w symulatorze ani w trybie ciągłej integracji (CI), ponieważ te środowiska nie kwalifikują się jako prawidłowe urządzenia. Aby uruchamiać aplikację w tych środowiskach podczas programowania i testowania, musisz utworzyć kompilację debugowania aplikacji, która używa dostawcy debugowania Sprawdzania aplikacji zamiast dostawcy potwierdzenia w wersji produkcyjnej.

1. Skonfiguruj fabrykę dostawcy debugowania w pliku AppDelegate:

   Swift

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

   Objective-C

   #if TARGET_OS_SIMULATOR
   id<FIRAppCheckProviderFactory> providerFactory = [[FIRAppCheckDebugProviderFactory alloc] init];
   #else
   id<FIRAppCheckProviderFactory> providerFactory = [[YourAppCheckProviderFactory alloc] init];
   #endif
   [FIRAppCheck setAppCheckProviderFactory:providerFactory];

2. Włącz logowanie w projekcie Xcode, uruchom aplikację i znajdź lokalny token debugowania w logu konsoli.
3. Skopiuj ten token debugowania i dodaj go do konsoli Firebase. Więcej informacji znajdziesz w dokumentacji dostawcy debugowania Sprawdzania aplikacji Firebase.

Krok 6. Monitorowanie próśb aplikacji i decydowanie o wymuszaniu

Uwaga: wymuszanie nie jest bezwzględnie wymagane, aby raporty o zakłóceniach w czasie rzeczywistym korzystały z weryfikacji integralności urządzenia. Jednak pełna ochrona przed oszustwami związanymi z płatnościami, spoofingiem i nadużyciami limitów wymaga włączenia wymuszania na poziomie projektu.

Zanim włączysz egzekwowanie, monitoruj żądania aplikacji, aby mieć pewność, że nie zakłócisz pracy legalnych użytkowników.

1. Otwórz ekran danych Sprawdzania aplikacji w konsoli Firebase, aby zobaczyć odsetek zweryfikowanego i niezweryfikowanego ruchu.
2. Gdy masz pewność, że większość ruchu jest zweryfikowana, a legalni użytkownicy zaktualizowali aplikację do wersji zawierającej implementację Sprawdzania aplikacji, włącz egzekwowanie.
3. Gdy wymuszanie jest włączone, Sprawdzanie aplikacji będzie odrzucać cały ruch bez prawidłowego tokena Sprawdzania aplikacji.