Asp.Net Core Authorize

19718 ワード

[Authorize][HttpGet]public async Task Get(){var userId=User.UserId();return new{name=User.Name()、userId=userId、displayName=User.DisplayName()、merchantId=User.MerchatId();}コード内の[Authorize]寸法によるapiリソースへのアクセスを制限
グローバル方式public void ConfigureServices(IServiceCollection services){//AuthorizeFilterフィルタ方式services.AddControllers(options=>options.Filters.)をグローバルに追加する.
 services.AddAuthorization();
 services.AddAuthentication("Bearer")
     .AddIdentityServerAuthentication(options =>
     {
         options.Authority = "http://localhost:5000";    //  Identityserver     
         options.RequireHttpsMetadata = false;           //   https    
         options.ApiName = OAuthConfig.UserApi.ApiName;  //api name,   config     
     });

}グローバルはAuthorizeFilterフィルタを追加することによってグローバルapiリソースの制限を行う
AuthorizeAttributeまずAuthorizeAttributeソースコードを見てみましょう.
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]public class AuthorizeAttribute : Attribute, IAuthorizeData{//////Initializes a new instance of the class.///public AuthorizeAttribute() { }
/// 
/// Initializes a new instance of the  class with the specified policy. 
/// 
/// The name of the policy to require for authorization.
public AuthorizeAttribute(string policy)
{
   Policy = policy;
}

/// 
///     
/// 
public string Policy { get; set; }

/// 
///     
/// 
public string Roles { get; set; }

/// 
///   Schemes
/// 
public string AuthenticationSchemes { get; set; }

}コードにはAuthorizeAttributeがIAuthorizeData抽象インタフェースを継承していることがわかります.このインタフェースは主に授権データの制約定義であり、3つのデータ属性を定義しています.
Prolicy:ライセンスポリシーRoles:ライセンスロールAuthenticationSchemes:ライセンスSchemesのサポートAsp.Net Coreのhttpミドルウェアは、IAuthorizeDataに基づいてどのようなライセンスフィルタがあるかを取得し、フィルタのブロックを実現し、関連コードを実行します.AuthorizeAttributeコードを見てみましょう.public interface IAuthorizeData{///////Gets or sets the policy name that determines access to the resource.//string Policy{get;set;}
    /// 
    /// Gets or sets a comma delimited list of roles that are allowed to access the resource.
    /// 
    string Roles { get; set; }

    /// 
    /// Gets or sets a comma delimited list of schemes from which user information is constructed.
    /// 
    string AuthenticationSchemes { get; set; }

}ライセンスミドルウェアのコアコードを見てみましょう.
public static IApplicationBuilder UseAuthorization(this IApplicationBuilder app){if (app == null){throw new ArgumentNullException(nameof(app));}
VerifyServicesRegistered(app);

return app.UseMiddleware();

}コードにはAuthorizationMiddlewareというミドルウェアが登録されています.AuthorizationMiddlewareミドルウェアのソースコードは次のとおりです.
public class AuthorizationMiddleware{//Property key is used by Endpoint routing to determine if Authorization has runprivate 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)
        {
            // EndpointRoutingMiddleware uses this flag to check if the Authorization middleware processed auth metadata on the endpoint.
            // The Authorization middleware can only make this claim if it observes an actual endpoint.
            context.Items[AuthorizationMiddlewareInvokedWithEndpointKey] = AuthorizationMiddlewareWithEndpointInvokedValue;
        }

        //          IAuthorizeData      AuthorizeAttribute    AuthorizeFilter 
        var authorizeData = endpoint?.Metadata.GetOrderedMetadata() ?? Array.Empty();
        var policy = await AuthorizationPolicy.CombineAsync(_policyProvider, authorizeData);
        if (policy == null)
        {
            await _next(context);
            return;
        }

        // Policy evaluator has transient lifetime so it fetched from request services instead of injecting in constructor
        var policyEvaluator = context.RequestServices.GetRequiredService();

        var authenticateResult = await policyEvaluator.AuthenticateAsync(policy, context);

        // Allow Anonymous skips all authorization
        if (endpoint?.Metadata.GetMetadata() != 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);
    }
}

コード内のコアは、AuthorizeFilterフィルタのコードをブロックして取得します.
var authorizeData = endpoint?.Metadata.GetOrderedMetadata() ?? Array.Empty();前にAspについてお話ししましたNet Core EndPointターミナルルーティングの動作原理解読の文章では、ControllerとActionにおけるAttribute特性表示をEndPointターミナルから取得することについて説明するが、ここでもこの方法によって、対するAuthorizeAttributeを取得することをブロックする.関連するauthorizeDataライセンスデータを取得すると、次の一連のコードは、AuthorizeAsyncライセンスの実行を判断する方法であり、ライセンス認証のプロセスを詳細に共有しません.注意深い学生はすでに上のコードに比較的特殊なコードがあることを発見したはずです.
if (endpoint?.Metadata.GetMetadata() != null){await _next(context);return;}コードにおいてendpoint終端点経路によってAllowAnonymousと表記されているか否かの特性を取得し、ある場合は次のミドルウェアを直接実行し、次のAuthorizeAsync認証方法を行わないのも、ControllerとActionにAllowAnonymousと表記されていることが認証認証をスキップできる理由である.
AuthorizeFilterのソースコードAuthorizeAttirbuteとAuthorizeFilterの関係は何ですか?それらは一つのものですか?AuthorizeFilterソースコードを見てみましょう.コードは次のとおりです.
public class AuthorizeFilter : IAsyncAuthorizationFilter, IFilterFactory{//////Initializes a new instance.///public AuthorizeFilter(): this(authorizeData: new[] { new AuthorizeAttribute() }){}
    /// 
    /// Initialize a new  instance.
    /// 
    /// Authorization policy to be used.
    public AuthorizeFilter(AuthorizationPolicy policy)
    {
        if (policy == null)
        {
            throw new ArgumentNullException(nameof(policy));
        }

        Policy = policy;
    }

    /// 
    /// Initialize a new  instance.
    /// 
    /// The  to use to resolve policy names.
    /// The  to combine into an .
    public AuthorizeFilter(IAuthorizationPolicyProvider policyProvider, IEnumerable authorizeData)
        : this(authorizeData)
    {
        if (policyProvider == null)
        {
            throw new ArgumentNullException(nameof(policyProvider));
        }

        PolicyProvider = policyProvider;
    }

    /// 
    /// Initializes a new instance of .
    /// 
    /// The  to combine into an .
    public AuthorizeFilter(IEnumerable authorizeData)
    {
        if (authorizeData == null)
        {
            throw new ArgumentNullException(nameof(authorizeData));
        }

        AuthorizeData = authorizeData;
    }

    /// 
    /// Initializes a new instance of .
    /// 
    /// The name of the policy to require for authorization.
    public AuthorizeFilter(string policy)
        : this(new[] { new AuthorizeAttribute(policy) })
    {
    }

    /// 
    /// The  to use to resolve policy names.
    /// 
    public IAuthorizationPolicyProvider PolicyProvider { get; }

    /// 
    /// The  to combine into an .
    /// 
    public IEnumerable AuthorizeData { get; }

    /// 
    /// Gets the authorization policy to be used.
    /// 
    /// 
    /// Ifnull, the policy will be constructed using
    /// .
    /// 
    public AuthorizationPolicy Policy { get; }

    bool IFilterFactory.IsReusable => true;

    // Computes the actual policy for this filter using either Policy or PolicyProvider + AuthorizeData
    private Task ComputePolicyAsync()
    {
        if (Policy != null)
        {
            return Task.FromResult(Policy);
        }

        if (PolicyProvider == null)
        {
            throw new InvalidOperationException(
                Resources.FormatAuthorizeFilter_AuthorizationPolicyCannotBeCreated(
                    nameof(AuthorizationPolicy),
                    nameof(IAuthorizationPolicyProvider)));
        }

        return AuthorizationPolicy.CombineAsync(PolicyProvider, AuthorizeData);
    }

    internal async Task GetEffectivePolicyAsync(AuthorizationFilterContext context)
    {
        // Combine all authorize filters into single effective policy that's only run on the closest filter
        var builder = new AuthorizationPolicyBuilder(await ComputePolicyAsync());
        for (var i = 0; i < context.Filters.Count; i++)
        {
            if (ReferenceEquals(this, context.Filters[i]))
            {
                continue;
            }

            if (context.Filters[i] is AuthorizeFilter authorizeFilter)
            {
                // Combine using the explicit policy, or the dynamic policy provider
                builder.Combine(await authorizeFilter.ComputePolicyAsync());
            }
        }

        var endpoint = context.HttpContext.GetEndpoint();
        if (endpoint != null)
        {
            // When doing endpoint routing, MVC does not create filters for any authorization specific metadata i.e [Authorize] does not
            // get translated into AuthorizeFilter. Consequently, there are some rough edges when an application uses a mix of AuthorizeFilter
            // explicilty configured by the user (e.g. global auth filter), and uses endpoint metadata.
            // To keep the behavior of AuthFilter identical to pre-endpoint routing, we will gather auth data from endpoint metadata
            // and produce a policy using this. This would mean we would have effectively run some auth twice, but it maintains compat.
            var policyProvider = PolicyProvider ?? context.HttpContext.RequestServices.GetRequiredService();
            var endpointAuthorizeData = endpoint.Metadata.GetOrderedMetadata() ?? Array.Empty();

            var endpointPolicy = await AuthorizationPolicy.CombineAsync(policyProvider, endpointAuthorizeData);
            if (endpointPolicy != null)
            {
                builder.Combine(endpointPolicy);
            }
        }

        return builder.Build();
    }

    /// 
    public virtual async Task OnAuthorizationAsync(AuthorizationFilterContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        if (!context.IsEffectivePolicy(this))
        {
            return;
        }

        // IMPORTANT: Changes to authorization logic should be mirrored in security's AuthorizationMiddleware
        var effectivePolicy = await GetEffectivePolicyAsync(context);
        if (effectivePolicy == null)
        {
            return;
        }

        var policyEvaluator = context.HttpContext.RequestServices.GetRequiredService();

        var authenticateResult = await policyEvaluator.AuthenticateAsync(effectivePolicy, context.HttpContext);

        // Allow Anonymous skips all authorization
        if (HasAllowAnonymous(context))
        {
            return;
        }

        var authorizeResult = await policyEvaluator.AuthorizeAsync(effectivePolicy, authenticateResult, context.HttpContext, context);

        if (authorizeResult.Challenged)
        {
            context.Result = new ChallengeResult(effectivePolicy.AuthenticationSchemes.ToArray());
        }
        else if (authorizeResult.Forbidden)
        {
            context.Result = new ForbidResult(effectivePolicy.AuthenticationSchemes.ToArray());
        }
    }

    IFilterMetadata IFilterFactory.CreateInstance(IServiceProvider serviceProvider)
    {
        if (Policy != null || PolicyProvider != null)
        {
            // The filter is fully constructed. Use the current instance to authorize.
            return this;
        }

        Debug.Assert(AuthorizeData != null);
        var policyProvider = serviceProvider.GetRequiredService();
        return AuthorizationApplicationModelProvider.GetFilter(policyProvider, AuthorizeData);
    }

    private static bool HasAllowAnonymous(AuthorizationFilterContext context)
    {
        var filters = context.Filters;
        for (var i = 0; i < filters.Count; i++)
        {
            if (filters[i] is IAllowAnonymousFilter)
            {
                return true;
            }
        }

        // When doing endpoint routing, MVC does not add AllowAnonymousFilters for AllowAnonymousAttributes that
        // were discovered on controllers and actions. To maintain compat with 2.x,
        // we'll check for the presence of IAllowAnonymous in endpoint metadata.
        var endpoint = context.HttpContext.GetEndpoint();
        if (endpoint?.Metadata?.GetMetadata() != null)
        {
            return true;
        }

        return false;
    }
}

コードにはIAsyncAuthorizationFilter,IFIlterFactoryの2つの抽象インタフェースが継承されています.それぞれ、この2つの抽象インタフェースのソースコードを見てみましょう.
IAsyncAuthorizationFilterソースコードは、////////////////////////////////////////////A filter that asynchronously confirms request authorization.////////public interface IAsyncAuthorizationFilter:IFIlterMetadata{///授権方法Task OnAuthorizationAsync(AuthorizationFilterContext context);IAsyncAuthorizationFilterコードにはIFIlterMetadataインタフェースが継承されているとともにOnAuthorizationAsync抽象メソッドが定義されており、サブクラスではこのメソッドを実装する必要があるが、AuthorizeFilterでもこのメソッドが実装されているので、後で詳細に説明し、IFIlterFactory抽象インタフェースを引き続き参照してください.コードは以下の通りです.
public interface IFilterFactory : IFilterMetadata{
bool IsReusable { get; }

//  IFilterMetadata     
IFilterMetadata CreateInstance(IServiceProvider serviceProvider);

}AuthorizeFilterソースコードに戻ります.このソースコードには、AuthorizeData、Policyプロパティを含む4つの構造初期化メソッドが用意されています.デフォルトの構造メソッドコードを見てみましょう.
public class AuthorizeFilter : IAsyncAuthorizationFilter, IFilterFactory{public IEnumerable AuthorizeData { get; }
    //            AuthorizeAttribute   
    public AuthorizeFilter()
        : this(authorizeData: new[] { new AuthorizeAttribute() })
    {
    }

    //  AuthorizeData
    public AuthorizeFilter(IEnumerable authorizeData)
    {
        if (authorizeData == null)
        {
            throw new ArgumentNullException(nameof(authorizeData));
        }

        AuthorizeData = authorizeData;
    }

}上のコードのデフォルトのコンストラクション関数は、AuthorizeAttributeオブジェクトが構築され、IEnumerableの集合プロパティに値が割り当てられます.ここで、AuthorizeFilterフィルタも、AuthorizeAttributeをデフォルトで構築するオブジェクトであり、ライセンスに必要なIAuthorizeData情報を構築する.同時に、AuthorizeFilterによって実装されるOnAuthorizationAsyncメソッドでは、GetEffectivePolicyAsyncというメソッドによって有効なライセンスポリシーが得られ、以下のライセンスAuthenticateAsyncの実行AuthorizeFilterコードにHasAllowAnonymousメソッドが提供されることによって、ControllerまたはActionにAllowAnonymousプロパティが表示されているかどうかが実現され、ライセンスHasAllowAnonymousコードをスキップするために使用される.
private static bool HasAllowAnonymous(AuthorizationFilterContext context){var filters = context.Filters;for (var i = 0; i < filters.Count; i++){if (filters[i] is IAllowAnonymousFilter){return true;}}//AllowAnonymous特性var endpoint=contextが表記するか否かは、同様にコンテキストのendpointによって取得する.HttpContext.GetEndpoint();if (endpoint?.Metadata?.GetMetadata() != null){return true;}
 return false;

}ここでは、フィルタをグローバルに追加する方法コードに戻ります.
services.AddControllers(options=>options.Filters.Add(new AuthorizeFilter()));ここまで分析すると、どうやってグローバルに追加されたのか知りたいです.ソースコードを開いてみましたが、ソースコードは以下の通りです.
public class MvcOptions : IEnumerable{
    public MvcOptions()
    {
        CacheProfiles = new Dictionary(StringComparer.OrdinalIgnoreCase);
        Conventions = new List();
        Filters = new FilterCollection();
        FormatterMappings = new FormatterMappings();
        InputFormatters = new FormatterCollection();
        OutputFormatters = new FormatterCollection();
        ModelBinderProviders = new List();
        ModelBindingMessageProvider = new DefaultModelBindingMessageProvider();
        ModelMetadataDetailsProviders = new List();
        ModelValidatorProviders = new List();
        ValueProviderFactories = new List();
    }

    //     
    public FilterCollection Filters { get; }

}
FilterCollection関連コアコードは次のとおりです.
public class FilterCollection : Collection{
    public IFilterMetadata Add() where TFilterType : IFilterMetadata
    {
        return Add(typeof(TFilterType));
    }

    //          
                1 http://www.kinghill.cn/LongHuaDaDao1Hao/index.html