Erstellen einer AuthorizeAttribute - was muss ich wissen?

Ich habe gehen durch so ziemlich das gleiche Szenario in den letzten paar Wochen, so könnte dies helfen, jemand anderes im gleichen Boot. Mein Szenario ist eine MVC4-Anwendung im intranet eines Unternehmens mit den Benutzern in Active Directory gespeichert. Dies ermöglicht Windows-Authentifizierung geben single sign-on, so dass keine Notwendigkeit für die Formularauthentifizierung. Rollen sind in einer Oracle Datenbank gespeichert. Ich habe 3 Rollen:

• Readonly: Alle Benutzer müssen ein Mitglied dieser Zugriff auf die Anwendung
• Benutzer: Erstellen Sie neue resords
• Admin: Bearbeiten und löschen von Datensätzen

Entschied ich mich für die asp.net Rolle-provider-api, um meine eigene AccountRoleProvider. Bisher habe ich nur 2 Methoden in diesem, GetRolesForUser und IsUserInRole:

public class AccountRoleProvider : RoleProvider //System.Web.Security.RoleProvider
{
    private readonly IAccountRepository _accountRepository;

    public AccountRoleProvider(IAccountRepository accountRepository)
    {
        this._accountRepository = accountRepository;
    }

    public AccountRoleProvider() : this (new AccountRepository())
    {}

    public override string[] GetRolesForUser(string user521)
    {
        var userRoles = this._accountRepository.GetRoles(user521).ToArray();

        return userRoles;
    }

    public override bool IsUserInRole(string username, string roleName)
    {
        var userRoles = this.GetRolesForUser(username);

        return Utils.IndexOfString(userRoles, roleName) >= 0;
    }
}

Ich aktualisierte die web -.config, um meine Rolle Anbieter:

<authentication mode="Windows" />
<roleManager enabled="true" defaultProvider="AccountRoleProvider">
  <providers>
    <clear/>
    <add name="AccountRoleProvider"
         type="MyApp.Infrastructure.AccountRoleProvider" />
  </providers>
</roleManager>

Dann erstellte ich 2 benutzerdefinierte Attribute aus AuthorizeAttribute, ReadOnlyAuthorize und CustomAuthorize.

ReadonlyAuthorize:

public class ReadonlyAuthorize : AuthorizeAttribute
{
    private IAccountRepository _accountRepository;

    protected override bool AuthorizeCore(HttpContextBase httpContext)
    {
        var user = httpContext.User;
        this._accountRepository = new AccountRepository();

        if (!user.Identity.IsAuthenticated)
        {
            return false;
        }

        //Get roles for current user
        var roles = this._accountRepository.GetRoles(user.Identity.Name);

        if (!roles.Contains("readonly"))
        {
            return false;
        }

        return base.AuthorizeCore(httpContext);
    }

    public override void OnAuthorization(AuthorizationContext filterContext)
    {
        base.OnAuthorization(filterContext);

        if (filterContext.HttpContext.User.Identity.IsAuthenticated && filterContext.Result is HttpUnauthorizedResult)
        {
            filterContext.Result = new ViewResult { ViewName = "AccessDenied" };
        }
    }
}

CustomAuthorize:

public class CustomAuthorizeAttribute : AuthorizeAttribute
{
    public string RedirectActionName { get; set; }
    public string RedirectControllerName { get; set; }
    private IAccountRepository _accountRepository;

    protected override bool AuthorizeCore(HttpContextBase httpContext)
    {
        var user = httpContext.User;
        this._accountRepository = new AccountRepository();
        var accessAllowed = false;

        //Get the roles passed in with the (Roles = "...") on the attribute
        var allowedRoles = this.Roles.Split(',');

        if (!user.Identity.IsAuthenticated)
        {
            return false;
        }

        //Get roles for current user
        var roles = this._accountRepository.GetRoles(user.Identity.Name);

        foreach (var allowedRole in allowedRoles)
        {
            if (roles.Contains(allowedRole))
            {
                accessAllowed = true;
            }
        }

        if (!accessAllowed)
        {
            return false;
        }

        return base.AuthorizeCore(httpContext);
    }

    public override void OnAuthorization(AuthorizationContext filterContext)
    {
        base.OnAuthorization(filterContext);

        if (filterContext.HttpContext.User.Identity.IsAuthenticated && filterContext.Result is HttpUnauthorizedResult)
        {   
            var values = new RouteValueDictionary(new
            {
                action = this.RedirectActionName == string.Empty ? "AccessDenied" : this.RedirectActionName,
                controller = this.RedirectControllerName == string.Empty ? "Home" : this.RedirectControllerName
            });

            filterContext.Result = new RedirectToRouteResult(values);
        }
    }
}

Den Grund für die 2 verschiedenen Attributen ist, dass ich eine Verwendung für die Readonly-Rolle, der alle Benutzer angehören muss, um Zugriff auf die app. Ich kann nur hinzufügen, das in der RegisterGlobalFilters Methode im Allgemeinen.asax, was bedeutet, es wird automatisch für jeden Controller:

public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
    filters.Add(new HandleErrorAttribute());
    filters.Add(new ReadonlyAuthorize());
}

Dann in der CustomAuthorize ich kann ein differenzierter und geben Sie die Rollen an, die ich will, und gelten für einen Controller oder eine einzelne Aktion, z.B. unten kann ich den Zugriff einschränken, um die Delete-Methode, um Benutzer in die Admin-Rolle:

[AccessDeniedAuthorize(RedirectActionName = "AccessDenied", RedirectControllerName = "Home", Roles = "Admin")]
public ActionResult Delete(int id = 0)
{
    var batch = myDBContext.Batches.Find(id);
    if (batch == null)
    {
        return HttpNotFound();
    }

    return View(batch);
}

Gibt es weitere Schritte, die ich ergreifen müssen, wie das aktualisieren der Benutzer-Objekt mit den Rollen, die der aktuelle Benutzer Mitglied ist. Dieser abgerufen werden die Rollen für den Benutzer einmal und nicht jedes mal in meine benutzerdefinierte Attribute und auch die User nutzen."IsInRole". So etwas sollte möglich sein, in Application_AuthenticateRequest in Gloal.asax:

var roles = "get roles for this user from respository";

if (Context.User != null)
    Context.User = new GenericPrincipal(Context.User.Identity, roles);

Verwenden Sie die Standard-Mitgliedschaftsanbieter und der rollenanbieter, sondern als Umsetzung Ihrer eigenen, aber Sie müssen auch verwenden Sie die Standardeinstellung asp.net Mitgliedschaft-Datenbank aspnetdb.mdf.

Sehen hier eine Exemplarische