asp.net mvc 用多个枚举装饰 [Authorize()]

Question

我有一个控制器，我希望两个角色能够访问它。 1-管理员或 2-主持人

我知道你可以执行 [Authorize(Roles="admin, moderators")] 但我在枚举中有我的角色。 使用枚举我只能授权一个角色。 我不知道如何授权两个。

我尝试过类似 [Authorize(Roles=MyEnum.Admin, MyEnum.Moderator)] 的方法，但无法编译。

有人曾经提出过这个建议：

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

但它不能作为 OR 起作用。 我认为在这种情况下，用户必须同时属于这两个角色。 我忽略了一些语法吗？ 或者在这种情况下我必须滚动自己的自定义授权？

Answer 1

这是我的版本，基于 @CalebHC 和 @Lee Harold 的答案。

我遵循在属性中使用命名参数的风格并覆盖基类 Roles 属性。

@CalebHC 的答案使用了一个新的 Is 属性，我认为这是不必要的，因为 AuthorizeCore() 被重写（在基类中使用 Roles），因此使用我们的也拥有自己的角色。 通过使用我们自己的Roles，我们可以在控制器上编写Roles = Roles.Admin，它遵循其他.Net属性的样式。

我在 CustomAuthorizeAttribute 中使用了两个构造函数来显示传入的真实活动目录组名称。在生产中，我使用参数化构造函数来避免类中的魔术字符串：组名称是在期间从 web.config 中提取的。 Application_Start() 并使用 DI 工具在创建时传入。

您需要在 Views\Shared 文件夹中添加一个 NotAuthorized.cshtml 或类似文件，否则未经授权的用户将会看到错误屏幕。

以下是基类 AuthorizationAttribute.cs 的代码。

控制器：

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

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

自定义授权属性：

// 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 2

要添加到 CalebHC 的代码并回答 ssmith 关于处理具有多个角色的用户的问题...

我们的自定义安全主体返回一个字符串数组，表示用户所在的所有组/角色。因此，首先我们必须转换与枚举中的项目匹配的数组。 最后，我们查找任何匹配项 - 如果是，则用户已获得授权。

请注意，我们还将未经授权的用户重定向到自定义“NotAuthorized”视图。

整个班级是这样的：

[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 3

我不完全同意之前答案的复杂性。 这是我的版本，使用字典将角色枚举值转换为字符串。

当然，每当引入新角色时，就需要更新映射。

public class AuthorizeRoles : AuthorizeAttribute
{
    private Dictionary<Roles, string> _rolesMap = new()
    {
        // Fully qualified name since Roles already exist in AuthorizeAttribute
        { Common.Enums.Roles.User, "CustomRoles.User" },
        { Common.Enums.Roles.Manager, "CustomRoles.Manager" },
        { Common.Enums.Roles.Admin, "CustomRoles.Admin" },
    };
    
    public AuthorizeRoles(params Roles[] roles)
    {
        Roles = string.Join(",", roles.Select(role => _rolesMap[role]));
    }
}

可以在这样的控制器中使用

[AuthorizeRoles(Roles.User, Roles.Manager, Roles.Admin)]

Answer 4

或者你可以像这样连接：

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

Answer 5

这是一个简单且优雅的解决方案，它允许您简单地使用以下语法：

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

创建自己的属性时，使用params构造函数中的 关键字：

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

这将允许您按如下方式使用该属性：

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

Answer 6

尝试使用位或运算符，如下所示：

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

如果这不起作用，您可以自己动手。 我目前刚刚在我的项目中这样做了。 这就是我所做的：

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() {}

另外，请确保向您的枚举添加一个 flags 属性，并确保它们的值都从 1 开始。 像这样：

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

左移位给出值 1、2、4、8、16 等。

嗯，我希望这会有所帮助。

Answer 7

我在这里结合了一些解决方案来创建我个人最喜欢的解决方案。 我的自定义属性只是将数据更改为 SimpleMembership 期望的形式，并让它处理其他所有内容。

我的角色枚举：

public enum MyRoles
{
    Admin,
    User,
}

创建角色：

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

自定义属性：

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

像这样使用：

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

Answer 8

要使用多个枚举来装饰 [Authorize()]，您可以编写如下代码：

[Authorize(Roles = nameof(MyEnum.Admin) + "," + nameof(MyEnum.Moderator))]

您也可以为单个角色编写此代码：

[Authorize(Roles = nameof(MyEnum.Admin))]

Answer 9

尝试

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