Passer au contenu principal
Le code source complet de l’implémentation ASP.NET Core se trouve dans ce répertoire GitHub.

​
Configurer le témoin et le logiciel médiateur OIDC

Pour les besoins de ce guide, nous utiliserons une simple connexion hébergée. Vous pouvez utiliser le témoin standard et le logiciel médiateur OIDC qui est disponible avec ASP.NET Core, assurez-vous donc d’installer les paquets NuGet. 
Install-Package Microsoft.AspNetCore.Authentication.Cookies
Install-Package Microsoft.AspNetCore.Authentication.OpenIdConnect
Configurez ensuite le logiciel médiateur OIDC et le témoin dans le pipeline du logiciel médiateur de votre application. 
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Add authentication services
        services.AddAuthentication(
            options => options.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme);

        // Code omitted for brevity...
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IOptions<Auth0Settings> auth0Settings)
    {
        // Code omitted for brevity...

        // Add the cookie middleware
        app.UseCookieAuthentication(new CookieAuthenticationOptions
        {
            AutomaticAuthenticate = true,
            AutomaticChallenge = true
        });

        // Add the OIDC middleware
        app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions("Auth0")
        {
            // Set the authority to your Auth0 domain
            Authority = "https://{yourDomain}/",

            // Configure the Auth0 Client ID and Client Secret
            ClientId = {yourClientId},
            ClientSecret = YOUR_CLIENT_SECRET,

            // Do not automatically authenticate and challenge
            AutomaticAuthenticate = false,
            AutomaticChallenge = false,

            // Set response type to code
            ResponseType = "code",

            CallbackPath = new PathString("/signin-auth0"),

            // Configure the Claims Issuer to be Auth0
            ClaimsIssuer = "Auth0"
        });

        // Code omitted for brevity...
    }
}
Comme vous pouvez le voir dans le code ci-dessus, nous avons configuré deux types différents du logiciel médiateur d’authentification. Le premier est le logiciel médiateur de gestion des témoin qui a été enregistré avec l’appel à UseCookieAuthentication. Le second est le logiciel médiateur OIDC qui a été enregistré avec l’appel à UseOpenIdConnectAuthentication. Une fois que l’utilisateur s’est connecté à Auth0 à l’aide du logiciel médiateur OIDC, ses informations sont automatiquement stockées dans un témoin de session. Il suffit de configurer le logiciel médiateur comme indiqué ci-dessus pour qu’il s’occupe de la gestion de la session de l’utilisateur. Le logiciel médiateur  Connect (OIDC) extraira également toutes les demandes du jeton d’ID, qui est envoyé par Auth0 une fois que l’utilisateur s’est authentifié, et les ajoutera en tant que demandes sur le ClaimsIdentity.

​
Mise en œuvre de la déconnexion

Vous pouvez contrôler à la fois la session de l’application et la session Auth0 en utilisant la méthode SignOutAsync de la classe AuthenticationManager, et en transmettant le schéma d’authentification à partir duquel vous souhaitez vous déconnecter. Par exemple, pour se déconnecter du logiciel médiateur de gestion des témoins, et ainsi effacer le témoin d’authentification de votre application, vous pouvez effectuer l’appel suivant : 
await HttpContext.Authentication.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
De même, vous pouvez déconnecter l’utilisateur d’Auth0 en appelant la méthode SignOutAsync et en transmettant Auth0 comme schéma d’authentification à déconnecter. 
await HttpContext.Authentication.SignOutAsync("Auth0");
Pour que cela fonctionne, vous devrez cependant ajouter une configuration supplémentaire lors de l’enregistrement du logiciel médiateur OIDC en gérant l’événement OnRedirectToIdentityProviderForSignOut. Dans cet événement, vous devrez rediriger vers le point de terminaison de déconnexion Auth0, ce qui effacera le témoin Auth0. 
app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions("Auth0")
{
    // Some code omitted for brevity
    Events = new OpenIdConnectEvents
    {
        OnRedirectToIdentityProviderForSignOut = context =>
        {
            context.Response.Redirect($"https://{auth0Settings.Value.Domain}/v2/logout?client_id={auth0Settings.Value.ClientId}&returnTo={context.Request.Scheme}://{context.Request.Host}/");
            context.HandleResponse();

            return Task.FromResult(0);
        }
    }
});
Vous devrez également vous assurer que vous ajoutez l’URL de votre application à URL de déconnexion autorisées de votre application dans le tableau de bord Auth0. Pour plus d’informations, reportez-vous à Déconnexion.

​
Mettre en oeuvre les permissions d’administration

La manière la plus simple d’intégrer les groupes dans une application ASP.NET Core est d’utiliser l’autorisation intégrée Autorisation basée sur les rôles disponible dans ASP.NET Core. Pour ce faire, nous devrons ajouter une Demande de type 
http://schemas.microsoft.com/ws/2008/06/identity/claims/role
pour chacun des groupes auxquels un utilisateur est assigné. Une fois les demandes ajoutées, nous pouvons facilement nous assurer qu’une action spécifique n’est disponible que pour les utilisateurs Admin en décorant la demande avec l’attribut [Authorize(Roles = "Admin")]. Vous pouvez également vérifier si un utilisateur occupe un rôle spécifique à partir du code en appelant User.IsInRole("Admin") à l’intérieur de votre contrôleur. Le logiciel médiateur ASP.NET OIDC ajoutera automatiquement toutes les demandes renvoyées dans le en tant que demandes à l’identité ClaimsIdentity. Nous devrions donc extraire les informations de la demande authorization, désérialiser le corps JSON de la demande et, pour chacun des groupes, ajouter une demande http://schemas.microsoft.com/ws/2008/06/identity/claims/role à ClaimsIdentity. 
app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions("Auth0")
{
    // Some configuration omitted for brevity

    Events = new OpenIdConnectEvents
    {
        OnTicketReceived = context =>
        {
            var options = context.Options as OpenIdConnectOptions;

            // Get the ClaimsIdentity
            var identity = context.Principal.Identity as ClaimsIdentity;
            if (identity != null)
            {
                // Add the groups as roles
                var authzClaim = context.Principal.FindFirst(c => c.Type == "authorization");
                if (authzClaim != null)
                {
                    var authorization = JsonConvert.DeserializeObject<Auth0Authorization>(authzClaim.Value);
                    if (authorization != null)
                    {
                        foreach (var group in authorization.Groups)
                        {
                            identity.AddClaim(new Claim(ClaimTypes.Role, group, ClaimValueTypes.String, options.Authority));
                        }
                    }
                }
            }

            return Task.FromResult(0);
        }
    }
});
Ensuite, nous pouvons ajouter une action qui permet aux Administrateurs d’approuver les feuilles de temps : 
[Authorize(Roles = "Admin")]
public IActionResult TimesheetApproval()
{          
    return View();
}
⌘I