web-dev-qa-db-fra.com

RoleProvider personnalisé ASP.NET Core 2.1 avec authentification Windows

Je migre des applications du framework ASP.Net MVC 5 vers le nouveau .Net Core 2.1.

J'ai utilisé l'authentification Windows avec un fournisseur de rôle personnalisé dans les projets MVC 5, comme indiqué dans le lien ci-dessous.

ASP.NET MVC Comment créer un fournisseur de rôle personnalisé

Comment puis-je accomplir la même chose dans Core 2.1, car il ne semble pas contenir de capacité RoleProvider?

Chaque exemple que je rencontre utilise des comptes individuels avec IdentityUser et IdentityRole.

Mes tables personnalisées pour l'utilisateur et les rôles:

public class User
{
    public User() { UserRoles = new HashSet<UserRole>(); }

    [Key]
    public string Id { get; set; }

    [StringLength(50)]
    [Required]
    public string Logon { get; set; } //The users Active Directory Username

    public bool Active { get; set; }

    public ICollection<UserRole> UserRoles { get; set; }

}


public class Role
{
    public Role() { UserRoles = new HashSet<UserRole>(); }

    [Key]
    public string Id { get; set; }

    public string Name { get; set; }

    public ICollection<UserRole> UserRoles { get; set; }
}

Modifier:

J'ai ajouté un CustomClaimsPrincipal qui ressemble à ceci: 

public class CustomClaimsPrincipal : ClaimsPrincipal
{
    private readonly ApplicationDbContext _context;

    public CustomClaimsPrincipal(ApplicationDbContext context)
    {
        _context = context;
    }

    public override bool IsInRole(string role)
    {
        var currentUser = ClaimsPrincipal.Current.Identity.Name;

        IdentityUser user = _context.Users.FirstOrDefault(u => u.UserName.Equals(currentUser, StringComparison.CurrentCultureIgnoreCase));
            //(ApplicationUser)_context.Users.FirstOrDefault(u => u.UserName.Equals(currentUser, StringComparison.CurrentCultureIgnoreCase));

        var roles = from ur in _context.UserRoles.Where(p => p.UserId == user.Id)
                    from r in _context.Roles
                    where ur.RoleId == r.Id
                    select r.Name;
        if (user != null)
            return roles.Any(r => r.Equals(role, StringComparison.CurrentCultureIgnoreCase));
        else
            return false;
    }
}

et ajouté à Startup.cs

        services.AddIdentity<ApplicationUser, IdentityRole>().AddEntityFrameworkStores<ApplicationDbContext>();

        services.AddScoped<ClaimsPrincipal, CustomClaimsPrincipal>();

Mais il semble toujours que la fonction originale ClaimsPrincipal IsInRole prenne la place du remplacement, ce qui explique pourquoi le message d'erreur "La relation de confiance entre le domaine principal et le domaine approuvé a échoué".

c#asp.net-coreasp.net-core-mvcasp.net-core-2.0roles
5
user2806570

La gestion des autorisations personnalisées dans Net Core est généralement effectuée via des revendications. Vous pouvez le faire via une identité Aspnet ( Comment ajouter des revendications dans ASP.NET Identity ) ou vous pouvez écrire votre propre middleware.

Une fois que vous avez des revendications, vous devez créer des politiques. Cela se fait via la classe Startup.cs dans la méthode ConfigureServices.

services.AddAuthorization(options =>
        {
            options.AddPolicy("HR", policy => policy.RequireClaim("HRTeam"));
            options.AddPolicy("Helpdesk", policy => policy.RequireClaim("HelpdeskTeam"));
        });

Et ensuite, décorez vos contrôleurs/actions avec l'attribut Authorize

[Authorize(Policy="Helpdesk")]
public class HelpDeskController : Controller
1
ste-fu

J'ai eu le même problème - les solutions données dans le post n'étaient pas utiles, mais les commentaires m'ont orienté dans la bonne direction. Vous devez ajouter des revendications à votre ClaimsPrincipal.

Étape 1: Créer un ClaimsTransformer - Remplacez "Admin" et ajoutez une revendication distincte pour chaque rôle extrait de votre base de données

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;

public class ClaimsTransformer : IClaimsTransformation
{ 
    public Task<ClaimsPrincipal> TransformAsync(ClaimsPrincipal principal)
    {
        var ci = (ClaimsIdentity) principal.Identity;
        var c = new Claim(ci.RoleClaimType, "Admin");
        ci.AddClaim(c);
        return Task.FromResult(principal);
    }
}

Étape 2: Ajoutez ClaimsTransformer à la méthode ConfigureServices de Startup.cs

services.AddAuthentication(Microsoft.AspNetCore.Server.IISIntegration.IISDefaults.AuthenticationScheme);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddSpaStaticFiles(configuration =>
{
    configuration.RootPath = "ClientApp/dist";
});

services.AddSingleton<IClaimsTransformation, ClaimsTransformer>();

Étape 3: Vous pouvez maintenant ajouter des attributs d'autorisation basés sur les rôles dans vos contrôleurs.

[Authorize(Roles = "Admin")]
[HttpGet("[action]/{id}")]        
public User GetUser([FromRoute] int id)
{
    UserLogic ul = new UserLogic();
    return ul.GetUser(id);
}
2
Aceofspades25