如何实现.NET 6 API基于多AADB2C实例的客户端差异化认证？

针对你的需求，核心思路是根据请求中的客户端ID动态匹配对应的AADB2C配置，完成令牌验证。以下是具体实现步骤：

1. 数据库配置存储 #

首先在数据库中维护客户端ID与AADB2C配置的映射关系，建议包含以下字段：

• ClientId：客户端唯一标识（与请求中携带的一致）
• TenantId：AADB2C租户ID
• SignUpSignInPolicy：AADB2C的登录/注册策略名称

对应实体类示例：

public class Aadb2cConfig
{
    public string ClientId { get; set; }
    public string TenantId { get; set; }
    public string SignUpSignInPolicy { get; set; }
    // 动态生成AADB2C授权地址
    public string Authority => $"https://{TenantId}.b2clogin.com/{TenantId}.onmicrosoft.com/{SignUpSignInPolicy}/v2.0/";
    // 令牌受众即客户端ID
    public string Audience => ClientId;
}

2. 实现配置获取服务 #

编写一个服务从数据库读取对应客户端的AADB2C配置，示例如下：

public interface IAadb2cConfigProvider
{
    Task<Aadb2cConfig> GetConfigByClientIdAsync(string clientId);
}

public class Aadb2cConfigProvider : IAadb2cConfigProvider
{
    private readonly IDbConnection _dbConn;
    // 可注入EF Core上下文或Dapper连接对象
    public Aadb2cConfigProvider(IDbConnection dbConn)
    {
        _dbConn = dbConn;
    }

    public async Task<Aadb2cConfig> GetConfigByClientIdAsync(string clientId)
    {
        // 示例使用Dapper查询，可替换为EF Core逻辑
        return await _dbConn.QueryFirstOrDefaultAsync<Aadb2cConfig>(
            @"SELECT ClientId, TenantId, SignUpSignInPolicy 
              FROM Aadb2cConfigs 
              WHERE ClientId = @ClientId",
            new { ClientId = clientId });
    }
}

3. 配置动态JWT认证 #

在Program.cs中配置JWT Bearer认证，通过事件钩子动态获取配置并验证令牌：

builder.Services.AddScoped<IAadb2cConfigProvider, Aadb2cConfigProvider>();

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            // 不固定Issuer和Audience，留空待动态验证
        };

        options.Events = new JwtBearerEvents
        {
            async OnMessageReceived(context)
            {
                // 从请求Header提取客户端ID（示例用X-Client-Id，可自定义）
                var clientId = context.Request.Headers["X-Client-Id"].FirstOrDefault();
                if (string.IsNullOrEmpty(clientId))
                {
                    context.Fail("缺少X-Client-Id请求头");
                    return;
                }
                // 暂存客户端ID到上下文供后续事件使用
                context.Items["ClientId"] = clientId;
            },

            async OnTokenValidated(context)
            {
                var clientId = context.Items["ClientId"] as string;
                if (string.IsNullOrEmpty(clientId))
                {
                    context.Fail("上下文未找到客户端ID");
                    return;
                }

                // 获取对应AADB2C配置
                var configProvider = context.HttpContext.RequestServices.GetRequiredService<IAadb2cConfigProvider>();
                var aadb2cConfig = await configProvider.GetConfigByClientIdAsync(clientId);
                if (aadb2cConfig == null)
                {
                    context.Fail($"未找到客户端ID {clientId}对应的AADB2C配置");
                    return;
                }

                // 验证令牌颁发者（Issuer）是否匹配
                var issuerClaim = context.Principal.FindFirst("iss")?.Value?.TrimEnd('/');
                if (issuerClaim != aadb2cConfig.Authority.TrimEnd('/'))
                {
                    context.Fail($"无效颁发者，预期为{aadb2cConfig.Authority}");
                    return;
                }

                // 验证令牌受众（Audience）是否匹配
                var audienceClaim = context.Principal.FindFirst("aud")?.Value;
                if (audienceClaim != aadb2cConfig.Audience)
                {
                    context.Fail($"无效受众，预期为{aadb2cConfig.Audience}");
                    return;
                }

                // 动态获取AADB2C的JWKS密钥用于签名验证
                var configManager = new ConfigurationManager<OpenIdConnectConfiguration>(
                    $"{aadb2cConfig.Authority}.well-known/openid-configuration",
                    new OpenIdConnectConfigurationRetriever());
                var openIdConfig = await configManager.GetConfigurationAsync(CancellationToken.None);
                options.TokenValidationParameters.IssuerSigningKeys = openIdConfig.SigningKeys;
            },

            async OnAuthenticationFailed(context)
            {
                // 可添加日志记录等失败处理逻辑
                context.Fail($"认证失败：{context.Exception.Message}");
            }
        };
    });

builder.Services.AddAuthorization();

4. 性能优化建议 #

• 给IAadb2cConfigProvider添加缓存（内存缓存或分布式缓存），避免每次请求都查询数据库
• 缓存AADB2C的JWKS配置，减少对AADB2C服务器的请求次数

除了上述动态匹配AADB2C配置的方案，还有以下几种常见思路：

1. 多认证Scheme注册 #

为每个认证提供商（或每个AADB2C实例）单独注册一个认证Scheme，然后在控制器/Action上指定允许的Scheme：

// 注册第一个AADB2C实例的Scheme
builder.Services.AddAuthentication()
    .AddJwtBearer("Aadb2cScheme1", options =>
    {
        options.Authority = "https://tenant1.b2clogin.com/tenant1.onmicrosoft.com/policy1/v2.0/";
        options.Audience = "clientId1";
    })
    // 注册第二个AADB2C实例的Scheme
    .AddJwtBearer("Aadb2cScheme2", options =>
    {
        options.Authority = "https://tenant2.b2clogin.com/tenant2.onmicrosoft.com/policy2/v2.0/";
        options.Audience = "clientId2";
    });

// 在控制器上允许多个Scheme
[Authorize(AuthenticationSchemes = "Aadb2cScheme1,Aadb2cScheme2")]
public class MyController : ControllerBase
{
    // ...
}

适用场景：认证提供商数量少且固定的情况，缺点是新增实例需要修改代码重新部署。

2. 网关层集中处理认证 #

将认证逻辑转移到API网关（如Azure API Management、Ocelot），网关根据客户端ID选择对应的AADB2C实例验证令牌，验证通过后再转发请求到后端API。后端API只需信任网关的请求（比如验证网关的签名或IP）。
优点：后端API无需处理认证逻辑，认证规则集中管理，易于扩展。

3. 自定义认证中间件 #

编写自定义认证中间件，手动完成令牌验证流程：

1. 从请求中提取客户端ID和令牌
2. 查询对应认证配置
3. 使用JwtSecurityTokenHandler手动验证令牌签名、有效期、Issuer、Audience等
4. 验证通过后设置HttpContext.User
   优点：灵活性最高，可完全自定义认证逻辑；缺点是需要自行处理所有认证细节，开发成本较高。

4. 统一认证中间层（如IdentityServer4） #

搭建一个IdentityServer4实例作为统一认证入口，将各个AADB2C实例配置为IdentityServer的外部身份提供者。客户端先向IdentityServer发起认证请求，IdentityServer转发到对应的AADB2C完成验证，再由IdentityServer颁发统一格式的令牌给客户端。后端API只需验证IdentityServer的令牌即可。
适用场景：存在大量认证提供商或需要统一用户管理、权限控制的场景。

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