Desktopová aplikace, která volá webová rozhraní API: Získání tokenu pomocí integrovaného ověřování systému Windows

Pokud se chcete přihlásit uživatele domény na doméně nebo počítači připojeném k Microsoft Entra, použijte integrované ověřování Systému Windows (IWA).

Omezení

• Integrované ověřování systému Windows je k dispozici pouze pro federované a uživatele, tj. uživatele vytvořené ve službě Active Directory a na základě Microsoft Entra ID. Uživatelé vytvořené přímo v Microsoft Entra ID bez zálohování služby Active Directory, označované jako spravované uživatele, nemůžou tento tok ověřování používat. Toto omezení nemá vliv na tok uživatelského jména a hesla.

• IWA neobejde vícefaktorové ověřování (MFA). Pokud je nakonfigurované vícefaktorové ověřování, může IWA selhat, pokud se vyžaduje výzva vícefaktorového ověřování, protože vícefaktorové ověřování vyžaduje interakci uživatele.

  IWA není interaktivní, ale vícefaktorové ověřování vyžaduje interaktivitu uživatelů. Neřídíte, kdy zprostředkovatel identity požaduje, aby se provedlo vícefaktorové ověřování, správce tenanta. Z našich pozorování se vícefaktorové ověřování vyžaduje, když se přihlásíte z jiné země nebo oblasti, když nejste připojení přes VPN k podnikové síti, a někdy i při připojení přes SÍŤ VPN. Neočekávejte deterministický soubor pravidel. Microsoft Entra ID používá AI k průběžnému učení, jestli se vyžaduje vícefaktorové ověřování. Pokud selže IWA, vraťte se k výzvě uživatele, jako je interaktivní ověřování nebo tok kódu zařízení.

• Orgán předaný PublicClientApplicationBuilder musí být:

  • Tenanted of the form https://login.microsoftonline.com/{tenant}/, where tenant is the GUID that represent the tenant ID or a domain associated with the tenant.
  • Pro všechny pracovní a školní účty: https://login.microsoftonline.com/organizations/.
  • Osobní účty Microsoft nejsou podporované. Tenanty /common ani /consumers nemůžete použít.

• Vzhledem k tomu, že integrované ověřování systému Windows je bezobslužný tok:

  • Uživatel vaší aplikace musel dříve odsouhlasit použití aplikace.
  • Nebo správce tenanta musel dříve odsouhlasit všechny uživatele v tenantovi, aby mohli aplikaci používat.
  • Jinými slovy:
    • Buď jste jako vývojář vybrali tlačítko Udělit na webu Azure Portal sami.
    • Nebo správce tenanta vybral na kartě Oprávnění rozhraní API pro registraci aplikace tlačítko Udělit nebo odvolat souhlas správce pro {tenant domain}. Další informace najdete v tématu Přidání oprávnění pro přístup k webovému rozhraní API.
    • Nebo jste uživatelům poskytli způsob vyjádření souhlasu s aplikací. Další informace najdete v tématu Žádost o souhlas jednotlivého uživatele.
    • Nebo jste správci tenanta poskytli způsob, jak udělit souhlas s aplikací. Další informace najdete v tématu Správa souhlasu.

• Tento tok je povolený pro aplikace .NET Desktop, .NET a UPW.

Další informace o souhlasu najdete v oprávněních a souhlasu platformy Microsoft Identity Platform.

Zjistěte, jak ho používat.

.NET

V MSAL.NET použijte:

AcquireTokenByIntegratedWindowsAuth(IEnumerable<string> scopes)

Obvykle potřebujete jenom jeden parametr (scopes). V závislosti na způsobu, jakým správce Systému Windows nastavil zásady, nemusí být aplikace na vašem počítači s Windows povolené vyhledávat přihlášeného uživatele. V takovém případě použijte druhou metodu .WithUsername()a předejte uživatelské jméno přihlášeného uživatele jako formát hlavního názvu uživatele , například joe@contoso.com.

Následující ukázka představuje nejaktuálnější případ s vysvětlením druhu výjimek, které můžete získat a jejich zmírnění.

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

Seznam možných modifikátorů na AcquireTokenByIntegratedWindowsAuthentication naleznete v tématu AcquireTokenByIntegratedWindowsAuthParameterBuilder.

Java

Tento extrahování pochází z ukázek kódu JAZYKA JAVA MSAL.

   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

Tento tok se nevztahuje na macOS.

Node.js

Tento tok se zatím v uzlu MSAL nepodporuje.

Python

Tento tok se zatím v MSAL Pythonu nepodporuje.

Další kroky

Přejděte k dalšímu článku v tomto scénáři volání webového rozhraní API z desktopové aplikace.