Firebase App Check per piattaforme Apple

1. Introduzione

Firebase App Check aiuta a proteggere le tue risorse di backend da abusi, come frodi nella fatturazione e phishing, assicurandoti che le richieste provengano da app e dispositivi legittimi. Funziona sia con i servizi Firebase che con i tuoi servizi backend per mantenere le tue risorse al sicuro.

Puoi trovare ulteriori informazioni su Firebase App Check nella documentazione di Firebase.

App Check utilizza servizi specifici della piattaforma per verificare l'integrità di un'app e/o di un dispositivo. Questi servizi sono chiamati provider di attestazioni . Uno di questi fornitori è il servizio App Attest di Apple, che App Check può utilizzare per verificare l'autenticità delle app e dei dispositivi Apple.

Cosa costruirai

In questo codelab aggiungerai e applicherai App Check in un'applicazione di esempio esistente in modo che il Realtime Database del progetto sia protetto dall'accesso da parte di app e dispositivi illegittimi.

Cosa imparerai

• Come aggiungere Firebase App Check a un'app esistente.
• Come installare diversi provider di attestazioni Firebase App Check.
• Come configurare l'attestazione dell'app per la tua app.
• Come configurare il provider di attestazioni di debug per testare la tua app sui simulatori durante lo sviluppo dell'app.

Di cosa avrai bisogno

• Xcode 13.3.1 o successivo
• Un account sviluppatore Apple che ti consente di creare nuovi identificatori di app
• Un dispositivo iOS/iPadOS che supporta App Attest (scopri di più sulla disponibilità dell'API App Attest )

Nota: puoi comunque completare questo codelab senza un account sviluppatore Apple e un dispositivo idoneo. In questo caso, potrai eseguire la tua app solo su un simulatore con un provider di debug Firebase App Check.

2. Ottieni il progetto iniziale

Il repository Firebase Quickstart per iOS contiene app di esempio per dimostrare diversi prodotti Firebase. Utilizzerai l'app Firebase Database Quickstart per SwiftUI come base per questo codelab.

Clona il repository Firebase Quickstarts per iOS dalla riga di comando:

git clone https://github.com/firebase/quickstart-ios.git
cd quickstart-ios

Apri il progetto dell'app Quickstart SwiftUI Realtime Database in Xcode:

cd database/DatabaseExampleSwiftUI/DatabaseExample
xed .

3. Aggiungi App Check alla tua app

1. Attendi che Swift Package Manager risolva le dipendenze del progetto.
2. Apri la scheda Generale della destinazione dell'app DatabaseExample (iOS) . Quindi, nella sezione Framework, librerie e contenuto incorporato , fare clic sul pulsante + .
3. Seleziona per aggiungere FirebaseAppCheck .

4. Creare e installare la factory del provider App Check

1. Nel gruppo File Shared aggiungere un nuovo gruppo denominato AppCheck .
2. All'interno di questo gruppo, crea una classe factory in un file separato, ad esempio MyAppCheckProviderFactory.swift , assicurandoti di aggiungerla al target DatabaseExample (iOS) :

   import Firebase
   
   class MyAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
     func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
       #if targetEnvironment(simulator)
         // App Attest is not available on simulators.
         // Use a debug provider.
         return AppCheckDebugProvider(app: app)
       #else
         // Use App Attest provider on real devices.
         return AppAttestProvider(app: app)
       #endif
     }
   }
   

3. Successivamente, in DatabaseExampleApp.swift , assicurati di importare FirebaseAppCheck e impostare un'istanza della classe MyAppCheckProviderFactory come factory del provider App Check.

   import SwiftUI
   import FirebaseCore
   import FirebaseAppCheck
   
   @main
   struct DatabaseExampleApp: App {
     init() {
       // Set an instance of MyAppCheckProviderFactory as an App Check
       // provider factory before configuring Firebase.
       AppCheck.setAppCheckProviderFactory(MyAppCheckProviderFactory())
       FirebaseApp.configure()
     }
     ...
   }
   

5. Crea e configura un progetto Firebase

Per utilizzare App Check nel tuo progetto iOS, devi seguire questi passaggi nella console Firebase:

• Configura un progetto Firebase.
• Aggiungi la tua app iOS al progetto Firebase.
• Configura l'autenticazione Firebase.
• Inizializza l'istanza di Realtime Database che intendi proteggere.
• Configura Controllo app.

Crea un progetto

Innanzitutto, devi creare un progetto Firebase.

1. Nella console Firebase , seleziona Aggiungi progetto .
2. Assegna un nome al tuo progetto App Check Codelab
3. Fare clic su Continua.
4. Disattiva Google Analytics per questo progetto, quindi fai clic su Crea progetto.

Crea un'istanza di database in tempo reale

Ora vai alla sezione Realtime Database della console Firebase.

1. Fare clic sul pulsante Crea database per avviare il flusso di lavoro di creazione del database.
2. Lasciare invariata la posizione predefinita ( us-central1 ) per il database e fare clic su Avanti .
3. Assicurati che sia selezionata la Modalità bloccata e fai clic sul pulsante Abilita per abilitare le regole di sicurezza per il tuo database.
4. Passare alla scheda Regole del browser Realtime Database e sostituire le regole predefinite con le seguenti:

   {
       "rules": {
           // User profiles are only readable/writable by the user who owns it
           "users": {
               "$UID": {
                   ".read": "auth.uid == $UID",
                   ".write": "auth.uid == $UID"
               }
           },
           // Posts can be read by anyone but only written by logged-in users.
           "posts": {
               ".read": true,
               ".write": "auth.uid != null",
               "$POSTID": {
                   // UID must match logged in user and is fixed once set
                   "uid": {
                       ".validate": "(data.exists() && data.val() == newData.val()) || newData.val() == auth.uid"
                   },
                   // User can only update own stars
                   "stars": {
                       "$UID": {
                           ".validate": "auth.uid == $UID"
                       }
                   }
               }
           },
           // User posts can be read by anyone but only written by the user that owns it,
           // and with a matching UID
           "user-posts": {
               ".read": true,
               "$UID": {
                   "$POSTID": {
                       ".write": "auth.uid == $UID",
                       ".validate": "data.exists() || newData.child('uid').val() == auth.uid"
                   }
               }
           },
           // Comments can be read by anyone but only written by a logged in user
           "post-comments": {
               ".read": true,
               ".write": "auth.uid != null",
               "$POSTID": {
                   "$COMMENTID": {
                       // UID must match logged in user and is fixed once set
                       "uid": {
                           ".validate": "(data.exists() && data.val() == newData.val()) || newData.val() == auth.uid"
                       }
                   }
               }
           }
       }
   }
   

5. Fare clic sul pulsante Pubblica per attivare le regole di sicurezza aggiornate.

Prepara la tua app iOS per la connessione a Firebase

Per poter eseguire l'app di esempio su un dispositivo fisico, devi aggiungere il progetto al tuo team di sviluppo in modo che Xcode possa gestire il profilo di provisioning richiesto per te. Segui questi passaggi per aggiungere l'app di esempio al tuo account sviluppatore:

1. In Xcode, seleziona il progetto DatabaseExample nel navigatore del progetto.
2. Seleziona la destinazione DatabaseExample (iOS) e apri la scheda Firma e funzionalità .
3. Dovresti visualizzare il messaggio di errore "La firma per DatabaseExample (iOS) richiede un team di sviluppo" .
4. Aggiorna l' identificatore del bundle in un identificatore univoco. Il modo più semplice per ottenere ciò è utilizzare il nome di dominio inverso del tuo sito web, ad esempio com.acme.samples.firebase.quickstart.DatabaseExample (non utilizzare questo ID; scegli invece il tuo ID univoco).
5. Seleziona il tuo team di sviluppo.
6. Saprai che tutto è andato bene quando Xcode visualizza "Profilo di provisioning: Profilo gestito Xcode" e una piccola icona di informazioni accanto a questa etichetta. Facendo clic su questa icona verranno visualizzati ulteriori dettagli sul profilo di provisioning.

Importante: la mancata fornitura di un identificatore univoco del pacchetto impedirà la registrazione del tuo progetto nel portale degli sviluppatori Apple. Solo le app registrate possono essere eseguite su un dispositivo fisico.

Collega la tua app iOS

Per una spiegazione approfondita sulla connessione della tua app, consulta la documentazione sull'aggiunta di Firebase al tuo progetto iOS . Per iniziare, segui questi passaggi principali nella console Firebase:

1. Dalla schermata Panoramica progetto del tuo nuovo progetto, fai clic sul pulsante + Aggiungi app , quindi fai clic sull'icona iOS+ per aggiungere una nuova app iOS al tuo progetto Firebase.
2. Inserisci l'ID bundle della tua app (usa quello che hai definito nella sezione precedente, come com.acme.samples.firebase.quickstart.DatabaseExample - tieni presente che deve essere un identificatore univoco)
3. Fare clic su Registra app .
4. Firebase genera un file GoogleService-Info.plist contenente tutti i metadati Firebase necessari per la tua app.
5. Fare clic su Scarica GoogleService-Info.plist per scaricare il file.
6. In Xcode, vedrai che il progetto contiene già un file denominato GoogleService-Info.plist . Elimina prima questo file: lo sostituirai con quello per il tuo progetto Firebase nel passaggio successivo.
7. Copia il file GoogleService-Info.plist che hai scaricato nel passaggio precedente nella cartella principale del tuo progetto Xcode e aggiungilo al target DatabaseExample (iOS) , assicurandoti che sia denominato GoogleService-Info.plist
8. Fai clic sui passaggi rimanenti del flusso di registrazione. Dato che il progetto di esempio è già impostato correttamente, non è necessario apportare alcuna modifica al codice.

Configura l'autenticazione Firebase

Uff! Finora è un bel po' di preparazione, ma tieniti forte! Se sei nuovo a Firebase, hai visto le parti essenziali di un flusso di lavoro con cui presto avrai familiarità.

Ora configurerai l'autenticazione Firebase per questa app.

Abilita provider di accesso tramite posta elettronica/password di autenticazione

1. Sempre nella console Firebase , apri la sezione Autenticazione della console.
2. Fai clic su Inizia per configurare l'autenticazione Firebase per il tuo progetto.
3. Seleziona la scheda Metodo di accesso .
4. Seleziona Email/Password nella sezione Provider nativi .
5. Abilita Email/Password e fai clic su Salva .

Aggiungi un utente di prova

1. Apri la scheda Utenti della sezione Autenticazione .
2. Fai clic su Aggiungi utente .
3. Specifica un indirizzo email e una password per l'utente di prova, quindi fai clic su Aggiungi utente .

Fai un giro con l'app

Torna a Xcode ed esegui l'applicazione sul simulatore iOS. Accedi con l'e-mail e la password dell'utente di prova appena creato. Una volta effettuato l'accesso, crea un post, pubblica un commento a un post esistente e aggiungi/rimuovi post da Speciali.

6. Configurare un provider di attestazione di attestazione dell'app

In questo passaggio configurerai App Check per utilizzare il provider App Attest nella console Firebase.

1. Nella console Firebase, vai alla sezione Controllo app della console.
2. Fare clic su Inizia .
3. Nella scheda App , fai clic sulla tua app per espanderne i dettagli.
4. Fai clic su Attestazione app per configurare Attestazione app, quindi inserisci l'ID team del tuo account sviluppatore Apple (puoi trovarlo nella sezione Iscrizione sul portale per sviluppatori Apple):
5. Fare clic su Salva .

Con questo, hai un progetto Firebase funzionante connesso alla nostra nuova app e App Check è abilitato.

Ora sei pronto per configurare il nostro servizio di attestazione specifico! Per ulteriori informazioni su questo flusso di lavoro, consulta Abilitare il controllo dell'app con l'attestazione dell'app su iOS .

7. Configura App Attest per la tua applicazione

Ora è il momento di mettere le mani sull'SDK di Firebase App Check e implementare del codice client.

Innanzitutto, devi configurare il progetto Xcode in modo che l'SDK possa utilizzare l'API App Attest di Apple per garantire che le richieste inviate dalla tua app provengano da istanze legittime della tua app.

1. Aggiungi la funzionalità di attestazione dell'app per la destinazione dell'app nel progetto Xcode:
2. apri la scheda Firma e funzionalità nelle impostazioni di destinazione dell'app
3. fare clic sul pulsante " + ".
4. nella finestra di dialogo, trova e seleziona Funzionalità di attestazione dell'app
5. Un file DatabaseExample (iOS).entitlements verrà visualizzato nella cartella principale del progetto Xcode dopo aver eseguito il passaggio precedente.
6. Nel file DatabaseExample (iOS).entitlements , modifica il valore della chiave App Attest Environment in production.

Importante: attualmente, Firebase App Check supporta il provider App Attest solo quando è in modalità di produzione . Per impostazione predefinita, quando esegui la tua app da Xcode, App Attest viene eseguito in modalità sandbox o sviluppo , quindi assicurati di completare i passaggi precedenti per cambiare la modalità App Attest; in caso contrario, Firebase App Check non riuscirà a eseguire l'attestazione del dispositivo.

Una volta completati questi passaggi e avviata l'app su un dispositivo iOS fisico (iPhone/iPad), l'app sarà comunque in grado di accedere al Realtime Database. In un passaggio successivo, applicherai App Check, che bloccherà le richieste inviate da app e dispositivi illegittimi.

Per ulteriori informazioni su questo flusso di lavoro, consulta Abilitare il controllo dell'app con l'attestazione dell'app su iOS .

8. Configurare un provider di attestazione di debug per il simulatore iOS

Il provider Firebase App Check Debug consente di testare le applicazioni con l'applicazione di Firebase App Check in ambienti non attendibili, incluso il simulatore iOS, durante il processo di sviluppo. Successivamente, è necessario configurare insieme il provider di debug.

Avviso : il provider di debug consente l'accesso alle risorse Firebase da dispositivi non verificati. Non dovresti mai usare il provider di debug nelle build di produzione della tua app. Fai anche attenzione a non perdere il token di debug.

Installa il provider di debug Firebase nella tua app

Opzione 1: crea in modo condizionale un'istanza del provider di debug nella tua fabbrica

La maggior parte di queste operazioni è stata eseguita quando è stato creato il factory del provider App Check. In questo passaggio, aggiungerai la registrazione del segreto di debug locale generato dal provider di debug, in modo da poter registrare questa istanza dell'app nella console Firebase per scopi di debug.

Aggiorna MyAppCheckProviderFactory.swift con il seguente codice:

import Firebase

class MyAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
  func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
#if targetEnvironment(simulator)
    // App Attest is not available on simulators.
    // Use a debug provider.
    let provider = AppCheckDebugProvider(app: app)

    // Print only locally generated token to avoid a valid token leak on CI.
    print("Firebase App Check debug token: \(provider?.localDebugToken() ?? "" )")

    return provider
#else
    // Use App Attest provider on real devices.
    return AppAttestProvider(app: app)
#endif
  }
}

Questo approccio ci offre maggiore flessibilità per la configurazione di App Check in base all'ambiente. Ad esempio, puoi utilizzare altri provider di attestazioni come DeviceCheck o un provider di attestazioni personalizzato sulle versioni del sistema operativo in cui App Attest non è disponibile. Vedi un esempio qui sotto:

import Firebase

class MyAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
  func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
      #if targetEnvironment(simulator)
      // App Attest is not available on simulators.
      // Use a debug provider.
      let provider = AppCheckDebugProvider(app: app)

      // Print only locally generated token to avoid a valid token leak on CI.
      print("Firebase App Check debug token: \(provider?.localDebugToken() ?? "" )")

      return provider
      #else
      if #available(iOS 14.0, *) {
        // Use App Attest provider on real devices.
        return AppAttestProvider(app: app)
      } else {
        return DeviceCheckProvider(app: app)
      }
      #endif
  }
}

Opzione 2: installa AppCheckDebugProviderFactory

Per i casi più semplici, puoi installare temporaneamente o in modo condizionale AppCheckDebugProviderFactory prima di configurare l'istanza dell'applicazione Firebase:

init() {
#if targetEnvironment(simulator)
  let providerFactory = AppCheckDebugProviderFactory()
#else
  let providerFactory = MyAppCheckProviderFactory()
#endif

  AppCheck.setAppCheckProviderFactory(providerFactory)

  FirebaseApp.configure()
}

Ciò ti farà risparmiare un paio di righe di codice sulla creazione del tuo factory provider App Check.

Registra il tuo segreto di debug nella console Firebase

Ottieni il segreto di debug dal tuo simulatore iOS

1. Se hai scelto di installare AppCheckDebugProviderFactory (opzione 2 sopra), devi abilitare la registrazione di debug per la tua app aggiungendo -FIRDebugEnabled agli argomenti di avvio dell'app:
2. Esegui la tua app su un simulatore
3. Trova il segreto di debug nella console Xcode. Puoi utilizzare il filtro della console per trovarlo più velocemente:

Nota: il segreto di debug viene generato per il tuo simulatore al primo avvio dell'app e viene archiviato nelle impostazioni predefinite dell'utente. Se rimuovi l'app, reimposti il ​​simulatore o utilizzi un altro simulatore, verrà generato un nuovo segreto di debug. Assicurati di registrare il nuovo segreto di debug.

Registra il segreto di debug

1. Tornando alla console Firevbase, vai alla sezione Controllo app .
2. Nella scheda App , fai clic sulla tua app per espanderne i dettagli.
3. Nel menu extra, seleziona Gestisci token di debug :
4. Aggiungi il segreto che hai copiato dalla console Xcode, quindi fai clic su Salva

Dopo questi passaggi, puoi utilizzare l'app sul simulatore anche con il controllo dell'app applicato.

Nota: il provider di debug è stato progettato specificamente per impedire la fuga dei segreti di debug. Con l'approccio attuale non è necessario archiviare il segreto di debug nel codice sorgente.

Ulteriori dettagli su questo flusso sono disponibili nella documentazione: vedere Utilizzare App Check con il provider di debug su iOS .

9. Abilita l'applicazione di App Check per Firebase Realtime Database

Per ora, la nostra app dichiara un AppCheckProviderFactory che restituisce un AppAttestProvider per i dispositivi reali. Quando viene eseguita su un dispositivo fisico, la tua app eseguirà l'attestazione e invierà i risultati al backend Firebase. Tuttavia, il backend Firebase accetta ancora richieste da qualsiasi dispositivo, dal simulatore iOS, da uno script, ecc. Questa modalità è utile quando hai ancora utenti con una vecchia versione della tua app senza App Check e non vuoi imporre l'accesso controlli ancora.

Ora devi abilitare l'applicazione di App Check per garantire che sia possibile accedere all'app Firebase solo da dispositivi legittimi. Le vecchie versioni dell'app senza integrazione di App Check smetteranno di funzionare una volta abilitata l'applicazione per il progetto Firebase.

Attenzione: per un'applicazione live con utenti esistenti, non abilitare l'imposizione a meno che non si abbia la certezza che gli utenti abbiano eseguito la migrazione alla nuova versione dell'app in grado di superare l'attestazione App Check. Tutti gli utenti reali che utilizzano la tua vecchia app senza App Check integrato perderanno l'accesso a Realtime Database anche se lo utilizzano da dispositivi legittimi.

Per rendere la transizione agevole per i tuoi utenti, in genere devi rilasciare in anticipo la tua app integrata con App Check e mantenere il progetto Firebase non applicato per un po'. I parametri delle richieste App Check disponibili nella console Firebase possono aiutarti a decidere quando è il momento giusto per abilitare l'applicazione.

1. Nella console Firebase, nella sezione App Check , fai clic su Realtime Database per espanderne i dettagli.
2. Fare clic su Applica .

3. Leggere le informazioni nella finestra di dialogo di conferma, quindi fare clic su Applica .

Dopo aver completato questi passaggi, solo le app legittime potranno accedere al database. Tutte le altre app verranno bloccate.

Prova ad accedere al Realtime Database con un'app illegittima

Per vedere l'applicazione di App Check in azione, procedi nel seguente modo:

1. Disattiva la registrazione di App Check commentando il codice di registrazione di App Check nel metodo init del punto di ingresso dell'app in DatabaseExampleApp .
2. Ripristina il simulatore selezionando Dispositivo > Cancella tutto il contenuto e le impostazioni . Ciò cancellerà il simulatore (e invaliderà il token del dispositivo).
3. Esegui nuovamente l'app sul simulatore.
4. Ora dovresti vedere il seguente messaggio di errore:

   [FirebaseDatabase][I-RDB034005] Firebase Database connection was forcefully killed by the server.  Will not attempt reconnect. Reason: Invalid appcheck token.
   

Per riattivare App Check, procedi come segue:

1. Rimuovere il commento dal codice di registrazione di App Check in DatabaseExampleApp .
2. Riavvia l'app.
3. Prendi nota del nuovo token App Check nella console di Xcode.
4. Registra il token di debug nelle impostazioni App Check della tua app nella console Firebase.
5. Esegui nuovamente l'app.
6. Non dovresti più visualizzare un messaggio di errore e dovresti essere in grado di aggiungere nuovi post e commenti nell'app.

10. Congratulazioni!

Ora sai come:

• Aggiungi App Check a un progetto esistente
• Configura un provider di attestazioni di attestazione dell'app per la versione di produzione della tua app
• Configura un provider di attestazioni di debug per testare la tua app su un simulatore
• Osserva l'implementazione della versione dell'app per sapere quando applicare App Check per il tuo progetto Firebase
• Abilita l'applicazione di App Check

Prossimi passi

Scopri come utilizzare Remote Config per implementare gradualmente App Check per i tuoi utenti nel Implementa gradualmente Firebase App Check utilizzando il codelab Firebase Remote Config

Queste sono altre risorse che potresti trovare utili

La configurazione descritta in questo codelab funzionerà nella maggior parte dei casi, ma App Check ti consente maggiore flessibilità se necessario: controlla i seguenti collegamenti per maggiori dettagli:

• Avvio rapido di Firebase per il repository iOS
• Abilita il controllo dell'app con l'attestazione dell'app su iOS
• App Firebase Controlla la documentazione di Firebase
• Stabilire l'integrità della tua app
• Registra un ID app
• Abilita le funzionalità dell'app