ASP.NET Core - Autorisation à l'aide de l'authentification Windows

Question

J'ai configuré mon interface web pour qu'elle fonctionne avec l'authentification Windows. Mon objectif est essentiellement de restreindre certaines actions dans mes contrôleurs en fonction du compte Windows de l'utilisateur. Certains pourront effectuer des actions de lecture tandis que d'autres pourront effectuer des actions d'écriture dans la base de données sous-jacente. J'ai trouvé beaucoup de documentation sur la façon de mettre en place une autorisation basée sur les revendications, ce qui est la voie que je pense devoir suivre. Ce que je n'ai pas trouvé, c'est comment configurer cela avec l'authentification Windows. Je pense qu'il me manque une étape intermédiaire telle que l'enregistrement de l'authentification Windows en tant que fournisseur d'identité ?

startup.cs

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();

    services.AddAuthentication(IISDefaults.AuthenticationScheme);

    services.AddAuthorization(options =>
    {
        options.AddPolicy("readOnly", policy =>
                          policy.RequireClaim(`???????????????????????`));
        options.AddPolicy("write", policy =>
                          policy.RequireClaim(`???????????????????????`));
    });
}

Contrôleur

[Authorize(Policy = "ReadOnly")]
public class MyController : Controller
{
    public ActionResult SomeReadOnlyAction()
    {
        //Return data from database
    }

    [Authorize(Policy = "Write")]
    public ActionResult AWriteAction()
    {
        //Create/Update/Delete data from database
    }
}

Je suppose qu'une autre façon de poser la question est de savoir comment configurer ou accéder aux revendications/rôles etc... avec l'authentification Windows.

Answer 1

Il semble que vous souhaitiez utiliser l'autorisation basée sur les réclamations par le biais de politiques. Après avoir configuré l'authentification Windows dans votre application, vous pouvez ajouter une revendication personnalisée à ClaimsPrincipal, vérifier l'identité de l'utilisateur et confirmer la permission dont dispose l'utilisateur actuel :

1. Vous pouvez ajouter un service de transformation des réclamations à votre application :

   class ClaimsTransformer : IClaimsTransformation
   {
       public Task<ClaimsPrincipal> TransformAsync(ClaimsPrincipal principal)
       {
           var id = ((ClaimsIdentity)principal.Identity);
   
           var ci = new ClaimsIdentity(id.Claims, id.AuthenticationType, id.NameClaimType, id.RoleClaimType);
           if (ci.Name.Equals("name"))
           {
               ci.AddClaim(new Claim("permission", "readOnly"));
           }
           else
           {
               ci.AddClaim(new Claim("permission", "write"));
   
           }
   
           var cp = new ClaimsPrincipal(ci);
   
           return Task.FromResult(cp);
       }
   }

2. Ajouter au Startup.cs(.net Core 2.0) :

       services.AddTransient<IClaimsTransformation, ClaimsTransformer>();

3. Définissez votre politique :

       services.AddAuthorization(options =>
       {
           options.AddPolicy("Readonly", policy =>
                             policy.RequireClaim("permission", "readOnly"));
   
           options.AddPolicy("Write", policy =>
                           policy.RequireClaim("permission", "write"));
       });

4. Restreindre l'accès à un contrôleur ou à une action en exigeant cette politique :

       [Authorize(Policy = "Write")]
       public IActionResult Contact()
       {
           ViewData["Message"] = "Your contact page.";
   
           return View();
       }

Si vous avez déjà ajouté des groupes (écriture, lecture seule) dans votre AD et ajouté les utilisateurs concernés au groupe, vous pouvez également vérifier les groupes :

public static class Security
{
    public static bool IsInGroup(this ClaimsPrincipal User, string GroupName)
    {
        var groups = new List<string>();

        var wi = (WindowsIdentity)User.Identity;
        if (wi.Groups != null)
        {
            foreach (var group in wi.Groups)
            {
                try
                {
                    groups.Add(group.Translate(typeof(NTAccount)).ToString());
                }
                catch (Exception)
                {
                    // ignored
                }
            }
            return groups.Contains(GroupName);
        }
        return false;
    }
}

Et utiliser comme :

 if (User.IsInGroup("GroupName"))
 {

 }