asp.net mvc decorare [Autorizza()] con più enumerazioni

Question

Ho un controller e voglio due ruoli per essere in grado di accedervi. 1-admin o 2 moderatore

So che si può fare [Autorizza (roles = "admin, moderatori")], ma ho i miei ruoli in un enum. Con l'enum posso solo autorizzare UN ruolo. Non riesco a capire come autorizzare due.

Ho provato qualcosa di simile [Autorizza (Ruoli = MyEnum.Admin, MyEnum.Moderator)], ma che sogliono compilazione.

Qualcuno una volta ha suggerito questa:

[Authorize(Roles=MyEnum.Admin)] 
[Authorize(MyEnum.Moderator)] 
public ActionResult myAction() 
{ 
} 

ma non funziona come un OR. Credo che in questo caso l'utente deve essere parte di entrambi i ruoli. Sto trascurando qualche sintassi? O è questo un caso in cui devo rilasciare la mia autorizzazione personalizzata?

Answer 1

provare a utilizzare il bit o operatore come questo:

[Authorize(Roles= MyEnum.Admin | MyEnum.Moderator)] 
public ActionResult myAction() 
{ 
} 

Se questo non funziona, si può solo rotolare il proprio. Al momento ho appena fatto questo sul mio progetto. Ecco quello che ho fatto:

public class AuthWhereRole : AuthorizeAttribute 
{ 
    /// <summary> 
    /// Add the allowed roles to this property. 
    /// </summary> 
    public UserRole Is; 

    /// <summary> 
    /// Checks to see if the user is authenticated and has the 
    /// correct role to access a particular view. 
    /// </summary> 
    /// <param name="httpContext"></param> 
    /// <returns></returns> 
    protected override bool AuthorizeCore(HttpContextBase httpContext) 
    { 
     if (httpContext == null) 
      throw new ArgumentNullException("httpContext"); 

     // Make sure the user is authenticated. 
     if (!httpContext.User.Identity.IsAuthenticated) 
      return false; 

     UserRole role = someUser.Role; // Load the user's role here 

     // Perform a bitwise operation to see if the user's role 
     // is in the passed in role values. 
     if (Is != 0 && ((Is & role) != role)) 
      return false; 

     return true; 
    } 
} 

// Example Use 
[AuthWhereRole(Is=MyEnum.Admin|MyEnum.Newbie)] 
public ActionResult Test() {} 

Inoltre, assicurarsi di aggiungere un flag di attributo per il tuo enum e assicurarsi che sono tutte valutate da 1 in su. Come questo:

[Flags] 
public enum Roles 
{ 
    Admin = 1, 
    Moderator = 1 << 1, 
    Newbie = 1 << 2 
    etc... 
} 

Lo spostamento bit sinistra riporta i valori 1, 2, 4, 8, 16 e così via.

Beh, spero che questo aiuta un po '.

Answer 2

Oppure si potrebbe concatenare come:

[Autorizza (Roles = Common.Lookup.Item.SecurityRole.Administrator + "" + Common.Lookup.Item.SecurityRole.Intake)]

Answer 3

Per aggiungere al codice di CalebHC e rispondi alla domanda di ssmith sulla gestione degli utenti che hanno più ruoli ...

Il nostro principio di sicurezza personalizzato restituisce una matrice di stringhe che rappresenta tutti i gruppi/ruoli in cui si trova un utente. Quindi, prima dobbiamo convertire tutte le stringhe nella matrice che corrisponde agli elementi nell'enumerazione. Infine, cerchiamo qualsiasi corrispondenza, se è così, l'utente è autorizzato.

Si noti che stiamo reindirizzando un utente non autorizzato a una vista personalizzata "NotAuthorized".

Tutta la classe si presenta così:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)] 
public class CustomAuthorizeAttribute : AuthorizeAttribute 
{ 
    /// <summary> 
    /// Add the allowed roles to this property. 
    /// </summary> 
    public Roles Is { get; set; } 

    /// <summary> 
    /// Checks to see if the user is authenticated and has the 
    /// correct role to access a particular view. 
    /// </summary> 
    /// <param name="httpContext"></param> 
    /// <returns></returns> 
    protected override bool AuthorizeCore(HttpContextBase httpContext) 
    { 
     if (httpContext == null) 
      throw new ArgumentNullException("httpContext"); 

     if (!httpContext.User.Identity.IsAuthenticated) 
      return false; 

     var iCustomPrincipal = (ICustomPrincipal) httpContext.User; 

     var roles = iCustomPrincipal.CustomIdentity 
         .GetGroups() 
         .Select(s => Enum.Parse(typeof (Roles), s)) 
         .ToArray(); 

     if (Is != 0 && !roles.Cast<Roles>().Any(role => ((Is & role) == role))) 
     { 
      return false; 
     } 

     return true; 
    } 

    protected override void HandleUnauthorizedRequest(AuthorizationContext filterContext) 
    { 
     if (filterContext == null) 
      throw new ArgumentNullException("filterContext"); 

     filterContext.Result = new ViewResult { ViewName = "NotAuthorized" }; 
    } 
} 

Answer 4

Ecco una soluzione semplice ed elegante che permette di utilizzare semplicemente la seguente sintassi:

[AuthorizeRoles(MyEnum.Admin, MyEnum.Moderator)] 

Quando si crea il proprio attributo, utilizza la parola chiave params nel tuo costruttore:

public class AuthorizeRoles : AuthorizeAttribute 
{ 
    public AuthorizeRoles(params MyEnum[] roles) 
    { 
     ... 
    } 
    protected override bool AuthorizeCore(HttpContextBase httpContext) 
    { 
     ... 
    } 
} 

Questo vi permetterà di utilizzare l'attributo come segue:

[AuthorizeRoles(MyEnum.Admin, MyEnum.Moderator)] 
public ActionResult myAction() 
{ 
} 

Answer 5

Prova

public class CustomAuthorize : AuthorizeAttribute 
{ 
    public enum Role 
    { 
     DomainName_My_Group_Name, 
     DomainName_My_Other_Group_Name 
    } 

    public CustomAuthorize(params Role[] DomainRoles) 
    { 
     foreach (var domainRole in DomainRoles) 
     { 
      var domain = domainRole.ToString().Split('_')[0] + "_"; 
      var role = domainRole.ToString().Replace(domain, "").Replace("_", " "); 
      domain=domain.Replace("_", "\\"); 
      Roles += ", " + domain + role; 
     } 
     Roles = Roles.Substring(2); 
    }  
} 

public class HomeController : Controller 
{ 
    [CustomAuthorize(Role.DomainName_My_Group_Name, Role.DomainName_My_Other_Group_Name)] 
    public ActionResult Index() 
    { 
     return View(); 
    } 
} 

Answer 6

Ecco la mia versione, basata su @CalebHC e risposte di @Lee Harold.

Ho seguito lo stile di utilizzo dei parametri con nome nell'attributo e ho sovrascritto le proprietà di base Roles.

@ risposta di CalebHC utilizza una nuova Is proprietà che credo sia inutile, perché AuthorizeCore() viene sostituita (che nella classe di base utilizza i ruoli) quindi ha senso usare la nostra Roles pure. Usando il nostro Roles si arriva a scrivere Roles = Roles.Admin sul controller, che segue lo stile di altri attributi .Net.

Ho usato due costruttori per CustomAuthorizeAttribute per mostrare i nomi dei gruppi directory reale attivi vengono passati Nella produzione io uso il costruttore parametrizzato per evitare le stringhe di magia nella classe:. I nomi dei gruppi sono tirati da web.config durante Application_Start() e superato in sulla creazione utilizzando uno strumento DI.

Avrete bisogno di un NotAuthorized.cshtml o simile nella vostra cartella Views\Shared o gli utenti non autorizzati visualizzeranno una schermata di errore.

Questo è il codice per la classe base AuthorizationAttribute.cs.

Controller:

public ActionResult Index() 
{ 
    return this.View(); 
} 

[CustomAuthorize(Roles = Roles.Admin)] 
public ActionResult About() 
{ 
    return this.View(); 
} 

CustomAuthorizeAttribute:

// The left bit shifting gives the values 1, 2, 4, 8, 16 and so on. 
[Flags] 
public enum Roles 
{ 
    Admin = 1, 
    User = 1 << 1  
} 

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)] 
public class CustomAuthorizeAttribute : AuthorizeAttribute 
{ 
    private readonly string adminGroupName; 

    private readonly string userGroupName; 

    public CustomAuthorizeAttribute() : this("Domain Admins", "Domain Users") 
    {  
    } 

    private CustomAuthorizeAttribute(string adminGroupName, string userGroupName) 
    { 
    this.adminGroupName = adminGroupName; 
    this.userGroupName = userGroupName; 
    } 

    /// <summary> 
    /// Gets or sets the allowed roles. 
    /// </summary> 
    public new Roles Roles { get; set; } 

    /// <summary> 
    /// Checks to see if the user is authenticated and has the 
    /// correct role to access a particular view. 
    /// </summary> 
    /// <param name="httpContext">The HTTP context.</param> 
    /// <returns>[True] if the user is authenticated and has the correct role</returns> 
    /// <remarks> 
    /// This method must be thread-safe since it is called by the thread-safe OnCacheAuthorization() method. 
    /// </remarks> 
    protected override bool AuthorizeCore(HttpContextBase httpContext) 
    { 
    if (httpContext == null) 
    { 
     throw new ArgumentNullException("httpContext"); 
    } 

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

    var usersRoles = this.GetUsersRoles(httpContext.User); 

    return this.Roles == 0 || usersRoles.Any(role => (this.Roles & role) == role); 
    } 

    protected override void HandleUnauthorizedRequest(AuthorizationContext filterContext) 
    { 
    if (filterContext == null) 
    { 
     throw new ArgumentNullException("filterContext"); 
    } 

    filterContext.Result = new ViewResult { ViewName = "NotAuthorized" }; 
    } 

    private IEnumerable<Roles> GetUsersRoles(IPrincipal principal) 
    { 
    var roles = new List<Roles>(); 

    if (principal.IsInRole(this.adminGroupName)) 
    { 
     roles.Add(Roles.Admin); 
    } 

    if (principal.IsInRole(this.userGroupName)) 
    { 
     roles.Add(Roles.User); 
    } 

    return roles; 
    }  
} 

Answer 7

ho unito alcune delle soluzioni qui per creare il mio preferito. Il mio attributo personalizzato cambia semplicemente i dati per essere nel modulo che SimpleMembership si aspetta e consente di gestire tutto il resto.

miei ruoli enum:

public enum MyRoles 
{ 
    Admin, 
    User, 
} 

Per creare ruoli: attributo

public static void CreateDefaultRoles() 
{ 
    foreach (var role in Enum.GetNames(typeof(MyRoles))) 
    { 
     if (!Roles.RoleExists(role)) 
     { 
      Roles.CreateRole(role); 
     } 
    } 
} 

personalizzato:

public class AuthorizeRolesAttribute : AuthorizeAttribute 
{ 
    public AuthorizeRolesAttribute(params MyRoles[] allowedRoles) 
    { 
     var allowedRolesAsStrings = allowedRoles.Select(x => Enum.GetName(typeof(MyRoles), x)); 
     Roles = string.Join(",", allowedRolesAsStrings); 
    } 
} 

Utilizzato in questo modo:

[AuthorizeRoles(MyRoles.Admin, MyRoles.User)] 
public ActionResult MyAction() 
{ 
    return View(); 
}