Choisir un fournisseur d’authentification Microsoft Graph en fonction du scénario

  • Article

Les fournisseurs d’authentification implémentent le code requis pour acquérir un jeton à l’aide de la bibliothèque d’authentification Microsoft (MSAL), gèrent certaines erreurs potentielles dans des cas tels que le consentement incrémentiel, les mots de passe expirés et l’accès conditionnel, puis définissent l’en-tête d’autorisation de requête HTTP. Le tableau suivant répertorie les fournisseurs qui correspondent aux scénarios des différents types d’applications.

Scénario Flux/octroi Audience Fournisseur
Application monopage Code d’autorisation avec PKCE Consommateur/organisation délégué Fournisseur de code d’autorisation
Application web qui appelle des API web
Code d’autorisation Consommateur/organisation délégué Fournisseur de code d’autorisation
Informations d’identification du client Application uniquement Fournisseur d’informations d’identification du client
API web qui appelle des API web
Au nom de Consommateur/organisation délégué Fournisseur de services de la part de
Informations d’identification du client Application uniquement Fournisseur d’informations d’identification du client
Application de bureau qui appelle des API web
Interactives Consommateur/organisation délégué Fournisseur interactif
Windows intégré Organisation déléguée Fournisseur Windows intégré
Propriétaire de la ressource Organisation déléguée Fournisseur de nom d’utilisateur/mot de passe
Code de l’appareil Organisation déléguée Fournisseur de code d’appareil
Application démon
Informations d’identification du client Application uniquement Fournisseur d’informations d’identification du client
Application mobile qui appelle des API web
Interactives Consommateur/organisation délégué Fournisseur interactif

Remarque

Les extraits de code suivants ont été écrits avec les dernières versions de leurs Kits de développement logiciel (SDK) respectifs. Si vous rencontrez des erreurs de compilateur avec ces extraits de code, vérifiez que vous disposez des dernières versions. Les bibliothèques d’identités Azure suivantes fournissent les fournisseurs d’authentification utilisés :

  • Les développeurs .NET doivent ajouter le package Azure.Identity .
  • Les développeurs TypeScript et JavaScript doivent ajouter la bibliothèque @azure/identité .
  • Les développeurs Java et Android doivent ajouter la bibliothèque azure-identity .

Fournisseur de code d’autorisation

Le flux de code d’autorisation permet aux applications natives et web d’obtenir des jetons dans le nom de l’utilisateur en toute sécurité. Pour plus d’informations, consultez flux de code d’autorisation Plateforme d'identités Microsoft et OAuth 2.0.

var scopes = new[] { "User.Read" };

// Multi-tenant apps can use "common",
// single-tenant apps must use the tenant ID from the Azure portal
var tenantId = "common";

// Values from app registration
var clientId = "YOUR_CLIENT_ID";
var clientSecret = "YOUR_CLIENT_SECRET";

// For authorization code flow, the user signs into the Microsoft
// identity platform, and the browser is redirected back to your app
// with an authorization code in the query parameters
var authorizationCode = "AUTH_CODE_FROM_REDIRECT";

// using Azure.Identity;
var options = new AuthorizationCodeCredentialOptions
{
    AuthorityHost = AzureAuthorityHosts.AzurePublicCloud,
};

// https://learn.microsoft.com/dotnet/api/azure.identity.authorizationcodecredential
var authCodeCredential = new AuthorizationCodeCredential(
    tenantId, clientId, clientSecret, authorizationCode, options);

var graphClient = new GraphServiceClient(authCodeCredential, scopes);

Fournisseur d’informations d’identification du client

Le flux d’informations d’identification du client permet aux applications de service de s’exécuter sans interaction de l’utilisateur. Access est basé sur l’identité de l’application. Pour plus d’informations, consultez Plateforme d'identités Microsoft et le flux d’informations d’identification du client OAuth 2.0.

Utilisation d’un certificat client

var scopes = new[] { "https://graph.microsoft.com/.default" };

// Values from app registration
var clientId = "YOUR_CLIENT_ID";
var tenantId = "YOUR_TENANT_ID";
var clientCertificate = new X509Certificate2("MyCertificate.pfx");

// using Azure.Identity;
var options = new ClientCertificateCredentialOptions
{
    AuthorityHost = AzureAuthorityHosts.AzurePublicCloud,
};

// https://learn.microsoft.com/dotnet/api/azure.identity.clientcertificatecredential
var clientCertCredential = new ClientCertificateCredential(
    tenantId, clientId, clientCertificate, options);

var graphClient = new GraphServiceClient(clientCertCredential, scopes);

Utilisation d’une clé secrète client

// The client credentials flow requires that you request the
// /.default scope, and pre-configure your permissions on the
// app registration in Azure. An administrator must grant consent
// to those permissions beforehand.
var scopes = new[] { "https://graph.microsoft.com/.default" };

// Values from app registration
var clientId = "YOUR_CLIENT_ID";
var tenantId = "YOUR_TENANT_ID";
var clientSecret = "YOUR_CLIENT_SECRET";

// using Azure.Identity;
var options = new ClientSecretCredentialOptions
{
    AuthorityHost = AzureAuthorityHosts.AzurePublicCloud,
};

// https://learn.microsoft.com/dotnet/api/azure.identity.clientsecretcredential
var clientSecretCredential = new ClientSecretCredential(
    tenantId, clientId, clientSecret, options);

var graphClient = new GraphServiceClient(clientSecretCredential, scopes);

Fournisseur de services de la part de

Le flux de la part de s’applique lorsque votre application appelle un service/UNE API web, qui appelle microsoft API Graph. En savoir plus en lisant Plateforme d'identités Microsoft et le flux On-Behalf-Of OAuth 2.0

var scopes = new[] { "https://graph.microsoft.com/.default" };

// Multi-tenant apps can use "common",
// single-tenant apps must use the tenant ID from the Azure portal
var tenantId = "common";

// Values from app registration
var clientId = "YOUR_CLIENT_ID";
var clientSecret = "YOUR_CLIENT_SECRET";

// using Azure.Identity;
var options = new OnBehalfOfCredentialOptions
{
    AuthorityHost = AzureAuthorityHosts.AzurePublicCloud,
};

// This is the incoming token to exchange using on-behalf-of flow
var oboToken = "JWT_TOKEN_TO_EXCHANGE";

var onBehalfOfCredential = new OnBehalfOfCredential(
    tenantId, clientId, clientSecret, oboToken, options);

var graphClient = new GraphServiceClient(onBehalfOfCredential, scopes);

Fournisseur implicite

Le flux d’authentification implicite n’est pas recommandé en raison de ses inconvénients. Les clients publics tels que les applications natives et les applications monopages doivent maintenant utiliser le flux de code d’autorisation avec l’extension PKCE à la place. Référence.

Fournisseur de code d’appareil

Le flux de code de l’appareil permet de se connecter aux appareils via un autre appareil. Pour plus d’informations, consultez Plateforme d'identités Microsoft et le flux de code d’appareil OAuth 2.0.

var scopes = new[] { "User.Read" };

// Multi-tenant apps can use "common",
// single-tenant apps must use the tenant ID from the Azure portal
var tenantId = "common";

// Value from app registration
var clientId = "YOUR_CLIENT_ID";

// using Azure.Identity;
var options = new DeviceCodeCredentialOptions
{
    AuthorityHost = AzureAuthorityHosts.AzurePublicCloud,
    ClientId = clientId,
    TenantId = tenantId,
    // Callback function that receives the user prompt
    // Prompt contains the generated device code that user must
    // enter during the auth process in the browser
    DeviceCodeCallback = (code, cancellation) =>
    {
        Console.WriteLine(code.Message);
        return Task.FromResult(0);
    },
};

// https://learn.microsoft.com/dotnet/api/azure.identity.devicecodecredential
var deviceCodeCredential = new DeviceCodeCredential(options);

var graphClient = new GraphServiceClient(deviceCodeCredential, scopes);

Fournisseur Windows intégré

Le flux Windows intégré permet aux ordinateurs Windows d’acquérir un jeton d’accès lorsqu’ils sont joints à un domaine en mode silencieux. Pour plus d’informations, consultez Authentification Windows intégrée.

Actuellement, le Azure.Identity package ne prend pas en charge l’authentification intégrée à Windows. Au lieu de cela, créez un fournisseur de jetons d’accès personnalisé à l’aide de MSAL.

Fournisseur de jetons d’accès

public class IntegratedWindowsTokenProvider : IAccessTokenProvider
{
    private readonly IPublicClientApplication publicClient;

    /// <summary>
    /// Initializes a new instance of the <see cref="IntegratedWindowsTokenProvider"/> class.
    /// </summary>
    /// <param name="clientId">The client ID from the app registration in Azure.</param>
    /// <param name="tenantId">The tenant ID from the app registration in Azure.</param>
    public IntegratedWindowsTokenProvider(string clientId, string tenantId)
    {
        // From MSAL (Microsoft.Identity.Client)
        publicClient = PublicClientApplicationBuilder
            .Create(clientId)
            .WithTenantId(tenantId)
            .Build();

        AllowedHostsValidator = new AllowedHostsValidator();
    }

    /// <summary>
    /// Gets an <see cref="AllowedHostsValidator"/> that validates if the
    /// target host of a request is allowed for authentication.
    /// </summary>
    public AllowedHostsValidator AllowedHostsValidator { get; }

    /// <inheritdoc/>
    public async Task<string> GetAuthorizationTokenAsync(
        Uri uri,
        Dictionary<string, object>? additionalAuthenticationContext = null,
        CancellationToken cancellationToken = default)
    {
        var scopes = new[] { "User.Read" };
        var result = await publicClient
            .AcquireTokenByIntegratedWindowsAuth(scopes)
            .ExecuteAsync(cancellationToken);
        return result.AccessToken;
    }
}

Créer le client

// Multi-tenant apps can use "common",
// single-tenant apps must use the tenant ID from the Azure portal
var tenantId = "common";

// Value from app registration
var clientId = "YOUR_CLIENT_ID";

var authenticationProvider = new BaseBearerTokenAuthenticationProvider(
    new IntegratedWindowsTokenProvider(clientId, tenantId));

var graphClient = new GraphServiceClient(authenticationProvider);

return graphClient;

Fournisseur interactif

Le flux interactif est utilisé par les applications mobiles (Xamarin et UWP) et les applications de bureau pour appeler Microsoft Graph dans le nom d’un utilisateur. Pour plus d’informations, consultez Acquisition interactive de jetons.

var scopes = new[] { "User.Read" };

// Multi-tenant apps can use "common",
// single-tenant apps must use the tenant ID from the Azure portal
var tenantId = "common";

// Value from app registration
var clientId = "YOUR_CLIENT_ID";

// using Azure.Identity;
var options = new InteractiveBrowserCredentialOptions
{
    TenantId = tenantId,
    ClientId = clientId,
    AuthorityHost = AzureAuthorityHosts.AzurePublicCloud,
    // MUST be http://localhost or http://localhost:PORT
    // See https://github.com/AzureAD/microsoft-authentication-library-for-dotnet/wiki/System-Browser-on-.Net-Core
    RedirectUri = new Uri("http://localhost"),
};

// https://learn.microsoft.com/dotnet/api/azure.identity.interactivebrowsercredential
var interactiveCredential = new InteractiveBrowserCredential(options);

var graphClient = new GraphServiceClient(interactiveCredential, scopes);

Fournisseur de nom d’utilisateur/mot de passe

Le fournisseur de nom d’utilisateur/mot de passe permet à une application de connecter un utilisateur à l’aide de son nom d’utilisateur et de son mot de passe. Utilisez ce flux uniquement lorsque vous ne pouvez pas utiliser d’autres flux OAuth. Pour plus d’informations, consultez Plateforme d'identités Microsoft et les informations d’identification du mot de passe du propriétaire de la ressource OAuth 2.0

var scopes = new[] { "User.Read" };

// Multi-tenant apps can use "common",
// single-tenant apps must use the tenant ID from the Azure portal
var tenantId = "common";

// Value from app registration
var clientId = "YOUR_CLIENT_ID";

// using Azure.Identity;
var options = new UsernamePasswordCredentialOptions
{
    AuthorityHost = AzureAuthorityHosts.AzurePublicCloud,
};

var userName = "adelev@contoso.com";
var password = "Password1!";

// https://learn.microsoft.com/dotnet/api/azure.identity.usernamepasswordcredential
var userNamePasswordCredential = new UsernamePasswordCredential(
    userName, password, tenantId, clientId, options);

var graphClient = new GraphServiceClient(userNamePasswordCredential, scopes);

Étapes suivantes