Appareil de bureau qui appelle des API web : acquérir un jeton en utilisant l’authentification Windows intégrée

Pour connecter un utilisateur de domaine sur un domaine ou un ordinateur rejoint par Microsoft Entra, utilisez l'Authentification Windows intégrée (IWA).

Contraintes

• L'Authentification Windows intégrée est disponible uniquement pour les utilisateurs fédérés+, c'est-à-dire les utilisateurs créés dans Active Directory et soutenus par Microsoft Entra ID. Les utilisateurs créés directement dans Microsoft Entra ID sans support Active Directory, appelés utilisateurs gérés, ne peuvent pas utiliser ce flux d'authentification. Cette restriction ne concerne pas le flux de nom d’utilisateur et de mot de passe.

• IWA ne permet pas de contourner l’authentification multifacteur (MFA). Si l’authentification MFA est configurée, IWA peut échouer en cas de demande MFA exigée, car MFA a besoin d’une interaction utilisateur.

  L’authentification IWA est non interactive, mais MFA nécessite l’interactivité avec l’utilisateur. Vous n’avez pas le contrôle lorsque le fournisseur d’identité demande l’exécution de MFA, l’administrateur de locataire, si. D’après ce que nous avons pu observer, l’authentification MFA est demandée lorsque vous vous connectez depuis un autre pays/région alors que vous n’êtes pas connecté à un réseau d’entreprise via un VPN, et parfois même lorsque vous êtes connecté via un VPN. Ne vous attendez pas à un ensemble déterministe de règles. Microsoft Entra ID utilise l'IA pour savoir en permanence si la MFA est requise. Ayez recours à une invite utilisateur de secours, comme une authentification interactive ou un flux de code d’appareil, si l’IWA échoue.

• L’autorité transmise dans PublicClientApplicationBuilder doit être :

  • Avec locataire sous le format https://login.microsoftonline.com/{tenant}/, dans lequel tenant est le GUID qui représente l’ID de locataire ou un domaine associé au locataire.
  • Pour les comptes professionnels et scolaires : https://login.microsoftonline.com/organizations/.
  • Les comptes Microsoft personnels ne sont pas pris en charge. Vous ne pouvez pas utiliser les locataires /common ou /consumers.

• Étant donné que l’authentification Windows intégrée est un flux silencieux :

  • L’utilisateur de votre application doit avoir précédemment donné son consentement pour utiliser l’application.
  • Ou bien, l’administrateur de locataires doit avoir préalablement consenti à ce que tous les utilisateurs dans le locataire utilisent l’application.
  • En d’autres termes :
    • En tant que développeur, vous avez sélectionné le bouton Accorder pour vous-même, dans le portail Azure.
    • Ou bien, un administrateur de locataire a sélectionné le bouton Accorder/révoquer le consentement administrateur pour {domaine du locataire} dans l’onglet Autorisations de l’API lors de l’inscription de l’application. Pour plus d’informations, consultez Ajouter des autorisations pour accéder à votre API web.
    • Ou bien, vous avez fourni un moyen aux utilisateurs de donner leur consentement pour l’utilisation de l’application. Pour plus d’informations, consultez Demande de consentement d’utilisateur individuel.
    • Ou bien, vous avez fourni un moyen à l’administrateur de locataire de donner son consentement pour l’utilisation de l’application. Pour plus d’informations, consultez Consentement administrateur.

• Ce flux est activé pour les applications .NET Desktop, .NET et UWP.

Pour plus d’informations sur le consentement, consultez Autorisations et consentement de la plateforme d’identités Microsoft.

Découvrez son utilisation

.NET

Dans MSAL.NET, utilisez ceci :

AcquireTokenByIntegratedWindowsAuth(IEnumerable<string> scopes)

Vous n’avez normalement besoin que d’un paramètre (scopes). En fonction de la façon dont votre administrateur Windows a configuré les stratégies, les applications sur votre machine Windows peuvent ne pas être autorisées à rechercher l’utilisateur connecté. Dans ce cas, utilisez une deuxième méthode, .WithUsername(), et passez le nom d’utilisateur de l’utilisateur connecté sous un format UPN, par exemple, joe@contoso.com.

L’exemple suivant met en évidence le cas le plus courant, avec des explications sur le genre d’exceptions que vous pouvez obtenir et les solutions d’atténuation.

static async Task GetATokenForGraph()
{
 string authority = "https://login.microsoftonline.com/contoso.com";
 string[] scopes = new string[] { "user.read" };
 IPublicClientApplication app = PublicClientApplicationBuilder
      .Create(clientId)
      .WithAuthority(authority)
      .Build();

 var accounts = await app.GetAccountsAsync();

 AuthenticationResult result = null;
 if (accounts.Any())
 {
  result = await app.AcquireTokenSilent(scopes, accounts.FirstOrDefault())
      .ExecuteAsync();
 }
 else
 {
  try
  {
   result = await app.AcquireTokenByIntegratedWindowsAuth(scopes)
      .ExecuteAsync(CancellationToken.None);
  }
  catch (MsalUiRequiredException ex)
  {
   // MsalUiRequiredException: AADSTS65001: The user or administrator has not consented to use the application
   // with ID '{appId}' named '{appName}'.Send an interactive authorization request for this user and resource.

   // you need to get user consent first. This can be done, if you are not using .NET (which does not have any Web UI)
   // by doing (once only) an AcquireToken interactive.

   // If you are using .NET or don't want to do an AcquireTokenInteractive, you might want to suggest the user to navigate
   // to a URL to consent: https://login.microsoftonline.com/common/oauth2/v2.0/authorize?client_id={clientId}&response_type=code&scope=user.read

   // AADSTS50079: The user is required to use multi-factor authentication.
   // There is no mitigation - if MFA is configured for your tenant and AAD decides to enforce it,
   // you need to fallback to an interactive flows such as AcquireTokenInteractive or AcquireTokenByDeviceCode
   }
   catch (MsalServiceException ex)
   {
    // Kind of errors you could have (in ex.Message)

    // MsalServiceException: AADSTS90010: The grant type is not supported over the /common or /consumers endpoints. Please use the /organizations or tenant-specific endpoint.
    // you used common.
    // Mitigation: as explained in the message from Azure AD, the authority needs to be tenanted or otherwise organizations

    // MsalServiceException: AADSTS70002: The request body must contain the following parameter: 'client_secret or client_assertion'.
    // Explanation: this can happen if your application was not registered as a public client application in Azure AD
    // Mitigation: in the Azure portal, edit the manifest for your application and set the `allowPublicClient` to `true`
   }
   catch (MsalClientException ex)
   {
      // Error Code: unknown_user Message: Could not identify logged in user
      // Explanation: the library was unable to query the current Windows logged-in user or this user is not AD or AAD
      // joined (work-place joined users are not supported).

      // Mitigation 1: on UWP, check that the application has the following capabilities: Enterprise Authentication,
      // Private Networks (Client and Server), User Account Information

      // Mitigation 2: Implement your own logic to fetch the username (e.g. john@contoso.com) and use the
      // AcquireTokenByIntegratedWindowsAuth form that takes in the username

      // Error Code: integrated_windows_auth_not_supported_managed_user
      // Explanation: This method relies on a protocol exposed by Active Directory (AD). If a user was created in Azure
      // Active Directory without AD backing ("managed" user), this method will fail. Users created in AD and backed by
      // AAD ("federated" users) can benefit from this non-interactive method of authentication.
      // Mitigation: Use interactive authentication
   }
 }

 Console.WriteLine(result.Account.Username);
}

Pour la liste des modificateurs possibles sur AcquireTokenByIntegratedWindowsAuthentication, voir AcquireTokenByIntegratedWindowsAuthParameterBuilder.

Java

Voici un extrait des exemples de code MSAL Java.

   PublicClientApplication pca = PublicClientApplication.builder(clientId)
                .authority(authority)
                .build();

        Set<IAccount> accountsInCache = pca.getAccounts().join();
        IAccount account = getAccountByUsername(accountsInCache, username);

        //Attempt to acquire token when user's account is not in the application's token cache
        IAuthenticationResult result = acquireTokenIntegratedWindowsAuth(pca, scope, account, username);
        System.out.println("Account username: " + result.account().username());
        System.out.println("Access token:     " + result.accessToken());
        System.out.println("Id token:         " + result.idToken());
        System.out.println();

        //Get list of accounts from the application's token cache, and search them for the configured username
        //getAccounts() will be empty on this first call, as accounts are added to the cache when acquiring a token
        accountsInCache = pca.getAccounts().join();
        account = getAccountByUsername(accountsInCache, username);

        //Attempt to acquire token again, now that the user's account and a token are in the application's token cache
        result = acquireTokenIntegratedWindowsAuth(pca, scope, account, username);
        System.out.println("Account username: " + result.account().username());
        System.out.println("Access token:     " + result.accessToken());
        System.out.println("Id token:         " + result.idToken());
    }

    private static IAuthenticationResult acquireTokenIntegratedWindowsAuth( PublicClientApplication pca,
                                                                            Set<String> scope,
                                                                            IAccount account,
                                                                            String username) throws Exception {

        IAuthenticationResult result;
        try {
            SilentParameters silentParameters =
                    SilentParameters
                            .builder(scope)
                            .account(account)
                            .build();
            // Try to acquire token silently. This will fail on the first acquireTokenIntegratedWindowsAuth() call
            // because the token cache does not have any data for the user you are trying to acquire a token for
            result = pca.acquireTokenSilently(silentParameters).join();
            System.out.println("==acquireTokenSilently call succeeded");
        } catch (Exception ex) {
            if (ex.getCause() instanceof MsalException) {
                System.out.println("==acquireTokenSilently call failed: " + ex.getCause());
                IntegratedWindowsAuthenticationParameters parameters =
                        IntegratedWindowsAuthenticationParameters
                                .builder(scope, username)
                                .build();

                // Try to acquire a token using Integrated Windows Authentication (IWA). You will need to generate a Kerberos ticket.
                // If successful, you should see the token and account information printed out to console
                result = pca.acquireToken(parameters).join();
                System.out.println("==Integrated Windows Authentication flow succeeded");
            } else {
                // Handle other exceptions accordingly
                throw ex;
            }
        }
        return result;
    }

macOS

Ce flux ne s’applique pas à macOS.

Node.JS

Ce flux n’est pas encore pris en charge dans MSAL Node.

Python

Ce flux n’est pas encore pris en charge dans MSAL Python.

Étapes suivantes

Passez à l’article suivant de ce scénario, Appeler une API web à partir de l’appareil de bureau.