ASP.NET Identity中如何安全实现内置角色层级？

ASP.NET Identity 并没有直接内置角色层级的现成实现，但可以基于其原生机制构建安全的角色权限控制逻辑，以下是几种公认的实践方案：

1. 基于角色继承与Claims扩展 #

核心思路是给高权限角色添加低权限角色的Claim，利用Identity的Claims系统实现权限覆盖，同时自定义逻辑判断操作范围：

• 创建角色时配置继承关系：

  // 初始化Master角色，包含Admin、Manager、Restricted的权限Claim
  var masterRole = new IdentityRole("Master");
  await _roleManager.CreateAsync(masterRole);
  await _roleManager.AddClaimAsync(masterRole, new Claim(ClaimTypes.Role, "Admin"));
  await _roleManager.AddClaimAsync(masterRole, new Claim(ClaimTypes.Role, "Manager"));
  await _roleManager.AddClaimAsync(masterRole, new Claim(ClaimTypes.Role, "Restricted"));
  
  // 初始化Admin角色，包含Manager、Restricted的权限Claim
  var adminRole = new IdentityRole("Admin");
  await _roleManager.CreateAsync(adminRole);
  await _roleManager.AddClaimAsync(adminRole, new Claim(ClaimTypes.Role, "Manager"));
  await _roleManager.AddClaimAsync(adminRole, new Claim(ClaimTypes.Role, "Restricted"));
  

• 自定义权限判断逻辑：

  public async Task<bool> CanEditUser(string currentUserId, User targetUser)
  {
      var currentUser = await _userManager.FindByIdAsync(currentUserId);
      // 获取当前用户拥有的所有角色Claim（包括继承来的）
      var currentUserAllowedRoles = await _userManager.GetClaimsAsync(currentUser)
          .Where(c => c.Type == ClaimTypes.Role)
          .Select(c => c.Value)
          .ToList();
  
      var targetUserRoles = await _userManager.GetRolesAsync(targetUser);
      // 若目标用户包含Master角色，直接拒绝Admin及以下权限的用户操作
      if (targetUserRoles.Contains("Master"))
          return currentUserRoles.Contains("Master");
  
      // 判断目标用户的所有角色是否都在当前用户的权限范围内
      return targetUserRoles.All(role => currentUserAllowedRoles.Contains(role));
  }
  

2. 自定义角色层级服务与授权策略 #

通过构建角色层级配置，结合ASP.NET Core的授权策略实现细粒度权限控制：

• 定义角色层级配置：

  public static class RoleHierarchy
  {
      // 高权限角色对应的可操作低权限角色列表
      private static readonly Dictionary<string, List<string>> _hierarchy = new()
      {
          ["Master"] = new() { "Admin", "Manager", "Restricted" },
          ["Admin"] = new() { "Manager", "Restricted" },
          ["Manager"] = new() { "Restricted" },
          ["Restricted"] = new()
      };
  
      public static bool HasPermissionToManage(string currentRole, string targetRole)
      {
          // 同角色或当前角色可管理目标角色则返回true
          if (currentRole == targetRole) return true;
          return _hierarchy.TryGetValue(currentRole, out var allowed) && allowed.Contains(targetRole);
      }
  }
  

• 注册并使用授权策略：

  // Startup/Program.cs 中注册策略
  services.AddAuthorization(options =>
  {
      options.AddPolicy("CanManageUser", policy =>
          policy.RequireAssertion(context =>
          {
              var currentRoles = context.User.Claims
                  .Where(c => c.Type == ClaimTypes.Role)
                  .Select(c => c.Value);
              var targetRole = context.Resource as string;
  
              return currentRoles.Any(role => RoleHierarchy.HasPermissionToManage(role, targetRole));
          }));
  });
  
  // 控制器中使用
  [Authorize(Policy = "CanManageUser")]
  public async Task<IActionResult> EditUser(string userId)
  {
      var targetUser = await _userManager.FindByIdAsync(userId);
      var targetRoles = await _userManager.GetRolesAsync(targetUser);
      
      // 额外校验：禁止非Master用户编辑Master角色用户
      if (targetRoles.Contains("Master") && !User.IsInRole("Master"))
          return Forbid();
  
      // 后续编辑逻辑
      return View(targetUser);
  }
  

3. 扩展RoleManager封装层级判断 #

通过扩展RoleManager方法，将角色层级判断逻辑封装复用：

• 扩展方法实现：

  public static class RoleManagerExtensions
  {
      private static readonly Dictionary<string, int> _roleLevels = new()
      {
          ["Master"] = 4,
          ["Admin"] = 3,
          ["Manager"] = 2,
          ["Restricted"] = 1
      };
  
      public static bool IsRoleHigherOrEqual(this RoleManager<IdentityRole> _, string currentRole, string targetRole)
      {
          if (!_roleLevels.TryGetValue(currentRole, out var currentLevel) || 
              !_roleLevels.TryGetValue(targetRole, out var targetLevel))
              return false;
  
          return currentLevel > targetLevel;
      }
  }
  

• 业务逻辑中调用：

  var currentUserRole = User.FindFirstValue(ClaimTypes.Role);
  var targetUserRoles = await _userManager.GetRolesAsync(targetUser);
  var highestTargetRole = targetUserRoles.OrderByDescending(r => _roleLevels[r]).First();
  
  if (!_roleManager.IsRoleHigherOrEqual(currentUserRole, highestTargetRole) || highestTargetRole == "Master")
  {
      // 拒绝操作，返回403
      return Forbid();
  }
  

以上方案均基于ASP.NET Identity原生机制扩展，避免了自研认证系统的安全风险，其中角色继承+Claims的方式最贴合官方设计理念，而自定义授权策略更适合复杂权限规则场景。

内容的提问来源于stack exchange，提问作者kj49