[Abp 源码分析]11、权限验证

0.简介

Abp 自己集成了一套权限验证体系，经过 ASP.NET Core 的过滤器与 Castle 的拦截器进行拦截请求，并进行权限验证。在 Abp 框架内部，权限分为两块，一个是功能(Feature)，一个是权限项(Permission)，在更多的时候二者仅仅是概念不一样而已，大致处理流程仍是同样的。

因为 Abp 自己是针对多租户架构进行设计的，功能是相对于租户而言，好比针对 A 租户他每个月的短信发送配额为 10000 条，而针对 B 租户其配额为 5000 条，可能 C 租户该功能都没有开通。

本篇文章仅针对基本的验证机制进行解析，后续文章会进行详解。

0.1 验证流程图

1.启动流程

1.1 流程图

1.2 代码流程

首先在注入 Abp 框架的时候，经过注入过滤器一块儿将权限验证过滤器进行了注入。

internal static class AbpMvcOptionsExtensions
{
    // ... 其余代码

    private static void AddFilters(MvcOptions options)
    {
        // ... 其余注入的过滤器
        options.Filters.AddService(typeof(AbpAuthorizationFilter));
        // ... 其余注入的过滤器
    }

    // ... 其余代码
}

Abp 除了拦截验证 API 接口，同时也经过 Castle Windsor Interceptor 来验证普通类型的方法，来检测当前用户是否有权限进行调用。拦截器的注册则是存放在 AbpBootstrapper 对象初始化的时候，经过 AddInterceptorRegistrars() 方法注入 Abp 自带的拦截器对象。

private AbpBootstrapper([NotNull] Type startupModule, [CanBeNull] Action<AbpBootstrapperOptions> optionsAction = null)
{
    Check.NotNull(startupModule, nameof(startupModule));

    var options = new AbpBootstrapperOptions();
    optionsAction?.Invoke(options);
    
    // 其余初始化代码
    
    // 判断用户在启用 Abp 框架的是时候是否禁用了全部的拦截器
    if (!options.DisableAllInterceptors)
    {
        // 初始化拦截器
        AddInterceptorRegistrars();
    }
}

private void AddInterceptorRegistrars()
{
    // 参数验证拦截器注册
    ValidationInterceptorRegistrar.Initialize(IocManager);
    // 审计信息记录拦截器注册
    AuditingInterceptorRegistrar.Initialize(IocManager);
    // 实体变动追踪拦截器注册
    EntityHistoryInterceptorRegistrar.Initialize(IocManager);
    // 工做单元拦截器注册
    UnitOfWorkRegistrar.Initialize(IocManager);
    // 受权拦截器注册
    AuthorizationInterceptorRegistrar.Initialize(IocManager);
}

Abp 经过注入过滤器与拦截器就可以从源头验证并控制权限校验逻辑，以上就是 Abp 在启动时所作的操做。

2.代码分析

整体来讲，Abp 针对权限的验证就是拦截+检测，总体思路便是这样，只是实现可能略微复杂，请耐心往下看。

2.1 权限拦截器与权限过滤器

首先咱们从入口点开始分析代码，在上一节咱们说过 Abp 经过拦截器与过滤器来实现权限的拦截与处理，那么在其内部是如何进行处理的呢？

其实很简单，在权限拦截器与权限过滤器的内部实现都使用了 IAuthorizationHelper 的 AuthorizeAsync() 方法来进行权限校验。

2.1.1 权限过滤器代码实现

public class AbpAuthorizationFilter : IAsyncAuthorizationFilter, ITransientDependency
{
    public ILogger Logger { get; set; }

    // 权限验证类，这个才是真正针对权限进行验证的对象
    private readonly IAuthorizationHelper _authorizationHelper;
    // 异常包装器，这个玩意儿在个人《[Abp 源码分析]10、异常处理》有讲，主要是用来封装没有受权时返回的错误信息
    private readonly IErrorInfoBuilder _errorInfoBuilder;
    // 事件总线处理器，一样在个人《[Abp 源码分析]9、事件总线》有讲，在这里用于触发一个未受权请求引起的事件，用户能够监听此事件来进行本身的处理
    private readonly IEventBus _eventBus;

    // 构造注入
    public AbpAuthorizationFilter(
        IAuthorizationHelper authorizationHelper,
        IErrorInfoBuilder errorInfoBuilder,
        IEventBus eventBus)
    {
        _authorizationHelper = authorizationHelper;
        _errorInfoBuilder = errorInfoBuilder;
        _eventBus = eventBus;
        Logger = NullLogger.Instance;
    }

    public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
    {
        // 若是注入了 IAllowAnonymousFilter 过滤器则容许全部匿名请求
        if (context.Filters.Any(item => item is IAllowAnonymousFilter))
        {
            return;
        }

        // 若是不是一个控制器方法则直接返回
        if (!context.ActionDescriptor.IsControllerAction())
        {
            return;
        }

        // 开始使用 IAuthorizationHelper 来进行权限校验
        try
        {
            await _authorizationHelper.AuthorizeAsync(
                context.ActionDescriptor.GetMethodInfo(),
                context.ActionDescriptor.GetMethodInfo().DeclaringType
            );
        }
        // 若是是未受权异常的处理逻辑
        catch (AbpAuthorizationException ex)
        {
            // 记录日志
            Logger.Warn(ex.ToString(), ex);

            // 触发异常事件
            _eventBus.Trigger(this, new AbpHandledExceptionData(ex));

            // 若是接口的返回类型为 ObjectResult，则采用 AjaxResponse 对象进行封装信息
            if (ActionResultHelper.IsObjectResult(context.ActionDescriptor.GetMethodInfo().ReturnType))
            {
                context.Result = new ObjectResult(new AjaxResponse(_errorInfoBuilder.BuildForException(ex), true))
                {
                    StatusCode = context.HttpContext.User.Identity.IsAuthenticated
                        ? (int) System.Net.HttpStatusCode.Forbidden
                        : (int) System.Net.HttpStatusCode.Unauthorized
                };
            }
            else
            {
                context.Result = new ChallengeResult();
            }
        }
        // 其余异常则显示为内部异常信息
        catch (Exception ex)
        {
            Logger.Error(ex.ToString(), ex);

            _eventBus.Trigger(this, new AbpHandledExceptionData(ex));

            if (ActionResultHelper.IsObjectResult(context.ActionDescriptor.GetMethodInfo().ReturnType))
            {
                context.Result = new ObjectResult(new AjaxResponse(_errorInfoBuilder.BuildForException(ex)))
                {
                    StatusCode = (int) System.Net.HttpStatusCode.InternalServerError
                };
            }
            else
            {
                //TODO: How to return Error page?
                context.Result = new StatusCodeResult((int)System.Net.HttpStatusCode.InternalServerError);
            }
        }
    }
}

2.1.2 权限拦截器初始化绑定

权限拦截器在 Abp 框架初始化完成的时候就开始监听了组件注册事件，只要被注入的类型实现了 AbpAuthorizeAttribute 特性与 RequiresFeatureAttribute 特性都会被注入 AuthorizationInterceptor 拦截器。

internal static class AuthorizationInterceptorRegistrar
{
    public static void Initialize(IIocManager iocManager)
    {
        // 监听 DI 组件注册事件
        iocManager.IocContainer.Kernel.ComponentRegistered += Kernel_ComponentRegistered;            
    }

    private static void Kernel_ComponentRegistered(string key, IHandler handler)
    {
        // 判断注入的类型是否符合要求
        if (ShouldIntercept(handler.ComponentModel.Implementation))
        {
            // 符合要求，针对该组件添加权限拦截器
            handler.ComponentModel.Interceptors.Add(new InterceptorReference(typeof(AuthorizationInterceptor))); 
        }
    }

    private static bool ShouldIntercept(Type type)
    {
        if (SelfOrMethodsDefinesAttribute<AbpAuthorizeAttribute>(type))
        {
            return true;
        }

        if (SelfOrMethodsDefinesAttribute<RequiresFeatureAttribute>(type))
        {
            return true;
        }

        return false;
    }

    private static bool SelfOrMethodsDefinesAttribute<TAttr>(Type type)
    {
        // 判断传入的 Type 有定义 TAttr 类型的特性
        if (type.GetTypeInfo().IsDefined(typeof(TAttr), true))
        {
            return true;
        }

        // 或者说，该类型的全部公开的方法是否有方法标注了 TAttr 类型的特性
        return type
            .GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
            .Any(m => m.IsDefined(typeof(TAttr), true));
    }
}

2.1.3 权限拦截器实现

Abp 框架针对权限拦截器的实现则是简单了许多，只是在被拦截的方法在执行的时候，会直接使用 IAuthorizationHelper 进行权限验证。

public class AuthorizationInterceptor : IInterceptor
{
    private readonly IAuthorizationHelper _authorizationHelper;

    public AuthorizationInterceptor(IAuthorizationHelper authorizationHelper)
    {
        _authorizationHelper = authorizationHelper;
    }

    public void Intercept(IInvocation invocation)
    {
        // 使用 IAuthorizationHelper 进行权限验证
        _authorizationHelper.Authorize(invocation.MethodInvocationTarget, invocation.TargetType);
        invocation.Proceed();
    }
}

2.2 权限特性

在 Abp 框架里面定义了两组特性，第一个是 AbpMvcAuthorizeAttribute ，适用于 MVC 控制器，它是直接继承了 ASP .NET Core 自带的权限验证特性 AuthorizeAttribute，当控制器或者控制器内部的方法标注了该特性，就会进入以前 Abp 定义的权限过滤器 AbpAuthorizationFilter 内部。

第二种特性则是 AbpAuthorizeAttribute ，该特性适用于应用服务层，也就是实现了 IApplicationService 接口的类型所使用的。

它们两个的内部定义基本同样，传入一个或者多哦个具体的权限项，以便给 IAuthorizationHelper 做验证使用。

在 Abp 框架内部，每个权限其实就是一个字符串，好比说用户资料新增，是一个权限，那么你能够直接建立一个 "Administration.UserManagement.CreateUser" 字符做为其权限项，那么代码示例就以下：

[AbpAuthorize("Administration.UserManagement.CreateUser")]
public void CreateUser(CreateUserInput input)
{
    // 若是用户没有 Administration.UserManagement.CreateUser 权限，则不会进入到本方法
}

下面是 AbpAuthorizeAttribute 权限特性的定义，另一个 MVC 权限特性定义也是同样的：

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
public class AbpAuthorizeAttribute : Attribute, IAbpAuthorizeAttribute
{
    // 特性拥有的权限项集合
    public string[] Permissions { get; }
    
    // 用于肯定是否须要验证用户是否拥有 Permission 数组内全部权限项，若是为 True 则用户须要拥有全部权限才可以操做接口，若是为 False 的话，用户只要拥有其中一个权限项则能够经过验证，默认值为：False
    public bool RequireAllPermissions { get; set; }

    public AbpAuthorizeAttribute(params string[] permissions)
    {
        Permissions = permissions;
    }
}

权限特性通常都会打在你的控制器/应用服务层的类定义，或者方法之上，当你为你的 API 接口标注了权限特性，那么当前请求的用户没有所须要的权限，则一概会被拦截器/过滤器阻止请求。

2.3 权限验证

当若是用户请求的方法或者控制器是标注了受权特性的话，都会经过 IAuthorizationHelper 进行验证，它一共有两个公开方法。

public interface IAuthorizationHelper
{
    // 判断用户是否拥有一组权限特性所标注的权限
    Task AuthorizeAsync(IEnumerable<IAbpAuthorizeAttribute> authorizeAttributes);

    // 判断用户是否拥有，被调用的方法所标注的权限
    Task AuthorizeAsync(MethodInfo methodInfo, Type type);
}

在其默认的实现当中，注入了两个相对重要的组件，第一个是 IAbpSession，它是 Abp 框架定义的用户会话状态，若是当前用户处于登陆状态的时候，其内部一定有值，在这里主要用于判断用户是否登陆。

第二个则是 IPermissionChecker ，它则是用于具体的检测逻辑，若是说 IAuthorizationHelper 是用来提供权限验证的工具，那么 IPermissionChecker 就是权限验证的核心，在 IPermissionChecker 内部则是真正的对传入的权限进行了验证逻辑。

IPermissionChecker 自己只有两个方法，都返回的 bool 值，有权限则为 true 没有则为 false，其接口定义以下：

// 权限检测器
public interface IPermissionChecker
{
    // 传入一个权限项的值，判断当前用户是否拥有该权限
    Task<bool> IsGrantedAsync(string permissionName);

    // 传入一个用户标识，判断该用户是否拥有制定的权限项
    Task<bool> IsGrantedAsync(UserIdentifier user, string permissionName);
}

能够看到 Abp 框架自己针对于设计来讲，都考虑了各个组件的可替换性与扩展性，你能够随时经过替换 IAuthorizationHelper 或者是 IPermissionChecker 的实现来达到本身想要的效果，这点值得咱们在编写代码的时候学习。

说了这么多，下面咱们来看一下 IAuthorizationHelper 的具体实现吧：

public class AuthorizationHelper : IAuthorizationHelper, ITransientDependency
{
    public IAbpSession AbpSession { get; set; }
    public IPermissionChecker PermissionChecker { get; set; }
    public IFeatureChecker FeatureChecker { get; set; }
    public ILocalizationManager LocalizationManager { get; set; }

    private readonly IFeatureChecker _featureChecker;
    private readonly IAuthorizationConfiguration _authConfiguration;

    public AuthorizationHelper(IFeatureChecker featureChecker, IAuthorizationConfiguration authConfiguration)
    {
        _featureChecker = featureChecker;
        _authConfiguration = authConfiguration;
        AbpSession = NullAbpSession.Instance;
        PermissionChecker = NullPermissionChecker.Instance;
        LocalizationManager = NullLocalizationManager.Instance;
    }

    public virtual async Task AuthorizeAsync(IEnumerable<IAbpAuthorizeAttribute> authorizeAttributes)
    {
        // 判断是否启用了受权系统，没有启用则直接跳过不作验证
        if (!_authConfiguration.IsEnabled)
        {
            return;
        }

        // 若是当前的用户会话状态其 SessionId 没有值，则说明用户没有登陆，抛出受权验证失败异常
        if (!AbpSession.UserId.HasValue)
        {
            throw new AbpAuthorizationException(
                LocalizationManager.GetString(AbpConsts.LocalizationSourceName, "CurrentUserDidNotLoginToTheApplication")
                );
        }

        // 遍历全部受权特性，经过 IPermissionChecker 来验证用户是否拥有这些特性所标注的权限
        foreach (var authorizeAttribute in authorizeAttributes)
        {
            await PermissionChecker.AuthorizeAsync(authorizeAttribute.RequireAllPermissions, authorizeAttribute.Permissions);
        }
    }

    // 受权过滤器与受权拦截器调用的方法，传入一个方法定义与方法所在的类的类型
    public virtual async Task AuthorizeAsync(MethodInfo methodInfo, Type type)
    {
        // 检测产品功能
        await CheckFeatures(methodInfo, type);
        // 检测权限
        await CheckPermissions(methodInfo, type);
    }

    protected virtual async Task CheckFeatures(MethodInfo methodInfo, Type type)
    {
        var featureAttributes = ReflectionHelper.GetAttributesOfMemberAndType<RequiresFeatureAttribute>(methodInfo, type);

        if (featureAttributes.Count <= 0)
        {
            return;
        }

        foreach (var featureAttribute in featureAttributes)
        {
            // 检查当前用户是否启用了被调用方法标注上面的功能
            await _featureChecker.CheckEnabledAsync(featureAttribute.RequiresAll, featureAttribute.Features);
        }
    }

    protected virtual async Task CheckPermissions(MethodInfo methodInfo, Type type)
    {
        // 判断是否启用了受权系统，没有启用则直接跳过不作验证
        if (!_authConfiguration.IsEnabled)
        {
            return;
        }

        // 判断方法或者控制器类上是否标注了匿名访问特性，若是标注了，不作权限验证
        if (AllowAnonymous(methodInfo, type))
        {
            return;
        }

        // 得到方法和类上面定义的全部权限特性数组
        var authorizeAttributes =
            ReflectionHelper
                .GetAttributesOfMemberAndType(methodInfo, type)
                .OfType<IAbpAuthorizeAttribute>()
                .ToArray();

        // 若是一个都不存在，跳过验证
        if (!authorizeAttributes.Any())
        {
            return;
        }

        // 传入全部权限特性，调用另一个重载方法，使用 IPermissionChecker 针对这些特性进行具体验证
        await AuthorizeAsync(authorizeAttributes);
    }

    private static bool AllowAnonymous(MemberInfo memberInfo, Type type)
    {
        return ReflectionHelper
            .GetAttributesOfMemberAndType(memberInfo, type)
            .OfType<IAbpAllowAnonymousAttribute>()
            .Any();
    }
}

看完上面你彷佛并无看到哪儿有抛出 AbpAuthorizationException 的地方，这是由于 Abp 给 IPermissionChecker 添加了一个扩展方法，叫作 AuthorizeAsync() ，看他的具体实现你就知道，它在这个扩展方法里面才真正调用了 IPermissionChecker.IsGrantedAsync() 方法进行权限验证。

public static async Task AuthorizeAsync(this IPermissionChecker permissionChecker, bool requireAll, params string[] permissionNames)
{
    // 这里仍是调用的一个扩展方法，其内部是遍历传入的权限项集合，针对每个权限进行检测
    if (await IsGrantedAsync(permissionChecker, requireAll, permissionNames))
    {
        return;
    }

    // 这儿呢就是本地化权限的名称，用于抛出异常的时候给前端展现用的，里面提列了你缺乏的权限项有哪些
    var localizedPermissionNames = LocalizePermissionNames(permissionChecker, permissionNames);

    if (requireAll)
    {
        throw new AbpAuthorizationException(
            string.Format(
                L(
                    permissionChecker,
                    "AllOfThesePermissionsMustBeGranted",
                    "Required permissions are not granted. All of these permissions must be granted: {0}"
                ),
                string.Join(", ", localizedPermissionNames)
            )
        );
    }
    else
    {
        throw new AbpAuthorizationException(
            string.Format(
                L(
                    permissionChecker,
                    "AtLeastOneOfThesePermissionsMustBeGranted",
                    "Required permissions are not granted. At least one of these permissions must be granted: {0}"
                ),
                string.Join(", ", localizedPermissionNames)
            )
        );
    }
}

若是你感受本身快被绕晕了，也没必要惊慌...由于 IPermissionChecker 自己只能针对单个权限进行检查，因此这里经过扩展了 IPermissionChecker 方法，使其可以一次检验一个集合而已。

3.结语

本篇文章主要解析了 Abp 框架针对权限验证所作的基本操做，总体思路仍是十分简单的，在 Abp 基本框架没有涉及到用户与角色的具体权限控制，这部分的内容是存放在 Abp.Zero 模块当中的，下一篇文章将会结合 Abp.Zero 来进行更加详细的讲解权限与功能的实现。

4.点此跳转到总目录