Bagaimana Anda membuat CustomizeAttribute kustom di ASP.NET Core?

Saya mencoba membuat atribut otorisasi khusus di ASP.NET Core. Dalam versi sebelumnya, dimungkinkan untuk mengganti bool AuthorizeCore(HttpContextBase httpContext). Tetapi ini tidak lagi ada di AuthorizeAttribute.

Apa pendekatan saat ini untuk membuat AuthorizeAttribute kustom?

Apa yang ingin saya capai: Saya menerima ID sesi di Header Authorization. Dari ID itu saya akan tahu apakah tindakan tertentu itu valid.

Pendekatan yang direkomendasikan oleh tim ASP.Net Core adalah dengan menggunakan desain kebijakan baru yang sepenuhnya didokumentasikan di sini . Ide dasar di balik pendekatan baru ini adalah menggunakan atribut [Otorisasi] baru untuk menunjuk "kebijakan" (mis. Di [Authorize( Policy = "YouNeedToBe18ToDoThis")]mana kebijakan terdaftar di Startup.cs aplikasi untuk menjalankan beberapa blok kode (yaitu memastikan pengguna memiliki klaim usia) di mana usianya 18 tahun atau lebih).

Desain kebijakan adalah tambahan yang bagus untuk kerangka kerja dan tim Inti Keamanan ASP.Net harus dipuji karena pengenalannya. Yang mengatakan, itu tidak cocok untuk semua kasus. Kelemahan dari pendekatan ini adalah bahwa ia gagal memberikan solusi yang nyaman untuk kebutuhan yang paling umum hanya dengan menyatakan bahwa controller atau aksi yang diberikan memerlukan tipe klaim yang diberikan. Dalam kasus di mana aplikasi mungkin memiliki ratusan izin terpisah yang mengatur operasi CRUD pada sumber daya REST individual ("CanCreateOrder", "CanReadOrder", "CanUpdateOrder", "CanDeleteOrder", dll.), Pendekatan baru ini membutuhkan pengulangan satu-ke- satu pemetaan antara nama kebijakan dan nama klaim (misoptions.AddPolicy("CanUpdateOrder", policy => policy.RequireClaim(MyClaimTypes.Permission, "CanUpdateOrder));), atau menulis beberapa kode untuk melakukan pendaftaran ini pada waktu berjalan (mis. membaca semua jenis klaim dari database dan melakukan panggilan tersebut dalam satu lingkaran). Masalah dengan pendekatan ini untuk sebagian besar kasus adalah bahwa itu tidak perlu overhead.

Meskipun tim ASP.Net Core Security merekomendasikan untuk tidak pernah membuat solusi Anda sendiri, dalam beberapa kasus ini mungkin merupakan opsi yang paling bijaksana untuk memulai.

Berikut ini adalah implementasi yang menggunakan IAuthorizationFilter untuk menyediakan cara sederhana untuk mengekspresikan persyaratan klaim untuk kontroler atau tindakan yang diberikan:

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

Saya orang keamanan asp.net. Pertama, izinkan saya meminta maaf bahwa semua ini belum didokumentasikan di luar sampel toko musik atau unit test, dan semuanya masih disempurnakan dalam hal API yang terbuka. Dokumentasi terperinci ada di sini .

Kami tidak ingin Anda menulis atribut otorisasi khusus. Jika Anda perlu melakukan itu, kami telah melakukan kesalahan. Sebaliknya, Anda harus menulis persyaratan otorisasi .

Otorisasi bertindak atas Identitas. Identitas dibuat dengan otentikasi.

Anda mengatakan dalam komentar Anda ingin memeriksa ID sesi di header. ID sesi Anda akan menjadi dasar untuk identitas. Jika Anda ingin menggunakan Authorizeatribut Anda akan menulis middleware otentikasi untuk mengambil header itu dan mengubahnya menjadi dikonfirmasi ClaimsPrincipal. Anda kemudian akan memeriksa di dalam persyaratan otorisasi. Persyaratan otorisasi dapat serumit yang Anda inginkan, misalnya di sini adalah yang mengambil tanggal klaim kelahiran pada identitas saat ini dan akan mengesahkan jika pengguna berusia di atas 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();
            }
        }
    }
}

Kemudian dalam ConfigureServices()fungsi Anda, Anda akan menghubungkannya

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

Dan akhirnya, terapkan ke metode kontrol atau tindakan dengan

[Authorize(Policy = "Over18")]

Tampaknya dengan ASP.NET Core 2, Anda dapat mewarisi lagi AuthorizeAttribute, Anda hanya perlu menerapkan IAuthorizationFilter(atau 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;
        }
    }
}

Berdasarkan jawaban Derek Greer HEBAT , saya melakukannya dengan enum.

Ini contoh kode saya:

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

Anda dapat membuat AuthorizationHandler Anda sendiri yang akan menemukan atribut khusus pada Pengontrol dan Tindakan Anda, dan meneruskannya ke metode 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>();
    }
}

Kemudian Anda dapat menggunakannya untuk atribut khusus apa pun yang Anda butuhkan pada pengontrol atau tindakan Anda. Misalnya menambahkan persyaratan izin. Cukup buat atribut khusus Anda.

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

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

Kemudian buat Persyaratan untuk ditambahkan ke Kebijakan Anda

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

Lalu buat OtorisasiHandler untuk atribut khusus Anda, mewarisi AttributeAuthorizationHandler yang kami buat sebelumnya. Itu akan melewati IEnumerable untuk semua atribut khusus Anda dalam metode HandleRequirementsAsync, diakumulasikan dari Controller dan Action Anda.

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
    }
}

Dan akhirnya, dalam metode Startup.cs ConfigureServices Anda, tambahkan AuthorizationHandler kustom Anda ke layanan, dan tambahkan Kebijakan Anda.

        services.AddSingleton<IAuthorizationHandler, PermissionAuthorizationHandler>();

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

Sekarang Anda cukup menghias Pengendali dan Tindakan Anda dengan atribut khusus Anda.

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

Apa pendekatan saat ini untuk membuat AuthorizeAttribute kustom

Mudah: jangan buat sendiri AuthorizeAttribute.

Untuk skenario otorisasi murni (seperti membatasi akses hanya ke pengguna tertentu), pendekatan yang disarankan adalah menggunakan blok otorisasi baru: https://github.com/aspnet/MusicStore/blob/1c0aeb08bb1ebd846726232226279bbe001782e1/samples/MusicStore/Startupcs## -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() { ... }
}

Untuk otentikasi, sebaiknya ditangani di tingkat middleware.

Apa yang sebenarnya ingin Anda capai?

Jika ada yang hanya ingin memvalidasi token pembawa di fase otorisasi menggunakan praktik keamanan saat ini yang Anda bisa,

tambahkan ini ke Startup / ConfigureServices Anda

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

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

dan ini di basis kode Anda,

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

Jika kode tidak mencapai context.Succeed(...) itu akan gagal (401).

Dan kemudian di controller Anda dapat Anda gunakan

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

Cara modern adalah AuthenticationHandlers

di startup.cs tambahkan

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 adalah layanan yang Anda buat di mana Anda memiliki nama pengguna dan kata sandi. pada dasarnya ia mengembalikan kelas pengguna yang Anda gunakan untuk memetakan klaim Anda.

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

Kemudian Anda dapat menanyakan klaim ini dan data apa pun yang Anda petakan, ada beberapa, lihat kelas ClaimTypes

Anda dapat menggunakan ini dalam metode ekstensi dan dapatkan pemetaan

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

Cara baru ini, saya pikir lebih baik daripada

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";
    }
}

Pada tulisan ini saya percaya ini dapat dicapai dengan antarmuka IClaimsTransformation di asp.net core 2 dan di atas. Saya baru saja menerapkan bukti konsep yang cukup sharable untuk dikirim ke sini.

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

Untuk menggunakan ini di Kontroler Anda cukup tambahkan yang sesuai [Authorize(Roles="whatever")]dengan metode Anda.

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

    result.StatusCode = (int)HttpStatusCode.OK;

    return result;
}

Dalam kasus kami, setiap permintaan menyertakan tajuk Otorisasi yang merupakan JWT. Ini adalah prototipe dan saya percaya kami akan melakukan sesuatu yang sangat dekat dengan ini dalam sistem produksi kami minggu depan.

Pemilih masa depan, pertimbangkan tanggal penulisan saat Anda memberikan suara. Mulai hari ini, works on my machine.™ ini Anda mungkin ingin lebih banyak penanganan kesalahan dan masuk ke implementasi Anda.

Untuk otorisasi di aplikasi kami. Kami harus memanggil layanan berdasarkan parameter yang diteruskan dalam atribut otorisasi.

Misalnya, jika kami ingin memeriksa apakah dokter yang masuk dapat melihat janji pasien, kami akan memberikan "View_Appointment" untuk atribut otorisasi khusus dan memeriksa hak itu dalam layanan DB dan berdasarkan hasil yang kami akan athorize. Berikut ini kode untuk skenario ini:

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

Dan pada tindakan API kami menggunakannya seperti ini:

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

    }

Jawaban yang diterima ( https://stackoverflow.com/a/41348219/4974715 ) tidak dapat dipertahankan atau cocok secara realistis karena "CanReadResource" digunakan sebagai klaim (tetapi pada dasarnya harus merupakan kebijakan dalam kenyataannya, IMO). Pendekatan pada jawaban tidak OK dalam cara itu digunakan, karena jika metode tindakan memerlukan banyak pengaturan klaim yang berbeda, maka dengan jawaban itu Anda harus berulang kali menulis sesuatu seperti ...

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

Jadi, bayangkan berapa banyak pengkodean yang akan diambil. Idealnya, "CanReadResource" seharusnya merupakan kebijakan yang menggunakan banyak klaim untuk menentukan apakah pengguna dapat membaca sumber daya.

Apa yang saya lakukan adalah saya membuat kebijakan saya sebagai enumerasi dan kemudian loop melalui dan mengatur persyaratan seperti ...

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.
     */
            }
        }); 

Kelas DefaultAuthorizationRequirement terlihat seperti ...

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

Perhatikan bahwa kode di atas juga dapat memungkinkan pra-pemetaan pengguna ke kebijakan di penyimpanan data Anda. Jadi, ketika membuat klaim untuk pengguna, Anda pada dasarnya mengambil kebijakan yang telah dipetakan sebelumnya ke pengguna secara langsung atau tidak langsung (misalnya karena pengguna memiliki nilai klaim tertentu dan bahwa nilai klaim telah diidentifikasi dan dipetakan ke suatu kebijakan, seperti bahwa ia menyediakan pemetaan otomatis untuk pengguna yang memiliki nilai klaim juga), dan mendaftar kebijakan sebagai klaim, sehingga dalam penangan otorisasi, Anda dapat dengan mudah memeriksa apakah klaim pengguna mengandung persyaratan. Kebijakan sebagai Nilai dari item Klaim dalam klaim. Itu untuk cara statis untuk memenuhi persyaratan kebijakan, misalnya persyaratan "Nama depan" cukup statis. Begitu,

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

Persyaratan dinamis dapat tentang memeriksa rentang usia, dll. Dan kebijakan yang menggunakan persyaratan tersebut tidak dapat dipetakan sebelumnya kepada pengguna.

Contoh pemeriksaan klaim kebijakan dinamis (mis. Untuk memeriksa apakah pengguna berusia di atas 18 tahun) sudah ada di jawaban yang diberikan oleh @blowdart ( https://stackoverflow.com/a/31465227/4974715 ).

PS: Saya mengetik ini di ponsel saya. Maafkan kesalahan ketik dan kurangnya format.