S'authentifier avec Microsoft sur Android

Vous pouvez permettre à vos utilisateurs de s'authentifier avec Firebase à l'aide de fournisseurs OAuth tels que Microsoft Azure Active Directory en intégrant la connexion OAuth générique sur le Web à votre application à l'aide du SDK Firebase pour effectuer le flux de connexion de bout en bout.

Avant de commencer

Pour permettre aux utilisateurs de se connecter à l'aide de comptes Microsoft (Azure Active Directory et comptes Microsoft personnels), vous devez d'abord activer Microsoft en tant que fournisseur de connexion pour votre projet Firebase:

1. Ajoutez Firebase à votre projet Android.

2. Dans la console Firebase, ouvrez la section Authentification.
3. Dans l'onglet Mode de connexion, activez le fournisseur Microsoft.
4. Ajoutez l'ID client et le code secret du client de la console de développement du fournisseur à la configuration du fournisseur :
   1. Pour enregistrer un client OAuth Microsoft, suivez les instructions de la section Démarrage rapide: enregistrer une application avec le point de terminaison Azure Active Directory v2.0. Notez que ce point de terminaison est compatible avec la connexion à l'aide de comptes personnels Microsoft et de comptes Azure Active Directory. En savoir plus sur Azure Active Directory v2.0
   2. Lorsque vous enregistrez des applications auprès de ces fournisseurs, veillez à enregistrer le domaine *.firebaseapp.com de votre projet comme domaine de redirection de votre application.
5. Cliquez sur Enregistrer.

6. Si vous n'avez pas encore spécifié l'empreinte SHA-1 de votre application, faites-le sur la page des paramètres de la console Firebase. Pour savoir comment obtenir l'empreinte SHA-1 de votre application, consultez la section Authentifier votre client.

Gérer le flux de connexion avec le SDK Firebase

Si vous créez une application Android, le moyen le plus simple d'authentifier vos utilisateurs avec Firebase à l'aide de leurs comptes Microsoft consiste à gérer l'ensemble du flux de connexion avec le SDK Android Firebase.

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 microsoft.com.

   Kotlin

   val provider = OAuthProvider.newBuilder("microsoft.com")
   GenericIdpActivity.kt

   Java

   OAuthProvider.Builder provider = OAuthProvider.newBuilder("microsoft.com");
   GenericIdpActivity.java

2. Facultatif: spécifiez des paramètres OAuth personnalisés supplémentaires que vous souhaitez envoyer avec la requête OAuth.

   Kotlin

   // Target specific email with login hint.
   // Force re-consent.
   provider.addCustomParameter("prompt", "consent")
   
   // Target specific email with login hint.
   provider.addCustomParameter("login_hint", "[e-mail]")
   GenericIdpActivity.kt

   Java

   // Target specific email with login hint.
   // Force re-consent.
   provider.addCustomParameter("prompt", "consent");
   
   // Target specific email with login hint.
   provider.addCustomParameter("login_hint", "[e-mail]");
   GenericIdpActivity.java

   Pour connaître les paramètres compatibles avec Microsoft, consultez la documentation Microsoft OAuth. Notez que vous ne pouvez pas transmettre de paramètres requis par Firebase avec setCustomParameters(). Ces paramètres sont client_id, response_type, redirect_uri, state, scope et response_mode.

   Pour n'autoriser que les utilisateurs d'un locataire Azure AD particulier à se connecter à l'application, vous pouvez utiliser le nom de domaine convivial du locataire Azure AD ou son identifiant GUID. Pour ce faire, spécifiez le champ "tenant" dans l'objet des paramètres personnalisés.

   Kotlin

   // Optional "tenant" parameter in case you are using an Azure AD tenant.
   // eg. '8eaef023-2b34-4da1-9baa-8bc8c9d6a490' or 'contoso.onmicrosoft.com'
   // or "common" for tenant-independent tokens.
   // The default value is "common".
   provider.addCustomParameter("tenant", "TENANT_ID")
   GenericIdpActivity.kt

   Java

   // Optional "tenant" parameter in case you are using an Azure AD tenant.
   // eg. '8eaef023-2b34-4da1-9baa-8bc8c9d6a490' or 'contoso.onmicrosoft.com'
   // or "common" for tenant-independent tokens.
   // The default value is "common".
   provider.addCustomParameter("tenant", "TENANT_ID");
   GenericIdpActivity.java

3. Facultatif: spécifiez des champs d'application OAuth 2.0 supplémentaires au-delà du profil de base que vous souhaitez demander au fournisseur d'authentification.

   Kotlin

   // Request read access to a user's email addresses.
   // This must be preconfigured in the app's API permissions.
   provider.scopes = listOf("mail.read", "calendars.read")
   GenericIdpActivity.kt

   Java

   // Request read access to a user's email addresses.
   // This must be preconfigured in the app's API permissions.
   List<String> scopes =
           new ArrayList<String>() {
               {
                   add("mail.read");
                   add("calendars.read");
               }
           };
   provider.setScopes(scopes);
   GenericIdpActivity.java

   Pour en savoir plus, consultez la documentation Microsoft sur les autorisations et le consentement.

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 affichant 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 via 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 pendingResultTask = firebaseAuth.pendingAuthResult
   if (pendingResultTask != null) {
       // There's something already here! Finish the sign-in for your user.
       pendingResultTask
           .addOnSuccessListener {
               // User is signed in.
               // IdP data available in
               // authResult.getAdditionalUserInfo().getProfile().
               // The OAuth access token can also be retrieved:
               // ((OAuthCredential)authResult.getCredential()).getAccessToken().
               // The OAuth secret can be retrieved by calling:
               // ((OAuthCredential)authResult.getCredential()).getSecret().
           }
           .addOnFailureListener {
               // Handle failure.
           }
   } else {
       // There's no pending result so you need to start the sign-in flow.
       // See below.
   }
   GenericIdpActivity.kt

   Java

   Task<AuthResult> pendingResultTask = firebaseAuth.getPendingAuthResult();
   if (pendingResultTask != null) {
       // There's something already here! Finish the sign-in for your user.
       pendingResultTask
               .addOnSuccessListener(
                       new OnSuccessListener<AuthResult>() {
                           @Override
                           public void onSuccess(AuthResult authResult) {
                               // User is signed in.
                               // IdP data available in
                               // authResult.getAdditionalUserInfo().getProfile().
                               // The OAuth access token can also be retrieved:
                               // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                               // The OAuth secret can be retrieved by calling:
                               // ((OAuthCredential)authResult.getCredential()).getSecret().
                           }
                       })
               .addOnFailureListener(
                       new OnFailureListener() {
                           @Override
                           public void onFailure(@NonNull Exception e) {
                               // Handle failure.
                           }
                       });
   } else {
       // There's no pending result so you need to start the sign-in flow.
       // See below.
   }
   GenericIdpActivity.java

   Pour démarrer le flux de connexion, appelez startActivityForSignInWithProvider:

   Kotlin

   firebaseAuth
       .startActivityForSignInWithProvider(activity, provider.build())
       .addOnSuccessListener {
           // User is signed in.
           // IdP data available in
           // authResult.getAdditionalUserInfo().getProfile().
           // The OAuth access token can also be retrieved:
           // ((OAuthCredential)authResult.getCredential()).getAccessToken().
           // The OAuth secret can be retrieved by calling:
           // ((OAuthCredential)authResult.getCredential()).getSecret().
       }
       .addOnFailureListener {
           // Handle failure.
       }
   GenericIdpActivity.kt

   Java

   firebaseAuth
           .startActivityForSignInWithProvider(/* activity= */ this, provider.build())
           .addOnSuccessListener(
                   new OnSuccessListener<AuthResult>() {
                       @Override
                       public void onSuccess(AuthResult authResult) {
                           // User is signed in.
                           // IdP data available in
                           // authResult.getAdditionalUserInfo().getProfile().
                           // The OAuth access token can also be retrieved:
                           // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                           // The OAuth secret can be retrieved by calling:
                           // ((OAuthCredential)authResult.getCredential()).getSecret().
                       }
                   })
           .addOnFailureListener(
                   new OnFailureListener() {
                       @Override
                       public void onFailure(@NonNull Exception e) {
                           // Handle failure.
                       }
                   });
   GenericIdpActivity.java

   Une fois l'opération terminée, le jeton d'accès OAuth associé au fournisseur peut être récupéré à partir de l'objet OAuthCredential renvoyé.

   À l'aide du jeton d'accès OAuth, vous pouvez appeler l'API Microsoft Graph.

   Contrairement aux autres fournisseurs acceptés par Firebase Auth, Microsoft ne fournit pas d'URL de photo. Les données binaires d'une photo de profil doivent être demandées via l'API Microsoft Graph.

   En plus du jeton d'accès OAuth, le jeton d'ID OAuth de l'utilisateur peut également être récupéré à partir de l'objet OAuthCredential. La revendication sub dans le jeton d'identification est spécifique à l'application et ne correspond pas à l'identifiant utilisateur fédéré utilisé par Firebase Auth et accessible via user.getProviderData().get(0).getUid(). Le champ de revendication oid doit être utilisé à la place. Lorsque vous utilisez un locataire Azure AD pour vous connecter, la revendication oid correspond exactement. Toutefois, dans le cas d'un locataire, le champ oid est rempli. Pour un ID fédéré 4b2eabcdefghijkl, oid aura la forme 00000000-0000-0000-4b2e-abcdefghijkl.

5. Bien que les exemples ci-dessus se concentrent sur les flux de connexion, vous pouvez également associer un fournisseur Microsoft à un utilisateur existant à l'aide de startActivityForLinkWithProvider. Par exemple, vous pouvez associer plusieurs fournisseurs au même utilisateur, ce qui lui permet de se connecter avec l'un ou l'autre.

   Kotlin

   // The user is already signed-in.
   val firebaseUser = firebaseAuth.currentUser!!
   firebaseUser
       .startActivityForLinkWithProvider(activity, provider.build())
       .addOnSuccessListener {
           // Provider credential is linked to the current user.
           // IdP data available in
           // authResult.getAdditionalUserInfo().getProfile().
           // The OAuth access token can also be retrieved:
           // authResult.getCredential().getAccessToken().
           // The OAuth secret can be retrieved by calling:
           // authResult.getCredential().getSecret().
       }
       .addOnFailureListener {
           // Handle failure.
       }
   GenericIdpActivity.kt

   Java

   // The user is already signed-in.
   FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();
   
   firebaseUser
           .startActivityForLinkWithProvider(/* activity= */ this, provider.build())
           .addOnSuccessListener(
                   new OnSuccessListener<AuthResult>() {
                       @Override
                       public void onSuccess(AuthResult authResult) {
                           // Provider credential is linked to the current user.
                           // IdP data available in
                           // authResult.getAdditionalUserInfo().getProfile().
                           // The OAuth access token can also be retrieved:
                           // authResult.getCredential().getAccessToken().
                           // The OAuth secret can be retrieved by calling:
                           // authResult.getCredential().getSecret().
                       }
                   })
           .addOnFailureListener(
                   new OnFailureListener() {
                       @Override
                       public void onFailure(@NonNull Exception e) {
                           // Handle failure.
                       }
                   });
   GenericIdpActivity.java

6. Le même schéma peut être utilisé avec startActivityForReauthenticateWithProvider, qui peut être utilisé pour récupérer de nouveaux identifiants pour les opérations sensibles qui nécessitent une connexion récente.

   Kotlin

   // The user is already signed-in.
   val firebaseUser = firebaseAuth.currentUser!!
   firebaseUser
       .startActivityForReauthenticateWithProvider(activity, provider.build())
       .addOnSuccessListener {
           // User is re-authenticated with fresh tokens and
           // should be able to perform sensitive operations
           // like account deletion and email or password
           // update.
       }
       .addOnFailureListener {
           // Handle failure.
       }
   GenericIdpActivity.kt

   Java

   // The user is already signed-in.
   FirebaseUser firebaseUser = firebaseAuth.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.
                       }
                   });
   GenericIdpActivity.java

Avancé: gérer manuellement le flux de connexion

Contrairement aux autres fournisseurs OAuth compatibles avec Firebase, tels que Google, Facebook et Twitter, où la connexion peut être effectuée directement avec des identifiants basés sur des jetons d'accès OAuth, Firebase Authentication n'offre pas la même fonctionnalité pour les fournisseurs tels que Microsoft, car le serveur Firebase Authentication ne peut pas vérifier l'audience des jetons d'accès OAuth Microsoft. Il s'agit d'une exigence de sécurité critique qui pourrait exposer les applications et les sites Web à des attaques par rejeu, où un jeton d'accès Microsoft OAuth obtenu pour un projet (pirate informatique) peut être utilisé pour se connecter à un autre projet (victime). Firebase Auth permet plutôt de gérer l'ensemble du flux OAuth et l'échange du code d'autorisation à l'aide de l'ID client OAuth et du secret configurés dans la console Firebase. Comme le code d'autorisation ne peut être utilisé qu'avec un ID client/secret spécifique, un code d'autorisation obtenu pour un projet ne peut pas être utilisé avec un autre.

Si vous devez utiliser ces fournisseurs dans des environnements non compatibles, vous devez utiliser une bibliothèque OAuth tierce et l'authentification personnalisée Firebase. Le premier est nécessaire pour s'authentifier auprès du fournisseur, et le second pour échanger les identifiants du fournisseur contre un jeton personnalisé.

É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