App Firebase Verifica la presenza di piattaforme Apple

1. Introduzione

Firebase App Check aiuta a proteggere le tue risorse di back-end da abusi, come frodi sulla fatturazione e phishing, assicurandoti che le richieste provengano da app e dispositivi legittimi. Funziona sia con i servizi Firebase che con i tuoi servizi di back-end per proteggere le tue risorse.

Puoi saperne di più 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 attestazione . Uno di questi provider è 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 database in tempo reale del progetto sia protetto dall'accesso di app e dispositivi illegittimi.

Cosa imparerai

• Come aggiungere Firebase App Check a un'app esistente.
• Come installare diversi provider di attestazione di Firebase App Check.
• Come configurare App Attest per la tua app.
• Come configurare il provider di attestazione di debug per testare l'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 (informazioni 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 di 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 Quickstart per iOS dalla riga di comando:

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

Apri il progetto dell'app SwiftUI Quickstart di 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 di file Shared , aggiungi 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 alla destinazione 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 imposta un'istanza della classe MyAppCheckProviderFactory come factory del provider di 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:

• Imposta 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 App Check.

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. Disabilita Google Analytics per questo progetto, quindi fai clic su Crea progetto.

Crea un'istanza di database in tempo reale

Ora vai alla sezione Database in tempo reale della console Firebase.

1. Fare clic sul pulsante Crea database per avviare il flusso di lavoro di creazione del database.
2. Lascia invariata la posizione predefinita ( us-central1 ) per il database e fai clic su Avanti .
3. Assicurati che la modalità bloccata sia selezionata 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 essere connessa 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 di progetto.
2. Selezionare la destinazione DatabaseExample (iOS) e aprire la scheda Signing & Capabilities .
3. Dovresti visualizzare un messaggio di errore che dice "La firma per DatabaseExample (iOS) richiede un team di sviluppo" .
4. Aggiorna l' identificatore del pacchetto a un identificatore univoco. Il modo più semplice per raggiungere questo obiettivo è 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 "Provisioning Profile: Xcode Managed Profile" e una piccola icona informativa accanto a questa etichetta. Facendo clic su questa icona verranno visualizzati ulteriori dettagli sul profilo di provisioning.

Importante: se non fornisci un identificatore univoco del pacchetto, il tuo progetto non verrà registrato nel portale per sviluppatori Apple. Solo le app registrate possono essere eseguite su un dispositivo fisico.

Collega la tua app iOS

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

1. Dalla schermata Panoramica del 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, ad esempio com.acme.samples.firebase.quickstart.DatabaseExample - tieni presente che deve essere un identificatore univoco)
3. Fai 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. Poiché il progetto di esempio è già impostato correttamente, non è necessario apportare modifiche al codice.

Configura l'autenticazione Firebase

Uff! Questo è un bel po 'di configurazione finora, ma tieniti forte! Se non conosci Firebase, hai visto parti essenziali di un flusso di lavoro con cui presto avrai familiarità.

Ora configurerai l'autenticazione Firebase per questa app.

Abilita autenticazione Email/password Provider di accesso

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 che hai appena creato. Una volta effettuato l'accesso, crea un post, pubblica un commento a un post esistente e contrassegna/annulla i post.

6. Configurare un provider di attestazione dell'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 App Check della console.
2. Fai clic su Inizia .
3. Nella scheda App , fai clic sulla tua app per espanderne i dettagli.
4. Fai clic su App Attest per configurare App Attest, quindi inserisci l'ID team del tuo account sviluppatore Apple (puoi trovarlo nella sezione Iscrizione sul portale Apple Developer):
5. Fare clic su Salva .

Con questo, hai un progetto Firebase funzionante che è 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 App Check con App Attest su iOS .

7. Configurare App Attest per la tua applicazione

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

Innanzitutto, devi configurare il progetto Xcode in modo che l'SDK possa usare 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 la 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 per la chiave App Attest Environment in production.

Importante: attualmente, Firebase App Check supporta solo il provider App Attest quando è in modalità di produzione . Per impostazione predefinita, quando esegui la tua app da Xcode, App Attest è in esecuzione in modalità sandbox o sviluppo , quindi assicurati di completare i passaggi precedenti per passare alla 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 database in tempo reale. 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 App Check con App Attest 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 tue 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 far trapelare il tuo 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 factory

Hai fatto la maggior parte di questo quando hai creato la factory del fornitore di 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 a scopo 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 a seconda dell'ambiente. Ad esempio, puoi utilizzare altri provider di attestazione come DeviceCheck o un provider di attestazione personalizzato nelle versioni del sistema operativo in cui App Attest non è disponibile. Vedere un esempio di seguito:

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: installare AppCheckDebugProviderFactory

Per i casi più semplici è possibile 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 della tua fabbrica di fornitori di App Check.

Registra il tuo segreto di debug nella console di 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 di Firevbase, vai alla sezione App Check .
2. Nella scheda App , fai clic sulla tua app per espanderne i dettagli.
3. Nel menu di overflow, 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 App Check applicato.

Nota: il provider di debug è stato specificamente progettato per aiutare a prevenire le fughe di 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 Usare 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 è in esecuzione su un dispositivo fisico, la tua app eseguirà l'attestazione e invierà i risultati al back-end Firebase. Tuttavia, il backend di Firebase accetta ancora richieste da qualsiasi dispositivo, simulatore iOS, uno script, ecc. Questa modalità è utile quando hai ancora utenti con una vecchia versione della tua app senza App Check e non vuoi forzare l'accesso controlli ancora.

Ora devi abilitare l'applicazione di App Check per assicurarti che sia possibile accedere all'app Firebase solo da dispositivi legittimi. Le vecchie versioni dell'app senza l'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 dovresti abilitare l'applicazione a meno che tu non sia sicuro che gli utenti abbiano eseguito la migrazione alla nuova versione dell'app che può 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 facilitare la transizione per i tuoi utenti, di solito devi rilasciare in anticipo la tua app integrata con App Check e mantenere il progetto Firebase non applicato per un po'. Le metriche della richiesta di 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 espandere i suoi 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 database in tempo reale 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 . Questo cancellerà il simulatore (e invaliderà il token del dispositivo).
3. Eseguire nuovamente l'app sul simulatore.
4. Ora dovrebbe essere visualizzato 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 di App Check della tua app nella console Firebase.
5. Riavvia 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 attestazione dell'attestazione dell'app per la versione di produzione della tua app
• Configura un provider di attestazione 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 codelab Implementazione graduale di Firebase App Check utilizzando Firebase Remote Config

Queste sono altre risorse che potresti trovare utili

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

• Quickstart di Firebase per il repository iOS
• Abilita App Check con App Attest su iOS
• App Firebase Consulta la documentazione di Firebase
• Stabilire l'integrità della tua app
• Registra un ID app
• Abilita le funzionalità dell'app