c# - 无法从均受 Azure AD B2C 保护的 MVC Web 应用程序访问 WebApi

Question

我有一个 Web 应用程序 (MVC) 和一个 WebApi，它们都在同一租户中由 ADB2C 保护。 Web 应用程序想要使用简单的 HttpClient 调用 WebApi。这是带有最新 Visaul Studio 项目模板的 .NET Core 2.1。

可以做到以下几点:

1. 我可以使用 B2C 成功登录并注册网络应用程序。我只使用新的 .NET Core 2.1 模板，其中 B2C 以最少的代码构建到项目中。

2. 我还使用向导创建了 WebApi 项目(这次是 WebAPI)。然后，我可以成功地使用 Postman 测试 在 WebApi 中签名，其中 Postman 在租户中注册为自己的 Web 应用程序。这是描述here

3. 我只在我的本地机器上测试所有这些，我还没有部署到 azurewebsites.net

我可以看出网络应用正在使用

services.AddAuthentication( AzureADB2CDefaults.AuthenticationScheme )
                .AddAzureADB2C( options =>
                {
                    Configuration.Bind( "AzureAdB2C", options );
                } );

WebApi startup.cs 使用不记名 token :

services.AddAuthentication(AzureADB2CDefaults.BearerAuthenticationScheme)
                .AddAzureADB2CBearer(options =>
                {
                    Configuration.Bind( "AzureAdB2C", options );
                } );

现在我的 Web 应用程序中有一个 Controller 操作，它想要调用 WebApi 项目中的 ValuesController 来获取虚拟值。

这是我不明白的，因为使用下面的代码，我能够获取 token :

var httpClient = new HttpClient
            {
                BaseAddress = new Uri( _configuration["WebApi:BaseUrl"] )
            };

            var clientId = _configuration["AzureAdB2C:ClientId"]; //the client ID for the web app (not web api!)
            var clientSecret = _configuration["AzureAdB2C:ClientSecret"]; //the secret for the web app
            var authority = _configuration["AzureAdB2C:Authority"]; //the instance name and the custom domain name for this tenant
            var id = _configuration["WebApi:Id"]; //the complete Url including the suffix of the web api

            var authContext = new AuthenticationContext( authority );
            var credentials = new ClientCredential( clientId, clientSecret );
            var authResult = await authContext.AcquireTokenAsync( id, credentials );

            _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue( "Bearer", authResult.AccessToken );

此时我有了 token 。我可以使用 http://jwt.ms 解密 token 但 token 不包含声明。不明白这是为什么。

但是当我调用 GetStringAsync() 时，我在 ValuesController 中的 Get() 操作上收到 401 未授权异常。

//this fails with a 401
var result = await _httpClient.GetStringAsync( "api/values" );
//HttpRequestException: Response status code does not indicate success: 401 (Unauthorized).

对于上面代码中的“id”，我使用了完整的 WebApi URL，如 Azure 门户中 WebApi 的属性所示。

在“API 访问”下，我已授予 Web 应用程序访问门户中 Web API 应用程序的权限。

我错过了什么？我不明白为什么 Postman 可以工作(它在 ADB2C 中注册为网络应用程序)，而这不是

这些是在 API 访问中定义的范围:

Answer 1

2018 年 6 月 27 日开始编辑

我在 GitHub 创建了一个代码示例对于使用 Azure AD B2C 的 ASP.NET Core 2.1 身份验证中间件针对 Azure AD B2C 对最终用户进行身份验证的 ASP.NET Core 2.1 Web 应用程序，使用 MSAL.NET 获取访问 token ，并使用此访问 token 访问 Web API .

以下答案总结了代码示例的实现内容。

2018 年 6 月 27 日结束编辑

要使 ASP.NET Core 2.1 Web 应用程序获取用于 API 应用程序的访问 token ，您必须:

1. 创建一个选项类，使用 API 选项扩展 Azure AD B2C 身份验证选项:

public class AzureADB2CWithApiOptions : AzureADB2COptions
{
    public string ApiScopes { get; set; }

    public string ApiUrl { get; set; }

    public string Authority => $"{Instance}/{Domain}/{DefaultPolicy}/v2.0";

    public string RedirectUri { get; set; }
}

1. 将这些 API 选项添加到 appsettings.json 文件:

{
  "AllowedHosts": "*",
  "AzureADB2C": {
    "ApiScopes": "https://***.onmicrosoft.com/demoapi/demo.read",
    "ApiUrl": "https://***.azurewebsites.net/hello",
    "CallbackPath": "/signin-oidc",
    "ClientId": "***",
    "ClientSecret": "***",
    "Domain": "***.onmicrosoft.com",
    "EditProfilePolicyId": "b2c_1_edit_profile",
    "Instance": "https://login.microsoftonline.com/tfp",
    "RedirectUri": "https://localhost:44316/signin-oidc",
    "ResetPasswordPolicyId": "b2c_1_reset",
    "SignUpSignInPolicyId": "b2c_1_susi"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  }
}

1. 创建一个配置类，实现IConfigureNamedOptions<OpenIdConnectOptions>接口(interface)，为 Azure AD B2C 身份验证中间件配置 OpenID Connect 身份验证选项:

public class AzureADB2COpenIdConnectOptionsConfigurator : IConfigureNamedOptions<OpenIdConnectOptions>
{
    private readonly AzureADB2CWithApiOptions _options;

    public AzureADB2COpenIdConnectOptionsConfigurator(IOptions<AzureADB2CWithApiOptions> optionsAccessor)
    {
        _options = optionsAccessor.Value;
    }

    public void Configure(string name, OpenIdConnectOptions options)
    {
        options.Events.OnAuthorizationCodeReceived = WrapOpenIdConnectEvent(options.Events.OnAuthorizationCodeReceived, OnAuthorizationCodeReceived);
        options.Events.OnRedirectToIdentityProvider = WrapOpenIdConnectEvent(options.Events.OnRedirectToIdentityProvider, OnRedirectToIdentityProvider);
    }

    public void Configure(OpenIdConnectOptions options)
    {
        Configure(Options.DefaultName, options);
    }

    private static Func<TContext, Task> WrapOpenIdConnectEvent<TContext>(Func<TContext, Task> baseEventHandler, Func<TContext, Task> thisEventHandler)
    {
        return new Func<TContext, Task>(async context =>
        {
            await baseEventHandler(context);
            await thisEventHandler(context);
        });
    }

    private async Task OnAuthorizationCodeReceived(AuthorizationCodeReceivedContext context)
    {
        var clientCredential = new ClientCredential(context.Options.ClientSecret);
        var userId = context.Principal.FindFirst(ClaimTypes.NameIdentifier).Value;
        var userTokenCache = new SessionTokenCache(context.HttpContext, userId);

        var confidentialClientApplication = new ConfidentialClientApplication(
            context.Options.ClientId,
            context.Options.Authority,
            $"{context.Request.Scheme}://{context.Request.Host}{context.Request.Path}",
            clientCredential,
            userTokenCache.GetInstance(),
            null);

        try
        {
            var authenticationResult = await confidentialClientApplication.AcquireTokenByAuthorizationCodeAsync(
                context.ProtocolMessage.Code, _options.ApiScopes.Split(' '));
            context.HandleCodeRedemption(authenticationResult.AccessToken, authenticationResult.IdToken);
        }
        catch (Exception ex)
        {
            // TODO: Handle.
            throw;
        }
    }

    public Task OnRedirectToIdentityProvider(RedirectContext context)
    {
        context.ProtocolMessage.ResponseType = OpenIdConnectResponseType.CodeIdToken;
        context.ProtocolMessage.Scope += $" offline_access {_options.ApiScopes}";
        return Task.FromResult(0);
    }
}

在向 Azure AD B2C 发送身份验证请求之前，此配置类将 API 范围添加到身份验证请求的 scope 参数中。

从 Azure AD B2C 收到授权码后，配置类将此授权码与访问 token 交换，并使用 Microsoft 身份验证库 (MSAL) 将此访问 token 保存到 token 缓存中。

1. 在 Startup 中注册配置类的单个实例类(class):

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // The following line configures the Azure AD B2C authentication with API options.
        services.Configure<AzureADB2CWithApiOptions>(options => Configuration.Bind("AzureADB2C", options));

        services.Configure<CookiePolicyOptions>(options =>
        {
            options.CheckConsentNeeded = context => true;
            options.MinimumSameSitePolicy = SameSiteMode.None;
        });

        services.AddAuthentication(AzureADB2CDefaults.AuthenticationScheme)
            .AddAzureADB2C(options => Configuration.Bind("AzureADB2C", options));

        // The following line registers the OpenID Connect authentication options for the Azure AD B2C authentication middleware.
        services.AddSingleton<IConfigureOptions<OpenIdConnectOptions>, AzureADB2COpenIdConnectOptionsConfigurator>();

        services.AddMvc()
            .SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
    }
}

对于使用 Microsoft 身份验证库 (MSAL) 从 token 缓存加载访问 token 的 Controller 方法，您必须:

public class HelloController : Controller
{
    private readonly AzureADB2CWithApiOptions _options;

    public HelloController(IOptions<AzureADB2CWithApiOptions> optionsAccessor)
    {
        _options = optionsAccessor.Value;
    }

    public async Task<IActionResult> Index()
    {
        var clientCredential = new ClientCredential(_options.ClientSecret);
        var userId = context.Principal.FindFirst(ClaimTypes.NameIdentifier).Value;
        var userTokenCache = new SessionTokenCache(HttpContext, userId);

        var confidentialClientApplication = new ConfidentialClientApplication(
            _options.ClientId,
            _options.Authority,
            _options.RedirectUri,
            clientCredential,
            userTokenCache.GetInstance(),
            null);

        var authenticationresult = await confidentialClientApplication.AcquireTokenSilentAsync(
            _options.ApiScopes.Split(' '),
            confidentialClientApplication.Users.FirstOrDefault(),
            _options.Authority,
            false);

        // TODO: Invoke the API endpoint by setting the Authorization header to "Bearer" + authenticationResult.AccessToken.
    }
}