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 di 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 mantenere le tue risorse al sicuro.

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 fornitori di attestazione . 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 database in tempo reale 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 attestazione 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 (ulteriori informazioni sulla disponibilità dell'API App Attest )

2. Ottieni il progetto iniziale

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

Clonare 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 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. Aprire 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. Crea e installa la fabbrica del provider di 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. Quindi, 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:

  • Configura un progetto Firebase.
  • Aggiungi la tua app iOS al progetto Firebase.
  • Configura l'autenticazione Firebase.
  • Inizializza l'istanza del database in tempo reale 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 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 del database in tempo reale 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 di progetto.
  2. Seleziona la destinazione DatabaseExample (iOS) e apri la scheda Firma e funzionalità .
  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 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 mostra "Provisioning Profile: Xcode Managed Profile" e una piccola icona di informazioni accanto a questa etichetta. Facendo clic su questa icona verranno visualizzati ulteriori dettagli sul profilo di fornitura.

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 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, ad esempio 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 chiamato GoogleService-Info.plist . Elimina prima questo file: nel passaggio successivo lo sostituirai con quello per il tuo progetto Firebase.
  7. Copia il file GoogleService-Info.plist che hai scaricato nel passaggio precedente nella cartella principale del tuo progetto Xcode e aggiungilo alla destinazione DatabaseExample (iOS) , assicurandoti che si chiami 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! Finora è un po' di configurazione, ma tieni duro! Se non conosci Firebase, hai visto le parti essenziali di un flusso di lavoro che conoscerai presto.

Ora configurerai l'autenticazione Firebase per questa app.

Abilita provider di accesso tramite e-mail/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 e-mail/password e fai clic su Salva .

Aggiungi un utente di prova

  1. Apri la scheda Utenti della sezione Autenticazione .
  2. Fare clic su Aggiungi utente .
  3. Specifica un'e-mail 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 per l'utente di prova che hai appena creato. Una volta effettuato l'accesso, crea un post, pubblica un commento su un post esistente e contrassegna/annulla i post.

6. Configurare un provider di attestazione App Attest

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. Fare 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 Membership sul portale per sviluppatori Apple): 1645f7a369b678c2.png
  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. Configura App Attest per la tua applicazione

Ora è il momento di mettere le mani su Firebase App Check SDK 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à App Attest 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 Capacità di attestazione app ae84cd988a5fab31.png
  5. Un file DatabaseExample (iOS).entitlements apparirà nella cartella principale del tuo progetto Xcode dopo aver eseguito il passaggio precedente.
  6. Nel file DatabaseExample (iOS).entitlements modificare il valore della chiave App Attest Environment in production.

Una volta completati questi passaggi e avviato l'app su un dispositivo iOS fisico (iPhone/iPad), l'app sarà ancora 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 iOS Simulator, durante il processo di sviluppo. Successivamente, è necessario configurare insieme il provider di debug.

Installa il provider di debug Firebase nella tua app

Opzione 1: crea condizionalmente un'istanza del provider di debug nella tua fabbrica

Hai fatto la maggior parte di questo quando hai creato la fabbrica del provider 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 per scopi di debug.

Aggiorna MyAppCheckProviderFactory.swift con il codice seguente:

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 una 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. 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 condizionalmente 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 del provider 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 del debug per la tua app aggiungendo -FIRDebugEnabled agli argomenti di avvio dell'app: f1c6b477a373e144.png
  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: d4c65af93e369c55.png

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

Registra il segreto di debug

  1. Di nuovo nella console 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 : d77c8ff768a00b4b.png
  4. Aggiungi il segreto che hai copiato dalla console Xcode, quindi fai clic su Salva f845c97b86f694d0.png

Dopo questi passaggi, puoi utilizzare l'app sul Simulatore anche con App Check applicato.

Nota: il provider di debug è stato progettato specificamente per aiutare a prevenire le perdite del segreto di debug. Con l'approccio attuale, non è necessario archiviare il segreto di debug nel codice sorgente.

Maggiori 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 dispositivi reali. Quando è in esecuzione su un dispositivo fisico, l'app eseguirà l'attestazione e invierà i risultati al back-end di Firebase. Tuttavia, il backend Firebase accetta ancora richieste da qualsiasi dispositivo, il 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 imporre l'accesso controlli ancora.

Ora devi abilitare l' applicazione di App Check per assicurarti che l'app Firebase sia accessibile solo da dispositivi legittimi. Le versioni precedenti dell'app senza l'integrazione di App Check smetteranno di funzionare una volta abilitata l'applicazione per il progetto Firebase.

  1. Nella console Firebase nella sezione Controllo app , fai clic su Database in tempo reale per espanderne i dettagli.
  2. Fare clic su Applica .

64e6a81fa979b635.png

  1. 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. Reimposta il simulatore selezionando Dispositivo > Cancella tutto il contenuto e le impostazioni . Questo cancellerà il simulatore (e invaliderà il token del dispositivo).
  3. Esegui nuovamente l'app sul simulatore.
  4. Ora dovresti visualizzare 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. Decommentare il 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. Esegui nuovamente l'app.
  6. Non dovresti più vedere un messaggio di errore e dovresti essere in grado di aggiungere nuovi post e commenti nell'app.

10. Congratulazioni!

9785d32f18b995d2.gif

Ora sai come:

  • Aggiungi App Check a un progetto esistente
  • Configura un provider di attestazione App Attest 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 in Implementazione graduale di Firebase App Check utilizzando il codelab di 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: