lin-cms-dotnetcore.是如何方法級別的權限控制的?

方法級別的權限控制（API級別）

• 直接上lin-cms-dotnetcore的demo https://vvlog.baimocore.cn/#/p/5fb409b6-a034-dc01-0033-11091a8a1ffe

Lin的定位在於實現一整套 CMS的解決方案，它是一個設計方案，提供了不同的后端，不同的前端，而且也支持不同的數據庫

目前官方團隊維護 lin-cms-vue,lin-cms-spring-boot,lin-cms-koa,lin-cms-flask
社區維護了 lin-cms-tp5,lin-cms-react,lin-cms-dotnetcore，即已支持vue,react二種前端框架，java,nodejs,python,php,c#等五種后端語言。

下面我們來講一下.NET Core這個項目中權限控制的實現。

對於CMS來說，一個完善的權限模塊是必不可少的，是系統內置實現的。為了更加簡單地理解權限，我們先來理解一下ASP.NET Core有哪些權限控制。

1.AuthorizeAttribute的作用？

這個特性標簽授權通過屬性參數配置，可應用於控制器或操作方法上，對用戶的身份進行驗證。

如果沒有授權，會返回403狀態碼，我們可以通過重寫，來實現返回JSON字符串，讓前台提示。前提是請求中間件配置了如下二行。

• app.UseAuthentication(); 認證，明確是誰在操作，認證方式如用戶名密碼,登錄后，可以得到一個token，或者寫入cookies，這樣可以確定這個用戶是誰

• app.UseAuthorization(); 授權中間件，明確你是否有某個權限。在http請求時，中間件會在帶有權限特性標簽 [Authorize] 的操作，進行權限判斷，包括角色，策略等。

該控制器下的操作都必須經過身份驗證，

[Authorize]
public class AccountController : Controller
{
    public ActionResult Login()
    {
    }

    public ActionResult Logout()
    {
    }
}

這樣只顯示單個方法必須應用授權。

public class AccountController : Controller
{
   public ActionResult Login()
   {
   }

   [Authorize]
   public ActionResult Logout()
   {
   }
}

如果我們通過AllowAnonymous特性標簽去掉身份驗證。Login方法無須進行驗證。即可匿名訪問。

[Authorize]
public class AccountController : Controller
{
    [AllowAnonymous]
    public ActionResult Login()
    {
    }

    public ActionResult Logout()
    {
    }
}

2. 基於角色的授權

我們可以通過給這個特性標簽加參數，配置，某個方法，控制器是否有這個角色，如果有此角色才能訪問這些資源。

單個角色

[Authorize(Roles = "Administrator")]
public class AdministrationController : Controller
{
}

多個角色，我們可以這樣配置,即用逗號分隔。用戶有其中一個角色即可訪問。

[Authorize(Roles = "HRManager,Finance")]
public class SalaryController : Controller
{
}

當某個方法必須同時有二個角色怎么辦呢。該控制器只有同時有PowerUser，和ControlPanelUser的角色才能訪問這些資源了。

[Authorize(Roles = "PowerUser")]
[Authorize(Roles = "ControlPanelUser")]
public class ControlPanelController : Controller
{
}

• 3.更多。請看官網 https://docs.microsoft.com/zh-cn/aspnet/core/security/authorization/roles?view=aspnetcore-3.1

更多該特性標簽的介紹，也可參考官網，這里就不展開了。

那這個角色，到底在哪配置的？？

登錄時生成的Token,是基於JWT的，其中的Claim的type為ClaimTypes.Role（枚舉值），角色名稱為字符串，與特性標簽中的Roles屬性值相同。
如

new Claim(ClaimTypes.Role, "Administrator");

有多個角色時，List 多加幾個 new Claim(ClaimTypes.Role, "PowerUser"); 也是支持的。user為用戶信息，LinGroups為當前用戶的分組（多個）

即如下代碼示例，多個分組（角色）

var claims = new List<Claim>()
{
    new Claim(ClaimTypes.NameIdentifier, user.Email ?? ""),
    new Claim(ClaimTypes.GivenName, user.Nickname ?? ""),
    new Claim(ClaimTypes.Name, user.Username ?? ""),
};

user.LinGroups?.ForEach(r =>
 {
     claims.Add(new Claim(ClaimTypes.Role, r.Name));
 });

AuthorizeAttribute源碼

 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
  public class AuthorizeAttribute : Attribute, IAuthorizeData
  {
    public AuthorizeAttribute()
    {
    }

    public AuthorizeAttribute(string policy)
    {
      this.Policy = policy;
    }

    public string Policy { get; set; }

    public string Roles { get; set; }

    public string AuthenticationSchemes { get; set; }
  }

我們可以看到，它繼承了Attribute，說明這是一個特性標簽，IAuthorizeData是一個接口，有這三個屬性，約束了 一個規范，即有角色Roles，有策略Policy，有身份驗證方案AuthenticationSchemes，該特性支持Class,支持方法，該特性標簽支持多個共用，該特性標簽支持被繼承。

基於角色的授權和基於聲明的授權是一種預配置的策略，即固定的角色，固定的Claims驗證。

我們可以基於自定義策略的實現更多的權限驗證或某些規則驗證。

AuthorizeAttribute能做的權限控制如下

• 基於角色級別的權限控制（多個角色，單個角色）
• 基於聲明的授權：可自定義聲明特性。
• 基於策略的授權：

lin-cms-dotnetcore中的權限設計

說了這么多官方提供的，我們講一下lin-cms-dotnetcore中的權限設計

完整的表結構如下
https://luoyunchong.github.io/vovo-docs/dotnetcore/lin-cms/table.html

LinCmsAuthorizeAttribute

 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
    public class LinCmsAuthorizeAttribute : Attribute, IAsyncAuthorizationFilter
    {
        public string Permission { get; }
        public string Module { get; }

        public LinCmsAuthorizeAttribute(string permission, string module)
        {
            Permission = permission;
            Module = module;
        }

        public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
        {
            ClaimsPrincipal claimsPrincipal = context.HttpContext.User;

            if (!claimsPrincipal.Identity.IsAuthenticated)
            {
                HandlerAuthenticationFailed(context, "認證失敗，請檢查請求頭或者重新登陸", ErrorCode.AuthenticationFailed);
                return;
            }

            IAuthorizationService authorizationService = (IAuthorizationService)context.HttpContext.RequestServices.GetService(typeof(IAuthorizationService));
            AuthorizationResult authorizationResult = await authorizationService.AuthorizeAsync(context.HttpContext.User, null, new OperationAuthorizationRequirement() { Name = Permission });
            if (!authorizationResult.Succeeded)
            {
                HandlerAuthenticationFailed(context, $"您沒有權限：{Module}-{Permission}", ErrorCode.NoPermission);
            }
        }

        public void HandlerAuthenticationFailed(AuthorizationFilterContext context, string errorMsg, ErrorCode errorCode)
        {
            context.HttpContext.Response.StatusCode = StatusCodes.Status401Unauthorized;
            context.Result = new JsonResult(new UnifyResponseDto(errorCode, errorMsg, context.HttpContext));
        }
    }

上面的實現非常簡單,LinCmsAuthorizeAttribute繼承於Attribute，說明是一個特性標簽，有二個屬性Permission，Module，代表權限名，模塊名（用於區分哪個功能模塊），然后將權限名稱轉化為OperationAuthorizationRequirement，然后調用authorizationService中的方法AuthorizeAsync來完成授權。

接下來，我們在控制器上使用LinCmsAuthorizeAttribute,那么我們

[Route("cms/admin/group")]
[ApiController]
public class GroupController : ControllerBase
{
    private readonly IGroupService _groupService;
    public GroupController(IGroupService groupService)
    {
        _groupService = groupService;
    }

    [HttpGet("all")]
    [LinCmsAuthorize("查詢所有權限組","管理員")]
    public Task<List<LinGroup>> GetListAsync()
    {
        return _groupService.GetListAsync();
    }

    [HttpGet("{id}")]
    [LinCmsAuthorize("查詢一個權限組及其權限","管理員")]
    public async Task<GroupDto> GetAsync(long id)
    {
        GroupDto groupDto = await _groupService.GetAsync(id);
        return groupDto;
    }

    [HttpPost]
    [LinCmsAuthorize("新建權限組","管理員")]
    public async Task<UnifyResponseDto> CreateAsync([FromBody] CreateGroupDto inputDto)
    {
        await _groupService.CreateAsync(inputDto);
        return UnifyResponseDto.Success("新建分組成功");
    }

    [HttpPut("{id}")]
    [LinCmsAuthorize("更新一個權限組","管理員")]
    public async Task<UnifyResponseDto> UpdateAsync(long id, [FromBody] UpdateGroupDto updateGroupDto)
    {
        await _groupService.UpdateAsync(id, updateGroupDto);
        return UnifyResponseDto.Success("更新分組成功");
    }

    [HttpDelete("{id}")]
    [LinCmsAuthorize("刪除一個權限組","管理員")]
    public async Task<UnifyResponseDto> DeleteAsync(long id)
    {
        await _groupService.DeleteAsync(id);
        return UnifyResponseDto.Success("刪除分組成功");
    }

}

這樣在方法上已經加了權限的標簽，但我們怎么得到系統中的所有權限，讓用戶配置呢。
獲取控制器及方法特性標簽。本質上，是通過反射,掃描當前程序集，會獲取到一個List，我們可以在系統啟動時把這些數據存到數據庫中。

最新的方式是采用此方法，原理都相同。name，module唯一值。存入lin_permission表中，這時就有id值了。lin_group_permission就能用分組關聯了。

public async Task SeedAsync()
{
    List<PermissionDefinition> linCmsAttributes = ReflexHelper.GeAssemblyLinCmsAttributes();

    List<LinPermission> insertPermissions = new List<LinPermission>();
    List<LinPermission>allPermissions=await  _permissionRepository.Select.ToListAsync();
    
    linCmsAttributes.ForEach(r =>
    {
        bool exist = allPermissions.Any(u => u.Module == r.Module && u.Name == r.Permission);
        if (!exist)
        {
            insertPermissions.Add(new LinPermission(r.Permission, r.Module));
        }
    });
    await _permissionRepository.InsertAsync(insertPermissions);
 }

實現方法級的權限控制源碼解析

原理可以看這個文章ASP.NET Core 認證與授權[7]:動態授權中的自定義授權過濾器

我們需要了解一下這些類/接口/抽象類

• IAuthorizationService(interface)
• AuthorizationService(class)
• IAuthorizationHandler(interface)
• AuthorizationHandler (abstract class)
• PermissionAuthorizationHandler（class 自定義的類,繼承AuthorizationHandler）

總結調用鏈如下

LinCmsAuthorizeAttribute（繼承了IAsyncAuthorizationFilter的特性標簽）
調用了---->
IAuthorizationService中的AuthorizeAsync方法
調用了---->
IAuthorizationHandler中的HandleAsync
調用了---->
AuthorizationHandler中的HandleRequirementAsync抽象方法
相當於調用---->
PermissionAuthorizationHandler類中的實現方法HandleRequirementAsync
調用了---->
IPermissionService類中的CheckPermissionAsync方法。
調用了---->
IAuditBaseRepository<LinPermission,long>
IAuditBaseRepository<LinGroupPermission, long>
使用FreeSql,判斷當前用戶所在分組是否擁有此權限。

IAuthorizationService是什么呢。我們可以理解為，驗證當前用戶是否擁有對應的資源權限。系統默認實現了該方法

public interface IAuthorizationService
{
    Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, IEnumerable<IAuthorizationRequirement> requirements);

    Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, string policyName);
}

AuthorizationService是什么呢.他實現了IAuthorizationService接口.
通過源碼我們知道，它調用 await authorizationHandler.HandleAsync(authContext);

 public async Task<AuthorizationResult> AuthorizeAsync(
  ClaimsPrincipal user,
  object resource,
  IEnumerable<IAuthorizationRequirement> requirements)
{
  if (requirements == null)
    throw new ArgumentNullException(nameof (requirements));
  AuthorizationHandlerContext authContext = this._contextFactory.CreateContext(requirements, user, resource);
  foreach (IAuthorizationHandler authorizationHandler in await this._handlers.GetHandlersAsync(authContext))
  {
    await authorizationHandler.HandleAsync(authContext);
    if (!this._options.InvokeHandlersAfterFailure)
    {
      if (authContext.HasFailed)
        break;
    }
  }
  AuthorizationResult authorizationResult = this._evaluator.Evaluate(authContext);
  if (authorizationResult.Succeeded)
    this._logger.UserAuthorizationSucceeded();
  else
    this._logger.UserAuthorizationFailed();
  return authorizationResult;
}

IAuthorizationHandler 僅一個接口。

public interface IAuthorizationHandler
{
    /// <summary>
    /// Makes a decision if authorization is allowed.
    /// </summary>
    /// <param name="context">The authorization information.</param>
    Task HandleAsync(AuthorizationHandlerContext context);
}

AuthorizationHandler，它繼承IAuthorizationHandler
而且他是一個抽象類，默認實現了HandleAsync方法，子類只用實現HandleRequirementAsync即可。

  public abstract class AuthorizationHandler<TRequirement> : IAuthorizationHandler
    where TRequirement : IAuthorizationRequirement
  {
    public virtual async Task HandleAsync(AuthorizationHandlerContext context)
    {
      foreach (TRequirement requirement in context.Requirements.OfType<TRequirement>())
        await this.HandleRequirementAsync(context, requirement);
    }

    protected abstract Task HandleRequirementAsync(
      AuthorizationHandlerContext context,
      TRequirement requirement);
  }

我們就可以繼承AuthorizationHandler，子類實現從數據庫中取數據做對比，其中泛型參數使用系統內置的一個只有Name的類OperationAuthorizationRequirement，當然，如果我們需要更多的參數，可以繼承IAuthorizationRequirement，增加更多的參數。

判斷當前用戶是否不為null,當調用CheckPermissionAsync，判斷是否有此權限。

   public class PermissionAuthorizationHandler : AuthorizationHandler<OperationAuthorizationRequirement>
    {
        private readonly IPermissionService _permissionService;

        public PermissionAuthorizationHandler(IPermissionService permissionService)
        {
            _permissionService = permissionService;
        }

        protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement)
        {
            Claim userIdClaim = context.User?.FindFirst(_ => _.Type == ClaimTypes.NameIdentifier);
            if (userIdClaim != null)
            {
                if (await _permissionService.CheckPermissionAsync(requirement.Name))
                {
                    context.Succeed(requirement);
                }
            }
        }
    }

另外我們還需要把這個Handler注入到我們的DI中，在ConfigureServices中替換如下服務

services.AddScoped<IAuthorizationHandler, PermissionAuthorizationHandler>();

其中的PermssionAppService中的實現,檢查當前登錄的用戶的是否有此權限

public async Task<bool> CheckPermissionAsync(string permission)
{
    long[] groups = _currentUser.Groups;

    LinPermission linPermission = await _permissionRepository.Where(r => r.Name == permission).FirstAsync();

    bool existPermission = await _groupPermissionRepository.Select
        .AnyAsync(r => groups.Contains(r.GroupId) && r.PermissionId == linPermission.Id);

    return existPermission;
}

更多參考

• ASP.NET Core 認證與授權[1]:初識認證

開源地址

• 后端接口Gitee 鏈接 https://gitee.com/igeekfan/lin-cms-dotnetcore
• 后端接口GitHub 鏈接 https://github.com/luoyunchong/lin-cms-dotnetcore
• 管理端UI https://github.com/luoyunchong/lin-cms-vue
• 用戶端UI https://github.com/luoyunchong/lin-cms-vvlog