Utilizzare App Check per proteggere l'SDK Navigation per iOS

Firebase App Check protegge le chiamate dalla tua app a Google Maps Platform bloccando il traffico proveniente da origini diverse dalle tue app legittime. A questo scopo, richiede a un provider di attestazione come App Attest una valutazione dell'autenticità dell'app o del dispositivo. Quando integri la tua app con App Check, aggiungi una protezione contro le richieste dannose e non autorizzate, che a sua volta protegge la fatturazione da addebiti non autorizzati. App Check migliora anche in modo significativo la segnalazione di interruzioni in tempo reale nell'ecosistema di app della tua flotta, a vantaggio di tutti i conducenti che utilizzano la tua app. Per ulteriori informazioni, consulta Segnalazione di interruzioni.

Importante:per impostazione predefinita, App Check non blocca il traffico non autorizzato. Devi attivare manualmente l'applicazione dopo aver verificato le metriche della tua app (vedi Passaggio 6: monitora le richieste della tua app e decidi l'applicazione).

Perché utilizzare App Check?

App Check protegge due aree distinte dell'SDK Navigation per iOS: la funzionalità di navigazione principale e la segnalazione di interruzioni.

Navigazione

App Check aiuta a bloccare le richieste principali dell'SDK Navigation per iOS provenienti da fonti dannose o non autorizzate. Ciò ti avvantaggia direttamente proteggendo il tuo progetto da fatturazione fraudolenta ed esaurimento della quota.

Segnalazione di interruzioni

App Check è consigliata vivamente se la tua app supporta le funzionalità di segnalazione e voto dei disservizi in tempo reale. L'attivazione di App Check garantisce che ai tuoi autisti vengano forniti i percorsi più accurati, tenendo conto di tutti i feedback in tempo reale.

Perché App Check è importante per la generazione di report:

• La barra di attendibilità elevata per le chiusure:gli eventi che influiscono sul percorso, come le chiusure stradali, possono alterare in modo significativo il comportamento di routing per tutti i conducenti. Per proteggere la mappa da potenziali atti vandalici, spam o segnalazioni imprecise, l'infrastruttura di moderazione di Google per le interruzioni dovute alla chiusura stradale si basa su solidi indicatori di integrità dell'app e dei dispositivi.
• Come App Check convalida i report:i report e i voti degli utenti inviati dall'SDK Navigation per iOS includono il token App Check, che viene utilizzato dal backend di Google per convalidare la legittimità del feedback, aumentandone il livello di attendibilità e consentendo di valutarne l'impatto sulla mappa live.
• Impatto dell'omissione di App Check:i report inviati senza un token App Check valido vengono valutati in base a un modello di attendibilità inferiore e potrebbero essere elaborati solo come indicatori silenziosi. Ciò significa che, sebbene gli utenti possano ancora segnalare e votare, è meno probabile che le loro segnalazioni siano visibili sulla mappa o influiscano sui percorsi di altri conducenti e richiederanno una convalida aggiuntiva.

App Check è adatto alle mie esigenze?

App Check è consigliato nella maggior parte dei casi; tuttavia, non è necessario o non è supportato nei seguenti scenari:

• App private o sperimentali:se la tua app non è accessibile pubblicamente, non è necessario App Check.
• Dispositivi compromessi:i fornitori di attestazione consigliati impediscono l'esecuzione di Navigation SDK per iOS su dispositivi non attendibili, come smartphone rooted o jailbroken. Per supportare questi dispositivi, implementa un provider di attestazione personalizzato.

Panoramica dei passaggi di implementazione

In linea generale, per integrare l'app con App Check, segui questi passaggi:

1. Aggiungi Firebase alla tua app.
2. Aggiungi la libreria App Check e inizializza App Check.
3. Aggiungi un fornitore di token. Questo passaggio richiama il provider di attestazione di tua scelta per verificare l'integrità del dispositivo o dell'app.
4. Inizializza le API Navigation e App Check.
5. Attiva il debug. Ciò è utile durante lo sviluppo o negli ambienti di integrazione continua (CI).
6. Monitora le richieste dell'app prima di attivare l'applicazione. In questo modo, puoi applicare App Check senza problemi e senza interrompere l'esperienza dei tuoi utenti.

Considerazioni per la pianificazione di un'integrazione di App Check

• Quote dei fornitori di attestazioni:i fornitori di attestazioni che consigliamo, DeviceCheck o App Attest, sono soggetti a quote e limitazioni stabilite da Apple.
• Latenza di avvio:nella maggior parte dei casi, gli utenti non riscontrano latenza durante l'utilizzo regolare, perché i token App Check vengono memorizzati nella cache del dispositivo. Il sistema aggiorna automaticamente i token di App Check in background prima della scadenza per mantenere prestazioni ottimali. Tuttavia, se non è presente un token App Check valido, gli utenti della tua app riscontreranno una certa latenza all'avvio. Ad esempio, questa latenza si verifica durante gli avvii a freddo quando un token memorizzato nella cache è scaduto o mancante.
• Durata (TTL) token:la durata (TTL) determina il periodo di validità del token App Check prima che debba essere aggiornato. Puoi configurare questa durata da 30 minuti a 7 giorni nella console Firebase. Una durata di 1 ora è consigliata come base sicura, ma l'SDK tenta automaticamente gli aggiornamenti in background a circa metà della durata TTL. Per istruzioni dettagliate sulla console, consulta la documentazione di Firebase App Check.

Integrare l'app con App Check

Prerequisiti e requisiti

• Un'app con l'SDK Navigation per iOS versione 11.0 o successive installata.
• L'ID pacchetto dell'app.
• Il tuo ID team dalla scheda Membership (Appartenenza) nella console per sviluppatori Apple.
• Se prevedi di utilizzare DeviceCheck, il file della chiave privata e l'ID chiave.
• Devi essere il proprietario dell'app nella console Google Cloud.
• L'ID progetto della tua app dalla console Google Cloud.

Passaggio 1: aggiungi Firebase alla tua app

Segui le istruzioni nella documentazione per gli sviluppatori di Firebase per aggiungere Firebase alla tua app. Aggiungi il file GoogleService-Info.plist, senza modifiche, al livello principale del progetto.

Nel file AppDelegate, importa i seguenti moduli:

Swift

import FirebaseCore
import FirebaseAppCheck
import GoogleNavigation

Objective-C

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

Passaggio 2: aggiungi la libreria App Check e inizializza App Check

Firebase fornisce istruzioni per ogni fornitore di attestazione predefinito. Queste istruzioni mostrano come configurare un progetto Firebase e aggiungere la libreria App Check alla tua app. Segui gli esempi di codice forniti per inizializzare App Check.

1. Segui le istruzioni di Firebase per aggiungere la libreria App Check:
   • Istruzioni per App Attest.
   • Istruzioni per DeviceCheck.
2. Inizializza App Check in AppDelegate:
   • Se utilizzi App Attest, crea un'implementazione di AppCheckProviderFactory e registrala prima di chiamare 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];

   • Se utilizzi DeviceCheck, imposta la fabbrica utilizzando quanto segue:

     Swift

     AppCheck.setAppCheckProviderFactory(DeviceCheckProviderFactory())

     Objective-C

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

Passaggio 3: aggiungi il fornitore di token

Nota:se la tua app utilizza anche altri SDK Google Maps Platform che supportano App Check (come l'SDK Places), puoi utilizzare la stessa configurazione di Firebase App Check, ma devi implementare e registrare l'interfaccia del fornitore di token specifica per ogni SDK.

Crea un file denominato AppCheckTokenProvider (o, se utilizzi Objective-C, due file denominati AppCheckTokenProvider.h e AppCheckTokenProvider.m) a livello di radice della tua app.

Questa classe deve essere conforme al protocollo GMSAppCheckTokenProvider e implementare il metodo 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

Passaggio 4: inizializza le API Navigation e App Check

Inizializza l'SDK Navigation per iOS e registra l'istanza del provider di token su 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];

(Facoltativo) Passaggio 5: attiva il debug

Dopo l'applicazione di App Check per l'SDK Navigation per iOS, le funzionalità della tua app che dipendono dall'SDK Navigation per iOS non verranno eseguite in un simulatore o da un ambiente di integrazione continua (CI) perché questi ambienti non sono considerati dispositivi validi. Per eseguire l'app in questi ambienti durante lo sviluppo e il test, devi creare una build di debug dell'app che utilizzi il provider di debug di App Check anziché un provider di attestazione di produzione.

1. Configura la fabbrica del provider di debug in 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. Attiva la registrazione nel progetto Xcode, avvia l'app e individua il token di debug locale nel log della console.
3. Copia e aggiungi questo token di debug alla console Firebase. Per ulteriori dettagli, consulta la documentazione del provider di debug di Firebase App Check.

Passaggio 6: monitora le richieste dell'app e decidi l'applicazione

Nota:l'applicazione non è strettamente necessaria per consentire ai report sulle interruzioni in tempo reale di usufruire della verifica dell'integrità del dispositivo. Tuttavia, la protezione completa da frodi di fatturazione, spoofing e abuso di quota si basa sull'attivazione dell'applicazione a livello di progetto.

Prima di attivare l'applicazione, monitora le richieste della tua app per assicurarti di non interrompere l'attività degli utenti legittimi.

1. Visita la schermata delle metriche di App Check nella console Firebase per visualizzare la percentuale di traffico verificato rispetto a quello non verificato.
2. Quando avrai la certezza che la maggior parte del traffico è verificata e che gli utenti legittimi hanno eseguito l'aggiornamento a una versione della tua app contenente l'implementazione di App Check, attiva l'applicazione.
3. Una volta attivata l'applicazione, App Check rifiuterà tutto il traffico senza un token App Check valido.