基於.NetCore3.1系列 —— 認證授權方案之授權揭秘 (下篇)

来源:https://www.cnblogs.com/i3yuan/archive/2020/07/09/13275774.html
-Advertisement-
Play Games

一、前言 回顧：基於.NetCore3.1系列 —— 認證授權方案之授權揭秘 (上篇) 在上一篇中，主要講解了授權在配置方面的源碼，從添加授權配置開始，我們引入了需要的授權配置選項，而不同的授權要求構建不同的策略方式，從而實現一種自己滿意的授權需求配置要求。 在這一節中，繼續上一篇的內容往下深入瞭解 ...


一、前言

回顧：基於.NetCore3.1系列 —— 認證授權方案之授權揭秘 (上篇)

在上一篇中，主要講解了授權在配置方面的源碼，從添加授權配置開始，我們引入了需要的授權配置選項，而不同的授權要求構建不同的策略方式，從而實現一種自己滿意的授權需求配置要求。

在這一節中，繼續上一篇的內容往下深入瞭解授權內部機制的奧秘以及是如何實現執行授權流程的。

二、說明

在上一篇中，我們通過定義授權策略，查看源碼發現，在對授權配置AuthorizationOptions之後，授權系統通過DI的方式註冊了幾個核心的預設實現。

之前我們進行對步驟一的授權有了大概瞭解，所以下麵我們將對步驟二進行的註冊對象進行說明。

三、開始

3.1 IAuthorizationService

授權服務介面，用來確定授權是否成功的主要服務，介面的定義為

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

兩個介面的參數不同之處在於IAuthorizationRequirement和policyName,分別是指定資源的一組特定要求和指定的授權名稱。

同時asp.net core還為IAuthorizationService 介面拓展了幾個方法：

    public static class AuthorizationServiceExtensions
    {
        public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService service, ClaimsPrincipal user, object resource, IAuthorizationRequirement requirement)
        {
            if (service == null)
            {
                throw new ArgumentNullException(nameof(service));
            }

            if (requirement == null)
            {
                throw new ArgumentNullException(nameof(requirement));
            }

            return service.AuthorizeAsync(user, resource, new IAuthorizationRequirement[] { requirement });
        }
        public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService service, ClaimsPrincipal user, object resource, AuthorizationPolicy policy)
        {
            if (service == null)
            {
                throw new ArgumentNullException(nameof(service));
            }

            if (policy == null)
            {
                throw new ArgumentNullException(nameof(policy));
            }

            return service.AuthorizeAsync(user, resource, policy.Requirements);
        }
        public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService service, ClaimsPrincipal user, AuthorizationPolicy policy)
        {
            if (service == null)
            {
                throw new ArgumentNullException(nameof(service));
            }

            if (policy == null)
            {
                throw new ArgumentNullException(nameof(policy));
            }

            return service.AuthorizeAsync(user, resource: null, policy: policy);
        }
        public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService service, ClaimsPrincipal user, string policyName)
        {
            if (service == null)
            {
                throw new ArgumentNullException(nameof(service));
            }

            if (policyName == null)
            {
                throw new ArgumentNullException(nameof(policyName));
            }

            return service.AuthorizeAsync(user, resource: null, policyName: policyName);
        }
    }

介面的預設實現為DefaultAuthorizationService

DefaultAuthorizationService的實現主要是用來對 IAuthorizationRequirement對象的授權檢驗。

public class DefaultAuthorizationService : IAuthorizationService
{
    private readonly AuthorizationOptions _options;
    private readonly IAuthorizationHandlerContextFactory _contextFactory;
    private readonly IAuthorizationHandlerProvider _handlers;
    private readonly IAuthorizationEvaluator _evaluator;
    private readonly IAuthorizationPolicyProvider _policyProvider;
    private readonly ILogger _logger;
    
    public DefaultAuthorizationService(IAuthorizationPolicyProvider policyProvider, IAuthorizationHandlerProvider handlers, ILogger<DefaultAuthorizationService> logger, IAuthorizationHandlerContextFactory contextFactory, IAuthorizationEvaluator evaluator, IOptions<AuthorizationOptions> options)
    {
        if (options == null)
        {
            throw new ArgumentNullException(nameof(options));
        }
        if (policyProvider == null)
        {
            throw new ArgumentNullException(nameof(policyProvider));
        }
        if (handlers == null)
        {
            throw new ArgumentNullException(nameof(handlers));
        }
        if (logger == null)
        {
            throw new ArgumentNullException(nameof(logger));
        }
        if (contextFactory == null)
        {
            throw new ArgumentNullException(nameof(contextFactory));
        }
        if (evaluator == null)
        {
            throw new ArgumentNullException(nameof(evaluator));
        }

        _options = options.Value;
        _handlers = handlers;
        _policyProvider = policyProvider;
        _logger = logger;
        _evaluator = evaluator;
        _contextFactory = contextFactory;
    }

    public async Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, IEnumerable<IAuthorizationRequirement> requirements)
    {
        if (requirements == null)
        {
            throw new ArgumentNullException(nameof(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;
            }
        }

        var result = _evaluator.Evaluate(authContext);
        if (result.Succeeded)
        {
            _logger.UserAuthorizationSucceeded();
        }
        else
        {
            _logger.UserAuthorizationFailed();
        }
        return result;
    }

    public async Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, string policyName)
    {
        if (policyName == null)
        {
            throw new ArgumentNullException(nameof(policyName));
        }

        var policy = await _policyProvider.GetPolicyAsync(policyName);
        if (policy == null)
        {
            throw new InvalidOperationException($"No policy found: {policyName}.");
        }
        return await this.AuthorizeAsync(user, resource, policy);
    }
}

通過上面的代碼可以發現，在對象實例中，通過構造函數的方式分別註入了IAuthorizationPolicyProvider、IAuthorizationHandlerProvider、IAuthorizationEvaluator、IAuthorizationHandlerContextFactory這幾個核心服務，以及配置選項的AuthorizationOptions對象，再通過實現的方法AuthorizeAsync可以看出，在方法中調用GetPolicyAsync來獲取Requirements，具體的可以看一下上一節的AuthorizationPolicy，而後在根據授權上下文來判斷。

這裡就用到了註入的幾個核心對象來實現完成授權的。下麵會分別介紹到的。

3.2 IAuthorizationPolicyProvider

由上面的IAuthorizationServer介面的預設實現可以發現，在進行授權檢驗的時候，DefaultAuthorizationService會利用註入的IAuthorizationPolicyProvider服務來提供註冊的授權策略，所以我們查看源碼發現，介面提供 了預設的授權策略GetDefaultPolicyAsync和指定名稱的授權策略·GetPolicyAsync(string policyName)的方法。

public interface IAuthorizationPolicyProvider
{
    Task<AuthorizationPolicy> GetPolicyAsync(string policyName);
    Task<AuthorizationPolicy> GetDefaultPolicyAsync();
    Task<AuthorizationPolicy> GetFallbackPolicyAsync();
}

再加上在使用[Authorize]進行策略授權的時候，會根據提供的介面方法來獲取指定的授權策略。

IAuthorizationPolicyProvider來根據名稱獲取到策略對象，預設實現為DefaultAuthorizationPolicyProvider：

DefaultAuthorizationPolicyProvider

    public class DefaultAuthorizationPolicyProvider : IAuthorizationPolicyProvider
    {
        private readonly AuthorizationOptions _options;
        private Task<AuthorizationPolicy> _cachedDefaultPolicy;
        private Task<AuthorizationPolicy> _cachedFallbackPolicy;

        public DefaultAuthorizationPolicyProvider(IOptions<AuthorizationOptions> options)
        {
            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }

            _options = options.Value;
        }

        public Task<AuthorizationPolicy> GetDefaultPolicyAsync()
        {
            return GetCachedPolicy(ref _cachedDefaultPolicy, _options.DefaultPolicy);
        }

        public Task<AuthorizationPolicy> GetFallbackPolicyAsync()
        {
            return GetCachedPolicy(ref _cachedFallbackPolicy, _options.FallbackPolicy);
        }

        private Task<AuthorizationPolicy> GetCachedPolicy(ref Task<AuthorizationPolicy> cachedPolicy, AuthorizationPolicy currentPolicy)
        {
            var local = cachedPolicy;
            if (local == null || local.Result != currentPolicy)
            {
                cachedPolicy = local = Task.FromResult(currentPolicy);
            }
            return local;
        }

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

由上面的代碼可以看出，在實現DefaultAuthorizationPolicyProvider對象進行構造函數的方式註入了IOptions<AuthorizationOptions> options服務來提供配置選項AuthorizationOptions(不懂的可以查看上一篇的AuthorizationOptions)，再通過實現的方法可以看出是如何獲取到註冊的授權策略的了。附加一個圖片

在上一章中介紹過，我們定義的策略都保存在AuthorizationOptions的中PolicyMap字典中，由上代碼可以發現這字典的用處。

3.3 IAuthorizationHandlerContextFactory

先看看這個介面的源代碼

public interface IAuthorizationHandlerContextFactory
{
    AuthorizationHandlerContext CreateContext(IEnumerable<IAuthorizationRequirement> requirements, ClaimsPrincipal user, object resource);
}

介面定義了一個唯一的方法CreateContext,作用在於創建授權上下文AuthorizationHandlerContext對象。介面預設實現方式

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

再來看看AuthorizationHandlerContext授權上下文對象，可以看出，上下文中主要包括用戶的Claims和授權策略的要求Requirements

public class AuthorizationHandlerContext
{
        private HashSet<IAuthorizationRequirement> _pendingRequirements;
        private bool _failCalled;
        private bool _succeedCalled;
    public AuthorizationHandlerContext(
        IEnumerable<IAuthorizationRequirement> requirements,
        ClaimsPrincipal user,
        object resource)
    {
        if (requirements == null)
        {
            throw new ArgumentNullException(nameof(requirements));
        }

        Requirements = requirements;
        User = user;
        Resource = resource;
        _pendingRequirements = new HashSet<IAuthorizationRequirement>(requirements);
    }

    public virtual IEnumerable<IAuthorizationRequirement> Requirements { get; }

    public virtual ClaimsPrincipal User { get; }

    public virtual object Resource { get; }

    public virtual IEnumerable<IAuthorizationRequirement> PendingRequirements { get { return _pendingRequirements; } }

    public virtual bool HasFailed { get { return _failCalled; } }

    public virtual bool HasSucceeded
    {
        get
        {
            return !_failCalled && _succeedCalled && !PendingRequirements.Any();
        }
    }

    public virtual void Fail()
    {
        _failCalled = true;
    }
    public virtual void Succeed(IAuthorizationRequirement requirement)
    {
        _succeedCalled = true;
        _pendingRequirements.Remove(requirement);
    }
}

因此，在下麵我們剛好會提到了IAuthorizationHandlerProvider 中的方法，可以根據授權上下文獲取到請求調用的處理程式。

3.4 IAuthorizationHandlerProvider

這個是介面的方法，作用是獲取所有的授權Handler

public interface IAuthorizationHandlerProvider
{
    Task<IEnumerable<IAuthorizationHandler>> GetHandlersAsync(AuthorizationHandlerContext context);
}

根據之前提到的授權上下文作為GetHandlersAsync方法參數對象來提取IAuthorizationHandler對象。

預設介面的實現為DefaultAuthorizationHandlerProvider, 處理程式的預設實現，為授權請求提供IAuthorizationHandler

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

        public DefaultAuthorizationHandlerProvider(IEnumerable<IAuthorizationHandler> handlers)
        {
            if (handlers == null)
            {
                throw new ArgumentNullException(nameof(handlers));
            }

            _handlers = handlers;
        }

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

從預設實現的方式可以看出，利用構造函數的方式註入預設的IAuthorizationHandler的對象，但是我們再看看介面的實現方法可以發現，GetHandlersAsync返回的IAuthorizationHandler對象並不是從給定的AuthorizationHandlerContext上下文中獲取的，而是直接通過構造函數的方式註入得到的。

這個時候，你可能會問，那麼IAuthorizationHandler是在哪裡註入的呢？

對應下麵的 IAuthorizationHandler

3.5 IAuthorizationEvaluator

由DefaultAuthorizationService中的授權方法過程調用了

   var result = _evaluator.Evaluate(authContext);

IAuthorizationEvaluator介面，來確定授權結果是否成功。

    public interface IAuthorizationEvaluator
    {
        AuthorizationResult Evaluate(AuthorizationHandlerContext context);
    }

IAuthorizationEvaluator的唯一方法Evaluate,該方法會根據之前提供的授權上下文返回一個表示授權成功的AuthorizationResult對象。預設實現為DefaultAuthorizationEvaluator

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

由預設實現可以看出，AuthorizationHandlerContext對象的HasSucceeded屬性決定了授權是否成功。當驗證通過時，授權上下文中的HasSucceeded才會為True。

其中的AuthorizationResult和AuthorizationFailure分別為

public class AuthorizationResult
{
     private 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()
        => new AuthorizationFailure
    {
        FailCalled = true,
        FailedRequirements = new IAuthorizationRequirement[0]
    };

    public static AuthorizationFailure Failed(IEnumerable<IAuthorizationRequirement> failed)
        => new AuthorizationFailure { FailedRequirements = failed };
}

這裡的兩個授權結果 正是IAuthorizationService 進行實現授權AuthorizeAsync來完成校驗返回的結果。

3.6 IAuthorizationHandler

介面方式實現，判斷是否授權，實現此介面的類

public interface IAuthorizationHandler
{
    Task HandleAsync(AuthorizationHandlerContext context);
}

如果允許授權，可通過此介面的方法來決定是否允許授權。

之前我們還介紹到，我們定義的Requirement，可以直接實現IAuthorizationHandler介面，也可以單獨定義Handler，但是需要註冊到DI系統中去。

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

我們在實現IAuthorizationHandler介面時，通常是繼承自AuthorizationHandler來實現，它有如下定義：

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又是如何執行的呢？

我們可以發現，IAuthorizationHandler在AddAuthorization拓展方法中可以看到預設註冊了一個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。通過介面實現的方法可以看出，當PassThroughAuthorizationHandler對象的HandleAsync方法被執行的時候，它會從AuthroizationHanderContext的Requirements屬性中提取所有的IAuthoizationHandler對象，並逐個調用它們的HandleAsync方法來實施授權檢驗。

所以可以看到的出，PassThroughAuthorizationHandler是一個特殊並且重要的授權處理器類型，其特殊之處在於它並沒有實現針對某個具體規則的授權檢驗，但是AuthorizationHandlerContext上下文所有的IAuthorizationHandler都是通過該對象驅動執行的。

3.7 IPolicyEvaluator

介面的方式實現，為特定需求類型調用的授權處理程式的基類

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

定義了兩個方法AuthenticateAsync和AuthorizeAsync方法

IPolicyEvaluator的預設實現為PolicyEvaluator

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

        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();
        }

        public virtual async Task<PolicyAuthorizationResult> AuthorizeAsync(AuthorizationPolicy policy, AuthenticateResult authenticationResult, HttpContext context, object resource)
        {
            if (policy == null)
            {
                throw new ArgumentNullException(nameof(policy));
            }

            var result = await _authorization.AuthorizeAsync(context.User, resource, policy);
            if (result.Succeeded)
            {
                return PolicyAuthorizationResult.Success();
            }

            // If authentication was successful, return forbidden, otherwise challenge
            return (authenticationResult.Succeeded) 
                ? PolicyAuthorizationResult.Forbid() 
                : PolicyAuthorizationResult.Challenge();
        }
    }

授權中間件委托它來實現身份驗證和授權處理，它內部會調用AuthorizationService，進而執行所有授權處理器AuthorizationHandler, （在後面會提到授權中間件用到這兩個方法）

3.7.1、AuthenticateAsync

當授權策略沒有設置AuthenticationSchemes，則只判斷下當前請求是否已做身份驗證，若做了就返回成功
當授權策略設置了AuthenticationSchemes，則遍歷身份驗證方案逐個進行身份驗證處理 。

其中context.User就是使用context.AuthenticateAsync(DefaultAuthenticateScheme)來賦值的，將所有得到的用戶標識重組成一個複合的用戶標識。

當我們希望使用非預設的Scheme，或者是想合併多個認證Scheme的Claims時，就需要使用基於Scheme的授權來重置Claims了。

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

3.7.2、AuthorizeAsync

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

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

以上彙總

  1. 授權服務IAuthorizationService，介面的預設實現為DefaultAuthorizationService，進行授權驗證。
  2. 在會根據授權策略提供器IAuthorizationPolicyProvider來獲取指定名稱的授權。
  3. 通過授權處理器上下文對象工廠IAuthorizationHandlerContextFactory授權處理器AuthorizationHandler在授權時需要傳入AuthorizationHandlerContext（上面說了授權完成後的結果也存儲在裡面）。所以在執行授權處理器之前需要構建這個上下文對象，就是通過這個工廠構建的，主要的數據來源就是 當前 或者 指定的 授權策略AuthorizationPolicy。
  4. 所以這個時候會授權處理提供其 IAuthorizationHandlerProvider，來獲取系統中所有授權處理器。
  5. 授權評估器IAuthorizationEvaluator來確定授權結果是否成功，在授權處理器AuthorizationHandler在執行完授權後，結果是存儲在AuthorizationHandlerContext中的，這裡的評估器只是根據AuthorizationHandlerContext創建一個授權結果AuthorizationResult。
  6. 上面所說的授權處理器就是IAuthorizationHandler,處理器中包含主要的授權邏輯，在處理的過程中會將所有的授權處理器一一驗證。
  7. 所以在授權中間件中會利用IPolicyEvaluator中實現的身份認證和授權處理方法來調用AuthorizationService來執行所有的處理器。

四、中間件

在Configure中註冊管道：運行使用調用方法來配置Http請求管道

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {    app.UseRouting();
        //開啟認證授權
         app.UseAuthentication();
        app.UseAuthorization();

    }

在這裡使用了授權中間件來檢查授權，來看看中間件的源碼AuthorizationMiddleware

public class AuthorizationMiddleware
{
    // Property key is used by Endpoint routing to determine if Authorization has run
    private const string AuthorizationMiddlewareInvokedWithEndpointKey = "__AuthorizationMiddlewareWithEndpointInvoked";
    private static readonly object AuthorizationMiddlewareWithEndpointInvokedValue = new object();

    private readonly RequestDelegate _next;
    private readonly IAuthorizationPolicyProvider _policyProvider;

    public AuthorizationMiddleware(RequestDelegate next, IAuthorizationPolicyProvider policyProvider)
    {
        _next = next ?? throw new ArgumentNullException(nameof(next));
        _policyProvider = policyProvider ?? throw new ArgumentNullException(nameof(policyProvider));
    }

    public async Task Invoke(HttpContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }
        var endpoint = context.GetEndpoint();

        if (endpoint != null)
        {
            context.Items[AuthorizationMiddlewareInvokedWithEndpointKey] = AuthorizationMiddlewareWithEndpointInvokedValue;
        }

        var authorizeData = endpoint?.Metadata.GetOrderedMetadata<IAuthorizeData>() ?? Array.Empty<IAuthorizeData>();
        var policy = await AuthorizationPolicy.CombineAsync(_policyProvider, authorizeData);
        if (policy == null)
        {
            await _next(context);
            return;
        }
        var policyEvaluator = context.RequestServices.GetRequiredService<IPolicyEvaluator>();

        var authenticateResult = await policyEvaluator.AuthenticateAsync(policy, context);
        // Allow Anonymous skips all authorization
        if (endpoint?.Metadata.GetMetadata<IAllowAnonymous>() != null)
        {
            await _next(context);
            return;
        }
        // Note that the resource will be null if there is no matched endpoint
        var authorizeResult = await policyEvaluator.AuthorizeAsync(policy, authenticateResult, context, resource: endpoint);

        if (authorizeResult.Challenged)
        {
            if (policy.AuthenticationSchemes.Any())
            {
                foreach (var scheme in policy.AuthenticationSchemes)
                {
                    await context.ChallengeAsync(scheme);
                }
            }
            else
            {
                await context.ChallengeAsync();
            }

            return;
        }
        else if (authorizeResult.Forbidden)
        {
            if (policy.AuthenticationSchemes.Any())
            {
                foreach (var scheme in policy.AuthenticationSchemes)
                {
                    await context.ForbidAsync(scheme);
                }
            }
            else
            {
                await context.ForbidAsync();
            }

            return;
        }
        await _next(context);
    }
}

進行代碼分解：

  1. 拿到當前請求的的終結點
  var endpoint = context.GetEndpoint();
  1. 在當前請求拿到終結點endpoint的時候，會通過終結點拿到關聯的IAuthorizeData集合
var authorizeData = endpoint?.Metadata.GetOrderedMetadata<IAuthorizeData>() ?? Array.Empty<IAuthorizeData>();
  1. 將根據IAuthorizeData集合調用AuthorizationPolicy.CombineAsync()來創建組合策略（具體了可以看一下上一章） （ 用例： [Authorize(Policy = "BaseRole")] ）
var policy = await AuthorizationPolicy.CombineAsync(_policyProvider, authorizeData);
  1. IPolicyEvaluator獲取策略評估器對得到的組合策略進行身份驗證，多種身份驗證得到的用戶證件信息會合併進HttpContext.User
 var policyEvaluator = context.RequestServices.GetRequiredService<IPolicyEvaluator>();

  var authenticateResult = await policyEvaluator.AuthenticateAsync(policy, context);
  1. 當使用[AllowAnonymous]的時候，則直接跳過授權檢驗。
 if (endpoint?.Metadata.GetMetadata<IAllowAnonymous>() != null)
 {
     await _next(context);
     return;
 }
  1. 將IPolicyEvaluator提供的AuthorizeAsync授權檢查方法，進行策略授權檢查。
 var authorizeResult = await policyEvaluator.AuthorizeAsync(policy, authenticateResult, context, resource: endpoint);
  1. 當進行授權時，遍歷策略所有的身份驗證方案，進行質詢，若策略里木有身份驗證方案則使用預設身份驗證方案進行質詢。

當授權評估拒絕就直接調用身份驗證方案進行拒絕。

 if (authorizeResult.Challenged)
 {
     if (policy.AuthenticationSchemes.Any())
     {
         foreach (var scheme in policy.AuthenticationSchemes)
         {
             await context.ChallengeAsync(scheme);
         }
     }
     else
     {
         await context.ChallengeAsync();
     }
     return;
 }
else if (authorizeResult.Forbidden)
{
    if (policy.AuthenticationSchemes.Any())
    {
        foreach (var scheme in policy.AuthenticationSchemes)
        {
            await context.ForbidAsync(scheme);
        }
    }
    else
    {
        await context.ForbidAsync();
    }

    return;
}

整個過程中，授權中間件會調用授權服務IAuthorizationService來進行授權處理

五、總結

  1. 通過對上述的處理流程的分析，可以看出授權主要是通過IAuthorizationService來實現的，而我們進行使用只需要提供授權策略的Requirement，非常方便靈活的使用。
  2. 從源碼許可權設計來看，系統註冊了各種服務，實現多種預設服務，加上預設的處理方式也滿足了大部分應用需求， 所以可以看出這一塊的功能還是很強大的，就算我們想通過自定義的方式來實現，也可以通過某些介面來實現拓展。
  3. 其中有很多核心源碼怕說的不夠清楚，所以在平時的開發項目中，再去看官方文檔或源碼這樣理解應該更容易。
  4. 如果有不對的或不理解的地方，希望大家可以多多指正，提出問題，一起討論,不斷學習,共同進步。
  5. 參考的文檔 和官方源碼

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 【JAVA SE基礎篇】51裝飾流之緩衝流和轉換流
    裝飾流也稱為處理流 1.緩衝流： 1、提升性能 2、任何處理流底層都是節點流 3、釋放外層流，內層流自動釋放，手動釋放則是從裡到外層層釋放 1.位元組緩衝流 1.BufferedInputStream 2.BufferedOutputStream 2.字元緩衝流 1.BufferedReader 2. ...
  • 數組在記憶體中的分配
    對於 Java 數組的初始化，有以下兩種方式： 靜態初始化：初始化時由程式員顯式指定每個數組元素的初始值，由系統決定數組長度，如： //只是指定初始值，並沒有指定數組的長度，但是系統為自動決定該數組的長度為4 String[] computers = {"Dell", "Lenovo", "Appl ...
  • wait 和 sleep 的區別
    sleep 的源碼： pub1ic class Thread imp1 ements Runnable { //native 表示調用操作系統底層實現的方法 pub1ic static native void sleep(1ong millis) throws InterruptedExceptio ...
  • Flutter 1.17 新 Material motion 規範的預構建動畫
    老孟導讀：在 Flutter 1.17 發佈大會上，Flutter 團隊還發佈了新的 Animations 軟體包，該軟體包提供了實現新的 Material motion 規範的預構建動畫。 軟體包 pub 地址：https://pub.dev/packages/animations Materia ...
  • Cloneable 介面實現原理
    Cloneable介面是Java開發中常用的一個介面， 它的作用是使一個類的實例能夠將自身拷貝到另一個新的實例中，註意，這裡所說的“拷貝”拷的是對象實例，而不是類的定義，進一步說，拷貝的是一個類的實例中各欄位的值。 在開發過程中，拷貝實例是常見的一種操作，如果一個類中的欄位較多，而我們又採用在客戶端 ...
  • Arrays.sort 和 Collections.sort 實現原理和區別
    Collection和Collections區別 java.util.Collection 是一個集合介面。它提供了對集合對象進行基本操作的通用介面方法。 java.util.Collections 是針對集合類的一個幫助類，他提供一系列靜態方法實現對各種集合的搜索、排序、線程安全等操作。 然後還有 ...
  • 同樣是在招聘信息凌亂的網站上找工作，同學的騷操作把我給整蒙了
    前言 本文的文字及圖片來源於網路,僅供學習、交流使用,不具有任何商業用途,版權歸原作者所有,如有問題請及時聯繫我們以作處理。 作者：Python進階者 現在在疫情階段，想找一份不錯的工作變得更為困難，很多人會選擇去網上看招聘信息。可是招聘信息有一些是錯綜複雜的。而且不能把全部的信息全部羅列出來，以外 ...
  • Redis集群搭建的三種方式
    一、單節點實例 單節點實例還是比較簡單的，平時做個測試，寫個小程式如果需要用到緩存的話，啟動一個 Redis 還是很輕鬆的，做為一個 key/value 資料庫也是可以勝任的 二、主從模式（master/slaver） redis 主從模式配置 主從模式： redis 的主從模式，使用非同步複製，sl ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類