在上一章中，詳細介紹了 ASP.NET Core 中的授權政策，在需要授權時，隻需要在對應的Controler或者Action上面打上[Authorize]特性，并指定要執行的政策名稱即可，但是，授權政策是怎麼執行的呢？懷着一顆好奇的心，忍不住來探索一下它的執行流程。

MVC中的授權AuthorizationApplicationModelProviderAuthorizeFilter
IPolicyEvaluatorAuthenticateAsync(AuthenticationSchemes)AuthorizeAsync(Requirements)
IAuthorizationServiceIAuthorizationPolicyProviderIAuthorizationHandlerContextFactoryIAuthorizationHandlerProviderIAuthorizationEvaluator

在《(上一章》中提到，AuthorizeAttribute隻是一個簡單的實作了IAuthorizeData接口的特性，并且在 ASP.NET Core 授權系統中并沒有使用到它。我們知道在認證中，還有一個UseAuthentication擴充方法來激活認證系統，但是在授權中并沒有類似的機制。

這是因為當我們使用[Authorize]通常是在MVC中，由MVC來負責激活授權系統。本來在這個系列的文章中，我并不想涉及到MVC的知識，但是為了能更好的了解授權系統的執行，就來簡單介紹一下MVC中與授權相關的知識。

MVC中的授權

當我們使用MVC時，首先會調用MVC的AddMvc擴充方法，用來注冊一些MVC相關的服務：

public static IMvcBuilder AddMvc(this IServiceCollection services)
{
    var builder = services.AddMvcCore();

    builder.AddAuthorization();

    ...
}

public static IMvcCoreBuilder AddAuthorization(this IMvcCoreBuilder builder)
{
    AddAuthorizationServices(builder.Services);
    return builder;
}

internal static void AddAuthorizationServices(IServiceCollection services)
{
    services.AddAuthenticationCore();
    services.AddAuthorization();
    services.AddAuthorizationPolicyEvaluator();

    services.TryAddEnumerable(
        ServiceDescriptor.Transient<IApplicationModelProvider, AuthorizationApplicationModelProvider>());
}

在上面AddAuthorizationServices中的前三個方法都屬于 ASP.NET Core 《Security》項目中提供的擴充方法，其中前兩個在前面幾章已經介紹過了，對于AddAuthorizationPolicyEvaluator放到後面再來介紹，我們先來看一下MVC中的AuthorizationApplicationModelProvider。

AuthorizationApplicationModelProvider

在MVC中有一個ApplicationModel的概念，它用來封裝Controller, Filter, ApiExplorer等。對應的，在MVC中還提供了一系列的ApplicationModelProvider來初始化ApplicationModel的各個部分，而AuthorizationApplicationModelProvider就是用來初始化與授權相關的部分。

public class AuthorizationApplicationModelProvider : IApplicationModelProvider
{
    public void OnProvidersExecuting(ApplicationModelProviderContext context)
    {
        foreach (var controllerModel in context.Result.Controllers)
        {
            var controllerModelAuthData = controllerModel.Attributes.OfType<IAuthorizeData>().ToArray();
            if (controllerModelAuthData.Length > 0)
            {
                controllerModel.Filters.Add(GetFilter(_policyProvider, controllerModelAuthData));
            }
            foreach (var attribute in controllerModel.Attributes.OfType<IAllowAnonymous>())
            {
                controllerModel.Filters.Add(new AllowAnonymousFilter());
            }
            foreach (var actionModel in controllerModel.Actions)
            {
                var actionModelAuthData = actionModel.Attributes.OfType<IAuthorizeData>().ToArray();
                if (actionModelAuthData.Length > 0)
                {
                    actionModel.Filters.Add(GetFilter(_policyProvider, actionModelAuthData));
                }
                foreach (var attribute in actionModel.Attributes.OfType<IAllowAnonymous>())
                {
                    actionModel.Filters.Add(new AllowAnonymousFilter());
                }
            }
        }
    }
}

如上，首先查找每個Controller中實作了IAuthorizeData接口的特性，然後将其轉化為AuthorizeFilter并添加到Controller的Filter集合中，緊接着再查找實作了IAllowAnonymous接口的特性，将其轉化為AllowAnonymousFilter過濾器也添加到Filter集合中，然後以同樣的邏輯查找Action上的特性并添加到Action的Filter集合中。

其中的關鍵點就是将IAuthorizeData（也就是通過我們熟悉的[Authorize]特性）轉化為MVC中的AuthorizeFilter過濾器：

public static AuthorizeFilter GetFilter(IAuthorizationPolicyProvider policyProvider, IEnumerable<IAuthorizeData> authData)
{
    if (policyProvider.GetType() == typeof(DefaultAuthorizationPolicyProvider))
    {
        var policy = AuthorizationPolicy.CombineAsync(policyProvider, authData).GetAwaiter().GetResult();
        return new AuthorizeFilter(policy);
    }
    else
    {
        return new AuthorizeFilter(policyProvider, authData);
    }
}

CombineAsync在上一章的《AuthorizationPolicy》中已經介紹過了，我們往下看看AuthorizeFilter的實作。

AuthorizeFilter

在MVC中有一個AuthorizeFilter過濾器，類似我們在ASP.NET 4.x中所熟悉的[Authorize]，它實作了IAsyncAuthorizationFilter接口，定義如下：

public class AuthorizeFilter : IAsyncAuthorizationFilter, IFilterFactory
{
    public AuthorizeFilter(AuthorizationPolicy policy) {}
    public AuthorizeFilter(IAuthorizationPolicyProvider policyProvider, IEnumerable<IAuthorizeData> authorizeData) : this(authorizeData) {}
    public AuthorizeFilter(IEnumerable<IAuthorizeData> authorizeData) {}

    public IEnumerable<IAuthorizeData> AuthorizeData { get; }
    public AuthorizationPolicy Policy { get; }

    public virtual async Task OnAuthorizationAsync(AuthorizationFilterContext context)
    {
        var effectivePolicy = Policy;
        if (effectivePolicy == null)
        {
            effectivePolicy = await AuthorizationPolicy.CombineAsync(PolicyProvider, AuthorizeData);
        }
        var policyEvaluator = context.HttpContext.RequestServices.GetRequiredService<IPolicyEvaluator>();
        var authenticateResult = await policyEvaluator.AuthenticateAsync(effectivePolicy, context.HttpContext);
        if (context.Filters.Any(item => item is IAllowAnonymousFilter))
        {
            return;
        }
        var authorizeResult = await policyEvaluator.AuthorizeAsync(effectivePolicy, authenticateResult, context.HttpContext, context);

        ... // 如果授權失敗，傳回ChallengeResult或ForbidResult
    }
}

AuthorizeFilter的OnAuthorizationAsync方法會在Action執行之前觸發，其調用IPolicyEvaluator來完成授權，将執行流程切回到 ASP.NET Core 授權系統中。關于MVC中IApplicationModelProvider以及Filter的概念，在以後MVC系列的文章中再來詳細介紹，下面就繼續介紹 ASP.NET Core 的授權系統，也就是《Security》項目。

IPolicyEvaluator

IPolicyEvaluator是MVC調用授權系統的入口點，其定義如下：

public interface IPolicyEvaluator
{
    Task<AuthenticateResult> AuthenticateAsync(AuthorizationPolicy policy, HttpContext context);
    Task<PolicyAuthorizationResult> AuthorizeAsync(AuthorizationPolicy policy, AuthenticateResult authenticationResult, HttpContext context, object resource);
}

在上面介紹的AddMVC中，調用了AddAuthorizationPolicyEvaluator擴充方法，它有如下定義：

public static class PolicyServiceCollectionExtensions
{
    public static IServiceCollection AddAuthorizationPolicyEvaluator(this IServiceCollection services)
    {
        services.TryAdd(ServiceDescriptor.Transient<IPolicyEvaluator, PolicyEvaluator>());
        return services;
    }
}

由此可知IPolicyEvaluator的預設實作為PolicyEvaluator，我們就從它入手，來一步一步解剖 ASP.NET Core 授權系統的執行步驟。

在AuthorizeFilter中，依次調到了AuthenticateAsync和AuthorizeAsync方法，我們就一一來看。

AuthenticateAsync(AuthenticationSchemes)

為什麼還有一個AuthenticateAsync方法呢，這不是在認證階段執行的嗎？我們看下它的實作：

public class PolicyEvaluator : IPolicyEvaluator
{
    public virtual async Task<AuthenticateResult> AuthenticateAsync(AuthorizationPolicy policy, HttpContext context)
    {
        if (policy.AuthenticationSchemes != null && policy.AuthenticationSchemes.Count > 0)
        {
            ClaimsPrincipal newPrincipal = null;
            foreach (var scheme in policy.AuthenticationSchemes)
            {
                var result = await context.AuthenticateAsync(scheme);
                if (result != null && result.Succeeded)
                {
                    newPrincipal = SecurityHelper.MergeUserPrincipal(newPrincipal, result.Principal);
                }
            }

            if (newPrincipal != null)
            {
                context.User = newPrincipal;
                return AuthenticateResult.Success(new AuthenticationTicket(newPrincipal, string.Join(";", policy.AuthenticationSchemes)));
            }
            else
            {
                context.User = new ClaimsPrincipal(new ClaimsIdentity());
                return AuthenticateResult.NoResult();
            }
        }

        return (context.User?.Identity?.IsAuthenticated ?? false) 
            ? AuthenticateResult.Success(new AuthenticationTicket(context.User, "context.User"))
            : AuthenticateResult.NoResult();
    }
}

在《上一章》中，我們知道在AuthorizationPolicy中有AuthenticationSchemes和IAuthorizationRequirement兩個屬性，并詳細介紹介紹了Requirement，但是沒有提到AuthenticationSchemes的調用。

那麼，看到這裡，也就大概明白了，它與Requirements的執行是完全獨立的，并在它之前執行，用于重置Claims，那麼為什麼要重置呢？

在認證的章節介紹過，在認證階段，隻會執行預設的認證Scheme，context.User就是使用context.AuthenticateAsync(DefaultAuthenticateScheme)來指派的，當我們希望使用非預設的Scheme，或者是想合并多個認證Scheme的Claims時，就需要使用基于Scheme的授權來重置Claims了。

它的實作也很簡單，直接使用我們在授權政策中指定的Schemes來依次調用認證服務的AuthenticateAsync方法，并将生成的Claims合并，最後傳回我們熟悉的AuthenticateResult認證結果。

AuthorizeAsync(Requirements)

接下來再看一下PolicyEvaluator的AuthorizeAsync方法：

public class PolicyEvaluator : IPolicyEvaluator
{
    private readonly IAuthorizationService _authorization;
    public PolicyEvaluator(IAuthorizationService authorization)
    {
        _authorization = authorization;
    }

    public virtual async Task<PolicyAuthorizationResult> AuthorizeAsync(AuthorizationPolicy policy, AuthenticateResult authenticationResult, HttpContext context, object resource)
    {
        var result = await _authorization.AuthorizeAsync(context.User, resource, policy);
        if (result.Succeeded) return PolicyAuthorizationResult.Success();
        return (authenticationResult.Succeeded) ? PolicyAuthorizationResult.Forbid() : PolicyAuthorizationResult.Challenge();
    }
}

該方法會根據Requirements來完成授權，具體的實作是通過調用IAuthorizationService來實作的。

最終傳回的是一個PolicyAuthorizationResult對象，并在授權失敗時，根據認證結果來傳回Forbid(未授權)或Challenge(未登入)。

public class PolicyAuthorizationResult
{
    private PolicyAuthorizationResult() { }
    public bool Challenged { get; private set; }
    public bool Forbidden { get; private set; }
    public bool Succeeded { get; private set; }
}

IAuthorizationService

然後就到了授權的核心對象AuthorizationService，也可以稱為授權的外交官，我們也可以直接在應用代碼中調用該對象來實作授權，它有如下定義：

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

在AuthorizeAsync中還涉及到一個resource對象，用來實作面向資源的授權，放在《下一章》中再來介紹，而在本章與《前一章》的示例中，該值均為null。

ASP.NET Core 中還為IAuthorizationService提供了幾個擴充方法：

public static class AuthorizationServiceExtensions
{
    public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService service, ClaimsPrincipal user, string policyName) {}
    public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService service, ClaimsPrincipal user, AuthorizationPolicy policy) {}
    public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService service, ClaimsPrincipal user, object resource, IAuthorizationRequirement requirement) {}
    public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService service, ClaimsPrincipal user, object resource, AuthorizationPolicy policy) {}
}

其預設實作為DefaultAuthorizationService:

public class DefaultAuthorizationService : IAuthorizationService
{
    private readonly AuthorizationOptions _options;
    private readonly IAuthorizationHandlerContextFactory _contextFactory;
    private readonly IAuthorizationHandlerProvider _handlers;
    private readonly IAuthorizationEvaluator _evaluator;
    private readonly IAuthorizationPolicyProvider _policyProvider;

    public async Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, string policyName)
    {        
        var policy = await _policyProvider.GetPolicyAsync(policyName);
        return await this.AuthorizeAsync(user, resource, policy);
    }

    public async Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, IEnumerable<IAuthorizationRequirement> requirements)
    {
        var authContext = _contextFactory.CreateContext(requirements, user, resource);
        var handlers = await _handlers.GetHandlersAsync(authContext);
        foreach (var handler in handlers)
        {
            await handler.HandleAsync(authContext);
            if (!_options.InvokeHandlersAfterFailure && authContext.HasFailed)
            {
                break;
            }
        }
        return _evaluator.Evaluate(authContext);
    }
}

通過上面代碼可以看出，在《上一章》中介紹的授權政策，在這裡擷取到它的Requirements，後續便不再需要了。而在AuthorizationService中是通過調用四大核心對象來完成授權，我們一一來看。

IAuthorizationPolicyProvider

由于在[Authorize]中，我們指定的是政策的名稱，是以需要使用IAuthorizationPolicyProvider來根據名稱擷取到政策對象，預設實作為DefaultAuthorizationPolicyProvider：

public class DefaultAuthorizationPolicyProvider : IAuthorizationPolicyProvider
{
    private readonly AuthorizationOptions _options;

    public Task<AuthorizationPolicy> GetDefaultPolicyAsync()
    {
        return Task.FromResult(_options.DefaultPolicy);
    }

    public virtual Task<AuthorizationPolicy> GetPolicyAsync(string policyName)
    {
        return Task.FromResult(_options.GetPolicy(policyName));
    }
}

在上一章中介紹過，我們定義的政策都儲存在《AuthorizationOptions》的字典中，是以在這裡隻是簡單的将AuthorizationOptions中的同名方法異步化。

IAuthorizationHandlerContextFactory

授權上下文是我們接觸較多的對象，當我們自定義授權Handler時就會用到它，它是使用簡單工廠模式來建立的：

public class DefaultAuthorizationHandlerContextFactory : IAuthorizationHandlerContextFactory
{
    public virtual AuthorizationHandlerContext CreateContext(IEnumerable<IAuthorizationRequirement> requirements, ClaimsPrincipal user, object resource)
    {
        return new AuthorizationHandlerContext(requirements, user, resource);
    }
}

授權上下文中主要包含使用者的Claims和授權政策的Requirements：

public class AuthorizationHandlerContext
{
    private HashSet<IAuthorizationRequirement> _pendingRequirements;
    private bool _failCalled;
    private bool _succeedCalled;

    public AuthorizationHandlerContext(IEnumerable<IAuthorizationRequirement> requirements, ClaimsPrincipal user, object resource)
    {
        Requirements = requirements; User = user; Resource = resource;
        _pendingRequirements = new HashSet<IAuthorizationRequirement>(requirements);
    }

    public virtual bool HasFailed { get { return _failCalled; } }
    public virtual bool HasSucceeded => !_failCalled && _succeedCalled && !_pendingRequirements.Any();
    public virtual void Fail()
    {
        _failCalled = true;
    }
    public virtual void Succeed(IAuthorizationRequirement requirement)
    {
        _succeedCalled = true;
        _pendingRequirements.Remove(requirement);
    }
}

如上，_pendingRequirements中儲存着所有待驗證的Requirements，驗證成功的Requirement則從中移除。

IAuthorizationHandlerProvider

兜兜轉轉，終于進入到了授權的最終驗證邏輯中了，首先，使用IAuthorizationHandlerProvider來擷取到所有的授權Handler。

IAuthorizationHandlerProvider的預設實作為DefaultAuthorizationHandlerProvider:

public class DefaultAuthorizationHandlerProvider : IAuthorizationHandlerProvider
{
    private readonly IEnumerable<IAuthorizationHandler> _handlers;

    public DefaultAuthorizationHandlerProvider(IEnumerable<IAuthorizationHandler> handlers)
    {
        _handlers = handlers;
    }

    public Task<IEnumerable<IAuthorizationHandler>> GetHandlersAsync(AuthorizationHandlerContext context)
        => Task.FromResult(_handlers);
}

在《上一章》中，我們還介紹到，我們定義的Requirement，可以直接實作IAuthorizationHandler接口，也可以單獨定義Handler，但是需要注冊到DI系統中去。

在預設的AuthorizationHandlerProvider中，會從DI系統中擷取到我們注冊的所有Handler，最終調用其HandleAsync方法。

我們在實作IAuthorizationHandler接口時，通常是繼承自AuthorizationHandler<TRequirement>來實作，它有如下定義：

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

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

如上，首先會在HandleAsync過濾出與Requirement對比對的Handler，然後再調用其HandleRequirementAsync方法。

那我們定義的直接實作IAuthorizationHandler了接口的Requirement又是如何執行的呢？

在AddAuthorization擴充方法中可以看到，預設還為IAuthorizationHandler注冊了一個PassThroughAuthorizationHandler，定義如下：

public class PassThroughAuthorizationHandler : IAuthorizationHandler
{
    public async Task HandleAsync(AuthorizationHandlerContext context)
    {
        foreach (var handler in context.Requirements.OfType<IAuthorizationHandler>())
        {
            await handler.HandleAsync(context);
        }
    }
}

它負責調用該政策中所有實作了IAuthorizationHandler接口的Requirement。

IAuthorizationEvaluator

最後，通過調用IAuthorizationEvaluator接口，來完成最終的授權結果，預設實作為DefaultAuthorizationEvaluator:

public class DefaultAuthorizationEvaluator : IAuthorizationEvaluator
{
    public AuthorizationResult Evaluate(AuthorizationHandlerContext context)
        => context.HasSucceeded
            ? AuthorizationResult.Success()
            : AuthorizationResult.Failed(context.HasFailed
                ? AuthorizationFailure.ExplicitFail()
                : AuthorizationFailure.Failed(context.PendingRequirements));
}

當我們在一個政策中指定多個Requirement時，隻有全部驗證通過時，授權上下文中的HasSucceeded才會為True，而HasFailed代表授權結果的顯式失敗。

這裡根據授權上下文的驗證結果來生成授權結果：

public class AuthorizationResult
{
    public bool Succeeded { get; private set; }
    public AuthorizationFailure Failure { get; private set; }
    public static AuthorizationResult Success() => new AuthorizationResult { Succeeded = true };
    public static AuthorizationResult Failed(AuthorizationFailure failure) => new AuthorizationResult { Failure = failure };
    public static AuthorizationResult Failed() => new AuthorizationResult { Failure = AuthorizationFailure.ExplicitFail() };
}

public class AuthorizationFailure
{
    private AuthorizationFailure() { }
    public bool FailCalled { get; private set; }
    public IEnumerable<IAuthorizationRequirement> FailedRequirements { get; private set; }
    public static AuthorizationFailure ExplicitFail()
    {
        return new AuthorizationFailure { FailCalled = true, FailedRequirements = new IAuthorizationRequirement[0] };
    }
    public static AuthorizationFailure Failed(IEnumerable<IAuthorizationRequirement> failed)
        => new AuthorizationFailure { FailedRequirements = failed };

}

整個授權流程的結構大緻如下：

總結

通過對 ASP.NET Core 授權系統執行流程的探索，可以看出授權是主要是通過調用IAuthorizationService來完成的，而授權政策的本質是提供 Requirement ，我們完全可以使用它們兩個來完成各種靈活的授權方式，而不用局限于政策。在 ASP.NET Core 中，還提供了基于資源的授權，放在《下一章》中來介紹，并會簡單示範一下在一個通用權限管理系統中如何來授權。

ASP.NET Core 認證與授權系列（6）——授權政策是怎麼執行的？

MVC中的授權

AuthorizationApplicationModelProvider

AuthorizeFilter

IPolicyEvaluator

AuthenticateAsync(AuthenticationSchemes)

AuthorizeAsync(Requirements)

IAuthorizationService

IAuthorizationPolicyProvider

IAuthorizationHandlerContextFactory

IAuthorizationHandlerProvider

IAuthorizationEvaluator

總結

繼續閱讀

面向對象與領域模組化

對自己發展的一些思考

Debug時檢測到Loaderlock的解決辦法

淺談MFC圖示

ASP.NET Core MVC(一)

建立ASP.NET CORE MVC項目

.NET程式員的技能分析參考V1.0(有附件)

asp.net AspNetpager的用法

在angularjs中通過ts編寫時，如何添加中英文轉換

msdn 訪談錄之C＃程式設計二

使用Windbg調試.Net應用程式

部署.net平台的應用程式

Robot Framework配置發送郵件功能

II6 IIS7 下 asp.net的生命周期 ASP.NET Application Life Cycle Overview for IIS 5.0 and 6.0

2010年終總結--技術篇

如何成為一名.net 工程師?