S'authentifier avec Apple

Vous pouvez autoriser vos utilisateurs à s'authentifier auprès de Firebase à l'aide de leur identifiant Apple en en utilisant le SDK Firebase pour exécuter le flux de connexion OAuth 2.0 de bout en bout.

Avant de commencer

Pour connecter les utilisateurs à l'aide d'Apple, configurez d'abord la fonctionnalité Se connecter avec Apple sur le site pour les développeurs d'Apple, puis activez Apple comme fournisseur de connexion pour votre projet Firebase.

Rejoindre l'Apple Developer Program

Seuls les membres de l'équipe Apple Developer peuvent configurer la fonctionnalité Se connecter avec Apple de sécurité.

Configurer la connexion avec Apple

  1. Activez la fonctionnalité Se connecter avec Apple pour votre application sur le Certificats, identifiants et Profils du site pour les développeurs d'Apple.
  2. Associez votre site Web à votre application comme décrit dans la première section de Configurer Se connecter avec Apple pour le Web. Lorsque vous y êtes invité, enregistrez le l'URL suivante en tant qu'URL de renvoi:
    https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler
    Vous pouvez obtenir l'ID de votre projet Firebase sur la page FirebaseParamètres de la console. Lorsque vous avez terminé, notez votre nouvel ID de service, dont vous aurez besoin dans la section suivante.
  3. Créez un Connectez-vous avec une clé privée Apple. Vous aurez besoin de votre nouvelle clé privée et de votre nouvelle clé dans la section suivante.
  4. Si vous utilisez l'une des fonctionnalités de Firebase Authentication qui envoient des e-mails aux utilisateurs, y compris la connexion via un lien e-mail, la validation d'adresse e-mail, la révocation de la modification de compte, etc., configurez le service de relais de messagerie privé d'Apple et enregistrez noreply@YOUR_FIREBASE_PROJECT_ID.firebaseapp.com (ou votre domaine de modèle d'e-mail personnalisé) afin qu'Apple puisse transférer les e-mails envoyés par Firebase Authentication vers des adresses e-mail Apple anonymisées.

Activer Apple comme fournisseur de connexion

  1. Ajoutez Firebase à votre projet Apple. N'oubliez pas enregistrez l'ID de bundle de votre application lorsque vous la configurez dans le Console Firebase.
  2. Dans la console Firebase, ouvrez la section Authentification. Dans l'onglet Méthode de connexion, activer le fournisseur Apple. Spécifiez l'ID de service que vous avez créé dans la section précédente. Dans la section Configuration du flux de code OAuth, indiquez également votre ID d'équipe Apple, ainsi que la clé privée et l'ID de clé que vous avez créés dans la section précédente.

Respecter les exigences d'Apple concernant les données anonymisées

Se connecter avec Apple offre aux utilisateurs la possibilité d'anonymiser leurs données, y compris son adresse e-mail, lorsqu'il se connecte. Les utilisateurs qui choisissent cette option disposent d'adresses e-mail avec le domaine privaterelay.appleid.com. Lorsque vous utilisez Se connecter avec Apple dans votre application, vous devez respecter le règlement pour les développeurs ou les conditions d'utilisation d'Apple concernant ces identifiants Apple anonymes.

Cela inclut l'obtention du consentement requis de l'utilisateur avant que associer des données permettant de vous identifier directement à une adresse e-mail anonyme ID. Lorsque vous utilisez Firebase Authentication, cela peut inclure les actions suivantes :

  • Associer une adresse e-mail à un identifiant Apple anonyme, ou inversement
  • Associez un numéro de téléphone à un identifiant Apple anonyme, ou inversement.
  • Associer un identifiant de réseau social non anonyme (Facebook, Google, etc.) à un identifiant Apple anonyme, ou inversement

La liste ci-dessus n'est pas exhaustive. Reportez-vous au Contrat de licence du programme Apple Developer dans la section "Souscription" de votre compte de développeur pour vous assurer que votre application respecte les exigences d'Apple.

Se connecter avec Apple et s'authentifier avec Firebase

Pour s'authentifier avec un compte Apple, commencez par connecter l'utilisateur à son compte Apple à l'aide du framework AuthenticationServices d'Apple puis utiliser le jeton d'ID de la réponse d'Apple pour créer un Objet AuthCredential:

  1. Pour chaque demande de connexion, générez une chaîne aléatoire (un "nonce") que vous utiliserez pour vous assurer que le jeton d'ID obtenu a été accordé spécifiquement en réponse à la requête d'authentification de votre application. Ce est importante pour empêcher les attaques par rejeu.

    Vous pouvez générer un nonce sécurisé par chiffrement avec SecRandomCopyBytes(_:_:_), comme dans l'exemple suivant :

    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)
    }
    
        
    // 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];
    }
        

    Vous enverrez le hachage SHA256 du nonce avec votre requête de connexion, qui Apple sera transmis tels quels dans la réponse. Firebase valide la réponse en hachant le nonce d'origine et en le comparant à la valeur transmise par Apple.

    @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
    }
    
        
    - (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. Lancez le flux de connexion d'Apple, y compris dans votre requête, le hachage SHA256 de le nonce et la classe déléguée qui gérera la réponse d'Apple (voir l'étape suivante):

    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()
    }
    
    @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. Traitez la réponse d'Apple dans votre mise en œuvre de ASAuthorizationControllerDelegate. Si la connexion a réussi, utilisez l'ID à partir de la réponse d'Apple avec le nonce non haché pour s'authentifier Firebase:

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

Contrairement à d'autres fournisseurs compatibles avec Firebase Auth, Apple ne fournit pas URL de la photo.

De plus, si l'utilisateur choisit de ne pas partager son adresse e-mail avec l'application, Apple fournit une adresse e-mail unique pour cet utilisateur (au format xyz@privaterelay.appleid.com), qu'il partage avec votre application. Si vous configuré le service de relais de messagerie privé, Apple transfère les e-mails envoyés au anonyme à la véritable adresse e-mail de l'utilisateur.

Réauthentification et association de comptes

Le même modèle peut être utilisé avec reauthenticateWithCredential(), que vous pouvez utiliser pour récupérer de nouvelles identifiants pour les opérations sensibles qui nécessitent une connexion récente :

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

Vous pouvez également utiliser linkWithCredential() pour associer différents fournisseurs d'identité comptes existants.

Remarque : Apple exige que vous obteniez le consentement explicite des utilisateurs avant d'effectuer l'association leurs comptes Apple vers d'autres données.

La connexion avec Apple ne vous permet pas de réutiliser des identifiants d'authentification pour associer compte existant. Si vous souhaitez associer un identifiant Se connecter avec Apple à un autre compte, vous devez d'abord essayer d'associer les comptes à l'aide de l'ancienne fonctionnalité Se connecter avec Identifiant Apple, puis examinez l'erreur renvoyée pour trouver un nouvel identifiant. Le nouvel identifiant se trouvera dans le dictionnaire userInfo de l'erreur et peut sont accessibles via la clé AuthErrorUserInfoUpdatedCredentialKey.

Par exemple, pour associer un compte Facebook au compte Firebase actuel, utilisez le jeton d'accès obtenu lorsque vous avez connecté l'utilisateur à Facebook :

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

Révocation des jetons

Apple exige que les applis qui permettent de créer un compte autorisent les utilisateurs à lancer la suppression de leur compte dans l'application, comme décrit dans l'App Store d'évaluation ; Consignes

Pour répondre à cette exigence, procédez comme suit:

  1. Assurez-vous d'avoir rempli les sections ID de service et Configuration du flux de code OAuth de la configuration du fournisseur Se connecter avec Apple, comme indiqué dans la section Configurer Se connecter avec Apple.

  2. Étant donné que Firebase ne stocke pas les jetons utilisateur lorsque les utilisateurs sont créés avec Se connecter avec Apple, vous devez demander à l'utilisateur de se connecter à nouveau avant de révoquer son jeton et de supprimer le compte.

    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. Obtenez le code d'autorisation auprès de ASAuthorizationAppleIDCredential, puis utilisez-le pour appeler Auth.auth().revokeToken(withAuthorizationCode:) afin de révoquer les jetons de l'utilisateur.

    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. Enfin, supprimez le compte utilisateur (et toutes les données associées).

Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associés aux identifiants, c'est-à-dire au nom d'utilisateur et au mot de passe, ou des informations sur le fournisseur d'authentification, c'est-à-dire l'utilisateur avec lequel l'utilisateur s'est connecté. Cette nouvelle est stocké dans votre projet Firebase et peut servir à identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la façon dont l'utilisateur se connecte.

  • Dans vos applications, vous pouvez obtenir les informations de profil de base de l'utilisateur à partir de l'objet User. Consultez la page Gérer les utilisateurs.

  • Dans votre Firebase Realtime Database et votre Cloud Storage Règles de sécurité, vous pouvez obtenez l'ID utilisateur unique de l'utilisateur connecté à partir de la variable auth et l'utiliser pour contrôler les données auxquelles un utilisateur peut accéder.

Vous pouvez autoriser les utilisateurs à se connecter à votre application à l'aide de plusieurs fournisseurs d'authentification en associant les identifiants du fournisseur d'authentification à un compte utilisateur existant.

Pour déconnecter un utilisateur, appelez signOut:.

let firebaseAuth = Auth.auth()
do {
  try firebaseAuth.signOut()
} catch let signOutError as NSError {
  print("Error signing out: %@", signOutError)
}
NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
  NSLog(@"Error signing out: %@", signOutError);
  return;
}

Vous pouvez également ajouter un code de gestion des erreurs pour la plage complète des authentifications les erreurs. Consultez la section Gérer les erreurs.