S'authentifier avec Apple sur Android

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 de commencer

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

Rejoindre l'Apple Developer Program

Seuls les membres du programme Apple Developer peuvent configurer "Se connecter avec Apple".

Configurer "Se connecter 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 la connexion 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, dont vous 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 l'ID de clé dans la section suivante.

  3. Si vous utilisez des fonctionnalités de Firebase Authentication qui envoient des e-mails aux utilisateurs, y compris la connexion par lien e-mail, la validation d'adresse e-mail, la révocation de modification de compte et d'autres, 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 relayer les e-mails envoyés par Firebase Authentication vers des adresses e-mail Apple anonymisées.

Activer Apple en tant que fournisseur d'identité

  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 Méthode de connexion, activez le fournisseur Apple. Indiquez l'ID de service que vous avez créé dans la section précédente. De plus, dans la section de configuration du flux de code OAuth, spécifiez 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

La fonctionnalité 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 S'identifier 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 d'identifier directement l'utilisateur à 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
  • Associez 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. Consultez le Contrat de licence du programme Apple Developer dans la section "Abonnement" de votre compte de 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. Créez une instance d'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 niveaux d'accès OAuth 2.0 supplémentaires au-delà 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 "e-mail" et "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. Consultez la documentation sur S'identifier avec Apple pour connaître les langues disponibles.

    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 auprès de Firebase à l'aide de l'objet du fournisseur OAuth. Notez que, contrairement aux autres opérations FirebaseAuth, celle-ci prendra 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 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. Pour éviter que l'utilisateur ne doive réessayer dans ce cas, 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) et la 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 le nom à afficher de l'utilisateur à Firebase.

Réauthentification et association de comptes

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

Kotlin 

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

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

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

Notez qu'Apple exige que vous obteniez le consentement explicite des utilisateurs avant d'associer 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 lors de la connexion de l'utilisateur à Facebook :

Kotlin 

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

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

Avancé : Gérer manuellement le flux de connexion

Vous pouvez également vous authentifier auprès de Firebase à l'aide d'un compte Apple en gérant le flux de connexion à l'aide du SDK Apple Sign-In JS, en créant manuellement le flux OAuth ou en utilisant 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 relecture.

    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 SHA256 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, qu'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'identité 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 auprès de 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 réussit, vous pouvez utiliser la méthode getCurrentUser pour obtenir les données du compte de l'utilisateur.

Révocation de jeton

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

De plus, 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 il 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 méthode de connexion de l'utilisateur.

    • 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