S'authentifier avec Apple sur Android

Vous pouvez autoriser vos utilisateurs à 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 les 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

Connectez - vous avec d' Apple ne peut être configuré par les membres du programme Apple Developer .

Configurer la connexion avec Apple

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

  1. Associer votre site Web à votre application comme décrit dans la première section de Configurer Connectez - vous 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 votre projet Firebase ID sur la page de la console Firebase .

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

  2. Créer un signe avec Apple clé privée . Vous aurez besoin de votre nouvelle clé privée et de votre identifiant de clé dans la section suivante.
  3. Si vous utilisez l' une des Firebase authentification des fonctionnalités qui envoient des e - mails aux utilisateurs, y compris les e - mail lien de connexion, adresse e - mail de vérification, compte révocation du changement, et d' autres, configurer le service de relais de courrier électronique privé d' noreply@ YOUR_FIREBASE_PROJECT_ID .firebaseapp.com Apple et vous inscrire 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. Ajouter Firebase à votre projet Android . Assurez-vous d'enregistrer la signature SHA-1 de votre application lorsque vous configurez votre application dans la console Firebase.
  2. Dans la console Firebase , ouvrez la section Auth. Sur l'onglet Connexion méthode, permettre au fournisseur d' Apple. Spécifiez l'ID de service que vous avez créé dans la section précédente. En outre, dans la section de configuration de flux de code OAuth, spécifiez votre Apple ID et équipe la clé privée et clé ID que vous avez créé dans la section précédente.

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

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

Cela inclut l'obtention du consentement de l'utilisateur requis avant d'associer des informations personnelles directement identifiables à un identifiant Apple anonymisé. Lorsque vous utilisez l'authentification Firebase, cela peut inclure les actions suivantes :

  • Associez une adresse e-mail à un identifiant Apple anonymisé ou vice versa.
  • Lier 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 Abonnement de votre compte développeur pour vous assurer que votre application répond aux 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'intégralité du flux de connexion avec le SDK Firebase Android.

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

  1. Construire une instance d'un OAuthProvider en utilisant son constructeur avec l'ID de fournisseur apple.com :

    Java

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

    Kotlin+KTX

    val provider = OAuthProvider.newBuilder("apple.com")
    
  2. Facultatif: Spécifiez OAuth 2.0 supplémentaires portées au - delà de la valeur par défaut que vous voulez la demande du fournisseur d'authentification.

    Java

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

    Kotlin+KTX

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

    Par défaut, quand on compte par adresse e - mail est activée, Firebase demande champs e - mail et nom. Si vous modifiez ce paramètre à plusieurs comptes par adresse e - mail, Firebase ne demande pas de champs d' application d'Apple à moins que vous spécifiez.

  3. Facultatif: Si vous voulez afficher le signe dans l' écran d'Apple dans une langue autre que l' anglais, définissez le locale paramètre. Voir le Connectez - vous avec docs d' Apple pour les paramètres régionaux pris en charge.

    Java

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

    Kotlin+KTX

    // Localize the Apple authentication screen in French.
    provider.addCustomParameter("locale", "fr")
    
  4. Authentifiez-vous auprès de Firebase à l'aide de l'objet fournisseur OAuth. Notez que contrairement à d' autres FirebaseAuth opérations, cela prendra le contrôle de l' interface utilisateur en ouvrant un onglet Custom Chrome. Par conséquent, ne fait pas référence à votre activité dans le OnSuccessListener et OnFailureListener que vous attachez comme ils se détachent immédiatement lorsque l'opération démarre l'interface utilisateur.

    Vous devez d'abord vérifier si vous avez déjà reçu une réponse. La connexion avec 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. Afin de vous assurer de ne pas obliger l'utilisateur à réessayer si cela se produit, vous devez vérifier si un résultat est déjà présent.

    Pour vérifier s'il y a un résultat dans l' attente, appelez getPendingAuthResult() :

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

    Kotlin+KTX

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

    S'il n'y a pas de résultat dans l' attente, démarrez le signe en flux, en appelant startActivityForSignInWithProvider() :

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

    Kotlin+KTX

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

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

    En outre, lorsque l'utilisateur choisit de ne pas partager leur e - mail avec l'application, les dispositions d' Apple une adresse e - mail unique pour cet utilisateur (de la forme xyz@privaterelay.appleid.com ), qu'elle 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 vers la véritable adresse e-mail de l'utilisateur.

    Apple ne partage les informations utilisateur telles que le nom d'affichage avec des applications la première fois un utilisateur se connecte. Habituellement, les magasins Firebase le nom d'affichage de la première fois qu'un utilisateur se connecte avec Apple, que vous pouvez obtenir avec getCurrentUser().getDisplayName() . Cependant, si vous avez déjà utilisé Apple pour connecter un utilisateur à l'application sans utiliser Firebase, Apple ne fournira pas à Firebase le nom d'affichage de l'utilisateur.

Réauthentification et liaison de compte

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

Java

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

Kotlin+KTX

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

Et, vous pouvez utiliser linkWithCredential() pour relier les 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.

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 :

Java

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

Kotlin+KTX

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

Avancé : gérer le flux de connexion manuellement

Vous pouvez également authentifier avec Firebase en utilisant un compte Apple en manipulant le flux de connexion soit en utilisant le Sign-In JS SDK d' Apple, la construction manuellement le flux OAuth ou en utilisant une bibliothèque de OAuth tels 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'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 rejeu.

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

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

    Kotlin+KTX

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

    Ensuite, obtenez le hachage SHA246 du nonce sous forme de chaîne hexadécimale :

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

    Kotlin+KTX

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

    Vous enverrez le hachage SHA256 du nonce avec votre demande de connexion, qu'Apple transmettra tel quel dans la réponse. 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. Assurez-vous d'inclure le nonce haché en tant que paramètre dans votre demande.

  3. Après avoir reçu la réponse d'Apple, obtenir l'ID jeton de la réponse et de l' utiliser et le nonce pour créer non hachés un AuthCredential :

    Java

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

    Kotlin+KTX

    val credential =  OAuthProvider.newCredentialBuilder("apple.com")
        .setIdTokenWithRawNonce(appleIdToken, rawUnhashedNonce)
        .build()
    
  4. Authentifiez-vous auprès de Firebase à l'aide des identifiants Firebase :

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

    Kotlin+KTX

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

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

Prochaines étapes

Une fois qu'un utilisateur se connecte pour la première fois, un nouveau compte d'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'autorisation, avec lesquelles 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, quel que soit le mode de connexion de l'utilisateur.

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

  • Dans votre base de données et en temps réel Firebase Cloud Storage Les règles de auth sécurité , vous pouvez obtenir la signature dans ID d'utilisateur unique de l' utilisateur de la auth variable et l' utiliser pour contrôler les données d' un accès utilisateur peut.

Vous pouvez permettre aux utilisateurs de se connecter à votre application à l' aide des fournisseurs d'authentification multiples en reliant les informations d' identification de fournisseur auth à un compte d'utilisateur existant.

Pour vous déconnecter un utilisateur, appelez signOut :

Java

FirebaseAuth.getInstance().signOut();

Kotlin+KTX

Firebase.auth.signOut()