.NET Core 2.0：基于HttpContext动态配置AddAuthentication的方案问询

我刚好在.NET Core 2.0里处理过类似的问题，确实这个版本的认证机制变更后，原来靠UseWhen结合上下文自定义认证的思路走不通了，不过有几个可行的方案可以解决你的需求：

方案1：利用认证方案的事件回调动态调整逻辑 #

大部分内置认证方案（比如JWT Bearer、Cookie）都提供了事件扩展点，这些回调会在请求处理阶段触发——此时已经能访问HttpContext，可以根据上下文动态调整认证参数或逻辑。

以JWT Bearer认证为例，你可以在事件中根据请求路径、Header等信息切换密钥、验证规则：

services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        // 先配置基础的验证参数
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuerSigningKey = true,
            ValidateIssuer = true,
            ValidateAudience = true,
            // 默认配置可以先设一个兜底值
            ValidAudience = "default-audience",
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("default-secret"))
        };

        // 注册事件回调，在接收请求时动态修改配置
        options.Events = new JwtBearerEvents
        {
            OnMessageReceived = context =>
            {
                var requestPath = context.HttpContext.Request.Path;
                
                // 针对不同路径使用不同的JWT配置
                if (requestPath.StartsWithSegments("/api/admin"))
                {
                    context.TokenValidationParameters.IssuerSigningKey = 
                        new SymmetricSecurityKey(Encoding.UTF8.GetBytes("admin-secret-key"));
                    context.TokenValidationParameters.ValidAudience = "admin-audience";
                }
                else if (requestPath.StartsWithSegments("/api/user"))
                {
                    context.TokenValidationParameters.IssuerSigningKey = 
                        new SymmetricSecurityKey(Encoding.UTF8.GetBytes("user-secret-key"));
                    context.TokenValidationParameters.ValidAudience = "user-audience";
                }

                return Task.CompletedTask;
            },
            OnTokenValidated = context =>
            {
                // 还能在这里根据上下文做额外校验，比如租户ID匹配
                var tenantId = context.HttpContext.Request.Headers["X-Tenant-Id"].FirstOrDefault();
                if (!string.IsNullOrEmpty(tenantId) && context.Principal?.FindFirst("TenantId")?.Value != tenantId)
                {
                    context.Fail("Tenant ID mismatch");
                }
                return Task.CompletedTask;
            }
        };
    });

这个方案的优势是无需自定义太多代码，直接利用现有认证方案的扩展点就能实现动态逻辑。

方案2：自定义IAuthenticationHandler完全控制认证流程 #

如果现有认证方案的事件满足不了你的复杂需求，可以自定义认证处理程序，在HandleAuthenticateAsync方法里完全掌控认证逻辑，同时自由访问HttpContext。

步骤如下：

1. 定义自定义认证的配置选项类：

public class DynamicAuthOptions : AuthenticationSchemeOptions
{
    // 可以在这里定义全局基础配置，比如默认的超时时间等
}

2. 实现IAuthenticationHandler接口：

public class DynamicAuthHandler : AuthenticationHandler<DynamicAuthOptions>
{
    public DynamicAuthHandler(IOptionsMonitor<DynamicAuthOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) 
        : base(options, logger, encoder, clock)
    {
    }

    protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        // 直接访问当前请求的HttpContext
        var request = Context.Request;
        var path = request.Path;

        // 根据上下文分支处理不同认证逻辑
        if (path.StartsWithSegments("/admin"))
        {
            // 管理员专属认证：验证自定义Header
            var adminToken = request.Headers["Admin-Auth-Token"].FirstOrDefault();
            if (adminToken == "admin-super-secret-123")
            {
                var claims = new List<Claim>
                {
                    new Claim(ClaimTypes.Name, "AdminUser"),
                    new Claim(ClaimTypes.Role, "Admin")
                };
                var identity = new ClaimsIdentity(claims, Scheme.Name);
                var principal = new ClaimsPrincipal(identity);
                var ticket = new AuthenticationTicket(principal, Scheme.Name);
                return AuthenticateResult.Success(ticket);
            }
            return AuthenticateResult.Fail("Invalid admin authentication token");
        }
        else
        {
            // 普通用户认证：验证JWT Token
            var authHeader = request.Headers["Authorization"].FirstOrDefault();
            if (string.IsNullOrEmpty(authHeader) || !authHeader.StartsWith("Bearer "))
            {
                return AuthenticateResult.NoResult();
            }
            
            var token = authHeader.Split(" ").Last();
            // 这里可以根据上下文选择不同的密钥验证JWT
            var secretKey = request.Query.ContainsKey("version") && request.Query["version"] == "v2" 
                ? "user-v2-secret" 
                : "user-v1-secret";
            
            // 省略JWT验证逻辑，直接返回认证结果示例
            var claims = new List<Claim> { new Claim(ClaimTypes.Name, "RegularUser") };
            var identity = new ClaimsIdentity(claims, Scheme.Name);
            var principal = new ClaimsPrincipal(identity);
            var ticket = new AuthenticationTicket(principal, Scheme.Name);
            return AuthenticateResult.Success(ticket);
        }
    }
}

3. 在ConfigureServices中注册自定义认证方案：

services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = "DynamicAuth";
    options.DefaultChallengeScheme = "DynamicAuth";
})
.AddScheme<DynamicAuthOptions, DynamicAuthHandler>("DynamicAuth", options =>
{
    // 配置全局基础选项
});

这个方案灵活性最高，适合需要完全自定义认证逻辑的场景。

方案3：结合IHttpContextAccessor动态获取上下文相关配置 #

如果你的认证配置是和请求上下文绑定的（比如多租户场景下不同租户用不同的密钥），可以注入IHttpContextAccessor，在事件回调中通过它获取上下文，再动态拉取对应配置。

注意不要在ConfigureServices阶段直接访问HttpContext，要在请求处理阶段的回调中通过RequestServices获取服务：

// 先注册IHttpContextAccessor
services.AddHttpContextAccessor();

services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Events = new JwtBearerEvents
        {
            OnMessageReceived = async context =>
            {
                // 从请求服务中获取自定义的租户配置服务
                var tenantConfigService = context.HttpContext.RequestServices.GetRequiredService<ITenantConfigService>();
                var tenantId = context.HttpContext.Request.Headers["X-Tenant-Id"].FirstOrDefault();
                
                // 根据租户ID获取对应的JWT配置
                var tenantJwtConfig = await tenantConfigService.GetJwtConfigAsync(tenantId);
                
                // 动态替换验证参数
                context.TokenValidationParameters.IssuerSigningKey = 
                    new SymmetricSecurityKey(Encoding.UTF8.GetBytes(tenantJwtConfig.SecretKey));
                context.TokenValidationParameters.ValidIssuer = tenantJwtConfig.Issuer;
                context.TokenValidationParameters.ValidAudience = tenantJwtConfig.Audience;
            }
        };
    });

这种方式适合需要从外部数据源（数据库、配置中心）动态获取认证配置的场景。

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