如何为单个控制器的不同操作配置不同认证方式并避免无效验证？

针对你的需求——同一个控制器的三个操作分别使用无认证、Basic Auth、Bearer Token，且避免不必要的数据库读取，可按以下步骤实现：

1. 注册多套认证方案 #

在Program.cs中分别注册Basic Auth和Bearer Token的认证方案，不设置默认方案（避免全局触发不必要的认证逻辑）：

// 注册Basic Auth方案，指定自定义Handler和方案名称"BasicAuth"
builder.Services.AddAuthentication()
    .AddScheme<AuthenticationSchemeOptions, BasicAuthenticationHandler>("BasicAuth", options => { })
    // 注册Bearer Token（JWT）方案，指定方案名称"BearerAuth"并配置参数
    .AddJwtBearer("BearerAuth", options => {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = "你的Issuer",
            ValidAudience = "你的Audience",
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("你的密钥"))
        };
    });

2. 修改Basic Auth Handler，跳过匿名操作的认证 #

你之前遇到[AllowAnonymous]仍触发数据库读取的问题，是因为认证中间件会执行所有注册的Handler，不管操作是否允许匿名。因此需要在BasicAuthenticationHandler中添加检查：如果当前操作标记了[AllowAnonymous]，则直接跳过认证逻辑：

public class BasicAuthenticationHandler : AuthenticationHandler<AuthenticationSchemeOptions>
{
    private readonly IUserRepository _userRepository;

    public BasicAuthenticationHandler(
        IOptionsMonitor<AuthenticationSchemeOptions> options,
        ILoggerFactory logger,
        UrlEncoder encoder,
        ISystemClock clock,
        IUserRepository userRepository)
        : base(options, logger, encoder, clock)
    {
        _userRepository = userRepository;
    }

    protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        // 检查当前端点是否允许匿名，是则跳过认证
        var endpoint = Context.GetEndpoint();
        if (endpoint?.Metadata.GetMetadata<IAllowAnonymous>() != null)
        {
            return AuthenticateResult.NoResult();
        }

        // 原Basic Auth验证逻辑
        var authHeader = Request.Headers.Authorization.ToString();
        if (!authHeader.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase))
        {
            return AuthenticateResult.Fail("缺少Basic认证头");
        }

        // 解析用户名密码
        var credentialBytes = Convert.FromBase64String(authHeader.Substring(6));
        var credentials = Encoding.UTF8.GetString(credentialBytes).Split(':', 2);
        var username = credentials[0];
        var password = credentials[1];

        // 验证用户（仅在需要认证的操作中执行）
        var user = await _userRepository.GetUserAsync(username);
        if (user == null || !BCrypt.Net.BCrypt.Verify(password, user.PasswordHash))
        {
            return AuthenticateResult.Fail("无效凭据");
        }

        // 生成认证票据
        var claims = new[] { new Claim(ClaimTypes.Name, username) };
        var identity = new ClaimsIdentity(claims, Scheme.Name);
        var principal = new ClaimsPrincipal(identity);
        var ticket = new AuthenticationTicket(principal, Scheme.Name);

        return AuthenticateResult.Success(ticket);
    }
}

3. 控制器操作上标记对应的认证特性 #

在控制器的每个操作上，明确指定所需的认证方式：

[ApiController]
[Route("api/auth")]
public class AuthController : ControllerBase
{
    // 无认证：标记[AllowAnonymous]，跳过所有认证逻辑
    [HttpGet("public-key")]
    [AllowAnonymous]
    public IActionResult GetPublicKey()
    {
        // 返回公钥的业务逻辑
        return Ok("你的公钥内容");
    }

    // 使用Basic Auth：指定认证方案为"BasicAuth"
    [HttpPost("generate-token")]
    [Authorize(AuthenticationSchemes = "BasicAuth")]
    public IActionResult GenerateToken()
    {
        // 从User.Identity获取已认证的用户名，生成JWT
        var username = User.Identity.Name;
        var token = GenerateJwt(username);
        return Ok(new { AccessToken = token });
    }

    // 使用Bearer Token：指定认证方案为"BearerAuth"
    [HttpPost("refresh-token")]
    [Authorize(AuthenticationSchemes = "BearerAuth")]
    public IActionResult RefreshToken()
    {
        // 从当前Bearer Token获取用户名，生成新的JWT
        var username = User.Identity.Name;
        var newToken = GenerateJwt(username);
        return Ok(new { AccessToken = newToken });
    }

    // JWT生成工具方法
    private string GenerateJwt(string username)
    {
        var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("你的密钥"));
        var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);

        var token = new JwtSecurityToken(
            issuer: "你的Issuer",
            audience: "你的Audience",
            claims: new[] { new Claim(ClaimTypes.Name, username) },
            expires: DateTime.Now.AddMinutes(30),
            signingCredentials: credentials);

        return new JwtSecurityTokenHandler().WriteToken(token);
    }
}

关键说明 #

• 不设置默认认证方案，避免全局触发不必要的认证逻辑；
• 通过[Authorize(AuthenticationSchemes = "方案名称")]为单个操作指定专属认证方式，中间件仅会执行该方案的Handler；
• 在Basic Auth Handler中添加匿名检查，确保标记[AllowAnonymous]的操作不会触发数据库读取。

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