wake-up-neo.net

ASP.NET Core 2.1 Custom RoleProvider mit Windows-Authentifizierung

Ich migriere Anwendungen vom ASP.Net MVC 5-Framework auf den neuen .Net Core 2.1.

Ich habe die Windows-Authentifizierung mit einem benutzerdefinierten Rollenprovider in den MVC 5-Projekten verwendet (siehe Link unten).

ASP.NET MVC So erstellen Sie einen benutzerdefinierten Rollenanbieter

Wie kann ich dasselbe in Core 2.1 erreichen, da es anscheinend keine RoleProvider-Funktion enthält?

Jedes Beispiel, dem ich begegne, verwendet Einzelkonten mit IdentityUser und IdentityRole.

Meine benutzerdefinierten Tabellen für Benutzer und Rollen:

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; }
}

Bearbeiten:

Ich habe einen CustomClaimsPrincipal hinzugefügt, der folgendermaßen aussieht: 

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;
    }
}

und zu Startup.cs hinzugefügt

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

        services.AddScoped<ClaimsPrincipal, CustomClaimsPrincipal>();

Es scheint jedoch immer noch, die ursprüngliche ClaimsPrincipal-Funktion IsInRole anstelle der Überschreibung zu verwenden, weshalb ich glaube, dass ich die Fehlermeldung bekomme, dass die Vertrauensbeziehung zwischen der primären Domäne und der vertrauenswürdigen Domäne fehlgeschlagen ist.

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

Die Verwaltung benutzerdefinierter Berechtigungen im Netzkern erfolgt normalerweise über Ansprüche. Sie können dies über aspnet identity ( Hinzufügen von Ansprüchen in ASP.NET Identity ) oder Sie können Ihre eigene Middleware schreiben.

Sobald Sie Ansprüche haben, müssen Sie Richtlinien erstellen. Dies geschieht über die Klasse Startup.cs in der Methode ConfigureServices.

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

Und dann schmücken Sie Ihre Controller/Aktionen mit dem Attribut Authorize

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

Ich hatte das gleiche Problem - die im Beitrag angegebenen Lösungen waren nicht hilfreich, aber die Kommentare wiesen mich in die richtige Richtung. Sie müssen Ihrem ClaimsPrincipal Ansprüche hinzufügen.

Schritt 1: Erstellen Sie einen ClaimsTransformer - Ersetzen Sie "Admin" und fügen Sie für jede Rolle, die Sie aus Ihrer Datenbank abrufen, einen separaten Anspruch hinzu

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

Schritt 2: Fügen Sie Ihren ClaimsTransformer der ConfigureServices-Methode von Startup.cs hinzu

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>();

Schritt 3: Sie können jetzt rollenbasierte Berechtigungsattribute in Ihren Controllern hinzufügen

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