Questa pagina è stata tradotta dall'API Cloud Translation.

Firebase App Check per le piattaforme Apple

1. Introduzione

Firebase App Check contribuisce a proteggere le tue risorse di backend da comportamenti illeciti, come fatturazione fraudolenta e phishing, assicurandosi che le richieste provengano da app e dispositivi legittimi. Funziona sia con i servizi Firebase sia con i tuoi servizi di backend per proteggere le tue risorse.

Puoi scoprire 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 attestazioni. Uno di questi fornitori è il servizio App Attest di Apple, che App Check può utilizzare per verificare l'autenticità di app e dispositivi Apple.

Cosa creerai

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 di app e dispositivi illegittimi.

Cosa imparerai a fare

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

Che cosa ti serve

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

2. Scarica 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.

Clona il repository delle guide rapide di Firebase per iOS dalla riga di comando:

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

Apri il progetto dell'app di avvio rapido SwiftUI di Realtime Database in Xcode:

cd database/DatabaseExampleSwiftUI/DatabaseExample
xed .

3. Aggiungere App Check alla tua app

Attendi che Swift Package Manager risolva le dipendenze del progetto.
Apri la scheda Generale della destinazione dell'app DatabaseExample (iOS). Poi, nella sezione Framework, librerie e contenuti incorporati, fai clic sul pulsante +.
Seleziona per aggiungere FirebaseAppCheck.

4. Crea e installa la factory del provider App Check

Nel gruppo di file Shared, aggiungi un nuovo gruppo denominato AppCheck.

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
  }
}

Successivamente, in DatabaseExampleApp.swift, assicurati di importare FirebaseAppCheck e imposta 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 per iOS al progetto Firebase.
Configura Firebase Authentication.
Inizializza l'istanza di Realtime Database che proteggerai.
Configura App Check.

Crea un progetto

Per prima cosa, devi creare un progetto Firebase.

Accedi alla console Firebase utilizzando il tuo Account Google.
Fai clic sul pulsante per creare un nuovo progetto, quindi inserisci un nome (ad esempio, App Check Codelab).
Fai clic su Continua.
Se richiesto, leggi e accetta i termini di Firebase, quindi fai clic su Continua.
(Facoltativo) Attiva l'assistenza AI nella console Firebase (denominata "Gemini in Firebase").
Per questo codelab non hai bisogno di Google Analytics, quindi disattiva l'opzione Google Analytics.
Fai clic su Crea progetto, attendi il provisioning del progetto, poi fai clic su Continua.

Crea un'istanza di Realtime Database

Ora vai alla sezione Realtime Database della console Firebase.

Fai clic sul pulsante Crea database per avviare il flusso di lavoro di creazione del database.
Lascia invariata la posizione predefinita (us-central1) per il database e fai clic su Avanti.
Assicurati che sia selezionata l'opzione Modalità bloccata e fai clic sul pulsante Attiva per attivare le regole di sicurezza per il tuo database.

Vai alla scheda Regole del browser Realtime Database e sostituisci 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"
                    }
                }
            }
        }
    }
}

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

Prepara la tua app per 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. Segui questi passaggi per aggiungere l'app di esempio al tuo account sviluppatore:

In Xcode, seleziona il progetto DatabaseExample nel navigatore del progetto.
Seleziona la destinazione DatabaseExample (iOS) e apri la scheda Firma e funzionalità.
Dovresti visualizzare un messaggio di errore che indica che "La firma per DatabaseExample (iOS) richiede un team di sviluppo".
Aggiorna l'identificatore bundle a un identificatore univoco. Il modo più semplice per farlo è utilizzare il nome di dominio inverso del tuo sito web, ad esempio com.acme.samples.firebase.quickstart.DatabaseExample (non utilizzare questo ID, scegli invece un ID univoco).
Seleziona il tuo team di sviluppo.
Saprai che tutto è andato bene quando Xcode visualizza "Provisioning Profile: Xcode Managed Profile" (Profilo di provisioning: profilo gestito da Xcode) e una piccola icona informativa accanto a questa etichetta. Se fai clic su questa icona, vengono visualizzati ulteriori dettagli sul profilo di provisioning.

Collegare l'app per iOS

Per una spiegazione dettagliata del collegamento dell'app, consulta la documentazione sull'aggiunta di Firebase al progetto iOS. Per iniziare, segui questi passaggi principali nella console Firebase:

Nella schermata Panoramica del progetto del nuovo progetto, fai clic sul pulsante + Aggiungi app e poi sull'icona iOS+ per aggiungere una nuova app per iOS al tuo progetto Firebase.
Inserisci l'ID pacchetto della tua app (utilizza quello definito nella sezione precedente, ad esempio com.acme.samples.firebase.quickstart.DatabaseExample. Tieni presente che questo deve essere un identificatore univoco).
Fai clic su Registra app.
Firebase genera un file GoogleService-Info.plist contenente tutti i metadati Firebase necessari per la tua app.
Fai clic su Scarica GoogleService-Info.plist per scaricare il file.
In Xcode, vedrai che il progetto contiene già un file denominato GoogleService-Info.plist. Elimina prima questo file, che verrà sostituito con quello del tuo progetto Firebase nel passaggio successivo.
Copia il file GoogleService-Info.plist che hai scaricato nel passaggio precedente nella cartella principale del progetto Xcode e aggiungilo al target DatabaseExample (iOS), assicurandoti che si chiami GoogleService-Info.plist
Fai clic sui passaggi rimanenti del flusso di registrazione. Poiché il progetto di esempio è già configurato correttamente, non devi apportare alcuna modifica al codice.

Configura Firebase Authentication

Finalmente. Finora la configurazione è stata piuttosto lunga, ma tieni duro. Se non hai mai utilizzato Firebase, hai visto le parti essenziali di un flusso di lavoro con cui presto avrai familiarità.

Ora configurerai Firebase Authentication per questa app.

Sempre nella console Firebase, apri la sezione Autenticazione.
Fai clic su Inizia per configurare Firebase Authentication per il tuo progetto.
Seleziona la scheda Metodo di accesso.
Seleziona Email/Password nella sezione Provider nativi.
Attiva Email/Password e fai clic su Salva.

Aggiungere un utente di test

Apri la scheda Utenti della sezione Autenticazione.
Fai clic su Add user (Aggiungi utente).
Specifica un indirizzo email e una password per l'utente di test, quindi fai clic su Aggiungi utente.

Prova l'app

Torna a Xcode ed esegui l'applicazione sul simulatore iOS. Accedi con l'email e la password dell'utente di test che hai appena creato. Una volta eseguito l'accesso, crea un post, pubblica un commento a un post esistente e aggiungi/rimuovi la stella dai post.

6. Configurare un fornitore di attestazioni App Attest

In questo passaggio, configurerai App Check in modo da utilizzare il provider App Attest nella console Firebase.

Nella console Firebase, vai alla sezione App Check.
Fai clic su Inizia.
Nella scheda App, fai clic sulla tua app per espandere i relativi dettagli.
Fai clic su App Attest per configurare App Attest, poi inserisci l'ID team del tuo account sviluppatore Apple (lo trovi nella sezione Abbonamento del portale per sviluppatori Apple):
Fai clic su Salva.

In questo modo, avrai un progetto Firebase funzionante collegato alla nuova app e App Check sarà abilitato.

Ora puoi configurare il nostro servizio di attestazione specifico. Per saperne di più su questo flusso di lavoro, vedi Abilitare App Check con App Attest su iOS.

7. Configurare App Attest per l'applicazione

Ora è il momento di utilizzare l'SDK Firebase App Check e implementare un po' di 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.

Aggiungi la funzionalità App Attest per il target dell'app nel progetto Xcode:
apri la scheda Firma e funzionalità nelle impostazioni di destinazione dell'app
fai clic sul pulsante "+".
Nella finestra di dialogo, trova e seleziona la funzionalità App Attest .
Dopo aver eseguito il passaggio precedente, nella cartella principale del progetto Xcode verrà visualizzato un file DatabaseExample (iOS).entitlements.
Nel file DatabaseExample (iOS).entitlements, modifica il valore della chiave App Attest Environment in production.

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

Per scoprire di più su questo flusso di lavoro, consulta Attivare App Check con App Attest su iOS.

8. Configura un fornitore di attestazione di debug per il simulatore iOS

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

Installa il fornitore di debug Firebase nella tua app

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

Hai eseguito la maggior parte di questa operazione quando hai creato la factory del fornitore App Check. In questo passaggio, aggiungerai la registrazione del secret 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 sulle versioni del sistema operativo in cui App Attest non è disponibile. Vedi 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: 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()
}

In questo modo, risparmierai un paio di righe di codice durante la creazione della tua fabbrica di provider App Check.

Registra il segreto di debug nella console Firebase

Recuperare il secret di debug dal simulatore iOS

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

Nota:il segreto di debug viene generato per il simulatore al primo avvio dell'app e viene memorizzato 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 secret di debug.

Registra il segreto di debug

Nella console Firebase, vai alla sezione App Check.
Nella scheda App, fai clic sulla tua app per espandere i relativi dettagli.
Nel menu extra, seleziona Gestisci token di debug:
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 fornitore di debug è stato progettato appositamente per contribuire a prevenire le fughe di segreti di debug. Con l'approccio attuale, non è necessario memorizzare il secret di debug nel codice sorgente.

Per ulteriori dettagli su questo flusso, consulta la documentazione: vedi Utilizzare App Check con il provider di debug su iOS.

9. Abilitare l'applicazione forzata 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, l'app esegue l'attestazione e invia i risultati al backend Firebase. Tuttavia, il backend Firebase continua ad accettare richieste da qualsiasi dispositivo, dal simulatore iOS, da uno script e così via. Questa modalità è utile quando hai ancora utenti con una vecchia versione della tua app senza App Check e non vuoi ancora applicare i controlli di accesso.

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

Nella sezione App Check della console Firebase, fai clic su Realtime Database per espandere i dettagli.
Fai clic su Applica.

Leggi le informazioni nella finestra di dialogo di conferma, quindi fai clic su Applica.

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

Tentativo di accesso a Realtime Database con un'app illegittima

Per vedere l'applicazione di App Check in azione, segui questi passaggi:

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.
Reimposta il simulatore selezionando Dispositivo > Inizializza contenuto e impostazioni. In questo modo il simulatore verrà cancellato e il token del dispositivo non sarà più valido.
Esegui di nuovo l'app sul simulatore.

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:

Rimuovi il commento dal codice di registrazione di App Check in DatabaseExampleApp.
Riavvia l'app.
Prendi nota del nuovo token App Check nella console di Xcode.
Registra il token di debug nelle impostazioni di App Check dell'app nella console Firebase.
Esegui di nuovo l'app.
Non dovresti più visualizzare un messaggio di errore e dovresti essere in grado di aggiungere nuovi post e commenti nell'app.

10. Complimenti!

Ora sai come:

Aggiungere App Check a un progetto esistente
Configurare un fornitore di attestazione App Attest per la versione di produzione dell'app
Configurare un fornitore di attestazione di debug per testare l'app su un simulatore
Osserva l'implementazione della versione dell'app per sapere quando applicare App Check per il tuo progetto Firebase
Abilitare l'applicazione di App Check

Passaggi successivi

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

Ecco altre risorse che potrebbero esserti utili

La configurazione descritta in questo codelab funziona nella maggior parte dei casi, ma App Check ti offre maggiore flessibilità, se necessario. Per maggiori dettagli, consulta i seguenti link: