造轮子之自定义授权策略

轮子,自定义,授权,策略 · 浏览次数 : 33

小编点评

**授权策略** * 使用 `PermissionAuthorizationHandler` 处理授权请求。 * `PermissionAuthorizationHandler` 检查 `ControllerName` 和 `ActionName`，并使用 `IPermissionChecker` 进行授权检查。 * `PermissionAuthorizationPolicyProvider` 用于在匹配到自定义 policy 时使用 `PermissionAuthorizationHandler` 进行授权校验。 **IPermissionChecker 接口** * 检查用户角色是否在指定控制器和动作上具有授权。 * 使用分布式缓存存储用户角色权限。 * 根据角色权限判断授权结果。 **PermissionAuthorizationHandler 接口** * 重写 `HandleRequirementAsync` 方法，进行授权检查。 * 如果通过，将 `AuthorizationPolicy` 设置为 `Permit`。 * 如果不通过，将 `AuthorizationPolicy` 设置为 `Forbidden`，并使用 `context.Fail` 方法退出处理。 **PermissionAuthorizationPolicyProvider 接口** * 在匹配到自定义 policy 时，使用 `PermissionAuthorizationHandler` 进行授权检查。 * 如果匹配到自定义 policy，设置 `AuthorizationPolicy`。 * 否则，设置 `AuthorizationPolicy` 为 `Default`，表示不进行授权。 **WheelControllerBase 抽象控制器** * 添加 `[Authorize(\"Permission\")]` 特性头部。 * 提供 `HandleAuthorize` 方法，用于实际授权检查。 **测试示例** ```csharp [Authorize("Permission")] public class MyController : WheelControllerBase { // ... } ``` 在 `MyController` 中，使用 `[Authorize]` 标记所有方法。在 `HandleAuthorize` 方法中，使用 `IPermissionChecker` 检查用户角色。

正文

前面我们已经弄好了用户角色这块内容，接下来就是我们的授权策略。在asp.net core中提供了自定义的授权策略方案，我们可以按照需求自定义我们的权限过滤。
这里我的想法是，不需要在每个Controller或者Action打上AuthorizeAttribute，自动根据ControllerName和ActionName匹配授权。只需要在Controller基类打上一个AuthorizeAttribute，其他Controller除了需要匿名访问的，使用统一的ControllerName和ActionName匹配授权方案。
话不多说，开整。

IPermissionChecker

首先我们需要一个PermissionChecker来作为检查当前操作是否有权限。很简单，只需要传入ControllerName和ActionName。至于实现，后续再写。

namespace Wheel.Authorization
{
    public interface IPermissionChecker
    {
        Task<bool> Check(string controller, string action);
    }
}

PermissionAuthorizationHandler

接下来我们则需要实现一个PermissionAuthorizationHandler和PermissionAuthorizationRequirement，继承AuthorizationHandler抽象泛型类。

using Microsoft.AspNetCore.Authorization;

namespace Wheel.Authorization
{
    public class PermissionAuthorizationRequirement : IAuthorizationRequirement
    {
        public PermissionAuthorizationRequirement()
        {
        }

    }
}

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.Controllers;
using Wheel.DependencyInjection;

namespace Wheel.Authorization
{
    public class PermissionAuthorizationHandler : AuthorizationHandler<PermissionAuthorizationRequirement>, ITransientDependency
    {
        private readonly IPermissionChecker _permissionChecker;

        public PermissionAuthorizationHandler(IPermissionChecker permissionChecker)
        {
            _permissionChecker = permissionChecker;
        }

        protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, PermissionAuthorizationRequirement requirement)
        {
            if (context.Resource is HttpContext httpContext)
            {
                var actionDescriptor = httpContext.GetEndpoint()?.Metadata.GetMetadata<ControllerActionDescriptor>();
                var controllerName = actionDescriptor?.ControllerName;
                var actionName = actionDescriptor?.ActionName;
                if (await _permissionChecker.Check(controllerName, actionName))
                {
                    context.Succeed(requirement);
                }
            }
        }
    }
}

在PermissionAuthorizationHandler中注入IPermissionChecker。
然后通过重写HandleRequirementAsync进行授权策略的校验。
这里使用HttpContext获取请求的ControllerName和ActionName，再使用IPermissionChecker进行检查，如果通过则放行，不通过则自动走AspNetCore的其他AuthorizationHandler流程，不需要调用context.Fail方法。

PermissionAuthorizationPolicyProvider

这里除了AuthorizationHandler，还需要实现一个PermissionAuthorizationPolicyProvider，用于在匹配到我们自定义Permission的时候，就使用PermissionAuthorizationHandler做授权校验，否则不会生效。

using Microsoft.AspNetCore.Authorization;
using Microsoft.Extensions.Options;
using Wheel.DependencyInjection;

namespace Wheel.Authorization
{
    public class PermissionAuthorizationPolicyProvider : DefaultAuthorizationPolicyProvider, ITransientDependency
    {
        public PermissionAuthorizationPolicyProvider(IOptions<AuthorizationOptions> options) : base(options)
        {
        }
        public override async Task<AuthorizationPolicy?> GetPolicyAsync(string policyName)
        {
            var policy = await base.GetPolicyAsync(policyName);
            if (policy != null)
            {
                return policy;
            }
            if (policyName == "Permission")
            {
                var policyBuilder = new AuthorizationPolicyBuilder(Array.Empty<string>());
                policyBuilder.AddRequirements(new PermissionAuthorizationRequirement());
                return policyBuilder.Build();
            }
            return null;
        }
    }
}

很简单，只需要匹配到policyName == "Permission"时，添加一个PermissionAuthorizationRequirement即可。

PermissionChecker

接下来我们来实现IPermissionChecker的接口。

namespace Wheel.Permission
{
    public class PermissionChecker : IPermissionChecker, ITransientDependency
    {
        private readonly ICurrentUser _currentUser;
        private readonly IDistributedCache _distributedCache;

        public PermissionChecker(ICurrentUser currentUser, IDistributedCache distributedCache)
        {
            _currentUser = currentUser;
            _distributedCache = distributedCache;
        }

        public async Task<bool> Check(string controller, string action)
        {
            if (_currentUser.IsInRoles("admin"))
                return true;
            foreach (var role in _currentUser.Roles)
            {
                var permissions = await _distributedCache.GetAsync<List<string>>($"Permission:R:{role}");
                if (permissions is null)
                    continue;
                if (permissions.Any(a => a == $"{controller}:{action}"))
                    return true;
            }
            return false;
        }
    }
}

通过当前请求用户ICurrentUser以及分布式缓存IDistributedCache做权限判断，避免频繁查询数据库。
这里ICurrentUser如何实现后续文章再写。
很简单，先判断用户角色是否是admin，如果是admin角色则默认所有权限放行。否则根据缓存中的角色权限进行判断。如果通过则放行，否则拒绝访问。

创建抽象Controller基类

创建WheelControllerBase抽象基类，添加[Authorize("Permission")]的特性头部，约定其余所有Controller都继承这个控制器。

    [Authorize("Permission")]
    public abstract class WheelControllerBase : ControllerBase
    {
        
    }

接下来我们测试一个需要权限的API。

通过DEBUG可以看到我们正常走了校验并响应401。

就这样我们完成了我们自定义的授权策略配置。

轮子仓库地址https://github.com/Wheel-Framework/Wheel
欢迎进群催更。