基于.NetCore3.1系列 —— 认证授权方案之授权揭秘 (下篇)

最新推荐文章于 2024-07-26 23:06:11 发布
最新推荐文章于 2024-07-26 23:06:11 发布
阅读量962 收藏
点赞数 1
原文链接：https://www.cnblogs.com/i3yuan/p/13275774.html
版权

一、前言

回顾：基于.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. 参考的文档 和官方源码

往期精彩回顾

dotNET跨平台
关注
聊聊asp.net core 授权流程
虚幻私塾
09-23 816
统一合并到一个策略对象中去，对于未指定具体策略的[Authorize]特性，则采用默认的授权策略(要求用户必须登录认证)，同时也把这些特性中指定的认证方案进行统一合并到一个策略对象中去，然后对当前用户对合并后的策略中所包含的认证方案一一进行身份认证，并将身份认证结果进行一一合并，然后就是对合并后的授权策略中的Requirement一一进行检查，如果全部授权通过，并且没有显式调用授权失败的方法，则授权成功。要看授权流程的具体执行逻辑，我们还是要看AuthorizationMiddleware类。
.NET Core 企业微信网页授权登录.doc
07-11
.NET Core 企业微信网页授权登录.doc
authorization_一张大图了解ASP.NET Core 3.1 中的Authentication与Authorization
weixin_39580749的博客
12-01 495
下面是一张ASP.NET Core 3.1 中关于Authentication与Authorization的主流程框线图，点击这里查看全图：https://johnnyqian.net/images/202004/aspnet-core-3.1-request-processing-pipeline.png重要组件一些重要的组件及其源码链接如下：AuthenticationCompone...
.net core 自定义授权策略提供程序进行权限验证
qw_6918966011的博客
07-11 869
/默认授权测率必须添加一个IAuthorizationRequirement的实现IPermissionsCheck 是我注入的权限检测程序，其实对于权限认证，重要的是控制对资源的访问，整篇文章下来无非就是将特性上的值提供到我们所需要进行权限检测的程序中去，当然我们也可以用权限过滤器反射获取Authorize特性上的值来实现.User?.Identity;?false;.User?.Claims;.Value;//判断是否通过鉴权中间件--是否登录。
ASP.NET Core 使用 JWT 自定义角色/策略授权需要实现的接口
dotNET跨平台
08-23 1591
目录① 存储角色/用户所能访问的 API② 实现 IAuthorizationRequirement 接口③ 实现 TokenValidationParameters④ ...
.NetCore统一认证授权学习——第一次授权（2）
世界既不黑也不白，而是一道精致的灰。
06-29 338
token授权实例
基于.NetCore3.1和Vue3的iMES工厂管家MES系统设计源码
04-07
本项目是一个基于.NetCore3.1和Vue3开发的iMES工厂管家MES管理系统，包含1455个文件，主要文件类型包括C#源代码、Vue组件、JavaScript脚本、图片、HTML页面、JSON配置文件、XLSX文件、MAP文件、CSPROJ项目文件。...
.NetCore统一认证授权学习——Run（1）
世界既不黑也不白，而是一道精致的灰。
06-29 455
项目地址工具：vs2019及以上 SDK：Net5及以上 API测试工具：Postman
.NET Core认证与授权
qq_18932003的博客
10-09 247
https://www.cnblogs.com/fanfan-90/category/1680969.html.NET Core认证与授权 jwt token 过期刷新_ASP.NET Core 应用JWT进行用户认证及Token的刷新https://blog.csdn.net/weixin_39785970/article/details/111262316 https://www.cnblogs.com/fanfan-90/category/1598782.html.NET Core知识点 ...
NetCore重写IAuthorizationPolicyProvider，自定义授权策略
weixin_43872830的博客
03-17 1919
比如你想所有Controller中的方法都需要登录，除了使用[AllowAnonymous]特性不需要外。就可以重写IAuthorizationPolicyProvider。针对Api的鉴权可以同通过不同的策略实现
Asp.Net Core 授权源码分析（上篇）
qq_41990222的博客
07-11 1574
我们通过定义授权策略，查看源码发现，在对授权配置之后，授权系统通过DI的方式注册了几个核心的默认实现。添加授权策略服务使用方法，以便调用。从源码可以发现，从core3.0后，由之前在core2.0中的文件中，原来的的方法变为了方法，微软在这一块进行了封装在文件中，沿用了之前拓展名称，不影响之前版本的使用。 由上可知，在调用方法进行授权配置的时候，需要使用到委托方式传参。所以我们再来看看下面这一行代码，通过实现添加策略方式。 通过上图可以把Policy(策略)加入到了AuthorizationOptions
Asp .Net Core 系列：详解授权以及实现角色、策略、自定义三种授权和自定义响应
最新发布
程序人生
07-26 687
在 ASP.NET Core 中，授权（Authorization）是控制对应用资源的访问的过程。它决定了哪些用户或用户组可以访问特定的资源或执行特定的操作。授权通常与身份验证（Authentication）一起使用，身份验证是验证用户身份的过程，授权与身份验证相互独立， 但是，授权需要一种身份验证机制。身份验证是确定用户标识的一个过程。身份验证可为当前用户创建一个或多个标识。在底层，基于角色的授权和基于声明的授权均使用要求、要求处理程序和预配置的策略。这些构建基块支持代码中的授权评估的表达式。
Asp.net core IdentityServer4与传统基于角色的权限系统的集成
寒冰屋的专栏
02-26 731
在学习或者做权限系统技术选型的过程中，经常有朋友有这样的疑问 ： “IdentityServer4的能不能做到与传统基于角色的权限系统集成呢？” “我的公司有几百个接口，IdentityServer4能不能做到关联用户，给这些用户授予不同的接口的权限呢？” 我的回答是，是的，可以！ 同时，我还想补充下，IdentityServer4是给我们的授权流程/需求提供一个新的 标准化的选择，而不是限制你的需求；它是一个基础的框架，你可以根据你的需求自定义成任意你要的样子。
windows2008r2安装.netcore3.1报500.xx错误的补丁包
01-05
在Windows Server 2008 R2操作系统上安装.NET Core 3.1时，可能会遇到500.xx系列错误，这通常表示服务器遇到了一个内部错误，导致安装过程无法正常进行。这种问题通常与系统组件、依赖关系或更新的缺失有关。在本...
ASP.NET Core：认证与授权
子昊
01-27 3554
认证 认证是安全体系的第一道屏障。当访问者的请求进入的时候，认证体系通过验证对方提供的凭证来确定它的真实身份。认证体系只有在证实了访问者的真实身份之后才允许它进入。.NET Core提供了多种认证方式。但是它们的实现都是一样的。都是基于同一个认证模型的。 ASP.NET Core的认证功能是通过内置的一个认证组件来提供的。这个组件在处理分发给它的请求时会按照指定的认证方案从请求中提取能够验证用户真实身份的数据。我们一般把这种数据称为安全令牌。在ASP.NET Core应用下的安全令牌也叫做认证票据。
教你实践ASP.NET Core Authorization（免看文档教程）
dotNET跨平台
06-17 3936
Asp.net Core 对于授权的改动很友好，非常的灵活，本文以MVC为主，当然如果说webapi或者其他的分布式解决方案授权，也容易就可以实现单点登录，可以使用现成的IdentityServer框架或者自定义实现动非常方便和干净
ASP.NET Core 认证与授权[5]:初识授权
weixin_33918357的博客
11-21 308
经过前面几章的姗姗学步，我们了解了在 ASP.NET Core 中是如何认证的，终于来到了授权阶段。在认证阶段我们通过用户令牌获取到用户的Claims，而授权便是对这些的Claims的验证，如：是否拥有Admin的角色，姓名是否叫XXX等等。本章就来介绍一下 ASP.NET Core 的授权系统的简单使用。 目录 简单授权 IAllowAnonymous IAuthorizeData 授权策...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值