Asp.Net Core Authorizeあなたが知らないこと(ソース解読)
23922 ワード
一、前言
IdentityServer4はすでにいくつかの応用実戦の文章を分かち合って、アーキテクチャから授権センターの着地応用まで、IdentityServer4に対していくつかの使用規則を掌握したことに伴って、しかし多くの原理的なものはまだ一知半解で、だから私のここの持続性はみんなを連れてその関連するソースコードを解読して、まず、ControllerまたはActionにAuthorizeまたはグローバルにAuthorizeFilterフィルタを追加すれば、このリソースが保護されるのはなぜですか.access_tokenを通じて関連するライセンスを通過する必要がありますか.今日はAuthorizeAttributeとAuthorizeFilterの関係とコード解読についてご紹介します.二、コード解読
解読する前に、次の2つの注釈認証方法のコードを見てみましょう.
すんぽうほうしき
[Authorize]
[HttpGet]
public async Taskコードに
[Authorize]の寸法でapiリソースへのアクセスを制限グローバルモード
public void ConfigureServices(IServiceCollection services)
{
// AuthorizeFilter
services.AddControllers(options=>options.Filters.Add(new AuthorizeFilter()));
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
});
}
グローバルapiリソースの制限は、
AuthorizeFilterフィルタを追加することによって行われます.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つのデータ属性を定義しています.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; }
}
(UseAuthorization)のコアコードを見てみましょう.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 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)
{
// 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ターミナルルーティングの動作原理解読の文章では、
EndPointターミナルからControllerとActionのうちAttributeの特性表示を取得することについて説明するが、ここでもこの方法によって取得する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;
}
}
// endpoint AllowAnonymous
var endpoint = context.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));
}
//
}
コードには
Addメソッドが提供され、IFilterMetadataタイプのオブジェクトが制約されています.これも、上記のフィルタでIFilterMetadataが継承されている理由です.ここまでコードの解読と実现の原理はすでに分析し终わって、もし分析の不十分なところがあるならばまたよろしくお愿いします!!!結論:授権ミドルウェアは
IAuthorizeDataを取得することによってAuthorizeAttributeのオブジェクトに関する授権情報を取得し、 のオブジェクトを構築して授権認証を行うが、AuthorizeFilterフィルタはAuthorizeAttributeの授権関連データIAuthorizeDataをデフォルトで追加し、OnAuthorizationAsyncの方法を実現するとともに、ミドルウェアにおいて授権ポリシープロバイダIAuthorizationPolicyProviderによって授権ポリシーに対する授権認証を取得する.