ASP.NET CoreでカスタムAuthorizeAttributeを作成するにはどうすればよいですか？

ASP.NET Coreでカスタム認証属性を作成しようとしています。以前のバージョンでは、オーバーライドすることが可能bool AuthorizeCore(HttpContextBase httpContext)でした。しかし、これはには存在しませんAuthorizeAttribute。

カスタムAuthorizeAttributeを作成するための現在のアプローチは何ですか？

達成しようとしていること：ヘッダー認証でセッションIDを受け取っています。そのIDから、特定のアクションが有効かどうかがわかります。

ASP.Net Coreチームが推奨するアプローチは、ここで完全に文書化されている新しいポリシー設計を使用することです。新しいアプローチの背後にある基本的な考え方は、新しい[Authorize]属性を使用して「ポリシー」を指定することです（たとえば[Authorize( Policy = "YouNeedToBe18ToDoThis")]、ポリシーをアプリケーションのStartup.csに登録して、コードブロックを実行します（つまり、ユーザーに年齢の主張があることを確認します）。 18歳以上の場合）。

ポリシー設計はフレームワークへのすばらしい追加であり、ASP.Net Security Coreチームはその導入を称賛する必要があります。とはいえ、すべての場合に適しているわけではありません。このアプローチの欠点は、特定のコントローラーまたはアクションが特定のクレームタイプを必要とすることを単純に主張するという最も一般的なニーズに対する便利なソリューションを提供できないことです。アプリケーションに、個々のRESTリソースに対するCRUD操作を制御する数百の個別の権限（「CanCreateOrder」、「CanReadOrder」、「CanUpdateOrder」、「CanDeleteOrder」など）がある場合、新しいアプローチでは、1対1の繰り返しが必要です。ポリシー名とクレーム名の間のマッピング（例：options.AddPolicy("CanUpdateOrder", policy => policy.RequireClaim(MyClaimTypes.Permission, "CanUpdateOrder));）、または実行時にこれらの登録を実行するコードを記述します（たとえば、データベースからすべてのクレームタイプを読み取り、前述の呼び出しをループで実行します）。ほとんどの場合のこのアプローチの問題は、不必要なオーバーヘッドであることです。

ASP.Net Core Securityチームは独自のソリューションを作成しないことをお勧めしますが、場合によってはこれが最も賢明なオプションになることがあります。

以下は、IAuthorizationFilterを使用して、特定のコントローラーまたはアクションのクレーム要件を表現する簡単な方法を提供する実装です。

public class ClaimRequirementAttribute : TypeFilterAttribute
{
    public ClaimRequirementAttribute(string claimType, string claimValue) : base(typeof(ClaimRequirementFilter))
    {
        Arguments = new object[] {new Claim(claimType, claimValue) };
    }
}

public class ClaimRequirementFilter : IAuthorizationFilter
{
    readonly Claim _claim;

    public ClaimRequirementFilter(Claim claim)
    {
        _claim = claim;
    }

    public void OnAuthorization(AuthorizationFilterContext context)
    {
        var hasClaim = context.HttpContext.User.Claims.Any(c => c.Type == _claim.Type && c.Value == _claim.Value);
        if (!hasClaim)
        {
            context.Result = new ForbidResult();
        }
    }
}


[Route("api/resource")]
public class MyController : Controller
{
    [ClaimRequirement(MyClaimTypes.Permission, "CanReadResource")]
    [HttpGet]
    public IActionResult GetResource()
    {
        return Ok();
    }
}

私はasp.netのセキュリティ担当者です。まず、これはまだミュージックストアのサンプルまたは単体テストの外に文書化されておらず、公開されているAPIに関してすべて改良されていることをお詫び申し上げます。詳細なドキュメントはこちらです。

カスタムの承認属性を記述したくない。あなたがそれをする必要があるならば、我々は何か間違ったことをしました。代わりに、承認要件を記述する必要があります。

承認はアイデンティティに作用します。IDは認証によって作成されます。

ヘッダーのセッションIDを確認したいというコメントで、セッションIDはIDの基礎になります。このAuthorize属性を使用したい場合は、認証ミドルウェアを記述してそのヘッダーを取得し、それを認証済みに変換しClaimsPrincipalます。次に、承認要件の中で確認します。承認の要件は、好きなだけ複雑にすることができます。たとえば、現在のIDに対する生年月日を取得し、ユーザーが18歳以上の場合に承認するものは次のとおりです。

public class Over18Requirement : AuthorizationHandler<Over18Requirement>, IAuthorizationRequirement
{
        public override void Handle(AuthorizationHandlerContext context, Over18Requirement requirement)
        {
            if (!context.User.HasClaim(c => c.Type == ClaimTypes.DateOfBirth))
            {
                context.Fail();
                return;
            }

            var dateOfBirth = Convert.ToDateTime(context.User.FindFirst(c => c.Type == ClaimTypes.DateOfBirth).Value);
            int age = DateTime.Today.Year - dateOfBirth.Year;
            if (dateOfBirth > DateTime.Today.AddYears(-age))
            {
                age--;
            }

            if (age >= 18)
            {
                context.Succeed(requirement);
            }
            else
            {
                context.Fail();
            }
        }
    }
}

次に、ConfigureServices()関数でそれを配線します

services.AddAuthorization(options =>
{
    options.AddPolicy("Over18", 
        policy => policy.Requirements.Add(new Authorization.Over18Requirement()));
});

最後に、それをコントローラーまたはアクションメソッドに適用します。

[Authorize(Policy = "Over18")]

ASP.NET Core 2では、を継承できAuthorizeAttributeます。実装する必要もありますIAuthorizationFilter（またはIAsyncAuthorizationFilter）：

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
public class CustomAuthorizeAttribute : AuthorizeAttribute, IAuthorizationFilter
{
    private readonly string _someFilterParameter;

    public CustomAuthorizeAttribute(string someFilterParameter)
    {
        _someFilterParameter = someFilterParameter;
    }

    public void OnAuthorization(AuthorizationFilterContext context)
    {
        var user = context.HttpContext.User;

        if (!user.Identity.IsAuthenticated)
        {
            // it isn't needed to set unauthorized result 
            // as the base class already requires the user to be authenticated
            // this also makes redirect to a login page work properly
            // context.Result = new UnauthorizedResult();
            return;
        }

        // you can also use registered services
        var someService = context.HttpContext.RequestServices.GetService<ISomeService>();

        var isAuthorized = someService.IsUserAuthorized(user.Identity.Name, _someFilterParameter);
        if (!isAuthorized)
        {
            context.Result = new StatusCodeResult((int)System.Net.HttpStatusCode.Forbidden);
            return;
        }
    }
}

Derek Greer GREATの回答に基づいて、列挙型でそれを行いました。

これが私のコードの例です：

public enum PermissionItem
{
    User,
    Product,
    Contact,
    Review,
    Client
}

public enum PermissionAction
{
    Read,
    Create,
}


public class AuthorizeAttribute : TypeFilterAttribute
{
    public AuthorizeAttribute(PermissionItem item, PermissionAction action)
    : base(typeof(AuthorizeActionFilter))
    {
        Arguments = new object[] { item, action };
    }
}

public class AuthorizeActionFilter : IAuthorizationFilter
{
    private readonly PermissionItem _item;
    private readonly PermissionAction _action;
    public AuthorizeActionFilter(PermissionItem item, PermissionAction action)
    {
        _item = item;
        _action = action;
    }
    public void OnAuthorization(AuthorizationFilterContext context)
    {
        bool isAuthorized = MumboJumboFunction(context.HttpContext.User, _item, _action); // :)

        if (!isAuthorized)
        {
            context.Result = new ForbidResult();
        }
    }
}

public class UserController : BaseController
{
    private readonly DbContext _context;

    public UserController( DbContext context) :
        base()
    {
        _logger = logger;
    }

    [Authorize(PermissionItem.User, PermissionAction.Read)]
    public async Task<IActionResult> Index()
    {
        return View(await _context.User.ToListAsync());
    }
}

コントローラーとアクションのカスタム属性を検索する独自のAuthorizationHandlerを作成し、それらをHandleRequirementAsyncメソッドに渡すことができます。

public abstract class AttributeAuthorizationHandler<TRequirement, TAttribute> : AuthorizationHandler<TRequirement> where TRequirement : IAuthorizationRequirement where TAttribute : Attribute
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, TRequirement requirement)
    {
        var attributes = new List<TAttribute>();

        var action = (context.Resource as AuthorizationFilterContext)?.ActionDescriptor as ControllerActionDescriptor;
        if (action != null)
        {
            attributes.AddRange(GetAttributes(action.ControllerTypeInfo.UnderlyingSystemType));
            attributes.AddRange(GetAttributes(action.MethodInfo));
        }

        return HandleRequirementAsync(context, requirement, attributes);
    }

    protected abstract Task HandleRequirementAsync(AuthorizationHandlerContext context, TRequirement requirement, IEnumerable<TAttribute> attributes);

    private static IEnumerable<TAttribute> GetAttributes(MemberInfo memberInfo)
    {
        return memberInfo.GetCustomAttributes(typeof(TAttribute), false).Cast<TAttribute>();
    }
}

次に、コントローラーまたはアクションで必要なカスタム属性に使用できます。たとえば、権限の要件を追加します。カスタム属性を作成するだけです。

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
public class PermissionAttribute : AuthorizeAttribute
{
    public string Name { get; }

    public PermissionAttribute(string name) : base("Permission")
    {
        Name = name;
    }
}

次に、ポリシーに追加する要件を作成します

public class PermissionAuthorizationRequirement : IAuthorizationRequirement
{
    //Add any custom requirement properties if you have them
}

次に、カスタム属性のAuthorizationHandlerを作成し、前に作成したAttributeAuthorizationHandlerを継承します。ControllerおよびActionから累積されたHandleRequirementsAsyncメソッドのすべてのカスタム属性のIEnumerableが渡されます。

public class PermissionAuthorizationHandler : AttributeAuthorizationHandler<PermissionAuthorizationRequirement, PermissionAttribute>
{
    protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, PermissionAuthorizationRequirement requirement, IEnumerable<PermissionAttribute> attributes)
    {
        foreach (var permissionAttribute in attributes)
        {
            if (!await AuthorizeAsync(context.User, permissionAttribute.Name))
            {
                return;
            }
        }

        context.Succeed(requirement);
    }

    private Task<bool> AuthorizeAsync(ClaimsPrincipal user, string permission)
    {
        //Implement your custom user permission logic here
    }
}

最後に、Startup.cs ConfigureServicesメソッドで、カスタムAuthorizationHandlerをサービスに追加し、ポリシーを追加します。

        services.AddSingleton<IAuthorizationHandler, PermissionAuthorizationHandler>();

        services.AddAuthorization(options =>
        {
            options.AddPolicy("Permission", policyBuilder =>
            {
                policyBuilder.Requirements.Add(new PermissionAuthorizationRequirement());
            });
        });

これで、コントローラーとアクションをカスタム属性で簡単に装飾できます。

[Permission("AccessCustomers")]
public class CustomersController
{
    [Permission("AddCustomer")]
    IActionResult AddCustomer([FromBody] Customer customer)
    {
        //Add customer
    }
}

カスタムAuthorizeAttributeを作成するための現在のアプローチは何ですか

簡単：自分で作成しないでくださいAuthorizeAttribute。

純粋な承認シナリオ（特定のユーザーのみにアクセスを制限するなど）の場合、推奨されるアプローチは、新しい承認ブロックを使用することです。 -L92

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.Configure<AuthorizationOptions>(options =>
        {
            options.AddPolicy("ManageStore", policy => policy.RequireClaim("Action", "ManageStore"));
        });
    }
}

public class StoreController : Controller
{
    [Authorize(Policy = "ManageStore"), HttpGet]
    public async Task<IActionResult> Manage() { ... }
}

認証の場合、ミドルウェアレベルで処理するのが最適です。

正確に何を達成しようとしていますか？

許可フェーズで無記名トークンを検証したい場合は、現在のセキュリティプラクティスを使用して、

これをStartup / ConfigureServicesに追加します

    services.AddSingleton<IAuthorizationHandler, BearerAuthorizationHandler>();
    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer();

    services.AddAuthorization(options => options.AddPolicy("Bearer",
        policy => policy.AddRequirements(new BearerRequirement())
        )
    );

そして、これはあなたのコードベースで、

public class BearerRequirement : IAuthorizationRequirement
{
    public async Task<bool> IsTokenValid(SomeValidationContext context, string token)
    {
        // here you can check if the token received is valid 
        return true;
    }
}

public class BearerAuthorizationHandler : AuthorizationHandler<BearerRequirement> 
{

    public BearerAuthorizationHandler(SomeValidationContext thatYouCanInject)
    {
       ...
    }

    protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, BearerRequirement requirement)
    {
        var authFilterCtx = (Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext)context.Resource;
        string authHeader = authFilterCtx.HttpContext.Request.Headers["Authorization"];
        if (authHeader != null && authHeader.Contains("Bearer"))
        {
            var token = authHeader.Replace("Bearer ", string.Empty);
            if (await requirement.IsTokenValid(thatYouCanInject, token))
            {
                context.Succeed(requirement);
            }
        }
    }
}

コードが届かない場合は、context.Succeed(...)とにかく失敗します（401）。

そして、あなたのコントローラーであなたは使うことができます

 [Authorize(Policy = "Bearer", AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]

現在の方法はAuthenticationHandlersです

startup.csに追加

services.AddAuthentication("BasicAuthentication").AddScheme<AuthenticationSchemeOptions, BasicAuthenticationHandler>("BasicAuthentication", null);

public class BasicAuthenticationHandler : AuthenticationHandler<AuthenticationSchemeOptions>
    {
        private readonly IUserService _userService;

        public BasicAuthenticationHandler(
            IOptionsMonitor<AuthenticationSchemeOptions> options,
            ILoggerFactory logger,
            UrlEncoder encoder,
            ISystemClock clock,
            IUserService userService)
            : base(options, logger, encoder, clock)
        {
            _userService = userService;
        }

        protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
        {
            if (!Request.Headers.ContainsKey("Authorization"))
                return AuthenticateResult.Fail("Missing Authorization Header");

            User user = null;
            try
            {
                var authHeader = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]);
                var credentialBytes = Convert.FromBase64String(authHeader.Parameter);
                var credentials = Encoding.UTF8.GetString(credentialBytes).Split(new[] { ':' }, 2);
                var username = credentials[0];
                var password = credentials[1];
                user = await _userService.Authenticate(username, password);
            }
            catch
            {
                return AuthenticateResult.Fail("Invalid Authorization Header");
            }

            if (user == null)
                return AuthenticateResult.Fail("Invalid User-name or Password");

            var claims = new[] {
                new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
                new Claim(ClaimTypes.Name, user.Username),
            };
            var identity = new ClaimsIdentity(claims, Scheme.Name);
            var principal = new ClaimsPrincipal(identity);
            var ticket = new AuthenticationTicket(principal, Scheme.Name);

            return AuthenticateResult.Success(ticket);
        }
    }

IUserServiceは、ユーザー名とパスワードがある場所で作成するサービスです。基本的に、クレームのマッピングに使用するユーザークラスを返します。

var claims = new[] {
                new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
                new Claim(ClaimTypes.Name, user.Username),
            }; 

次に、これらのクレームとマップしたデータをクエリできます。それらはかなりの数ですが、ClaimTypesクラスを見てください。

これを拡張メソッドで使用して、任意のマッピングを取得できます

public int? GetUserId()
{
   if (context.User.Identity.IsAuthenticated)
    {
       var id=context.User.FindFirst(ClaimTypes.NameIdentifier);
       if (!(id is null) && int.TryParse(id.Value, out var userId))
            return userId;
     }
      return new Nullable<int>();
 }

この新しい方法は、私はより良いと思います

public class BasicAuthenticationAttribute : AuthorizationFilterAttribute
{
    public override void OnAuthorization(HttpActionContext actionContext)
    {
        if (actionContext.Request.Headers.Authorization != null)
        {
            var authToken = actionContext.Request.Headers.Authorization.Parameter;
            // decoding authToken we get decode value in 'Username:Password' format
            var decodeauthToken = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(authToken));
            // spliting decodeauthToken using ':'
            var arrUserNameandPassword = decodeauthToken.Split(':');
            // at 0th postion of array we get username and at 1st we get password
            if (IsAuthorizedUser(arrUserNameandPassword[0], arrUserNameandPassword[1]))
            {
                // setting current principle
                Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity(arrUserNameandPassword[0]), null);
            }
            else
            {
                actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.Unauthorized);
            }
        }
        else
        {
            actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.Unauthorized);
        }
    }

    public static bool IsAuthorizedUser(string Username, string Password)
    {
        // In this method we can handle our database logic here...
        return Username.Equals("test") && Password == "test";
    }
}

これを書いている時点では、asp.netコア2以降のIClaimsTransformationインターフェイスでこれを実現できると思います。ここに投稿するのに十分共有可能な概念実証を実装しました。

public class PrivilegesToClaimsTransformer : IClaimsTransformation
{
    private readonly IPrivilegeProvider privilegeProvider;
    public const string DidItClaim = "http://foo.bar/privileges/resolved";

    public PrivilegesToClaimsTransformer(IPrivilegeProvider privilegeProvider)
    {
        this.privilegeProvider = privilegeProvider;
    }

    public async Task<ClaimsPrincipal> TransformAsync(ClaimsPrincipal principal)
    {
        if (principal.Identity is ClaimsIdentity claimer)
        {
            if (claimer.HasClaim(DidItClaim, bool.TrueString))
            {
                return principal;
            }

            var privileges = await this.privilegeProvider.GetPrivileges( ... );
            claimer.AddClaim(new Claim(DidItClaim, bool.TrueString));

            foreach (var privilegeAsRole in privileges)
            {
                claimer.AddClaim(new Claim(ClaimTypes.Role /*"http://schemas.microsoft.com/ws/2008/06/identity/claims/role" */, privilegeAsRole));
            }
        }

        return principal;
    }
}

これをコントローラーで使用[Authorize(Roles="whatever")]するには、メソッドに適切なものを追加するだけです。

[HttpGet]
[Route("poc")]
[Authorize(Roles = "plugh,blast")]
public JsonResult PocAuthorization()
{
    var result = Json(new
    {
        when = DateTime.UtcNow,
    });

    result.StatusCode = (int)HttpStatusCode.OK;

    return result;
}

今回のケースでは、すべてのリクエストにJWTであるAuthorizationヘッダーが含まれています。これはプロトタイプで、来週のプロダクションシステムではこれに非常に近いことを行うと思います。

将来の有権者は、投票するときに執筆日を考慮してください。今日の時点で、このworks on my machine.™おそらく実装でより多くのエラー処理とロギングが必要になるでしょう。

アプリでの認証用。認可属性で渡されたパラメータに基づいてサービスを呼び出す必要がありました。

たとえば、ログインした医師が患者の予定を表示できるかどうかを確認する場合は、 "View_Appointment"をカスタム認証属性に渡し、DBサービスでその権利を確認し、結果に基づいて確認します。このシナリオのコードは次のとおりです。

    public class PatientAuthorizeAttribute : TypeFilterAttribute
    {
    public PatientAuthorizeAttribute(params PatientAccessRights[] right) : base(typeof(AuthFilter)) //PatientAccessRights is an enum
    {
        Arguments = new object[] { right };
    }

    private class AuthFilter : IActionFilter
    {
        PatientAccessRights[] right;

        IAuthService authService;

        public AuthFilter(IAuthService authService, PatientAccessRights[] right)
        {
            this.right = right;
            this.authService = authService;
        }

        public void OnActionExecuted(ActionExecutedContext context)
        {
        }

        public void OnActionExecuting(ActionExecutingContext context)
        {
            var allparameters = context.ActionArguments.Values;
            if (allparameters.Count() == 1)
            {
                var param = allparameters.First();
                if (typeof(IPatientRequest).IsAssignableFrom(param.GetType()))
                {
                    IPatientRequest patientRequestInfo = (IPatientRequest)param;
                    PatientAccessRequest userAccessRequest = new PatientAccessRequest();
                    userAccessRequest.Rights = right;
                    userAccessRequest.MemberID = patientRequestInfo.PatientID;
                    var result = authService.CheckUserPatientAccess(userAccessRequest).Result; //this calls DB service to check from DB
                    if (result.Status == ReturnType.Failure)
                    {
                        //TODO: return apirepsonse
                        context.Result = new StatusCodeResult((int)System.Net.HttpStatusCode.Forbidden);
                    }
                }
                else
                {
                    throw new AppSystemException("PatientAuthorizeAttribute not supported");
                }
            }
            else
            {
                throw new AppSystemException("PatientAuthorizeAttribute not supported");
            }
        }
    }
}

APIアクションでは、次のように使用します。

    [PatientAuthorize(PatientAccessRights.PATIENT_VIEW_APPOINTMENTS)] //this is enum, we can pass multiple
    [HttpPost]
    public SomeReturnType ViewAppointments()
    {

    }

承認された回答（https://stackoverflow.com/a/41348219/4974715）は、「CanReadResource」がクレームとして使用されているため、現実的に保守可能または適切ではありません（ただし、実際にはIMOのポリシーである必要があります）。回答でのアプローチは、それが使用された方法でOKではありません。アクションメソッドが多くの異なるクレームセットアップを必要とする場合、その回答では、次のようなものを繰り返し記述する必要があるためです...

[ClaimRequirement(MyClaimTypes.Permission, "CanReadResource")] 
[ClaimRequirement(MyClaimTypes.AnotherPermision, "AnotherClaimVaue")]
//and etc. on a single action.

では、どれだけのコーディングが必要になるか想像してみてください。理想的には、「CanReadResource」は、ユーザーがリソースを読み取ることができるかどうかを判断するために多くのクレームを使用するポリシーであると想定されています。

私がしていることは、列挙型としてポリシーを作成し、ループしてこのように要件を設定することです...

services.AddAuthorization(authorizationOptions =>
        {
            foreach (var policyString in Enum.GetNames(typeof(Enumerations.Security.Policy)))
            {
                authorizationOptions.AddPolicy(
                    policyString,
                    authorizationPolicyBuilder => authorizationPolicyBuilder.Requirements.Add(new DefaultAuthorizationRequirement((Enumerations.Security.Policy)Enum.Parse(typeof(Enumerations.Security.Policy), policyWrtString), DateTime.UtcNow)));

      /* Note that thisn does not stop you from 
          configuring policies directly against a username, claims, roles, etc. You can do the usual.
     */
            }
        }); 

DefaultAuthorizationRequirementクラスは次のようになります...

public class DefaultAuthorizationRequirement : IAuthorizationRequirement
{
    public Enumerations.Security.Policy Policy {get; set;} //This is a mere enumeration whose code is not shown.
    public DateTime DateTimeOfSetup {get; set;} //Just in case you have to know when the app started up. And you may want to log out a user if their profile was modified after this date-time, etc.
}

public class DefaultAuthorizationHandler : AuthorizationHandler<DefaultAuthorizationRequirement>
{
    private IAServiceToUse _aServiceToUse;

    public DefaultAuthorizationHandler(
        IAServiceToUse aServiceToUse
        )
    {
        _aServiceToUse = aServiceToUse;
    }

    protected async override Task HandleRequirementAsync(AuthorizationHandlerContext context, DefaultAuthorizationRequirement requirement)
    {
        /*Here, you can quickly check a data source or Web API or etc. 
           to know the latest date-time of the user's profile modification...
        */
        if (_aServiceToUse.GetDateTimeOfLatestUserProfileModication > requirement.DateTimeOfSetup)
        {
            context.Fail(); /*Because any modifications to user information, 
            e.g. if the user used another browser or if by Admin modification, 
            the claims of the user in this session cannot be guaranteed to be reliable.
            */
            return;
        }

        bool shouldSucceed = false; //This should first be false, because context.Succeed(...) has to only be called if the requirement specifically succeeds.

        bool shouldFail = false; /*This should first be false, because context.Fail() 
        doesn't have to be called if there's no security breach.
        */

        // You can do anything.
        await doAnythingAsync();

       /*You can get the user's claims... 
          ALSO, note that if you have a way to priorly map users or users with certain claims 
          to particular policies, add those policies as claims of the user for the sake of ease. 
          BUT policies that require dynamic code (e.g. checking for age range) would have to be 
          coded in the switch-case below to determine stuff.
       */

        var claims = context.User.Claims;

        // You can, of course, get the policy that was hit...
        var policy = requirement.Policy

        //You can use a switch case to determine what policy to deal with here...
        switch (policy)
        {
            case Enumerations.Security.Policy.CanReadResource:
                 /*Do stuff with the claims and change the 
                     value of shouldSucceed and/or shouldFail.
                */
                 break;
            case Enumerations.Security.Policy.AnotherPolicy:
                 /*Do stuff with the claims and change the 
                    value of shouldSucceed and/or shouldFail.
                 */
                 break;
                // Other policies too.

            default:
                 throw new NotImplementedException();
        }

        /* Note that the following conditions are 
            so because failure and success in a requirement handler 
            are not mutually exclusive. They demand certainty.
        */

        if (shouldFail)
        {
            context.Fail(); /*Check the docs on this method to 
            see its implications.
            */
        }                

        if (shouldSucceed)
        {
            context.Succeed(requirement); 
        } 
     }
}

上記のコードは、データストアのポリシーへのユーザーの事前マッピングを有効にすることもできます。したがって、ユーザーのクレームを作成するときは、基本的に、ユーザーに直接または間接的に事前にマップされたポリシーを取得します（たとえば、ユーザーに特定のクレーム値があり、そのクレーム値が特定されてポリシーにマップされているため）そのクレーム値を持つユーザーにも自動マッピングを提供し、ポリシーをクレームとして登録することで、承認ハンドラで、ユーザーのクレームに要件が含まれているかどうかを簡単に確認できます。請求。これは、ポリシー要件を満たすための静的な方法です。たとえば、「名」要件は本質的に非常に静的です。そう、

[Authorize(Policy = nameof(Enumerations.Security.Policy.ViewRecord))] 

動的要件は、年齢範囲などのチェックに関するものである可能性があり、そのような要件を使用するポリシーをユーザーに事前にマッピングすることはできません。

動的ポリシーのクレームチェックの例（たとえば、ユーザーが18歳を超えているかどうかをチェックするため）は、@ blowdart（https://stackoverflow.com/a/31465227/4974715）の回答にすでに達しています。

PS：私はこれを私の電話でタイプしました。タイプミスやフォーマットの欠如はご容赦ください。