S'authentifier avec Apple sur Android

Vous pouvez autoriser vos utilisateurs à s'authentifier avec 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 de commencer

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

Rejoindre le programme Apple Developer

La fonctionnalité Se connecter avec Apple ne peut être configurée que par les membres du programme Apple Developer.

Configurer la connexion avec Apple

Sur le site Apple Developer, procédez comme suit:

1. 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 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 des paramètres de la console Firebase.

   Lorsque vous avez terminé, notez votre nouvel ID de service, car vous en aurez besoin dans la section suivante.

2. Créez une clé privée pour "Se connecter avec Apple". Vous aurez besoin de votre nouvelle clé privée et de son ID de clé dans la section suivante.

3. 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 le domaine de votre 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 en tant que fournisseur de connexion

1. Ajoutez Firebase à votre projet Android. Veillez à enregistrer la signature SHA-1 de votre application lorsque vous la configurez dans la console Firebase.
2. Dans la console Firebase, ouvrez la section Authentification. Dans l'onglet Mode de connexion, activez le fournisseur Apple. Indiquez 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 permet aux utilisateurs d'anonymiser leurs données, y compris leur adresse e-mail, lorsqu'ils se connectent. 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 de l'autorisation de l'utilisateur avant d'associer des informations personnelles permettant de l'identifier directement à un identifiant Apple anonyme. Lorsque vous utilisez Firebase Authentication, cela peut inclure les actions suivantes:

• Associer une adresse e-mail à un identifiant Apple anonyme, ou inversement
• Associer 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.

Gérer le flux de connexion avec le SDK Firebase

Sur Android, le moyen le plus simple d'authentifier vos utilisateurs avec Firebase à l'aide de leurs comptes Apple consiste à gérer l'ensemble du flux de connexion avec le SDK Firebase Android.

Pour gérer le flux de connexion avec le SDK Android Firebase, procédez comme suit:

1. Créez une instance d'un OAuthProvider à l'aide de son compilateur avec l'ID de fournisseur apple.com:

   Kotlin

   val provider = OAuthProvider.newBuilder("apple.com")
   

   Java

   OAuthProvider.Builder provider = OAuthProvider.newBuilder("apple.com");
   

2. Facultatif:spécifiez des champs d'application OAuth 2.0 supplémentaires en plus de ceux par défaut que vous souhaitez demander au fournisseur d'authentification.

   Kotlin

   provider.setScopes(arrayOf("email", "name"))
   

   Java

   List<String> scopes =
       new ArrayList<String>() {
         {
           add("email");
           add("name");
         }
       };
   provider.setScopes(scopes);
   

   Par défaut, lorsque l'option Un compte par adresse e-mail est activée, Firebase demande les champs d'application d'adresse e-mail et de nom. Si vous définissez ce paramètre sur Plusieurs comptes par adresse e-mail, Firebase ne demande aucun champ d'application à Apple, sauf si vous les spécifiez.

3. Facultatif:Si vous souhaitez afficher l'écran de connexion d'Apple dans une autre langue que l'anglais, définissez le paramètre locale. Pour connaître les langues disponibles, consultez la documentation sur Se connecter avec Apple.

   Kotlin

   // Localize the Apple authentication screen in French.
   provider.addCustomParameter("locale", "fr")
   

   Java

   // Localize the Apple authentication screen in French.
   provider.addCustomParameter("locale", "fr");
   

4. Authentifiez-vous avec Firebase à l'aide de l'objet du fournisseur OAuth. Notez que, contrairement aux autres opérations FirebaseAuth, cette opération prend le contrôle de votre UI en ouvrant un onglet Chrome personnalisé. Par conséquent, ne faites pas référence à votre activité dans les OnSuccessListener et OnFailureListener que vous associez, car ils seront immédiatement dissociés lorsque l'opération démarrera l'UI.

   Commencez par vérifier si vous avez déjà reçu une réponse. La connexion à l'aide de cette méthode place votre activité en arrière-plan, ce qui signifie qu'elle peut être récupérée par le système pendant le flux de connexion. Pour vous assurer de ne pas demander à l'utilisateur de réessayer si cela se produit, vous devez vérifier si un résultat est déjà présent.

   Pour vérifier si un résultat est en attente, appelez getPendingAuthResult():

   Kotlin

   val pending = auth.pendingAuthResult
   if (pending != null) {
       pending.addOnSuccessListener { authResult ->
           Log.d(TAG, "checkPending:onSuccess:$authResult")
           // Get the user profile with authResult.getUser() and
           // authResult.getAdditionalUserInfo(), and the ID
           // token from Apple with authResult.getCredential().
       }.addOnFailureListener { e ->
           Log.w(TAG, "checkPending:onFailure", e)
       }
   } else {
       Log.d(TAG, "pending: null")
   }
   

   Java

   mAuth = FirebaseAuth.getInstance();
   Task<AuthResult> pending = mAuth.getPendingAuthResult();
   if (pending != null) {
       pending.addOnSuccessListener(new OnSuccessListener<AuthResult>() {
           @Override
           public void onSuccess(AuthResult authResult) {
               Log.d(TAG, "checkPending:onSuccess:" + authResult);
               // Get the user profile with authResult.getUser() and
               // authResult.getAdditionalUserInfo(), and the ID
               // token from Apple with authResult.getCredential().
           }
       }).addOnFailureListener(new OnFailureListener() {
           @Override
           public void onFailure(@NonNull Exception e) {
               Log.w(TAG, "checkPending:onFailure", e);
           }
       });
   } else {
       Log.d(TAG, "pending: null");
   }
   

   Si aucun résultat n'est en attente, démarrez le flux de connexion en appelant startActivityForSignInWithProvider():

   Kotlin

   auth.startActivityForSignInWithProvider(this, provider.build())
           .addOnSuccessListener { authResult ->
               // Sign-in successful!
               Log.d(TAG, "activitySignIn:onSuccess:${authResult.user}")
               val user = authResult.user
               // ...
           }
           .addOnFailureListener { e ->
               Log.w(TAG, "activitySignIn:onFailure", e)
           }
   

   Java

   mAuth.startActivityForSignInWithProvider(this, provider.build())
           .addOnSuccessListener(
                   new OnSuccessListener<AuthResult>() {
                       @Override
                       public void onSuccess(AuthResult authResult) {
                           // Sign-in successful!
                           Log.d(TAG, "activitySignIn:onSuccess:" + authResult.getUser());
                           FirebaseUser user = authResult.getUser();
                           // ...
                       }
                   })
           .addOnFailureListener(
                   new OnFailureListener() {
                       @Override
                       public void onFailure(@NonNull Exception e) {
                           Log.w(TAG, "activitySignIn:onFailure", e);
                       }
                   });
   

   Contrairement aux autres fournisseurs acceptés par Firebase Auth, Apple ne fournit pas d'URL de photo.

   De plus, lorsque l'utilisateur choisit de ne pas partager son adresse e-mail avec l'application, Apple provisionne une adresse e-mail unique pour cet utilisateur (au format 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 anonyme à l'adresse e-mail réelle de l'utilisateur.

   Apple ne partage des informations utilisateur, telles que le nom à afficher, qu'avec les applications la première fois qu'un utilisateur se connecte. En règle générale, Firebase stocke le nom à afficher la première fois qu'un utilisateur se connecte avec Apple. Vous pouvez l'obtenir avec getCurrentUser().getDisplayName(). Toutefois, si vous avez déjà utilisé Apple pour connecter un utilisateur à l'application sans utiliser Firebase, Apple ne fournira pas à Firebase le nom à afficher de l'utilisateur.

Réauthentification et association de comptes

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

// The user is already signed-in.
val firebaseUser = auth.getCurrentUser()

firebaseUser
    .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
    .addOnSuccessListener( authResult -> {
        // User is re-authenticated with fresh tokens and
        // should be able to perform sensitive operations
        // like account deletion and email or password
        // update.
    })
    .addOnFailureListener( e -> {
        // Handle failure.
    })

// The user is already signed-in.
FirebaseUser firebaseUser = mAuth.getCurrentUser();

firebaseUser
    .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
    .addOnSuccessListener(
        new OnSuccessListener<AuthResult>() {
          @Override
          public void onSuccess(AuthResult authResult) {
            // User is re-authenticated with fresh tokens and
            // should be able to perform sensitive operations
            // like account deletion and email or password
            // update.
          }
        })
    .addOnFailureListener(
        new OnFailureListener() {
          @Override
          public void onFailure(@NonNull Exception e) {
            // Handle failure.
          }
        });

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

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

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 a Facebook access token.
val credential = FacebookAuthProvider.getCredential(token.getToken())

// Assuming the current user is an Apple user linking a Facebook provider.
mAuth.getCurrentUser().linkWithCredential(credential)
    .addOnCompleteListener(this, task -> {
        if (task.isSuccessful()) {
          // Facebook credential is linked to the current Apple user.
          // The user can now sign in to the same account
          // with either Apple or Facebook.
        }
      });

// Initialize a Facebook credential with a Facebook access token.
AuthCredential credential = FacebookAuthProvider.getCredential(token.getToken());

// Assuming the current user is an Apple user linking a Facebook provider.
mAuth.getCurrentUser().linkWithCredential(credential)
    .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
      @Override
      public void onComplete(@NonNull Task<AuthResult> task) {
        if (task.isSuccessful()) {
          // Facebook credential is linked to the current Apple user.
          // The user can now sign in to the same account
          // with either Apple or Facebook.
        }
      }
    });

Avancé: gérer manuellement le flux de connexion

Vous pouvez également vous authentifier avec Firebase à l'aide d'un compte Apple en gérant le flux de connexion à l'aide du SDK JavaScript Apple Sign-In, en créant manuellement le flux OAuth ou à l'aide d'une bibliothèque OAuth telle que AppAuth.

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. Cette étape est importante pour éviter les attaques par rejeu.

   Vous pouvez générer un nonce sécurisé par chiffrement sur Android avec SecureRandom, comme dans l'exemple suivant:

   Kotlin

   private fun generateNonce(length: Int): String {
       val generator = SecureRandom()
   
       val charsetDecoder = StandardCharsets.US_ASCII.newDecoder()
       charsetDecoder.onUnmappableCharacter(CodingErrorAction.IGNORE)
       charsetDecoder.onMalformedInput(CodingErrorAction.IGNORE)
   
       val bytes = ByteArray(length)
       val inBuffer = ByteBuffer.wrap(bytes)
       val outBuffer = CharBuffer.allocate(length)
       while (outBuffer.hasRemaining()) {
           generator.nextBytes(bytes)
           inBuffer.rewind()
           charsetDecoder.reset()
           charsetDecoder.decode(inBuffer, outBuffer, false)
       }
       outBuffer.flip()
       return outBuffer.toString()
   }
   

   Java

   private String generateNonce(int length) {
       SecureRandom generator = new SecureRandom();
   
       CharsetDecoder charsetDecoder = StandardCharsets.US_ASCII.newDecoder();
       charsetDecoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
       charsetDecoder.onMalformedInput(CodingErrorAction.IGNORE);
   
       byte[] bytes = new byte[length];
       ByteBuffer inBuffer = ByteBuffer.wrap(bytes);
       CharBuffer outBuffer = CharBuffer.allocate(length);
       while (outBuffer.hasRemaining()) {
           generator.nextBytes(bytes);
           inBuffer.rewind();
           charsetDecoder.reset();
           charsetDecoder.decode(inBuffer, outBuffer, false);
       }
       outBuffer.flip();
       return outBuffer.toString();
   }
   

   Obtenez ensuite le hachage SHA246 du nonce sous forme de chaîne hexadécimale:

   Kotlin

   private fun sha256(s: String): String {
       val md = MessageDigest.getInstance("SHA-256")
       val digest = md.digest(s.toByteArray())
       val hash = StringBuilder()
       for (c in digest) {
           hash.append(String.format("%02x", c))
       }
       return hash.toString()
   }
   

   Java

   private String sha256(String s) throws NoSuchAlgorithmException {
       MessageDigest md = MessageDigest.getInstance("SHA-256");
       byte[] digest = md.digest(s.getBytes());
       StringBuilder hash = new StringBuilder();
       for (byte c: digest) {
           hash.append(String.format("%02x", c));
       }
       return hash.toString();
   }
   

   Vous envoyez le hachage SHA256 du nonce avec votre requête de connexion, que Apple transmet dans la réponse sans la modifier. Firebase valide la réponse en hachant le nonce d'origine et en le comparant à la valeur transmise par Apple.

2. Lancez le flux de connexion d'Apple à l'aide de votre bibliothèque OAuth ou d'une autre méthode. Veillez à inclure le nonce haché en tant que paramètre dans votre requête.

3. Une fois que vous avez reçu la réponse d'Apple, récupérez le jeton d'ID de la réponse et utilisez-le avec le nonce non haché pour créer un AuthCredential:

   Kotlin

   val credential =  OAuthProvider.newCredentialBuilder("apple.com")
       .setIdTokenWithRawNonce(appleIdToken, rawUnhashedNonce)
       .build()
   

   Java

   AuthCredential credential =  OAuthProvider.newCredentialBuilder("apple.com")
       .setIdTokenWithRawNonce(appleIdToken, rawUnhashedNonce)
       .build();
   

4. Authentifiez-vous avec Firebase à l'aide des identifiants Firebase:

   Kotlin

   auth.signInWithCredential(credential)
         .addOnCompleteListener(this) { task ->
             if (task.isSuccessful) {
               // User successfully signed in with Apple ID token.
               // ...
             }
         }
   

   Java

   mAuth.signInWithCredential(credential)
       .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
         @Override
         public void onComplete(@NonNull Task<AuthResult> task) {
           if (task.isSuccessful()) {
             // User successfully signed in with Apple ID token.
             // ...
           }
         }
       });
   

Si l'appel à signInWithCredential aboutit, vous pouvez utiliser la méthode getCurrentUser pour obtenir les données de compte de l'utilisateur.

Révocation de jetons

Apple exige que les applications permettant de créer un compte doivent permettre aux utilisateurs de lancer la suppression de leur compte dans l'application, comme décrit dans les Consignes d'examen de l'App Store.

En outre, les applications compatibles avec Se connecter avec Apple doivent utiliser l'API REST Se connecter avec Apple pour révoquer les jetons utilisateur.

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

1. Utilisez la méthode startActivityForSignInWithProvider() pour vous connecter avec Apple et obtenir AuthResult.

2. Obtenez le jeton d'accès pour le fournisseur Apple.

   Kotlin

   val oauthCredential: OAuthCredential =  authResult.credential
   val accessToken = oauthCredential.accessToken
   

   Java

   OAuthCredential oauthCredential = (OAuthCredential) authResult.getCredential();
   String accessToken = oauthCredential.getAccessToken();
   

3. Révoquez le jeton à l'aide de l'API revokeAccessToken.

   Kotlin

   mAuth.revokeAccessToken(accessToken)
     .addOnCompleteListener(this) { task ->
       if (task.isSuccessful) {
         // Access token successfully revoked
         // for the user ...
       }
   }
   

   Java

   mAuth.revokeAccessToken(accessToken)
       .addOnCompleteListener(this, new OnCompleteListener<Void>() {
           @Override
           public void onComplete(@NonNull Task<Void> task) {
             if (task.isSuccessful()) {
               // Access token successfully revoked
               // for the user ...
             }
           }
     });
   

1. 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é aux identifiants (nom d'utilisateur et mot de passe, numéro de téléphone ou informations du fournisseur d'authentification) avec lesquels l'utilisateur s'est connecté. Ce nouveau compte est stocké dans votre projet Firebase et peut être utilisé pour identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la manière dont il se connecte.

   • Dans vos applications, vous pouvez obtenir les informations de profil de base de l'utilisateur à partir de l'objet FirebaseUser. Consultez 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 identifiants du fournisseur d'authentification à un compte utilisateur existant.

   Pour déconnecter un utilisateur, appelez signOut:

   Kotlin

   Firebase.auth.signOut()
   MainActivity.kt

   Java

   FirebaseAuth.getInstance().signOut();
   MainActivity.java