Criar um aplicativo Web ASP.NET com inscrição/entrada, edição de perfil e redefinição de senha do Azure Active Directory B2C

Este tutorial mostra como:

  • Adicionar recursos de identidade do Azure AD B2C ao seu aplicativo Web
  • Registrar seu aplicativo Web em seu diretório do Azure AD B2C
  • Criar inscrição/entrada, edição de perfil e política de redefinição de senha de usuário para o seu aplicativo Web

Pré-requisitos

  • Você deve conectar seu Locatário B2C a uma conta do Azure. Você pode criar uma conta gratuita do Azure aqui.
  • Você precisa do Microsoft Visual Studio ou um programa semelhante para exibir e modificar o código de exemplo.

Criar um diretório do AD B2C do Azure

Antes de usar AD B2C do Azure, você deve criar um diretório ou locatário. Um diretório é um contêiner para todos os seus usuários, aplicativos, grupos e muito mais. Se você ainda não tiver um, crie um diretório B2C antes de prosseguir neste guia.

Clique no botão Novo. No campo Pesquisar no Marketplace, insira Azure Active Directory B2C.

Botão Adicionar realçado, e o texto Azure Active Directory B2C na pesquisa no campo do marketplace

Na lista de resultados, selecione Azure Active Directory B2C.

Azure Active Directory B2C selecionado na lista de resultados

Alguns detalhes sobre o Azure Active Directory B2C são exibidos. Para começar a configurar seu novo locatário do Azure Active Directory B2C, clique no botão Criar.

Selecione Criar um novo Locatário Azure AD B2C. As configurações especificadas na tabela a seguir usam o nome da empresa Contoso como exemplo. Você precisará fornecer o nome da sua própria organização e um nome exclusivo de locatário ao criar o locatário.

Azure AD B2C cria locatário com texto de exemplo nos campos disponíveis

Configuração Valor de exemplo Descrição
Nome da organização Contoso Nome da organização.
Nome de domínio inicial ContosoB2CTenant Nome de domínio para o locatário B2C. Por padrão, o nome de domínio inicial inclui .onmicrosoft.com. Se você está criando um locatário de teste, escolha um nome que não remeta à produção, como ContosoB2CTesting.
País ou região Estados Unidos Escolha o país ou região para o diretório. O diretório será criado nesse local e não poderá ser alterado posteriormente.

Clique no botão Criar para criar seu locatário. A criação do locatário pode levar alguns minutos. Você receberá um alerta em suas notificações após a conclusão.

Observação

Você precisa se conectar ao Locatário B2C para sua assinatura do Azure. Depois de selecionar Criar, selecione a opção Associar um Locatário do Azure AD B2C existente à minha assinatura do Azure e, em seguida, na lista suspensa de Locatário do Azure AD B2C, selecione o locatário que você deseja associar.

Criar e registrar um aplicativo

Em seguida, você precisa criar e registrar um aplicativo em seu diretório B2C. Isso fornece ao Azure AD B2C as informações de que ele precisa para se comunicar de forma segura com seu aplicativo.

Nas configurações de B2C, clique em Aplicativos e depois em +Adicionar.

Botão + Adicionar em aplicativos

Para registrar sua API da Web, use as configurações especificadas na tabela.

Exemplo de configurações de registro para nova API Web

Configuração Valor de exemplo Descrição
Nome API B2C da Contoso Insira um Nome para o aplicativo que descreva sua API aos consumidores.
Incluir aplicativo Web/API Web Sim Selecione Sim para uma API Web.
Permitir fluxo implícito Sim Escolha Sim se o seu aplicativo usar Entrada do OpenID Connect
URL de Resposta https://localhost:44316/ As URLs de Resposta são pontos de extremidade para onde o Azure AD B2C retorna quaisquer tokens que seus aplicativo solicitarem. Insira uma URL de Resposta apropriada. Neste exemplo, a sua API Web é local e escuta na porta 44316.
URI da ID do Aplicativo api O URI da ID do Aplicativo é o identificador usado para sua API Web. O URI do identificador completo, incluindo o domínio, é gerado para você.

Clique em Criar para registrar seu aplicativo.

Seu aplicativo recém-registrado é exibido na lista de aplicativos para o locatário B2C. Selecione sua API Web na lista. O painel de propriedade da API é exibido.

Propriedades da API Web

Anote o identificador global exclusivo ID do Cliente do Aplicativo. Use a ID no código do seu aplicativo.

Importante

Não é possível usar aplicativos registrados na guia Aplicativos no Portal de Gerenciamento do Azure para fazer isso.

Quando você terminar, você terá uma API e um aplicativo nativo nas suas configurações de aplicativo.

Criar políticas em seu locatário B2C

No AD B2C do Azure, cada experiência do usuário é definida por uma política. Este exemplo de código contém três experiências de identidade: inscrição e entrada, edição de perfil e redefinição de senha. Você precisa criar uma política de cada tipo, conforme descrito no artigo de referência de política. Para cada política, certifique-se de selecionar a declaração ou atributo de Nome de exibição e copiar o nome da sua política para uso posterior.

Adicionar seus provedores de identidade

Nas configurações, selecione Provedores de Identidade e escolha Inscrição do nome de usuário ou Inscrição de email.

Criar uma política de inscrição e entrada

Para habilitar a entrada no aplicativo, você precisará criar uma política de entrada. Essa política descreve as experiências pelas quais os consumidores passarão durante a entrada e o conteúdo de tokens que o aplicativo receberá de entradas bem-sucedidas.

Selecione Azure AD B2C da lista de serviços no Portal do Azure.

Selecione o serviço B2C

Na seção de políticas das configurações, selecione Políticas de inscrição ou entrada e clique em + Adicionar.

Selecione as políticas de inscrição ou entrada e clique no botão Adicionar

Insira um Nome de política para referência de seu aplicativo. Por exemplo, insira: SiUpIn.

Selecione Provedores de identidade e marque Inscrição por email. Opcionalmente, você também pode selecionar provedores de identidade social, se já configurado. Clique em OK.

Selecione Inscrição por email como provedor de identidade e clique no botão OK

Selecione Atributos de inscrição. Escolha os atributos que você deseja coletar do consumidor durante a inscrição. Por exemplo, marque País/Região, Nome de Exibição e CEP. Clique em OK.

Selecione alguns atributos e clique no botão OK

Selecione Declarações do aplicativo. Escolha as declarações que você deseja retornar nos tokens de autorização enviados ao aplicativo após uma experiência de inscrição ou entrada bem-sucedida. Por exemplo, selecione Nome de Exibição, Provedor de Identidade, CEP, Novo Usuário e ID de Objeto do Usuário.

Selecione algumas declarações de aplicativo e clique no botão OK

Clique em Criar para adicionar a política. A política está listada como B2C_1_SiUpIn. O prefixo B2C_1_ está anexado ao nome.

Abra a política selecionando B2C_1_SiUpIn. Verifique as configurações especificadas na tabela e, depois, clique em Executar agora.

Selecione a política e execute-a

Configuração Valor
Aplicativos Aplicativo B2C da Contoso
Selecionar URL de resposta https://localhost:44316/

Uma nova guia do navegador é aberta e você poderá verificar a experiência de inscrição ou entrada do consumidor, conforme configurado.

Observação

Leva até um minuto para a criação de políticas e as atualizações entrem em vigor.

Criar uma política de edição de perfil

Para habilitar a edição de perfil no aplicativo, você precisará criar uma política de edição de perfil. Essa política descreve as experiências pelas quais os consumidores passarão durante a edição do perfil e o conteúdo de tokens que o aplicativo receberá na conclusão bem-sucedida.

Selecione Azure AD B2C da lista de serviços no Portal do Azure.

Selecione o serviço B2C

Na seção de políticas das configurações, selecione Políticas de edição de perfil e clique em + Adicionar.

Selecione as Políticas de edição de perfil e clique no botão Adicionar

Insira um Nome de política para referência de seu aplicativo. Por exemplo, insira: SiPe.

Clique em Provedores de identidade e marque Entrada na Conta Local. Opcionalmente, você também pode selecionar provedores de identidade social, se já configurado. Clique em OK.

Selecione Inscrição na Conta Local como provedor de identidade e clique no botão OK

Selecione Atributos do perfil. Escolha os atributos que o consumidor pode exibir e editar no perfil. Por exemplo, marque País/Região, Nome de Exibição e CEP. Clique em OK.

Selecione alguns atributos e clique no botão OK

Selecione Declarações do aplicativo. Escolha as declarações que você quer retornar nos tokens de autorização enviados ao aplicativo após uma experiência de edição de perfil bem-sucedida. Por exemplo, selecione Nome de Exibição e CEP.

Selecione algumas declarações de aplicativo e clique no botão OK

Clique em Criar para adicionar a política. A política está listada como B2C_1_SiPe. O prefixo B2C_1_ está anexado ao nome.

Abra a política selecionando B2C_1_SiPe. Verifique as configurações especificadas na tabela e, depois, clique em Executar agora.

Selecione a política e execute-a

Configuração Valor
Aplicativos Aplicativo B2C da Contoso
Selecionar URL de resposta https://localhost:44316/

Uma nova guia do navegador é aberta e você poderá verificar a experiência de edição de perfil do consumidor, conforme configurado.

Observação

Leva até um minuto para a criação de políticas e as atualizações entrem em vigor.

Criar uma política de redefinição de senha

Para habilitar a redefinição de senha refinada, você precisará criar uma política de redefinição de senha. Observe que a opção de redefinição de senha para todo o locatário é especificada aqui. Essa política descreve as experiências pelas quais os consumidores passarão durante a redefinição da senha e o conteúdo de tokens que o aplicativo receberá na conclusão bem-sucedida.

Selecione Azure AD B2C da lista de serviços no Portal do Azure.

Selecione o serviço B2C

Na seção de políticas das configurações, selecione Políticas de redefinição de senha e clique em + Adicionar.

Selecione as políticas de inscrição ou entrada e clique no botão Adicionar

Insira um Nome de política para referência de seu aplicativo. Por exemplo, insira: SSPR.

Selecione Provedores de identidade e marque Redefinir senha usando endereço de email. Clique em OK.

Selecione Redefinir senha usando endereço de email como provedor de identidade e clique no botão OK

Selecione Declarações do aplicativo. Escolha as declarações que você quer retornar nos tokens de autorização enviados ao seu aplicativo após uma experiência de redefinição de senha bem-sucedida. Por exemplo, selecione ID de Objeto do Usuário.

Selecione algumas declarações de aplicativo e clique no botão OK

Clique em Criar para adicionar a política. A política está listada como B2C_1_SSPR. O prefixo B2C_1_ está anexado ao nome.

Abra a política selecionando B2C_1_SSPR. Verifique as configurações especificadas na tabela e, depois, clique em Executar agora.

Selecione a política e execute-a

Configuração Valor
Aplicativos Aplicativo B2C da Contoso
Selecionar URL de resposta https://localhost:44316/

Uma nova guia do navegador é aberta e você pode verificar a experiência de redefinição de senha do consumidor em seu aplicativo.

Observação

Leva até um minuto para a criação de políticas e as atualizações entrem em vigor.

Depois de criar as políticas, você estará pronto para compilar o aplicativo.

Baixe o código de exemplo

O código para este tutorial é mantido no GitHub. Você pode clonar a amostra executando:

git clone https://github.com/Azure-Samples/active-directory-b2c-dotnet-webapp-and-webapi.git

Depois de baixar o código de exemplo, abra o arquivo .sln do Visual Studio para começar. Agora, sua solução contém dois projetos: TaskWebApp e TaskService. TaskWebApp é o aplicativo Web MVC com o qual o usuário interage. TaskService é API Web back-end do aplicativo que armazena a lista de tarefas de cada usuário. Este artigo discutirá apenas o aplicativo TaskWebApp. Para saber como criar TaskService usando o Azure AD B2C, confira nosso tutorial da API Web .NET.

Atualizar o código para usar as suas políticas e locatário

Nossa amostra é configurada para usar as políticas e a ID do cliente de nosso locatário de demonstração. Para conectar-se ao seu próprio locatário, você precisa abrir web.config no projeto TaskWebApp e substituir os valores a seguir:

  • ida:Tenant pelo nome do locatário
  • ida:ClientId pela ID de aplicativo do aplicativo Web
  • ida:ClientSecret pela chave de segredo do aplicativo Web
  • ida:SignUpSignInPolicyId pelo nome da política "Inscrever-se ou Entrar"
  • ida:EditProfilePolicyId pelo nome de política "Editar Perfil"
  • ida:ResetPasswordPolicyId pelo nome de política "Redefinir Senha"

Iniciar o aplicativo

No Visual Studio, inicie o aplicativo. Navegue até a guia Lista de tarefas e observe que o URl é: https://login.microsoftonline.com/*YourTenantName*/oauth2/v2.0/authorize?p=*YourSignUpPolicyName*&client_id=*YourclientID*.....

Inscreva-se no aplicativo usando o seu endereço de email ou nome de usuário. Saia, em seguida, entre novamente e edite o perfil ou redefina a senha. Saia e entre como outro usuário.

Adicionar IDPs sociais

Atualmente, o aplicativo suporta inscrição e entrada usando apenas contas locais; contas armazenadas no seu diretório do B2C que usam um nome de usuário e senha. Com o Azure AD B2C, você pode adicionar suporte a outros provedores de identidade (IDPs), sem alterar qualquer código.

Para adicionar IDPs sociais ao seu aplicativo, comece seguindo as instruções detalhadas nestes artigos. Para cada IDP ao qual deseja oferecer suporte, você precisa registrar um aplicativo no sistema e obter uma ID de cliente.

Após adicionar provedores de identidade ao seu diretório de B2C, edite cada uma das suas três políticas para incluir os novos IDPs, como descrito no artigo de referência de política. Depois de salvar as políticas, execute o aplicativo novamente. Você deve ver os novos IDPs adicionados como opções de entrada e de inscrição em cada experiência de identidade.

Você pode fazer experiências com suas políticas e observar o efeito no exemplo de aplicativo. Adicione ou remova IDPs, manipule declarações de aplicativo ou altere os atributos de inscrição. Experimente até começar a entender como as políticas, solicitações de autenticação e OWIN funcionam juntos.

Passo a passo do código de exemplo

As seções a seguir mostram como o código do aplicativo de exemplo está configurado. Você pode usar isso como um guia no desenvolvimento do seu futuro aplicativo.

Adicionar suporte a autenticação

Agora você pode configurar seu aplicativo para usar o Azure AD B2C. Seu aplicativo se comunica com o Azure AD B2C ao enviar solicitações de autenticação OpenID Connect. As solicitações determinam a experiência do usuário que o aplicativo deseja executar especificando a política. Você pode usar a biblioteca OWIN da Microsoft para enviar essas solicitações, executar políticas, gerenciar sessões do usuário e assim por diante.

Instalar a OWIN

Para começar, adicione os pacotes do NuGet de middleware do OWIN ao projeto usando o Console do Gerenciador de Pacotes do Visual Studio.

PM> Install-Package Microsoft.Owin.Security.OpenIdConnect
PM> Install-Package Microsoft.Owin.Security.Cookies
PM> Install-Package Microsoft.Owin.Host.SystemWeb

Adicionar uma classe de inicialização da OWIN

Adicione uma classe de inicialização OWIN para a API chamada Startup.cs. Clique com o botão direito do mouse no projeto, selecione Adicionar e Novo Item e pesquise OWIN. O middleware OWIN invocará o método Configuration(…) quando seu aplicativo for iniciado.

Em nossa amostra, alteramos a declaração de classe para public partial class Startup e implementamos a outra parte da classe em App_Start\Startup.Auth.cs. No método Configuration, adicionamos uma chamada para ConfigureAuth, que é definida em Startup.Auth.cs. Após as modificações, Startup.cs é semelhante ao seguinte:

// Startup.cs

public partial class Startup
{
    // The OWIN middleware will invoke this method when the app starts
    public void Configuration(IAppBuilder app)
    {
        // ConfigureAuth defined in other part of the class
        ConfigureAuth(app);
    }
}

Configurar do middleware de autenticação

Abra o arquivo App_Start\Startup.Auth.cs e implemente o método ConfigureAuth(...). Os parâmetros que você fornece em OpenIdConnectAuthenticationOptions servem como coordenadas para seu aplicativo se comunicar com o Azure AD B2C. Se você não especificar certos parâmetros, ele usará o valor padrão. Por exemplo, não especificamos o ResponseType na amostra, então o valor padrão code id_token será usado em cada solicitação de saída para o Azure AD B2C.

Você também precisa configurar a autenticação de cookie. O middleware OpenID Connect usa cookies para manter as sessões de usuário, entre outras coisas.

// App_Start\Startup.Auth.cs

public partial class Startup
{
    // Initialize variables ...

    // Configure the OWIN middleware
    public void ConfigureAuth(IAppBuilder app)
    {
        app.UseCookieAuthentication(new CookieAuthenticationOptions());
        app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);

        app.UseOpenIdConnectAuthentication(
            new OpenIdConnectAuthenticationOptions
            {
                // Generate the metadata address using the tenant and policy information
                MetadataAddress = String.Format(AadInstance, Tenant, DefaultPolicy),

                // These are standard OpenID Connect parameters, with values pulled from web.config
                ClientId = ClientId,
                RedirectUri = RedirectUri,
                PostLogoutRedirectUri = RedirectUri,

                // Specify the callbacks for each type of notifications
                Notifications = new OpenIdConnectAuthenticationNotifications
                {
                    RedirectToIdentityProvider = OnRedirectToIdentityProvider,
                    AuthorizationCodeReceived = OnAuthorizationCodeReceived,
                    AuthenticationFailed = OnAuthenticationFailed,
                },

                // Specify the claims to validate
                TokenValidationParameters = new TokenValidationParameters
                {
                    NameClaimType = "name"
                },

                // Specify the scope by appending all of the scopes requested into one string (seperated by a blank space)
                Scope = $"{OpenIdConnectScopes.OpenId} {ReadTasksScope} {WriteTasksScope}"
            }
        );
    }

    // Implement the "Notification" methods...
}

Em OpenIdConnectAuthenticationOptions acima, definimos um conjunto de funções de retorno de chamada para notificações específicas que são recebidas pelo middleware OpenID Connect. Esses comportamentos são definidos usando um objeto OpenIdConnectAuthenticationNotifications e armazenados na variável Notifications. Em nossa amostra, podemos definir três retornos de chamada diferentes dependendo do evento.

Usando políticas diferentes

A notificação RedirectToIdentityProvider é disparada sempre que uma solicitação é feita ao Azure AD B2C. Na função de retorno de chamada OnRedirectToIdentityProvider, verificamos na chamada de saída se desejamos usar uma política diferente. Para fazer uma redefinição de senha ou editar um perfil, você precisa usar a política correspondente, assim como a política de redefinição de senha, em vez da política padrão de "Inscrever-se ou Entrar".

Em nossa amostra, quando um usuário deseja redefinir a senha ou editar o perfil, adicionamos a política que preferimos usar no contexto do OWIN. Isso pode ser feito fazendo o seguinte:

    // Let the middleware know you are trying to use the edit profile policy
    HttpContext.GetOwinContext().Set("Policy", EditProfilePolicyId);

Você também pode implementar a função de retorno de chamada OnRedirectToIdentityProvider fazendo o seguinte:

/*
*  On each call to Azure AD B2C, check if a policy (e.g. the profile edit or password reset policy) has been specified in the OWIN context.
*  If so, use that policy when making the call. Also, don't request a code (since it won't be needed).
*/
private Task OnRedirectToIdentityProvider(RedirectToIdentityProviderNotification<OpenIdConnectMessage, OpenIdConnectAuthenticationOptions> notification)
{
    var policy = notification.OwinContext.Get<string>("Policy");

    if (!string.IsNullOrEmpty(policy) && !policy.Equals(DefaultPolicy))
    {
        notification.ProtocolMessage.Scope = OpenIdConnectScopes.OpenId;
        notification.ProtocolMessage.ResponseType = OpenIdConnectResponseTypes.IdToken;
        notification.ProtocolMessage.IssuerAddress = notification.ProtocolMessage.IssuerAddress.Replace(DefaultPolicy, policy);
    }

    return Task.FromResult(0);
}

Manipulando códigos de autorização

A notificação AuthorizationCodeReceived é disparada quando um código de autorização é recebido. O middleware OpenID Connect não dá suporte à permutação de códigos por tokens de acesso. Você pode permutar manualmente o código pelo token em uma função de retorno de chamada. Para obter mais informações, examine a documentação que explica como fazê-lo.

Tratamento de erros

A notificação AuthenticationFailed é disparada quando a autenticação falha. Em seu método de retorno de chamada, você pode tratar os erros como desejar. No entanto, você deve adicionar uma verificação para o código de erro AADB2C90118. Durante a execução da política "Inscrever-se ou Entrar", o usuário tem a oportunidade de selecionar o link Esqueceu sua senha?. Nesse caso, o Azure AD B2C envia esse código de erro para o seu aplicativo indicando que seu aplicativo faça uma solicitação usando a política de redefinição de senha em vez disso.

/*
* Catch any failures received by the authentication middleware and handle appropriately
*/
private Task OnAuthenticationFailed(AuthenticationFailedNotification<OpenIdConnectMessage, OpenIdConnectAuthenticationOptions> notification)
{
    notification.HandleResponse();

    // Handle the error code that Azure AD B2C throws when trying to reset a password from the login page
    // because password reset is not supported by a "sign-up or sign-in policy"
    if (notification.ProtocolMessage.ErrorDescription != null && notification.ProtocolMessage.ErrorDescription.Contains("AADB2C90118"))
    {
        // If the user clicked the reset password link, redirect to the reset password route
        notification.Response.Redirect("/Account/ResetPassword");
    }
    else if (notification.Exception.Message == "access_denied")
    {
        notification.Response.Redirect("/");
    }
    else
    {
        notification.Response.Redirect("/Home/Error?message=" + notification.Exception.Message);
    }

    return Task.FromResult(0);
}

Enviar solicitações de autenticação ao AD do Azure

Seu aplicativo agora está configurado corretamente para se comunicar com o AD B2C do Azure usando o protocolo de autenticação OpenID Connect. O OWIN gerencia todos os detalhes da criação de mensagens de autenticação, validação de tokens do Azure AD B2C e manutenção da sessão do usuário. Tudo o que resta é iniciar o fluxo de cada usuário.

Quando um usuário escolhe Inscrever-se/Entrar, Editar perfil ou Redefinir senha no aplicativo Web, a ação associada é invocada em Controllers\AccountController.cs:

// Controllers\AccountController.cs

/*
*  Called when requesting to sign up or sign in
*/
public void SignUpSignIn()
{
    // Use the default policy to process the sign up / sign in flow
    if (!Request.IsAuthenticated)
    {
        HttpContext.GetOwinContext().Authentication.Challenge();
        return;
    }

    Response.Redirect("/");
}

/*
*  Called when requesting to edit a profile
*/
public void EditProfile()
{
    if (Request.IsAuthenticated)
    {
        // Let the middleware know you are trying to use the edit profile policy (see OnRedirectToIdentityProvider in Startup.Auth.cs)
        HttpContext.GetOwinContext().Set("Policy", Startup.EditProfilePolicyId);

        // Set the page to redirect to after editing the profile
        var authenticationProperties = new AuthenticationProperties { RedirectUri = "/" };
        HttpContext.GetOwinContext().Authentication.Challenge(authenticationProperties);

        return;
    }

    Response.Redirect("/");

}

/*
*  Called when requesting to reset a password
*/
public void ResetPassword()
{
    // Let the middleware know you are trying to use the reset password policy (see OnRedirectToIdentityProvider in Startup.Auth.cs)
    HttpContext.GetOwinContext().Set("Policy", Startup.ResetPasswordPolicyId);

    // Set the page to redirect to after changing passwords
    var authenticationProperties = new AuthenticationProperties { RedirectUri = "/" };
    HttpContext.GetOwinContext().Authentication.Challenge(authenticationProperties);

    return;
}

Você também pode usar OWIN para desconectar o usuário do aplicativo. Em Controllers\AccountController.cs, temos:

// Controllers\AccountController.cs

/*
*  Called when requesting to sign out
*/
public void SignOut()
{
    // To sign out the user, you should issue an OpenIDConnect sign out request.
    if (Request.IsAuthenticated)
    {
        IEnumerable<AuthenticationDescription> authTypes = HttpContext.GetOwinContext().Authentication.GetAuthenticationTypes();
        HttpContext.GetOwinContext().Authentication.SignOut(authTypes.Select(t => t.AuthenticationType).ToArray());
        Request.GetOwinContext().Authentication.GetAuthenticationTypes();
    }
}

Além de chamar explicitamente uma política, você pode usar uma marca [Authorize] em seus controladores que executa uma política se o usuário não estiver conectado. Abra Controllers\HomeController.cs e adicione a marca [Authorize] ao controlador de declarações. O OWIN seleciona a última política configurada quando a marca [Authorize] for atingida.

// Controllers\HomeController.cs

// You can use the Authorize decorator to execute a certain policy if the user is not already signed into the app.
[Authorize]
public ActionResult Claims()
{
  ...

Exibir informações do usuário

Ao autenticar usuários com o OpenID Connect, o Azure AD B2C retorna um token de ID para o aplicativo que contém declarações. Esses são declarações sobre o usuário. Você pode usar as declarações para personalizar o aplicativo.

Abra o arquivo Controllers\HomeController.cs . Você pode acessar as declarações do usuário em seus controladores por meio do objeto principal de segurança ClaimsPrincipal.Current .

// Controllers\HomeController.cs

[Authorize]
public ActionResult Claims()
{
    Claim displayName = ClaimsPrincipal.Current.FindFirst(ClaimsPrincipal.Current.Identities.First().NameClaimType);
    ViewBag.DisplayName = displayName != null ? displayName.Value : string.Empty;
    return View();
}

Você pode acessar qualquer declaração de que seu aplicativo recebe da mesma maneira. Confira na página Declarações uma lista de todas as declarações recebidas pelo aplicativo.