Esegui l'autenticazione con Apple

Puoi consentire agli utenti di autenticarsi con Firebase utilizzando il proprio ID Apple utilizzando l'SDK Firebase per eseguire il flusso di accesso OAuth 2.0 end-to-end.

Importante: per accedere con un account Apple, gli utenti devono:

• Avere un ID Apple con l'autenticazione a due fattori (2FA) attivata.
• Aver eseguito l'accesso a iCloud su un dispositivo Apple.

Consulta Come utilizzare Accedi con Apple. Per testare l'integrazione con Accedi con Apple, devi soddisfare anche questi requisiti.

Prima di iniziare

Per consentire agli utenti di accedere utilizzando Apple, configura innanzitutto l'accesso con Apple sul sito per sviluppatori di Apple, quindi attiva Apple come provider di accesso per il tuo progetto Firebase.

Partecipa all'Apple Developer Program

L'accesso con Apple può essere configurato solo dai membri dell'Apple Developer Program.

Configurare Accedi con Apple

1. Attiva l'accesso con Apple per la tua app nella pagina Certificati, identificatori e profili del sito per sviluppatori di Apple.
2. Associa il tuo sito web alla tua app come descritto nella prima sezione di Configurare Accedi con Apple per il web. Quando richiesto, registra il seguente URL come URL di ritorno:

   https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler

   Puoi trovare l'ID progetto Firebase nella pagina delle impostazioni della console Firebase. Al termine, annota il nuovo ID servizio, che ti servirà nella sezione successiva.
3. Crea una chiave privata Accedi con Apple. Nella sezione successiva ti serviranno la nuova chiave privata e l'ID chiave.
4. Se utilizzi una delle funzionalità di Firebase Authentication che inviano email agli utenti, tra cui l'accesso tramite link email, la verifica dell'indirizzo email, la revoca della modifica dell'account e altre, configura il servizio di inoltro email privato di Apple e registra noreply@YOUR_FIREBASE_PROJECT_ID.firebaseapp.com (o il dominio del modello di email personalizzato) in modo che Apple possa inoltrare le email inviate da Firebase Authentication a indirizzi email Apple anonimizzati.

Attivare Apple come provider di accesso

1. Aggiungi Firebase al tuo progetto Apple. Assicurati di registrare l'ID bundle della tua app quando la configuri nella console Firebase.
2. Nella Firebaseconsole, apri la sezione Auth. Nella scheda Metodo di accesso, attiva il provider Apple. Specifica l'ID servizio che hai creato nella sezione precedente. Inoltre, nella sezione di configurazione del flusso di codice OAuth, specifica l'ID team Apple e la chiave privata e l'ID chiave che hai creato nella sezione precedente.

Rispetta i requisiti relativi ai dati anonimizzati di Apple

Accedi con Apple offre agli utenti la possibilità di anonimizzare i propri dati, incluso l'indirizzo email, al momento dell'accesso. Gli utenti che scelgono questa opzione hanno indirizzi email con il dominio privaterelay.appleid.com. Quando utilizzi Accedi con Apple nella tua app, devi rispettare le norme o i termini per gli sviluppatori applicabili di Apple in merito a questi ID Apple anonimizzati.

Ciò include l'ottenimento del consenso dell'utente richiesto prima di associare informazioni personali che consentono l'identificazione diretta a un ID Apple anonimizzato. Quando utilizzi Firebase Authentication, potrebbero essere incluse le seguenti azioni:

• Collegare un indirizzo email a un ID Apple anonimo o viceversa.
• Collegare un numero di telefono a un Apple ID anonimizzato o viceversa
• Collegare una credenziale social non anonima (Facebook, Google e così via) a un Apple ID anonimizzato o viceversa.

L'elenco riportato sopra non è esaustivo. Consulta il Contratto di licenza del programma per sviluppatori Apple nella sezione Abbonamento del tuo account sviluppatore per assicurarti che la tua app soddisfi i requisiti di Apple.

Accedere con Apple ed eseguire l'autenticazione con Firebase

Per eseguire l'autenticazione con un account Apple, accedi prima all'account Apple dell'utente utilizzando il framework AuthenticationServices di Apple e poi utilizza il token ID della risposta di Apple per creare un oggetto AuthCredential Firebase:

1. Per ogni richiesta di accesso, genera una stringa casuale, un "nonce", che utilizzerai per assicurarti che il token ID che ricevi sia stato concesso specificamente in risposta alla richiesta di autenticazione della tua app. Questo passaggio è importante per prevenire gli attacchi di replay.

   Puoi generare un nonce sicuro dal punto di vista crittografico con SecRandomCopyBytes(_:_:_), come nel seguente esempio:

   Swift

   private func randomNonceString(length: Int = 32) -> String {
     precondition(length > 0)
     var randomBytes = [UInt8](repeating: 0, count: length)
     let errorCode = SecRandomCopyBytes(kSecRandomDefault, randomBytes.count, &randomBytes)
     if errorCode != errSecSuccess {
       fatalError(
         "Unable to generate nonce. SecRandomCopyBytes failed with OSStatus \(errorCode)"
       )
     }
   
     let charset: [Character] =
       Array("0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._")
   
     let nonce = randomBytes.map { byte in
       // Pick a random character from the set, wrapping around if needed.
       charset[Int(byte) % charset.count]
     }
   
     return String(nonce)
   }
   
       

   Objective-C

   // Adapted from https://auth0.com/docs/api-auth/tutorials/nonce#generate-a-cryptographically-random-nonce
   - (NSString *)randomNonce:(NSInteger)length {
     NSAssert(length > 0, @"Expected nonce to have positive length");
     NSString *characterSet = @"0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._";
     NSMutableString *result = [NSMutableString string];
     NSInteger remainingLength = length;
   
     while (remainingLength > 0) {
       NSMutableArray *randoms = [NSMutableArray arrayWithCapacity:16];
       for (NSInteger i = 0; i < 16; i++) {
         uint8_t random = 0;
         int errorCode = SecRandomCopyBytes(kSecRandomDefault, 1, &random);
         NSAssert(errorCode == errSecSuccess, @"Unable to generate nonce: OSStatus %i", errorCode);
   
         [randoms addObject:@(random)];
       }
   
       for (NSNumber *random in randoms) {
         if (remainingLength == 0) {
           break;
         }
   
         if (random.unsignedIntValue < characterSet.length) {
           unichar character = [characterSet characterAtIndex:random.unsignedIntValue];
           [result appendFormat:@"%C", character];
           remainingLength--;
         }
       }
     }
   
     return [result copy];
   }
       

   Invii l'hash SHA256 del nonce con la richiesta di accesso, che Apple trasmetterà invariato nella risposta. Firebase convalida la risposta calcolando l'hash del nonce originale e confrontandolo con il valore trasmesso da Apple.

   Swift

   @available(iOS 13, *)
   private func sha256(_ input: String) -> String {
     let inputData = Data(input.utf8)
     let hashedData = SHA256.hash(data: inputData)
     let hashString = hashedData.compactMap {
       String(format: "%02x", $0)
     }.joined()
   
     return hashString
   }
   
       

   Objective-C

   - (NSString *)stringBySha256HashingString:(NSString *)input {
     const char *string = [input UTF8String];
     unsigned char result[CC_SHA256_DIGEST_LENGTH];
     CC_SHA256(string, (CC_LONG)strlen(string), result);
   
     NSMutableString *hashed = [NSMutableString stringWithCapacity:CC_SHA256_DIGEST_LENGTH * 2];
     for (NSInteger i = 0; i < CC_SHA256_DIGEST_LENGTH; i++) {
       [hashed appendFormat:@"%02x", result[i]];
     }
     return hashed;
   }
       

2. Avvia il flusso di accesso di Apple, includendo nella richiesta l'hash SHA256 del nonce e la classe delegata che gestirà la risposta di Apple (vedi il passaggio successivo):

   Swift

   import CryptoKit
   
   // Unhashed nonce.
   fileprivate var currentNonce: String?
   
   @available(iOS 13, *)
   func startSignInWithAppleFlow() {
     let nonce = randomNonceString()
     currentNonce = nonce
     let appleIDProvider = ASAuthorizationAppleIDProvider()
     let request = appleIDProvider.createRequest()
     request.requestedScopes = [.fullName, .email]
     request.nonce = sha256(nonce)
   
     let authorizationController = ASAuthorizationController(authorizationRequests: [request])
     authorizationController.delegate = self
     authorizationController.presentationContextProvider = self
     authorizationController.performRequests()
   }
   

   Objective-C

   @import CommonCrypto;
   
   - (void)startSignInWithAppleFlow {
     NSString *nonce = [self randomNonce:32];
     self.currentNonce = nonce;
     ASAuthorizationAppleIDProvider *appleIDProvider = [[ASAuthorizationAppleIDProvider alloc] init];
     ASAuthorizationAppleIDRequest *request = [appleIDProvider createRequest];
     request.requestedScopes = @[ASAuthorizationScopeFullName, ASAuthorizationScopeEmail];
     request.nonce = [self stringBySha256HashingString:nonce];
   
     ASAuthorizationController *authorizationController =
         [[ASAuthorizationController alloc] initWithAuthorizationRequests:@[request]];
     authorizationController.delegate = self;
     authorizationController.presentationContextProvider = self;
     [authorizationController performRequests];
   }
   

3. Gestisci la risposta di Apple nell'implementazione di ASAuthorizationControllerDelegate. Se l'accesso è andato a buon fine, utilizza il token ID dalla risposta di Apple con il nonce non sottoposto ad hashing per l'autenticazione con Firebase:

   Swift

   @available(iOS 13.0, *)
   extension MainViewController: ASAuthorizationControllerDelegate {
   
     func authorizationController(controller: ASAuthorizationController, didCompleteWithAuthorization authorization: ASAuthorization) {
       if let appleIDCredential = authorization.credential as? ASAuthorizationAppleIDCredential {
         guard let nonce = currentNonce else {
           fatalError("Invalid state: A login callback was received, but no login request was sent.")
         }
         guard let appleIDToken = appleIDCredential.identityToken else {
           print("Unable to fetch identity token")
           return
         }
         guard let idTokenString = String(data: appleIDToken, encoding: .utf8) else {
           print("Unable to serialize token string from data: \(appleIDToken.debugDescription)")
           return
         }
         // Initialize a Firebase credential, including the user's full name.
         let credential = OAuthProvider.appleCredential(withIDToken: idTokenString,
                                                           rawNonce: nonce,
                                                           fullName: appleIDCredential.fullName)
         // Sign in with Firebase.
         Auth.auth().signIn(with: credential) { (authResult, error) in
           if error {
             // Error. If error.code == .MissingOrInvalidNonce, make sure
             // you're sending the SHA256-hashed nonce as a hex string with
             // your request to Apple.
             print(error.localizedDescription)
             return
           }
           // User is signed in to Firebase with Apple.
           // ...
         }
       }
     }
   
     func authorizationController(controller: ASAuthorizationController, didCompleteWithError error: Error) {
       // Handle error.
       print("Sign in with Apple errored: \(error)")
     }
   
   }
   

   Objective-C

   - (void)authorizationController:(ASAuthorizationController *)controller
      didCompleteWithAuthorization:(ASAuthorization *)authorization API_AVAILABLE(ios(13.0)) {
     if ([authorization.credential isKindOfClass:[ASAuthorizationAppleIDCredential class]]) {
       ASAuthorizationAppleIDCredential *appleIDCredential = authorization.credential;
       NSString *rawNonce = self.currentNonce;
       NSAssert(rawNonce != nil, @"Invalid state: A login callback was received, but no login request was sent.");
   
       if (appleIDCredential.identityToken == nil) {
         NSLog(@"Unable to fetch identity token.");
         return;
       }
   
       NSString *idToken = [[NSString alloc] initWithData:appleIDCredential.identityToken
                                                 encoding:NSUTF8StringEncoding];
       if (idToken == nil) {
         NSLog(@"Unable to serialize id token from data: %@", appleIDCredential.identityToken);
       }
   
       // Initialize a Firebase credential, including the user's full name.
       FIROAuthCredential *credential = [FIROAuthProvider appleCredentialWithIDToken:IDToken
                                                                            rawNonce:self.appleRawNonce
                                                                            fullName:appleIDCredential.fullName];
   
       // Sign in with Firebase.
       [[FIRAuth auth] signInWithCredential:credential
                                 completion:^(FIRAuthDataResult * _Nullable authResult,
                                              NSError * _Nullable error) {
         if (error != nil) {
           // Error. If error.code == FIRAuthErrorCodeMissingOrInvalidNonce,
           // make sure you're sending the SHA256-hashed nonce as a hex string
           // with your request to Apple.
           return;
         }
         // Sign-in succeeded!
       }];
     }
   }
   
   - (void)authorizationController:(ASAuthorizationController *)controller
              didCompleteWithError:(NSError *)error API_AVAILABLE(ios(13.0)) {
     NSLog(@"Sign in with Apple errored: %@", error);
   }
   

A differenza di altri provider supportati da Firebase Auth, Apple non fornisce un URL della foto.

Inoltre, quando l'utente sceglie di non condividere la propria email con l'app, Apple fornisce un indirizzo email univoco per l'utente (nel formato [e-mail]), che condivide con la tua app. Se hai configurato il servizio di inoltro email privato, Apple inoltra le email inviate all'indirizzo anonimizzato all'indirizzo email reale dell'utente.

Importante :Apple condivide le informazioni dell'utente, ad esempio il nome visualizzato, con le app solo al primo accesso. Utilizza OAuthProvider.appleCredential(withIDToken:rawNonce:fullName:) per assicurarti che Firebase memorizzi il nome visualizzato al primo accesso di un utente con Apple. Puoi recuperare il nome completo dell'utente in un secondo momento con Auth.auth().currentUser.displayName. Tuttavia, se in precedenza hai utilizzato Apple per consentire a un utente di accedere all'app senza utilizzare Firebase, Apple non fornirà a Firebase il nome visualizzato dell'utente.

Riautenticazione e collegamento dell'account

Lo stesso pattern può essere utilizzato con reauthenticateWithCredential(), che puoi utilizzare per recuperare una nuova credenziale per le operazioni sensibili che richiedono un accesso recente:

Swift

// Initialize a fresh Apple credential with Firebase.
let credential = OAuthProvider.credential(
  withProviderID: "apple.com",
  IDToken: appleIdToken,
  rawNonce: rawNonce
)
// Reauthenticate current Apple user with fresh Apple credential.
Auth.auth().currentUser.reauthenticate(with: credential) { (authResult, error) in
  guard error != nil else { return }
  // Apple user successfully re-authenticated.
  // ...
}

Objective-C

FIRAuthCredential *credential = [FIROAuthProvider credentialWithProviderID:@"apple.com",
                                                                   IDToken:appleIdToken,
                                                                  rawNonce:rawNonce];
[[FIRAuth auth].currentUser
    reauthenticateWithCredential:credential
                      completion:^(FIRAuthDataResult * _Nullable authResult,
                                   NSError * _Nullable error) {
  if (error) {
    // Handle error.
  }
  // Apple user successfully re-authenticated.
  // ...
}];

Inoltre, puoi utilizzare linkWithCredential() per collegare diversi provider di identità a account esistenti.

Tieni presente che Apple ti impone di ottenere il consenso esplicito degli utenti prima di collegare i loro account Apple ad altri dati.

L'accesso con Apple non ti consentirà di riutilizzare una credenziale di autenticazione per collegarla a un account esistente. Se vuoi collegare una credenziale Accedi con Apple a un altro account, devi prima tentare di collegare gli account utilizzando la vecchia credenziale Accedi con Apple ed esaminare l'errore restituito per trovare una nuova credenziale. La nuova credenziale si troverà nel dizionario userInfo dell'errore e sarà accessibile tramite la chiave AuthErrorUserInfoUpdatedCredentialKey.

Ad esempio, per collegare un account Facebook all'account Firebase corrente, utilizza il token di accesso ottenuto dall'accesso dell'utente a Facebook:

Swift

// Initialize a Facebook credential with Firebase.
let credential = FacebookAuthProvider.credential(
  withAccessToken: AccessToken.current!.tokenString
)
// Assuming the current user is an Apple user linking a Facebook provider.
Auth.auth().currentUser.link(with: credential) { (authResult, error) in
  // Facebook credential is linked to the current Apple user.
  // The user can now sign in with Facebook or Apple to the same Firebase
  // account.
  // ...
}

Objective-C

// Initialize a Facebook credential with Firebase.
FacebookAuthCredential *credential = [FIRFacebookAuthProvider credentialWithAccessToken:accessToken];
// Assuming the current user is an Apple user linking a Facebook provider.
[FIRAuth.auth linkWithCredential:credential completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
  // Facebook credential is linked to the current Apple user.
  // The user can now sign in with Facebook or Apple to the same Firebase
  // account.
  // ...
}];

Revoca del token

Apple richiede che le app che supportano la creazione di account consentano agli utenti di avviare l'eliminazione del proprio account all'interno dell'app, come descritto nelle linee guida per la revisione dell'App Store.

Per soddisfare questo requisito, segui questi passaggi:

1. Assicurati di aver compilato le sezioni ID servizi e Configurazione del flusso di codice OAuth della configurazione del fornitore Sign in with Apple, come descritto nella sezione Configurare Sign in with Apple.

2. Poiché Firebase non memorizza i token utente quando gli utenti vengono creati con Accedi con Apple, devi chiedere all'utente di accedere di nuovo prima di revocare il suo token ed eliminare l'account.

   Swift

   private func deleteCurrentUser() {
     do {
       let nonce = try CryptoUtils.randomNonceString()
       currentNonce = nonce
       let appleIDProvider = ASAuthorizationAppleIDProvider()
       let request = appleIDProvider.createRequest()
       request.requestedScopes = [.fullName, .email]
       request.nonce = CryptoUtils.sha256(nonce)
   
       let authorizationController = ASAuthorizationController(authorizationRequests: [request])
       authorizationController.delegate = self
       authorizationController.presentationContextProvider = self
       authorizationController.performRequests()
     } catch {
       // In the unlikely case that nonce generation fails, show error view.
       displayError(error)
     }
   }

3. Ottieni il codice di autorizzazione da ASAuthorizationAppleIDCredential e utilizzalo per chiamare Auth.auth().revokeToken(withAuthorizationCode:) per revocare i token dell'utente.

   Swift

   func authorizationController(controller: ASAuthorizationController,
                                didCompleteWithAuthorization authorization: ASAuthorization) {
     guard let appleIDCredential = authorization.credential as? ASAuthorizationAppleIDCredential
     else {
       print("Unable to retrieve AppleIDCredential")
       return
     }
   
     guard let _ = currentNonce else {
       fatalError("Invalid state: A login callback was received, but no login request was sent.")
     }
   
     guard let appleAuthCode = appleIDCredential.authorizationCode else {
       print("Unable to fetch authorization code")
       return
     }
   
     guard let authCodeString = String(data: appleAuthCode, encoding: .utf8) else {
       print("Unable to serialize auth code string from data: \(appleAuthCode.debugDescription)")
       return
     }
   
     Task {
       do {
         try await Auth.auth().revokeToken(withAuthorizationCode: authCodeString)
         try await user?.delete()
         self.updateUI()
       } catch {
         self.displayError(error)
       }
     }
   }

4. Infine, elimina l'account utente (e tutti i dati associati).

Passaggi successivi

Dopo che un utente ha eseguito l'accesso per la prima volta, viene creato un nuovo account utente e collegato alle credenziali, ovvero nome utente e password, numero di telefono o informazioni del fornitore di autenticazione, con cui l'utente ha eseguito l'accesso. Questo nuovo account viene memorizzato come parte del tuo progetto Firebase e può essere utilizzato per identificare un utente in ogni app del tuo progetto, indipendentemente dalla modalità di accesso.

• Nelle tue app, puoi ottenere le informazioni di base del profilo dell'utente dall'oggetto User . Vedi Gestire gli utenti.

• Nelle regole di sicurezza di Firebase Realtime Database e Cloud Storage, puoi ottenere l'ID utente univoco dell'utente che ha eseguito l'accesso dalla variabile auth e utilizzarlo per controllare a quali dati può accedere un utente.

Puoi consentire agli utenti di accedere alla tua app utilizzando più provider di autenticazione collegando le credenziali del provider di autenticazione a un account utente esistente.

Per disconnettere un utente, chiama signOut:.

Swift

let firebaseAuth = Auth.auth()
do {
  try firebaseAuth.signOut()
} catch let signOutError as NSError {
  print("Error signing out: %@", signOutError)
}

Objective-C

NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
  NSLog(@"Error signing out: %@", signOutError);
  return;
}

Potresti anche voler aggiungere un codice di gestione degli errori per l'intera gamma di errori di autenticazione. Consulta la sezione Gestisci gli errori.