Habilitar as opções de autenticação em um aplicativo Web usando o Azure AD B2C

Este artigo descreve como habilitar, personalizar e aprimorar a experiência de autenticação do Azure Active Directory B2C (Azure AD B2C) para o aplicativo Web.

Antes de começar, é importante familiarizar-se com os seguintes artigos:

• Configurar a autenticação em um aplicativo Web de exemplo
• Habilitar a autenticação em seu próprio aplicativo Web.

Usar um domínio personalizado

Ao usar um domínio personalizado, você pode recriar por completo a URL de autenticação. Da perspectiva do usuário, os usuários permanecem nos domínios durante o processo de autenticação, em vez de serem redirecionados para o nome de domínio b2clogin.com do Azure AD B2C.

Para remover todas as referências a “b2c” na URL, você também pode substituir o nome do locatário b2c, contoso.onmicrosoft.com, na URL de solicitação de autenticação pelo GUID da ID do locatário. Por exemplo, você pode mudar de https://fabrikamb2c.b2clogin.com/contoso.onmicrosoft.com/ para https://account.contosobank.co.uk/<tenant ID GUID>/.

Para usar um domínio personalizado e sua ID de locatário na URL de autenticação, siga as diretrizes em Habilitar domínios personalizados. Na pasta raiz do projeto, abra o arquivo appsettings.json. Esse arquivo contém informações sobre seu provedor de identidade do Azure AD B2C.

No arquivo appsettings.json, faça o seguinte:

• Atualize a entrada Instance com seu domínio personalizado.
• Atualize a entrada Domain com a ID do locatário. Para obter mais informações,consulte Usar ID do locatário.

O JSON a seguir mostra as configurações do aplicativo antes da alteração:

"AzureAdB2C": {
  "Instance": "https://contoso.b2clogin.com",
  "Domain": "tenant-name.onmicrosoft.com",
  ...
}

O JSON a seguir mostra as configurações do aplicativo após a alteração:

"AzureAdB2C": {
  "Instance": "https://login.contoso.com",
  "Domain": "00000000-0000-0000-0000-000000000000",
  ...
}

Suporte a cenários avançados

O método AddMicrosoftIdentityWebAppAuthentication na API da plataforma de identidade da Microsoft permite que os desenvolvedores adicionem código para cenários de autenticação avançada ou assinem eventos OpenIdConnect. Por exemplo, você pode assinar OnRedirectToIdentityProvider, que permite personalizar a solicitação de autenticação que seu aplicativo envia para o Azure Active Directory B2C.

Para dar suporte a cenários avançados, abra o arquivo Startup.cs e, na função ConfigureServices, substitua AddMicrosoftIdentityWebAppAuthentication pelo seguinte snippet de código:

// Configuration to sign-in users with Azure AD B2C

//services.AddMicrosoftIdentityWebAppAuthentication(Configuration, "AzureAdB2C");

services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
        .AddMicrosoftIdentityWebApp(options =>
{
    Configuration.Bind("AzureAdB2C", options);
    options.Events ??= new OpenIdConnectEvents();
    options.Events.OnRedirectToIdentityProvider += OnRedirectToIdentityProviderFunc;
});

O código anterior adiciona o evento OnRedirectToIdentityProvider com uma referência ao método OnRedirectToIdentityProviderFunc. Adicione o seguinte snippet de código à classe Startup.cs.

private async Task OnRedirectToIdentityProviderFunc(RedirectContext context)
{
    // Custom code here
    
    // Don't remove this line
    await Task.CompletedTask.ConfigureAwait(false);
}

Você pode passar parâmetros entre o controlador e a função OnRedirectToIdentityProvider usando parâmetros de contexto.

Preencher previamente o nome de usuário

Durante um percurso de entrada do usuário, um aplicativo pode ser direcionado a um usuário específico. Ao direcionar a um usuário, um aplicativo pode especificar, na solicitação de autorização, o parâmetro de consulta login_hint com o nome de entrada do usuário. O Azure AD B2C preenche automaticamente o nome de entrada, e o usuário só precisa fornecer a senha.

Para preencher o nome de logon, faça o seguinte:

1. Se você estiver usando uma política personalizada, adicione a declaração de entrada necessária, conforme descrito em Configurar conexão direta.

2. Conclua o procedimento de Cenários avançados de suporte.

3. Adicione a seguinte linha de código à função OnRedirectToIdentityProvider:

   private async Task OnRedirectToIdentityProviderFunc(RedirectContext context)
   {
     context.ProtocolMessage.LoginHint = "emily@contoso.com";
   
     // More code
     await Task.CompletedTask.ConfigureAwait(false);
   }
   

Pré-selecionar um provedor de identidade

Se você configurou o percurso de entrada para seu aplicativo para incluir contas sociais, como Facebook, LinkedIn ou do Google, você pode especificar o domain_hint parâmetro. Esse parâmetro de consulta fornece uma dica para o Azure AD B2C sobre o provedor de identidade social que deve ser usado para entrar. Por exemplo, se o aplicativo especifica domain_hint=facebook.com, o fluxo de entrada vai diretamente para a página de entrada do Facebook.

Para redirecionar usuários para um provedor de identidade externo, faça o seguinte:

1. Verifique o nome de domínio do seu provedor de identidade externo. Para obter mais informações, consulte redirecionar entrada para um provedor social.

2. Conclua o procedimento de Cenários avançados de suporte.

3. Na função OnRedirectToIdentityProviderFunc, adicione a seguinte linha de código à função OnRedirectToIdentityProvider:

   private async Task OnRedirectToIdentityProviderFunc(RedirectContext context)
   {
     context.ProtocolMessage.DomainHint = "facebook.com";
   
     // More code
     await Task.CompletedTask.ConfigureAwait(false);
   }
   

Especificar a linguagem de programação da interface do usuário

A personalização da linguagem de programação no Azure Active Directory B2C permite que o fluxo do usuário acomode uma variedade de linguagens de programação para atender às necessidades dos clientes. Para obter mais informações, consulte Personalização de linguagem de programação.

Para definir o idioma preferencial, faça o seguinte:

1. Configurar a personalização de linguagem.

2. Conclua o procedimento de Cenários avançados de suporte.

3. Adicione a seguinte linha de código à função OnRedirectToIdentityProvider:

   private async Task OnRedirectToIdentityProviderFunc(RedirectContext context)
   {
     context.ProtocolMessage.UiLocales = "es";
   
     // More code
     await Task.CompletedTask.ConfigureAwait(false);
   }
   

Passar um parâmetro de cadeia de caracteres de consulta personalizado

Com as políticas personalizadas, é possível passar um parâmetro de cadeia de caracteres de consulta personalizado. Um bom exemplo de caso de uso é quando você deseja alterar dinamicamente o conteúdo da página.

Para passar um parâmetro de cadeia de caracteres de consulta personalizado, siga estas etapas:

1. Configure o elemento ContentDefinitionParameters.

2. Conclua o procedimento de Cenários avançados de suporte.

3. Adicione a seguinte linha de código à função OnRedirectToIdentityProvider:

   private async Task OnRedirectToIdentityProviderFunc(RedirectContext context)
   {
     context.ProtocolMessage.Parameters.Add("campaignId", "123");
   
     // More code
     await Task.CompletedTask.ConfigureAwait(false);
   }
   

Passar uma dica de token de ID

Um aplicativo de terceira parte confiável pode enviar um JWT (Token Web JSON) de entrada como parte da solicitação de autorização OAuth2. O token de entrada é uma dica sobre o usuário ou a solicitação de autorização. O Azure AD B2C valida o token e, em seguida, extrai a declaração.

Para incluir uma dica de token de ID na solicitação de autenticação, faça o seguinte:

1. Conclua o procedimento de Cenários avançados de suporte.

2. Em sua política personalizada, defina um perfil técnico de dica de token de ID.

3. Adicione a seguinte linha de código à função OnRedirectToIdentityProvider:

   private async Task OnRedirectToIdentityProviderFunc(RedirectContext context)
   {
     // The idTokenHint variable holds your ID token 
     context.ProtocolMessage.IdTokenHint = idTokenHint
   
     // More code
     await Task.CompletedTask.ConfigureAwait(false);
   }
   

Controlador de conta

Se desejar personalizar as ações SignIn, SignUp ou SignOut, será recomendado criar seu próprio controlador. Ter seu próprio controlador permite que você passe parâmetros entre o controlador e a biblioteca de autenticação. AccountController é parte do pacote NuGet Microsoft.Identity.Web.UI, que lida com as ações de entrada e saída. Você pode encontrar sua implementação na biblioteca da Web do Microsoft Identity.

Adicionar o controlador de conta

No projeto do Visual Studio, clique com o botão direito do mouse na pasta Controladores e adicione um novo Controlador. Selecione MVC – Controlador Vazio e forneça o nome MyAccountController.cs.

O snippet de código a seguir demonstra um MyAccountController personalizado com a ação SignIn.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.OpenIdConnect;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;


namespace mywebapp.Controllers
{
    [AllowAnonymous]
    [Area("MicrosoftIdentity")]
    [Route("[area]/[controller]/[action]")]
    public class MyAccountController : Controller
    {

        [HttpGet("{scheme?}")]
        public IActionResult SignIn([FromRoute] string scheme)
        {
            scheme ??= OpenIdConnectDefaults.AuthenticationScheme;
            var redirectUrl = Url.Content("~/");
            var properties = new AuthenticationProperties { RedirectUri = redirectUrl };
            return Challenge(properties, scheme);
        }

    }
}

Na exibição _LoginPartial.cshtml, altere o link de entrada para o controlador.

<form method="get" asp-area="MicrosoftIdentity" asp-controller="MyAccount" asp-action="SignIn">

Passar a ID da política do Azure AD B2C

O snippet de código a seguir demonstra um MyAccountController personalizado com a ação SignIn e SignUp. A ação passa um parâmetro chamado policy para a biblioteca de autenticação. Isso permite que você forneça a ID de política correta do Azure AD B2C para a ação específica.

public IActionResult SignIn([FromRoute] string scheme)
{
    scheme ??= OpenIdConnectDefaults.AuthenticationScheme;
    var redirectUrl = Url.Content("~/");
    var properties = new AuthenticationProperties { RedirectUri = redirectUrl };
    properties.Items["policy"] = "B2C_1_SignIn";
    return Challenge(properties, scheme);
}

public IActionResult SignUp([FromRoute] string scheme)
{
    scheme ??= OpenIdConnectDefaults.AuthenticationScheme;
    var redirectUrl = Url.Content("~/");
    var properties = new AuthenticationProperties { RedirectUri = redirectUrl };
    properties.Items["policy"] = "B2C_1_SignUp";
    return Challenge(properties, scheme);
}

Na exibição _LoginPartial.cshtml, altere o valor asp-controller para MyAccountController para todos os outros links de autenticação, como edição de perfil ou inscrever-se.

Passar parâmetros personalizados

O snippet de código a seguir demonstra um MyAccountController personalizado com a ação SignIn. A ação passa um parâmetro chamado campaign_id para a biblioteca de autenticação.

public IActionResult SignIn([FromRoute] string scheme)
{
    scheme ??= OpenIdConnectDefaults.AuthenticationScheme;
    var redirectUrl = Url.Content("~/");
    var properties = new AuthenticationProperties { RedirectUri = redirectUrl };
    properties.Items["policy"] = "B2C_1_SignIn";
    properties.Items["campaign_id"] = "1234";
    return Challenge(properties, scheme);
}

Realize o procedimento em Cenários avançados de suporte e, em seguida, no método OnRedirectToIdentityProvider, leia o parâmetro personalizado:

private async Task OnRedirectToIdentityProviderFunc(RedirectContext context)
{
    // Read the custom parameter
    var campaign_id = context.Properties.Items.FirstOrDefault(x => x.Key == "campaign_id").Value;

    // Add your custom code here
    if (campaign_id != null)
    {
        // Send parameter to authentication request
        context.ProtocolMessage.SetParameter("campaign_id", campaign_id);
    }
    
    await Task.CompletedTask.ConfigureAwait(false);
}

Proteger seu redirecionamento de logout

Após o logout, o usuário é redirecionado para o URI especificado no post_logout_redirect_uri parâmetro, independentemente das URLs de resposta que foram especificadas para o aplicativo. No entanto, se um valor válido id_token_hint for passado e o token de ID necessário em solicitações de logout estiver ativado, o Azure AD B2C verificará se o valor de post_logout_redirect_uri corresponde a um dos URIs de redirecionamento configurados do aplicativo antes de executar o redirecionamento. Se nenhuma URL de resposta correspondente tiver sido configurada para o aplicativo, uma mensagem de erro será exibida e o usuário não será redirecionado.

Para dar suporte a um redirecionamento de logoff seguro no aplicativo, primeiro siga as etapas nas seções Controlador de conta e Cenários avançados de suporte. Em seguida, siga as etapas abaixo:

1. No controlador MyAccountController.cs, adicione uma ação SignOut usando o seguinte snippet de código:

   [HttpGet("{scheme?}")]
   public async Task<IActionResult> SignOutAsync([FromRoute] string scheme)
   {
       scheme ??= OpenIdConnectDefaults.AuthenticationScheme;
   
       //obtain the id_token
       var idToken = await HttpContext.GetTokenAsync("id_token");
       //send the id_token value to the authentication middleware
       properties.Items["id_token_hint"] = idToken;            
   
       return SignOut(properties,CookieAuthenticationDefaults.AuthenticationScheme,scheme);
   }
   

2. Na classe Startup.cs, , analise o valor id_token_hint e anexar o valor à solicitação de autenticação. O seguinte snippet de código demonstra como passar o valor id_token_hint para a solicitação de autenticação:

   private async Task OnRedirectToIdentityProviderForSignOutFunc(RedirectContext context)
   {
       var id_token_hint = context.Properties.Items.FirstOrDefault(x => x.Key == "id_token_hint").Value;
       if (id_token_hint != null)
       {
           // Send parameter to authentication request
           context.ProtocolMessage.SetParameter("id_token_hint", id_token_hint);
       }
   
       await Task.CompletedTask.ConfigureAwait(false);
   }
   

3. Na função ConfigureServices, adicione a opção SaveTokens para que os Controladores tenham acesso ao valor id_token:

   services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
       .AddMicrosoftIdentityWebApp(options =>
       {
           Configuration.Bind("AzureAdB2C", options);
           options.Events ??= new OpenIdConnectEvents();        
           options.Events.OnRedirectToIdentityProviderForSignOut += OnRedirectToIdentityProviderForSignOutFunc;
           options.SaveTokens = true;
       });
   

4. No arquivo de configuração appsettings.json, adicione o caminho de URI de redirecionamento de logoff para a chave SignedOutCallbackPath.

   "AzureAdB2C": {
     "Instance": "https://<your-tenant-name>.b2clogin.com",
     "ClientId": "<web-app-application-id>",
     "Domain": "<your-b2c-domain>",
     "SignedOutCallbackPath": "/signout/<your-sign-up-in-policy>",
     "SignUpSignInPolicyId": "<your-sign-up-in-policy>"
   }
   

No exemplo acima, o post_logout_redirect_uri passado na solicitação de logoff estará no formato: https://your-app.com/signout/<your-sign-up-in-policy>. Essa URL deve ser adicionada à URL de Resposta do Registro de Aplicativo.

Controle de acesso baseado em função

Com a autorização no ASP.NET Core, você pode verificar se os usuários estão autorizados a acessar um recurso protegido usando um dos seguintes métodos:

• Autorização baseada em função
• Autorização baseada em declarações
• Autorização baseada em política

No método ConfigureServices, adicione o método AddAuthorization, o que adiciona o modelo de autorização. O exemplo a seguir cria uma política chamada EmployeeOnly. A política verifica se existe uma declaração EmployeeNumber. O valor da declaração deve ser uma das seguintes IDs: 1, 2, 3, 4 ou 5.

services.AddAuthorization(options =>
    {
        options.AddPolicy("EmployeeOnly", policy =>
              policy.RequireClaim("EmployeeNumber", "1", "2", "3", "4", "5"));
    });

A autorização no ASP.NET Core é controlada com AuthorizeAttribute e seus vários parâmetros. Em sua forma mais básica, aplicar o atributo Authorize a um controlador, ação ou Página Razor limita o acesso aos usuários autenticados desse componente.

As políticas são aplicadas aos controladores usando o atributo Authorize com o nome da política. O seguinte código limita o acesso à ação Claims aos usuários autorizados pela política EmployeeOnly:

[Authorize(Policy = "EmployeeOnly")]
public IActionResult Claims()
{
    return View();
}

Próximas etapas

• Para saber mais sobre a autorização, confira Introdução à autorização no ASP.NET Core.