Skrivbordsapp som anropar webb-API:er: Hämta en token med integrerad Windows-autentisering

Om du vill logga in en domänanvändare på en domän eller en Microsoft Entra-ansluten dator använder du integrerad Windows-autentisering (IWA).

Krav

• Integrerad Windows-autentisering är endast tillgänglig för federerade+ användare, dvs. användare som skapats i Active Directory och som backas upp av Microsoft Entra-ID. Användare som skapats direkt i Microsoft Entra-ID utan Active Directory-stöd, så kallade hanterade användare, kan inte använda det här autentiseringsflödet. Den här begränsningen påverkar inte flödet för användarnamn och lösenord.

• IWA kringgår inte multifaktorautentisering (MFA). Om MFA har konfigurerats kan IWA misslyckas om en MFA-utmaning krävs, eftersom MFA kräver användarinteraktion.

  IWA är inte interaktivt, men MFA kräver användarinteraktivitet. Du styr inte när identitetsprovidern begär att MFA ska utföras, gör klientadministratören det. Från våra observationer krävs MFA när du loggar in från ett annat land/en annan region, när du inte är ansluten via VPN till ett företagsnätverk, och ibland även när du är ansluten via VPN. Förvänta dig inte en deterministisk uppsättning regler. Microsoft Entra ID använder AI för att kontinuerligt lära sig om MFA krävs. Återgå till en användarfråga som interaktiv autentisering eller enhetskodflöde om IWA misslyckas.

• Den myndighet som skickas in PublicClientApplicationBuilder måste vara:

  • Klientorganisation för formuläret https://login.microsoftonline.com/{tenant}/, där tenant är antingen det GUID som representerar klientorganisations-ID:t eller en domän som är associerad med klientorganisationen.
  • För alla arbets- och skolkonton: https://login.microsoftonline.com/organizations/.
  • Microsofts personliga konton stöds inte. Du kan inte använda /common- eller /consumers-klientorganisationer.

• Eftersom integrerad Windows-autentisering är ett tyst flöde:

  • Användaren av ditt program måste tidigare ha samtyckt till att använda programmet.
  • Eller så måste klientadministratören tidigare ha samtyckt till att alla användare i klientorganisationen använder programmet.
  • Med andra ord:
    • Antingen valde du som utvecklare knappen Bevilja i Azure Portal själv.
    • Eller så valde en klientadministratör knappen Bevilja/återkalla administratörsmedgivande för {klientdomän} på fliken API-behörigheter i registreringen för programmet. Mer information finns i Lägga till behörigheter för åtkomst till webb-API:et.
    • Eller så har du gett användarna ett sätt att samtycka till programmet. Mer information finns i Begära individuellt användarmedgivande.
    • Eller så har du gett klientadministratören ett sätt att samtycka till programmet. Mer information finns i Administratörsmedgivande.

• Det här flödet är aktiverat för .NET Desktop-, .NET- och UWP-appar.

Mer information om medgivande finns i Microsofts identitetsplattform behörigheter och medgivande.

Lär dig hur du använder den

.NET

I MSAL.NET använder du:

AcquireTokenByIntegratedWindowsAuth(IEnumerable<string> scopes)

Normalt behöver du bara en parameter (scopes). Beroende på hur Windows-administratören konfigurerar principerna kan det hända att program på Windows-datorn inte kan söka efter den inloggade användaren. I så fall använder du en andra metod, .WithUsername(), och skickar användarnamnet för den inloggade användaren som UPN-format, till exempel joe@contoso.com.

Följande exempel visar det mest aktuella fallet, med förklaringar av vilken typ av undantag du kan få och deras åtgärder.

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

Listan över möjliga modifierare på AcquireTokenByIntegratedWindowsAuthentication finns i AcquireTokenByIntegratedWindowsAuthParameterBuilder.

Java

Det här extraktet kommer från MSAL Java-kodexemplen.

   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

Det här flödet gäller inte för macOS.

Node.js

Det här flödet stöds ännu inte i MSAL Node.

Python

Det här flödet stöds ännu inte i MSAL Python.

Nästa steg

Gå vidare till nästa artikel i det här scenariot, Anropa ett webb-API från skrivbordsappen.