Mise en œuvre ASP.NET Core (Web Apps + SSO)

La mise en œuvre en ASP.NET Core du scénario d’architecture SSO (authentification unique) pour les Regular Web Apps

Le code source complet de la mise en œuvre en ASP.NET Core se trouve dans ce dépôt GitHub.

​

Configurer le cookie et le middleware OIDC

Dans ce guide, nous utiliserons un hosted login simple. Vous pouvez utiliser le cookie standard et le middleware OIDC fournis 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 middleware de cookie et le middleware OIDC dans le pipeline de middleware de votre application.

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

Le premier est le middleware de cookie, qui a été enregistré par l’appel à UseCookieAuthentication. Le second est le middleware OIDC, configuré par l’appel à UseOpenIdConnectAuthentication.

Une fois que l’utilisateur s’est connecté à 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 tous les claims du ID Token, envoyé par Auth0 une fois l’utilisateur authentifié, et les ajoutera à ClaimsIdentity sous forme de claims.

​

Implement le Logout

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

Par exemple, pour vous déconnecter du middleware de cookies et ainsi effacer le cookie d’authentification de votre application, vous pouvez effectuer la requête suivante :

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 à déconnecter.

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

Pour que ce qui précède fonctionne, vous devrez toutefois également 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 endpoint de logout 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 veiller à ajouter l’URL de votre application aux Allowed Logout URLs de votre application dans le Auth0 Dashboard. Pour en savoir plus, consultez Logout.

​

Autorisations Admin d’Implement

La manière la plus simple d’intégrer les groupes à une application ASP.NET Core consiste à utiliser l’autorisation fondée sur les rôles intégrée à ASP.NET Core. Pour ce faire, nous devrons ajouter un claim de type

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

pour chacun des groupes qui sont attribués à un utilisateur.

Une fois les claims ajoutés, nous pouvons facilement nous assurer qu’une action donnée est accessible uniquement aux utilisateurs Admin en décorant le claim avec l’attribut [Authorize(Roles = "Admin")]. Vous pouvez aussi vérifier dans le code si un utilisateur appartient à un role précis en appelant User.IsInRole("Admin") dans votre contrôleur.

Le middleware OIDC ASP.NET ajoute automatiquement au ClaimsIdentity tous les claims renvoyés dans le JWT. Nous devons donc extraire l’information du claim authorization, désérialiser le corps JSON du claim et, pour chacun des groupes, ajouter un 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;

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

Par la suite, nous pouvons ajouter une action permettant aux administrateurs d’approuver les feuilles de temps :

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