Questa pagina è stata tradotta dall'API Cloud Translation.

Autenticarsi utilizzando Apple

Puoi consentire ai tuoi 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.

Prima di iniziare

Per accedere agli utenti che utilizzano Apple, configura innanzitutto Accedi con Apple sul sito degli sviluppatori Apple, quindi abilita Apple come provider di accesso per il tuo progetto Firebase.

Unisciti al programma per sviluppatori Apple

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

Configura l'accesso con Apple

Abilita Accedi con Apple per la tua app nella pagina Certificati, identificatori e profili del sito degli sviluppatori Apple.
Associa il tuo sito web alla tua app come descritto nella prima sezione di Configura l'accesso 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 ottenere l'ID del tuo progetto Firebase nella pagina delle impostazioni della console Firebase . Una volta terminato, prendi nota del tuo nuovo ID servizio, che ti servirà nella sezione successiva.
Crea un accesso con la chiave privata Apple . Avrai bisogno della tua nuova chiave privata e dell'ID chiave nella sezione successiva.
Se utilizzi una delle funzionalità di Firebase Authentication che inviano e-mail agli utenti, incluso l'accesso tramite collegamento e-mail, la verifica dell'indirizzo e-mail, la revoca della modifica dell'account e altro, configura il servizio di inoltro e-mail privato Apple e registrati noreply@ YOUR_FIREBASE_PROJECT_ID .firebaseapp.com (o il dominio del tuo modello di email personalizzato) in modo che Apple possa inoltrare le email inviate tramite Firebase Authentication a indirizzi email Apple anonimizzati.

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

Rispettare i requisiti relativi ai dati anonimi di Apple

Accedi con Apple offre agli utenti la possibilità di rendere anonimi i propri dati, incluso il proprio indirizzo e-mail, al momento dell'accesso. Gli utenti che scelgono questa opzione hanno indirizzi e-mail con il dominio privaterelay.appleid.com . Quando utilizzi Accedi con Apple nella tua app, devi rispettare tutte le politiche o i termini per sviluppatori applicabili di Apple relativi a questi ID Apple anonimizzati.

Ciò include l'ottenimento del consenso dell'utente richiesto prima di associare qualsiasi informazione personale che possa identificare direttamente un ID Apple anonimo. Quando si utilizza l'autenticazione Firebase, ciò può includere le seguenti azioni:

Collega un indirizzo email a un ID Apple anonimo o viceversa.
Collega un numero di telefono a un ID Apple anonimo o viceversa
Collega una credenziale social non anonima (Facebook, Google, ecc.) a un ID Apple anonimo o viceversa.

L'elenco sopra riportato non è esaustivo. Fai riferimento al contratto di licenza del programma per sviluppatori Apple nella sezione Iscrizione del tuo account sviluppatore per assicurarti che la tua app soddisfi i requisiti Apple.

Accedi con Apple e autenticati con Firebase

Per autenticarsi con un account Apple, accedi prima all'utente al proprio account Apple utilizzando il framework AuthenticationServices di Apple, quindi utilizza il token ID dalla risposta di Apple per creare un oggetto AuthCredential Firebase:

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

È possibile generare un nonce crittograficamente sicuro con SecRandomCopyBytes(_:_:_) , come nell'esempio seguente:

Veloce

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

Obiettivo-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];
}

Invierai l'hash SHA256 del nonce con la tua richiesta di accesso, che Apple trasmetterà senza modifiche nella risposta. Firebase convalida la risposta eseguendo l'hashing del nonce originale e confrontandolo con il valore passato da Apple.

Veloce

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

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

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

Veloce

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

Obiettivo-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];
}

Gestisci la risposta di Apple nell'implementazione di ASAuthorizationControllerDelegate . Se l'accesso ha avuto esito positivo, utilizza il token ID dalla risposta di Apple con il nonce senza hash per autenticarti con Firebase:

Veloce

@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)")
  }

}

Obiettivo-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 l'URL di una foto.

Inoltre, quando l'utente sceglie di non condividere la propria email con l'app, Apple fornisce a quell'utente un indirizzo email univoco (nel formato xyz@privaterelay.appleid.com ), che condivide con la tua app. Se hai configurato il servizio di inoltro e-mail privato, Apple inoltra le e-mail inviate all'indirizzo anonimo al vero indirizzo e-mail dell'utente.

Riautenticazione e collegamento dell'account

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

Veloce

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

Obiettivo-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à agli account esistenti.

Tieni presente che Apple richiede che tu ottenga 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 collegarti a un account esistente. Se desideri collegare una credenziale Accedi con Apple a un altro account, devi prima provare a collegare gli account utilizzando la vecchia credenziale Accedi con Apple e quindi esaminare l'errore restituito per trovare una nuova credenziale. La nuova credenziale verrà posizionata nel dizionario userInfo dell'errore ed è possibile accedervi 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:

Veloce

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

Obiettivo-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, implementare i seguenti passaggi:

Assicurati di aver compilato la sezione di configurazione dell'ID servizi e del flusso di codice OAuth della configurazione del provider Accedi con Apple, come indicato nella sezione Configura l'accesso con Apple .

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

Veloce

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

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

Veloce

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

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

Prossimi passi

Dopo che un utente accede per la prima volta, viene creato un nuovo account utente e collegato alle credenziali, ovvero nome utente e password, numero di telefono o informazioni sul provider di autenticazione, con cui l'utente ha effettuato l'accesso. Questo nuovo account viene archiviato 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 dell'utente.

Nelle tue app puoi ottenere le informazioni di base del profilo dell'utente dall'oggetto User . Vedi Gestisci utenti .
Nel tuo Firebase Realtime Database e Cloud Storage Security Rules , puoi ottenere l'ID utente univoco dell'utente che ha effettuato 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, chiamare signOut: .

Veloce

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

Obiettivo-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 Gestire gli errori .

Autenticarsi utilizzando Apple

Prima di iniziare

Unisciti al programma per sviluppatori Apple

Configura l'accesso con Apple

Abilita Apple come provider di accesso

Rispettare i requisiti relativi ai dati anonimi di Apple

Accedi con Apple e autenticati con Firebase

Veloce

Obiettivo-C

Veloce

Obiettivo-C

Veloce

Obiettivo-C

Veloce

Obiettivo-C

Riautenticazione e collegamento dell'account

Veloce

Obiettivo-C

Veloce

Obiettivo-C

Revoca del token

Veloce

Veloce

Prossimi passi

Veloce

Obiettivo-C