Zabezpieczanie pakietu Navigation SDK na iOS za pomocą usługi Sprawdzanie aplikacji

Sprawdzanie aplikacji Firebase chroni wywołania z aplikacji do Google Maps Platform, blokując ruch pochodzący ze źródeł innych niż Twoje uprawnione aplikacje. W tym celu wysyła do dostawcy atestów, np. App Attest, prośbę o ocenę autentyczności aplikacji lub urządzenia. Gdy zintegrujesz aplikację z App Check, dodasz ochronę przed złośliwymi i nieautoryzowanymi żądaniami, co z kolei zabezpieczy Twoje rozliczenia przed nieautoryzowanymi opłatami. App Check znacznie ulepsza też raportowanie zakłóceń w czasie rzeczywistym w ekosystemie aplikacji dla flot, 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. Musisz ręcznie włączyć egzekwowanie po sprawdzeniu danych aplikacji (patrz Krok 6. Monitorowanie żądań do aplikacji i podejmowanie decyzji dotyczących egzekwowania).

Dlaczego warto korzystać ze Sprawdzania aplikacji?

Usługa App Check chroni 2 obszary pakietu SDK do nawigacji na iOS: główną funkcję nawigacji i zgłaszanie zakłóceń.

Nawigacja

Sprawdzanie aplikacji pomaga blokować główne żądania pakietu Navigation SDK na iOS pochodzące ze szkodliwych lub nieautoryzowanych źródeł. Przynosi to bezpośrednie korzyści, ponieważ chroni projekt przed oszustwami związanymi z płatnościami i wyczerpaniem limitu.

Zgłaszanie zakłóceń

Jeśli Twoja aplikacja obsługuje zgłaszanie zakłóceń w czasie rzeczywistym i głosowanie, zdecydowanie zalecamy korzystanie z usługi App Check. Włączenie usługi Sprawdzanie aplikacji zapewnia kierowcom najdokładniejsze trasy uwzględniające wszystkie informacje zwrotne w czasie rzeczywistym.

Dlaczego Sprawdzanie aplikacji ma znaczenie 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 w przypadku 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 dotyczących integralności urządzenia i integralności aplikacji.
• Jak Sprawdzanie aplikacji weryfikuje zgłoszenia: zgłoszenia 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ększa to poziom zaufania do opinii i umożliwia jej ocenę pod kątem wpływu na mapę publiczną.
• Skutki pominięcia sprawdzania aplikacji: raporty przesłane bez prawidłowego tokena sprawdzania aplikacji są oceniane w ramach modelu o niższym poziomie zaufania i mogą być przetwarzane wyłącznie jako sygnały ciche. Oznacza to, że użytkownicy nadal mogą zgłaszać problemy i oddawać głosy, ale ich zgłoszenia 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 to odpowiednie rozwiązanie dla mnie?

Sprawdzanie aplikacji jest zalecane w większości przypadków. Nie jest ono jednak potrzebne lub nie jest obsługiwane w tych sytuacjach:

• Aplikacje prywatne lub eksperymentalne: jeśli aplikacja nie jest dostępna publicznie, usługa Sprawdzanie aplikacji nie jest potrzebna.
• Zhakowane urządzenia: zalecani dostawcy atestów 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ę atestów.

Omówienie etapów wdrażania

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 atestów w celu zweryfikowania integralności urządzenia lub aplikacji.
4. Zainicjuj interfejsy Navigation API i Sprawdzanie aplikacji API.
5. Włącz debugowanie. Jest to przydatne podczas programowania lub w środowiskach trybu ciągłej integracji (CI).
6. Zanim włączysz egzekwowanie, monitoruj żądania aplikacji. W ten sposób możesz bezproblemowo wymusić Sprawdzanie aplikacji bez zakłócania pracy użytkowników.

Co wziąć pod uwagę podczas planowania integracji ze Sprawdzaniem aplikacji

• Limity dostawców atestów: dostawcy atestów, których rekomendujemy, czyli DeviceCheck i App Attest, podlegają limitom i ograniczeniom określonym przez Apple.
• Opóźnienie uruchamiania: w większości sytuacji użytkownicy nie odczuwają opóźnienia podczas normalnego korzystania z aplikacji, ponieważ tokeny Sprawdzania aplikacji są buforowane na urządzeniu. System automatycznie odświeża tokeny Sprawdzania aplikacji w tle przed ich wygaśnięciem, aby zapewnić płynne działanie. Jeśli jednak nie ma prawidłowego tokena Sprawdzania aplikacji, użytkownicy aplikacji będą odczuwać pewne opóźnienie podczas uruchamiania. Na przykład to opóźnienie występuje podczas zimnego startu, gdy token w pamięci podręcznej wygasł lub go brakuje.
• Czas życia tokena: Czas życia danych (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 trwania w zakresie od 30 minut do 7 dni. Zalecany czas trwania to 1 godzina, ale pakiet SDK automatycznie próbuje odświeżać w tle co około połowę czasu TTL. Szczegółowe instrukcje dotyczące konsoli znajdziesz w dokumentacji Sprawdzania aplikacji Firebase.

Integrowanie aplikacji ze Sprawdzaniem aplikacji

Wymagania wstępne i wymagania

• Aplikacja z zainstalowanym pakietem SDK do nawigacji na iOS w wersji 11.0 lub nowszej.
• Identyfikator pakietu aplikacji.
• Identyfikator zespołu z karty Członkostwo w konsoli Apple Developer.
• Jeśli planujesz używać DeviceCheck, potrzebujesz pliku klucza prywatnego i identyfikatora klucza.
• Musisz być właścicielem aplikacji w konsoli Google Cloud.
• Identyfikator projektu aplikacji w konsoli Google Cloud.

Krok 1. Dodaj Firebase do aplikacji

Aby dodać Firebase do 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 dla każdego domyślnego dostawcy atestów. Z tych instrukcji dowiesz się, jak skonfigurować projekt w Firebase i dodać do aplikacji bibliotekę Sprawdzania aplikacji. Aby zainicjować Sprawdzanie aplikacji, skorzystaj z podanych przykładów 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 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 Platformy Google Maps, które obsługują App Check (np. pakietu SDK Miejsc), możesz użyć tej samej konfiguracji Firebase App Check, 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 języka 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 wdrażać 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 Navigation API i Sprawdzanie aplikacji API

Zainicjuj pakiet Navigation SDK na iOS i zarejestruj instancję dostawcy tokenów w GMSServices:

Swift

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

// Register your App Check token provider before initializing Navigation SDK for iOS
GMSServices.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.appCheckTokenProvider = [[AppCheckTokenProvider alloc] init];

Krok 5. Włącz debugowanie (opcjonalnie)

Gdy w przypadku pakietu Navigation SDK na iOS zostanie wymuszone stosowanie usługi Sprawdzanie aplikacji, funkcje aplikacji, które zależą od tego pakietu SDK, nie będą działać w symulatorze ani w środowisku trybu ciągłej integracji (CI), ponieważ te środowiska nie są uznawane za prawidłowe urządzenia. Aby uruchamiać aplikację w tych środowiskach podczas programowania i testowania, musisz utworzyć wersję debugowania aplikacji, która używa dostawcy debugowania weryfikacji aplikacji zamiast dostawcy atestów 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 dzienniku 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. Monitoruj prośby dotyczące aplikacji i podejmuj decyzje o egzekwowaniu zasad

Uwaga: egzekwowanie nie jest ściśle 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, podszywaniem się i nadużywaniem limitów zależy od włączenia egzekwowania na poziomie projektu.

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

1. Otwórz ekran danych App Check w konsoli Firebase, aby zobaczyć odsetek zweryfikowanego i niezweryfikowanego ruchu.
2. Gdy będziesz mieć pewność, że większość ruchu pochodzi od zweryfikowanych i prawdziwych użytkowników, którzy zaktualizowali aplikację do wersji zawierającej wdrożenie Sprawdzania aplikacji, włącz egzekwowanie.
3. Po włączeniu wymuszania Sprawdzanie aplikacji będzie odrzucać cały ruch bez prawidłowego tokena Sprawdzania aplikacji.