Authentifier avec Apple

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

Avant que tu commences

Pour connecter des utilisateurs à l'aide d'Apple, configurez d'abord la connexion avec Apple sur le site des développeurs d'Apple, puis activez Apple en tant que fournisseur de connexion pour votre projet Firebase.

Rejoignez le programme pour développeurs Apple

La connexion avec Apple ne peut être configurée que par les membres du programme pour développeurs Apple .

Configurer la connexion avec Apple

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

Activer Apple en tant que fournisseur de connexion

  1. Ajoutez Firebase à votre projet Apple . Assurez-vous d'enregistrer l'ID de bundle de votre application lorsque vous configurez votre application dans la console Firebase.
  2. Dans la console Firebase , ouvrez la section Auth . Dans l'onglet Méthode de connexion , activez le fournisseur Apple . Spécifiez l'ID de service que vous avez créé dans la section précédente. De plus, dans la section Configuration du flux de code OAuth , spécifiez votre identifiant 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.

Se conformer aux exigences d'Apple en matière de données anonymisées

Se connecter avec Apple donne aux utilisateurs la possibilité d'anonymiser leurs données, y compris leur adresse e-mail, lors de la connexion. Les utilisateurs qui choisissent cette option ont des adresses e-mail avec le domaine privaterelay.appleid.com . Lorsque vous utilisez la connexion avec Apple dans votre application, vous devez vous conformer à toutes les politiques de développement ou conditions applicables d'Apple concernant ces identifiants Apple anonymisés.

Cela inclut l'obtention de tout consentement requis de l'utilisateur avant d'associer des informations personnelles d'identification directe à un identifiant Apple anonymisé. Lors de l'utilisation de l'authentification Firebase, cela peut inclure les actions suivantes :

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

La liste ci-dessus n'est pas exhaustive. Reportez-vous au contrat de licence du programme pour développeurs Apple dans la section Adhésion de votre compte développeur pour vous assurer que votre application répond aux exigences d'Apple.

Connectez-vous avec Apple et authentifiez-vous avec Firebase

Pour vous authentifier avec un compte Apple, connectez d'abord l'utilisateur à son compte Apple à l'aide du framework AuthenticationServices d'Apple, puis utilisez le jeton d'identification de la réponse d'Apple pour créer un objet Firebase 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'identification que vous obtenez a été accordé spécifiquement en réponse à la demande d'authentification de votre application. Cette étape est importante pour empêcher les attaques par relecture.

    Vous pouvez générer un nom occasionnel cryptographiquement sécurisé avec SecRandomCopyBytes(_:_:_) , comme dans l'exemple suivant :

    Rapide

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

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

    Vous enverrez le hachage SHA256 du nonce avec votre demande de connexion, qu'Apple transmettra sans modification dans la réponse. Firebase valide la réponse en hachant le nom occasionnel d'origine et en le comparant à la valeur transmise par Apple.

    Rapide

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

    Objectif 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. Démarrez le flux de connexion d'Apple, en incluant dans votre demande le hachage SHA256 du nom occasionnel et la classe déléguée qui gérera la réponse d'Apple (voir l'étape suivante) :

    Rapide

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

    Objectif 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. Gérez la réponse d'Apple dans votre implémentation de ASAuthorizationControllerDelegate . Si la connexion a réussi, utilisez le jeton d'identification de la réponse d'Apple avec le nom occasionnel non haché pour vous authentifier auprès de Firebase :

    Rapide

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

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

Contrairement à d'autres fournisseurs pris en charge par Firebase Auth, Apple ne fournit pas d'URL de photo.

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

Réauthentification et liaison de compte

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

Rapide

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

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

Et vous pouvez utiliser linkWithCredential() pour lier différents fournisseurs d’identité aux comptes existants.

Notez qu'Apple exige que vous obteniez le consentement explicite des utilisateurs avant de lier leurs comptes Apple à d'autres données.

La connexion avec Apple ne vous permettra pas de réutiliser un identifiant d'authentification pour vous connecter à un compte existant. Si vous souhaitez lier un identifiant de connexion avec Apple à un autre compte, vous devez d'abord essayer de lier les comptes à l'aide de l'ancien identifiant de connexion avec Apple, puis examiner l'erreur renvoyée pour trouver un nouvel identifiant. Le nouvel identifiant sera situé dans le dictionnaire userInfo de l'erreur et sera accessible via la clé AuthErrorUserInfoUpdatedCredentialKey .

Par exemple, pour lier un compte Facebook au compte Firebase actuel, utilisez le jeton d'accès que vous avez obtenu en connectant l'utilisateur à Facebook :

Rapide

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

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

Révocation du jeton

Apple exige que les applications prenant en charge la création de compte permettent aux utilisateurs de lancer la suppression de leur compte dans l'application, comme décrit dans les directives d'examen de l'App Store.

Pour répondre à cette exigence, mettez en œuvre les étapes suivantes :

  1. Assurez-vous d'avoir rempli la section de configuration de l'ID de services et du flux de code OAuth de la configuration du fournisseur de connexion avec Apple, comme indiqué dans la section Configurer la connexion avec Apple .

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

    Rapide

    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 et utilisez-le pour appeler Auth.auth().revokeToken(withAuthorizationCode:) afin de révoquer les jetons de l'utilisateur.

    Rapide

    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)

Prochaines étapes

Après qu'un utilisateur se connecte pour la première fois, un nouveau compte utilisateur est créé et lié aux informations d'identification (c'est-à-dire le nom d'utilisateur et le mot de passe, le numéro de téléphone ou les informations du fournisseur d'authentification) avec lesquels l'utilisateur s'est connecté. Ce nouveau compte est stocké dans le cadre de votre projet Firebase et peut être utilisé pour identifier un utilisateur dans chaque application de votre projet, quelle que soit la manière dont l'utilisateur se connecte.

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

  • Dans vos règles de sécurité Firebase Realtime Database et Cloud Storage, vous pouvez obtenir 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 informations d'identification du fournisseur d'authentification à un compte utilisateur existant.

Pour déconnecter un utilisateur, appelez signOut: .

Rapide

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

Objectif c

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

Vous souhaiterez peut-être également ajouter un code de gestion des erreurs pour la gamme complète des erreurs d’authentification. Voir Gérer les erreurs .