ASP.NET Core 6.0如何实现策略或角色的二选一授权？

当多个[Authorize]特性叠加时，默认是逻辑与关系，要实现“满足其一即可”的逻辑，推荐以下两种方案：

方法一：自定义复合授权策略（推荐，可复用） #

步骤1：定义授权要求与处理程序 #

创建两个类，分别承载授权规则和实现“或”逻辑判断：

// 自定义授权要求，传递角色、目标策略、认证方案参数
public class EitherRoleOrPolicyRequirement : IAuthorizationRequirement
{
    public string Role { get; }
    public string PolicyName { get; }
    public string AuthenticationScheme { get; }

    public EitherRoleOrPolicyRequirement(string role, string policyName, string authenticationScheme)
    {
        Role = role;
        PolicyName = policyName;
        AuthenticationScheme = authenticationScheme;
    }
}

// 授权处理程序，实现二选一的逻辑判断
public class EitherRoleOrPolicyHandler : AuthorizationHandler<EitherRoleOrPolicyRequirement>
{
    private readonly IAuthorizationService _authorizationService;

    public EitherRoleOrPolicyHandler(IAuthorizationService authorizationService)
    {
        _authorizationService = authorizationService;
    }

    protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, EitherRoleOrPolicyRequirement requirement)
    {
        // 检查用户是否属于指定角色
        if (context.User.IsInRole(requirement.Role))
        {
            context.Succeed(requirement);
            return;
        }

        // 尝试用Custom方案完成认证
        var authResult = await context.HttpContext.AuthenticateAsync(requirement.AuthenticationScheme);
        if (authResult.Succeeded)
        {
            // 验证认证后的用户是否满足目标策略
            var policyResult = await _authorizationService.AuthorizeAsync(authResult.Principal, requirement.PolicyName);
            if (policyResult.Succeeded)
            {
                context.Succeed(requirement);
                return;
            }
        }

        // 两种条件都不满足，授权失败
        context.Fail();
    }
}

步骤2：注册处理程序并配置复合策略 #

在Program.cs中注册自定义处理程序，同时添加包含“或”逻辑的新策略：

// 注册自定义授权处理程序
builder.Services.AddScoped<IAuthorizationHandler, EitherRoleOrPolicyHandler>();

// 配置授权策略
builder.Services.AddAuthorization(options =>
{
    // 保留你已有的RandomPolicyName策略配置
    options.AddPolicy("RandomPolicyName", policy =>
    {
        policy.RequireAuthenticatedUser();
        policy.AddAuthenticationSchemes("Custom");
        // 替换为你实际的策略要求（比如作用域）
        policy.RequireClaim("scope", "your-required-scope");
    });

    // 添加复合策略：满足User角色 或 满足Custom方案的RandomPolicyName策略
    options.AddPolicy("EitherRoleOrCustomPolicy", policy =>
    {
        policy.AddRequirements(new EitherRoleOrPolicyRequirement(
            role: "User",
            policyName: "RandomPolicyName",
            authenticationScheme: "Custom"
        ));
    });
});

步骤3：在控制器上使用复合策略 #

直接在控制器或Action上应用新策略：

[Authorize(Policy = "EitherRoleOrCustomPolicy")]
public class YourController : ControllerBase
{
    // 你的业务Action
}

方法二：使用RequireAssertion快速定义策略 #

如果不需要复用逻辑，可以直接用RequireAssertion简化配置，无需自定义处理程序：

在Program.cs的授权配置中添加：

builder.Services.AddAuthorization(options =>
{
    // 保留原有RandomPolicyName策略
    options.AddPolicy("RandomPolicyName", policy =>
    {
        policy.RequireAuthenticatedUser();
        policy.AddAuthenticationSchemes("Custom");
        policy.RequireClaim("scope", "your-required-scope");
    });

    // 直接定义二选一的策略逻辑
    options.AddPolicy("EitherRoleOrCustomPolicy", policy =>
    {
        policy.RequireAssertion(async context =>
        {
            // 检查角色条件
            if (context.User.IsInRole("User")) return true;

            // 检查Custom方案认证与策略条件
            var authResult = await context.HttpContext.AuthenticateAsync("Custom");
            if (authResult.Succeeded)
            {
                var policyResult = await context.AuthorizationService.AuthorizeAsync(authResult.Principal, "RandomPolicyName");
                return policyResult.Succeeded;
            }

            return false;
        });
    });
});

之后同样在控制器上使用[Authorize(Policy = "EitherRoleOrCustomPolicy")]即可。

注意事项 #

• 确保Custom认证方案的JWT配置正确（比如密钥、受众、颁发者等），能正确解析请求中的令牌。
• 异步操作务必使用await，避免用.Result同步等待引发死锁。

内容的提问来源于stack exchange，提问作者serhatyt