web-dev-qa-db-de.com

ASP.NET Core - Hinzufügen von Rollenansprüchen zu Benutzer

Ich habe einen ASP.NET Core (basierend auf .NET Framework), der die Windows-Authentifizierung verwendet. Der Punkt ist, ich muss einen Rollenanspruch für diesen Benutzer hinzufügen, und diese Rolle wird in einer entfernten Datenbank gespeichert.

Ich habe so viel über OWIN/Cookie/UserManager/UserStore/Identity usw. gelesen, dass ich verloren bin.

Frage: Wie füge ich einen Rollenanspruch für den aktuell angemeldeten Benutzer (Windows) für die gesamte Anwendung auf einfachste Weise hinzu?

Was ich brauche, ist die einfache Verwendung von [Authorize(Role= "MyAddedRole")] oder bool res = User.IsInRole("MyAddedRole")

Vielen Dank

8
Arnaud F.

Antworten auf mich selbst, was ich getan habe:

Erstellen Sie meinen eigenen UserClaimStore (ich brauche nur diesen Shop, nicht die anderen):

public class MyIdentityStore :
    IUserClaimStore<IdentityUser>
{
    private MyDbContext _myDbContext;
    private bool _disposed = false; 

    public MyIdentityStore(MyDbContext myDbContext)
    {
        _myDbContext = myDbContext;
    }

    #region IUserClaimStore
    public Task<IList<Claim>> GetClaimsAsync(IdentityUser user, CancellationToken cancellationToken)
    {
        // logic here to retrieve claims from my own database using _myDbContext
    }

    // All other methods from interface throwing System.NotSupportedException.
    #endregion

    #region IDisposable Support

    protected virtual void Dispose(bool disposing)
    { /* do cleanup */ }
    #endregion
}

Dann erstellte ich meinen eigenen ClaimTransformer:

public class MyClaimsTransformer : IClaimsTransformer
{
    private UserManager<IdentityUser> _userManager;

    public MyClaimsTransformer(UserManager<IdentityUser> userManager)
    {
        _userManager = userManager;
    }

    public async Task<ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
    {
        var identity = ((ClaimsIdentity)context.Principal.Identity);

        // Accessing the UserClaimStore described above
        var claims = await _userManager.GetClaimsAsync(new IdentityUser(identity.Name));
        identity.AddClaims(claims);

        return await Task.FromResult(context.Principal);
    }
}

Endlich in Startup.cs: 

    public void ConfigureServices(IServiceCollection services)
    {
        /* All other stuff here */ 

        // Adding Database connection
        services.AddDbContext<MyDbContext>(o => /* my options */);

        // Associates our database and store to identity
        services.AddIdentity<IdentityUser, IdentityRole>()
            .AddEntityFrameworkStores<MyDbContext>()
            .AddUserStore<MyIdentityStore>();

        // Claims transformation from database to claims
        services.AddTransient<IClaimsTransformer, MyClaimsTransformer>();
    }


    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        /* All other stuff here */ 

        app.UseIdentity();

        app.UseClaimsTransformation(async (context) =>
        { // Retrieve user claims from database
            IClaimsTransformer transformer = context.Context.RequestServices.GetRequiredService<IClaimsTransformer>();
            return await transformer.TransformAsync(context);
        });
    }

Und jetzt kann ich [Authorize(Roles = "MyRole")] oder User.IsInRole("MyRole") oder sogar User.HasClaim(/* */) frei verwenden!

7
Arnaud F.

Sie können eine neue Rolle in Ihrer Datenbank hinzufügen (AspNetRoles) und diese dann dem Benutzer (AspNetUserRoles) zuweisen.

1
vhr

Neben den Antworten habe ich gerade die Antwort gefunden, die in asp .net core völlig vordefiniert ist. Wenn Sie Ansprüche hinzufügen, nur:

var claims = new List<Claim>
{
    new Claim(ClaimTypes.Name, UserName),
    new Claim(ClaimTypes.Role, "User"),
    new Claim(ClaimTypes.Role, "Admin"),
    new Claim(ClaimTypes.Role, Watever)
};

danach können Sie es einfach wie gesagt verwenden:

[Authorize(Roles = "Watever")]

oder

User.IsInRole("Watever")
1
ashk hp