Implémentation ASP.NET Core (applications Web classiques + SSO)

L’implémentation ASP.NET Core pour le scénario d’architecture d’authentification unique (SSO) des applications Web classiques

Le code source complet de l’implémentation ASP.NET Core se trouve dans ce dépôt GitHub.

​

Configurer le middleware de cookie et OIDC

Dans ce guide, nous utiliserons une page de connexion hébergée simple. Vous pouvez utiliser le middleware de cookie et OIDC standard offert avec ASP.NET Core; assurez-vous donc d’installer les packages NuGet.

Install-Package Microsoft.AspNetCore.Authentication.Cookies
Install-Package Microsoft.AspNetCore.Authentication.OpenIdConnect

Ensuite, configurez le cookie et le middleware OIDC dans la chaîne de middlewares de votre application.

Comme vous pouvez le voir dans le code ci-dessus, nous avons configuré deux types distincts de middleware d’authentification.

Le premier est le middleware de cookie, enregistré au moyen de l’appel à UseCookieAuthentication. Le second est le middleware OIDC, configuré au moyen de l’appel à UseOpenIdConnectAuthentication.

Une fois que l’utilisateur s’est authentifié auprès d’Auth0 à l’aide du middleware OIDC, ses informations seront automatiquement stockées dans un cookie de session. Il vous suffit de configurer le middleware comme ci-dessus, et il se chargera de gérer la session de l’utilisateur.

Le middleware OpenID Connect (OIDC) extraira également toutes les claims du ID Token, envoyé par Auth0 une fois l’utilisateur authentifié, et les ajoutera comme claims à ClaimsIdentity.

​

Implémenter la déconnexion

Vous pouvez gérer à la fois la session de l’application et la session d’Auth0 à l’aide de la méthode SignOutAsync de la classe AuthenticationManager, en transmettant le schéma d’authentification à partir duquel vous souhaitez vous déconnecter.

Par exemple, pour vous déconnecter du middleware de cookies et ainsi supprimer le cookie d’authentification de votre application, vous pouvez effectuer l’appel suivant :

await HttpContext.Authentication.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);

De la même façon, vous pouvez déconnecter l’utilisateur d’Auth0 en appelant la méthode SignOutAsync et en passant Auth0 comme schéma d’authentification duquel se déconnecter.

await HttpContext.Authentication.SignOutAsync("Auth0");

Pour que ce qui précède fonctionne, vous devrez toutefois aussi ajouter une configuration supplémentaire lors de l’enregistrement du middleware OIDC en gérant l’événement OnRedirectToIdentityProviderForSignOut. Dans cet événement, vous devrez rediriger vers le point de terminaison de déconnexion d’Auth0, ce qui effacera le cookie Auth0.

app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions("Auth0")
{
    // Certaines parties du code ont été omises par souci de concision
    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 d’ajouter l’URL de votre application à la liste des Allowed Logout URLs de votre application dans l’Auth0 Dashboard. Pour en savoir plus, consultez Déconnexion.

​

Implémenter les autorisations d’administrateur

La façon la plus simple d’intégrer les groupes à une application ASP.NET Core consiste à utiliser la fonctionnalité intégrée d’autorisation basée sur les rôles d’ASP.NET Core. Pour ce faire, nous devrons ajouter une revendication de type

http://schemas.microsoft.com/ws/2008/06/identity/claims/role

pour chacun des groupes auxquels un utilisateur est attribué.

Une fois les claims ajoutées, nous pouvons facilement faire en sorte qu’une action donnée soit accessible uniquement aux utilisateurs Admin en annotant la claim avec l’attribut [Authorize(Roles = "Admin")]. Vous pouvez également vérifier si un utilisateur appartient à un rôle précis dans le code en appelant User.IsInRole("Admin") depuis votre contrôleur.

Le middleware OIDC d’ASP.NET ajoutera automatiquement toutes les claims renvoyées dans le JWT en tant que claims au ClaimsIdentity. Nous devons donc extraire l’information de la claim authorization, désérialiser le corps JSON de la claim et, pour chacun des groupes, ajouter une claim http://schemas.microsoft.com/ws/2008/06/identity/claims/role au ClaimsIdentity.

app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions("Auth0")
{
    // Certaines configurations omises par souci de concision

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

            // Récupérer le ClaimsIdentity
            var identity = context.Principal.Identity as ClaimsIdentity;
            if (identity != null)
            {
                // Ajouter les groupes en tant que rôles
                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);
        }
    }
});

Nous pouvons ensuite ajouter une Action qui permet aux administrateurs d’approuver les feuilles de temps :

[Authorize(Roles = "Admin")]
public IActionResult TimesheetApproval()
{          
    return View();
}