Implementación en ASP.NET Core (Aplicaciones web + SSO)

La implementación en ASP.NET Core para el escenario de arquitectura de inicio de sesión único (SSO) en aplicaciones web tradicionales

El código fuente completo de la implementación de ASP.NET Core se encuentra en este repositorio de GitHub.

​

Configure el middleware de cookies y OIDC

Para esta guía, usaremos un inicio de sesión alojado sencillo. Puede usar el middleware estándar de cookies y OIDC disponible en ASP.NET Core, así que asegúrese de instalar los paquetes NuGet.

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

Luego, configure el middleware de cookies y el de OIDC en el flujo de middleware de su aplicación.

Como puede ver en el código anterior, hemos configurado dos tipos diferentes de middleware de autenticación.

El primero es el middleware de cookies, que se registró con la llamada a UseCookieAuthentication. El segundo es el middleware de OIDC, que se configura con la llamada a UseOpenIdConnectAuthentication.

Una vez que el usuario haya iniciado sesión en Auth0 mediante el middleware de OIDC, su información se almacenará automáticamente en una cookie de sesión. Todo lo que necesita hacer es configurar el middleware como se muestra arriba, y este se encargará de administrar la sesión del usuario.

El middleware de OpenID Connect (OIDC) también extraerá todos los claims del ID Token, que Auth0 envía una vez que el usuario se ha autenticado, y los agregará como claims en ClaimsIdentity.

​

Implemente el cierre de sesión

Puede controlar tanto la sesión de la aplicación como la sesión de Auth0 mediante el método SignOutAsync de la clase AuthenticationManager, e indicar el esquema de autenticación para el que desea cerrar la sesión.

Por ejemplo, para cerrar la sesión en el middleware de cookies y, de ese modo, borrar la cookie de autenticación de su aplicación, puede realizar la siguiente llamada:

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

De forma similar, puede cerrar la sesión del usuario en Auth0 haciendo una llamada al método SignOutAsync y pasando Auth0 como el esquema de autenticación del que desea cerrar la sesión.

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

Sin embargo, para que lo anterior funcione, también deberá agregar una configuración adicional al registrar el middleware de OIDC mediante el control del evento OnRedirectToIdentityProviderForSignOut. Dentro del evento, deberá redirigir al endpoint de cierre de sesión de Auth0, que eliminará la cookie de Auth0.

app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions("Auth0")
{
    // Se omite parte del código por brevedad
    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);
        }
    }
});

También deberá asegurarse de agregar la URL de su aplicación a Allowed Logout URLs de la aplicación en el Auth0 Dashboard. Para obtener más información, consulte Logout.

​

Implementar permisos de Admin

La forma más sencilla de integrar los grupos en una aplicación ASP.NET Core es usar la autorización basada en roles integrada de ASP.NET Core. Para lograrlo, tendremos que agregar un claim de tipo

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

para cada uno de los grupos a los que esté asignado un usuario.

Una vez agregados los claims, podemos garantizar fácilmente que una acción específica esté disponible solo para los usuarios Admin decorando el claim con el atributo [Authorize(Roles = "Admin")]. También puede comprobar en el código si un usuario pertenece a un rol específico haciendo una llamada a User.IsInRole("Admin") desde dentro del controlador.

El middleware de OIDC de ASP.NET agregará automáticamente todos los claims devueltos en el JWT como claims a ClaimsIdentity. Por lo tanto, tendríamos que extraer la información del claim authorization, deserializar el cuerpo JSON del claim y, para cada uno de los grupos, agregar un claim http://schemas.microsoft.com/ws/2008/06/identity/claims/role a ClaimsIdentity.

app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions("Auth0")
{
    // Se omite parte de la configuración por brevedad

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

            // Obtener el ClaimsIdentity
            var identity = context.Principal.Identity as ClaimsIdentity;
            if (identity != null)
            {
                // Agregar los grupos como 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);
        }
    }
});

Y, posteriormente, podemos agregar una Action para que los administradores aprueben los registros de horas:

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