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 des 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 le programme Apple Developer

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

Configurer Se connecter avec Apple

Sur le site Apple Developer :

  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 comme URL de retour :

    https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler

    Vous trouverez l'ID de votre projet Firebase dans les Settings > General tab de la Firebase console.

    Une fois que 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 votre ID de clé dans la section suivante.

  3. Si vous utilisez l'une des fonctionnalités de Firebase Authentication qui envoie des e-mails aux utilisateurs, y compris la connexion par lien, la validation d'adresse e-mail, la révocation de modification de compte, et autres, 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 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 Android.
  2. Spécifiez l'empreinte SHA-1 de votre application si ce n'est pas déjà fait.
    1. Dans la console Firebase, accédez aux Settings > General (Paramètres > Général).
    2. Faites défiler la page jusqu'à la fiche Your apps (Vos applications), sélectionnez votre application Android, puis ajoutez votre empreinte SHA-1 dans le champ SHA certificate fingerprints (Empreintes de certificat SHA).
  3. Dans la console Firebase, accédez à Security > Authentication.
  4. Dans l'onglet Sign-in method (Mode de connexion), activez le fournisseur de connexion Apple. Spécifiez l'ID de service que vous avez créé dans la section précédente. Dans la section OAuth code flow configuration (Configuration du flux de code OAuth), spécifiez é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 de données anonymes d'Apple

Se connecter avec Apple permet aux utilisateurs d'anonymiser leurs données, y compris leur adresse e-mail, lors de la connexion. 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 tout consentement utilisateur requis avant d'associer des informations personnelles directement identifiables à 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 "Membership" (Adhésion) 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 auprès de 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 pour Android, 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 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 "email" et "name". Si vous remplacez ce paramètre par 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 Se connecter avec Apple pour connaître les paramètres régionaux compatibles.

    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 de fournisseur OAuth. Notez que, contrairement à d'autres opérations FirebaseAuth, cette opération 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 écouteurs OnSuccessListener et OnFailureListener que vous associez, car ils seront immédiatement dissociés lorsque l'opération démarrera l'UI.

    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. Pour vous assurer que l'utilisateur n'a pas à 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 Authentication, 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, que vous pouvez 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 modèle 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 vous demande d'obtenir 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 que vous avez obtenu en connectant 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.
        }
      }
    });

Méthode avancée : 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 JS Apple Sign-In, 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();
}

    Ensuite, obtenez 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 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 qui permettent de créer un compte autorisent les utilisateurs à lancer la suppression de leur compte dans l'application, comme décrit dans les Règles d'évaluation de l'App Store

De plus, les applications qui acceptent 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 à l'aide d'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 méthode de connexion utilisée.

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

    • Dans les règles de sécurité de votre Firebase Realtime Database et Cloud Storage Security Rules, 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()

    Java

    FirebaseAuth.getInstance().signOut();