Habilitar a entrada para aplicativos Java WebSphere usando MSAL4J com o Azure Ative Directory B2C

Este artigo demonstra um aplicativo Java Servlet que autentica usuários no Azure Ative Directory B2C (Azure AD B2C) usando a Biblioteca de Autenticação da Microsoft para Java (MSAL4J).

O diagrama a seguir mostra a topologia do aplicativo:

O aplicativo usa MSAL4J para entrar em usuários e obter um token de ID do Azure AD B2C. O token de ID prova que o usuário está autenticado em um locatário do Azure AD B2C.

Pré-requisitos

• JDK versão 8 ou superior
• Maven 3
• Um locatário do Azure AD B2C. Para obter mais informações, consulte Tutorial: Criar um locatário B2C do Azure Ative Directory
• Uma conta de usuário em seu locatário do Azure AD B2C.

• WebSphere
• Visual Studio Code
• Ferramentas do Azure para Visual Studio Code

Recomendações

• Alguma familiaridade com os servlets Java / Jacarta.
• Alguma familiaridade com o terminal Linux/OSX.
• jwt.ms para inspecionar seus tokens.
• Fiddler para monitorizar a sua atividade de rede e resolução de problemas.
• Siga o Blog do Microsoft Entra ID para ficar atualizado com os últimos desenvolvimentos.

Configurar o exemplo

As seções a seguir mostram como configurar o aplicativo de exemplo.

Clone ou faça download do repositório de exemplo

Para clonar o exemplo, abra uma janela Bash e use o seguinte comando:

git clone https://github.com/Azure-Samples/ms-identity-msal-java-samples.git
cd 3-java-servlet-web-app/1-Authentication/sign-in-b2c

Como alternativa, navegue até o repositório ms-identity-msal-java-samples , faça o download como um arquivo .zip e extraia-o para o disco rígido.

Registrar o aplicativo de exemplo com seu locatário do Azure AD B2C

A amostra vem com um aplicativo pré-registrado para fins de teste. Se você quiser usar seu próprio locatário e aplicativo do Azure AD B2C, siga as etapas nas seções a seguir para registrar e configurar o aplicativo no portal do Azure. Caso contrário, continue com as etapas para Executar o exemplo.

Escolha o locatário do Azure AD B2C onde você deseja criar seus aplicativos

Para escolher seu locatário, use as seguintes etapas:

1. Inicie sessão no portal do Azure.

2. Se sua conta estiver presente em mais de um locatário do Azure AD B2C, selecione seu perfil no canto do portal do Azure e selecione Alternar diretório para alterar sua sessão para o locatário desejado do Azure AD B2C.

Criar fluxos de usuário e políticas personalizadas

Para criar fluxos de usuário comuns, como inscrição, entrada, edição de perfil e redefinição de senha, consulte Tutorial: Criar fluxos de usuário no Azure Ative Directory B2C.

Você também deve considerar a criação de políticas personalizadas no Azure Ative Directory B2C , no entanto, isso está além do escopo deste tutorial.

Adicionar provedores de identidade externos

Consulte Tutorial: Adicionar provedores de identidade aos seus aplicativos no Azure Ative Directory B2C.

Registrar o aplicativo (ms-identity-b2c-java-servlet-webapp-authentication)

Para registrar o aplicativo, use as seguintes etapas:

1. Navegue até o portal do Azure e selecione Azure AD B2C.

2. Selecione Registos de Aplicações no painel de navegação e, em seguida, selecione Novo registo.

3. Na página Registrar um aplicativo que aparece, insira as seguintes informações de registro do aplicativo:

   • Na seção Nome, insira um nome de aplicativo significativo para exibição aos usuários do aplicativo - por exemplo, ms-identity-b2c-java-servlet-webapp-authentication.
   • Em Tipos de conta suportados, selecione Contas em qualquer diretório organizacional e contas pessoais da Microsoft (por exemplo, Skype, Xbox, Outlook.com).
   • Na seção Redirecionar URI (opcional), selecione Web na caixa de combinação e digite o seguinte URI de redirecionamento: http://localhost:8080/ms-identity-b2c-java-servlet-webapp-authentication/auth_redirect.

4. Selecione Registar para criar a aplicação.

5. Na página de registro do aplicativo, localize e copie o valor da ID do aplicativo (cliente) para usar mais tarde. Você usa esse valor no(s) arquivo(s) de configuração do seu aplicativo.

6. Selecione Guardar para guardar as alterações.

7. Na página de registo da aplicação, selecione Certificados & segredos no painel de navegação para abrir a página onde pode gerar segredos e carregar certificados.

8. Na seção Segredos do cliente, selecione Novo segredo do cliente.

9. Digite uma descrição - por exemplo, segredo do aplicativo.

10. Selecione uma das durações disponíveis: Em 1 ano, Em 2 anos ou Nunca expira.

11. Selecione Adicionar. O valor gerado é exibido.

12. Copie e salve o valor gerado para uso em etapas posteriores. Você precisa desse valor para os arquivos de configuração do seu código. Esse valor não é exibido novamente e você não pode recuperá-lo por nenhum outro meio. Portanto, certifique-se de salvá-lo do portal do Azure antes de navegar para qualquer outra tela ou painel.

Configure o aplicativo (ms-identity-b2c-java-servlet-webapp-authentication) para usar o registro do aplicativo

Use as seguintes etapas para configurar o aplicativo:

1. Abra o projeto no seu IDE.

2. Abra o arquivo ./src/main/resources/authentication.properties .

3. Localize a aad.clientId propriedade e substitua o valor existente pela ID do aplicativo ou clientId do ms-identity-b2c-java-servlet-webapp-authentication aplicativo no portal do Azure.

4. Localize a aad.secret propriedade e substitua o valor existente pelo valor que você salvou durante a ms-identity-b2c-java-servlet-webapp-authentication criação do aplicativo no portal do Azure.

5. Localize a aad.scopes propriedade e substitua o clientId do aplicativo existente pelo valor que aad.clientId você colocou na etapa 1 desta seção.

6. Localize a aad.authority propriedade e substitua a primeira instância de fabrikamb2c pelo nome do locatário do Azure AD B2C no qual você criou o ms-identity-b2c-java-servlet-webapp-authentication aplicativo no portal do Azure.

7. Localize a aad.authority propriedade e substitua a segunda instância de fabrikamb2c pelo nome do locatário do Azure AD B2C no qual você criou o ms-identity-b2c-java-servlet-webapp-authentication aplicativo no portal do Azure.

8. Localize a aad.signInPolicy propriedade e substitua-a pelo nome da política de fluxo de usuário de inscrição/entrada que você criou no locatário do Azure AD B2C no qual você criou o ms-identity-b2c-java-servlet-webapp-authentication aplicativo no portal do Azure.

9. Localize a aad.passwordResetPolicy propriedade e substitua-a pelo nome da política de fluxo de usuário de redefinição de senha que você criou no locatário do Azure AD B2C no qual você criou o ms-identity-b2c-java-servlet-webapp-authentication aplicativo no portal do Azure.

10. Localize a aad.editProfilePolicy propriedade e substitua-a pelo nome da política de fluxo de usuário de perfil de edição que você criou no locatário do Azure AD B2C no qual você criou o ms-identity-b2c-java-servlet-webapp-authentication aplicativo no portal do Azure.

Criar o exemplo

Para criar o exemplo usando o Maven, navegue até o diretório que contém o arquivo pom.xml para o exemplo e execute o seguinte comando:

mvn clean package

Este comando gera um arquivo .war que você pode executar em vários servidores de aplicativos.

Executar o exemplo

Estas instruções pressupõem que você instalou o WebSphere e configurou um servidor. É possível usar a orientação em Implementar o WebSphere Application Server (tradicional) Cluster em Máquinas Virtuais do Azure para uma configuração básica do servidor.

Antes de implantar no WebSphere, use as seguintes etapas para fazer algumas alterações de configuração no próprio exemplo e, em seguida, compilar ou reconstruir o pacote:

1. Navegue até o arquivo authentication.properties do seu aplicativo e altere o valor de para a URL do servidor e o número da app.homePage porta que você está planejando usar, conforme mostrado no exemplo a seguir:

   # app.homePage is by default set to dev server address and app context path on the server
   # for apps deployed to azure, use https://your-sub-domain.azurewebsites.net
   app.homePage=https://<server-url>:<port-number>/msal4j-servlet-auth/
   

2. Depois de salvar esse arquivo, use o seguinte comando para reconstruir seu aplicativo:

   mvn clean package
   

3. Depois que o código terminar de construir, copie o arquivo .war para o sistema de arquivos do servidor de destino.

Você também precisa fazer a mesma alteração no registro do aplicativo do Azure, onde você o define no portal do Azure como o valor de URI de redirecionamento na guia Autenticação.

1. Navegue até a página Registros de aplicativos da plataforma de identidade da Microsoft para desenvolvedores.

2. Use a caixa de pesquisa para pesquisar o registro do seu aplicativo - por exemplo, java-servlet-webapp-authentication.

3. Abra o registro do aplicativo selecionando seu nome.

4. Selecione Autenticação a partir do menu.

5. Na seção URIs de redirecionamento da Web - , selecione Adicionar URI.

6. Preencha o URI do seu aplicativo, anexando /auth/redirect - por exemplo, https://<server-url>:<port-number>/auth/redirect.

7. Selecione Guardar.

Use as seguintes etapas para implantar o exemplo usando o Console de Soluções Integradas do WebSphere:

1. Na guia Aplicativos, selecione Novo Aplicativo e, em seguida, Novo Aplicativo Empresarial.

2. Escolha o arquivo .war que você criou e, em seguida, selecione Avançar até chegar à etapa Mapear raízes de contexto para instalação de módulos da Web. As outras configurações padrão devem ser boas.

3. Para a raiz de contexto, defina-a com o mesmo valor que após o número da porta no 'URI de redirecionamento' definido na configuração de exemplo/registro do aplicativo do Azure. Ou seja, se o URI de redirecionamento for http://<server-url>:9080/msal4j-servlet-auth/, então a raiz de contexto deve ser msal4j-servlet-auth.

4. Selecione Concluir.

5. Depois que o aplicativo concluir a instalação, vá para a seção WebSphere enterprise applications da guia Aplicativos .

6. Selecione o arquivo .war que você instalou na lista de aplicativos e, em seguida, selecione Iniciar para implantar.

7. Depois que a implantação terminar, navegue até http://<server-url>:9080/{whatever you set as the context root} e você poderá ver o aplicativo.

Explorar o exemplo

Use as seguintes etapas para explorar o exemplo:

1. Observe o status de entrada ou saída exibido no centro da tela.
2. Selecione o botão sensível ao contexto no canto. Este botão lê Iniciar sessão quando executa a aplicação pela primeira vez.
3. Na página seguinte, siga as instruções e inicie sessão com uma conta do fornecedor de identidade escolhido.
4. Observe que o botão sensível ao contexto agora diz Sair e exibe seu nome de usuário.
5. Selecione Detalhes do token de ID para ver algumas das declarações decodificadas do token de ID.
6. Você também tem a opção de editar seu perfil. Selecione o link para editar detalhes como seu nome para exibição, local de residência e profissão.
7. Use o botão no canto para sair.
8. Depois de sair, navegue até o seguinte URL para a página de detalhes do token: http://localhost:8080/ms-identity-b2c-java-servlet-webapp-authentication/auth_token_details. Aqui, você pode observar como o aplicativo exibe um 401: unauthorized erro em vez das declarações de token de ID.

Sobre o código

Este exemplo demonstra como usar o MSAL4J para entrar usuários em seu locatário do Azure AD B2C.

Conteúdos

A tabela a seguir mostra o conteúdo da pasta de projeto de exemplo:

ConfidentialClientApplication

Uma ConfidentialClientApplication instância é criada no arquivo AuthHelper.java , conforme mostrado no exemplo a seguir. Este objeto ajuda a criar a URL de autorização do Azure AD B2C e também ajuda a trocar o token de autenticação por um token de acesso.

IClientSecret secret = ClientCredentialFactory.createFromSecret(SECRET);
confClientInstance = ConfidentialClientApplication
                     .builder(CLIENT_ID, secret)
                     .b2cAuthority(AUTHORITY + policy)
                     .build();

Os seguintes parâmetros são usados para instanciação:

• A ID do cliente do aplicativo.
• O segredo do cliente, que é um requisito para Aplicativos Clientes Confidenciais.
• A Autoridade B2C do Azure AD concatenada com a apropriada UserFlowPolicy para inscrição, entrada, edição de perfil ou redefinição de senha.

Neste exemplo, esses valores são lidos do arquivo authentication.properties usando um leitor de propriedades no arquivo Config.java .

Passo a passo

As etapas a seguir fornecem um passo a passo da funcionalidade do aplicativo:

1. A primeira etapa do processo de entrada é enviar uma solicitação ao ponto de extremidade para seu /authorize locatário B2C do Azure Ative Directory. A instância MSAL4J ConfidentialClientApplication é usada para construir uma URL de solicitação de autorização e o aplicativo redireciona o navegador para essa URL, conforme mostrado no exemplo a seguir:

   final ConfidentialClientApplication client = getConfidentialClientInstance(policy);
   final AuthorizationRequestUrlParameters parameters = AuthorizationRequestUrlParameters
       .builder(REDIRECT_URI, Collections.singleton(SCOPES)).responseMode(ResponseMode.QUERY)
       .prompt(Prompt.SELECT_ACCOUNT).state(state).nonce(nonce).build();
   
   final String redirectUrl = client.getAuthorizationRequestUrl(parameters).toString();
   Config.logger.log(Level.INFO, "Redirecting user to {0}", redirectUrl);
   resp.setStatus(302);
   resp.sendRedirect(redirectUrl);
   

   A lista a seguir descreve os recursos desse código:

   • AuthorizationRequestUrlParameters: Parâmetros que devem ser definidos para criar um AuthorizationRequestUrl.

   • REDIRECT_URI: Onde o Azure AD B2C redireciona o navegador - junto com o código de autenticação - depois de coletar as credenciais do usuário.

   • SCOPES: Escopos são permissões solicitadas pelo aplicativo.

     Normalmente, os três escopos seriam suficientes para receber uma resposta de token de openid profile offline_access ID. No entanto, o MSAL4J requer que todas as respostas do Azure AD B2C também contenham um token de acesso.

     Para que o Azure AD B2C dispense um token de acesso, bem como um token de ID, a solicitação deve incluir um escopo de recurso adicional. Como esse aplicativo não requer um escopo de recurso externo, ele adiciona sua própria ID de cliente como um quarto escopo para receber um token de acesso.

     Você pode encontrar uma lista completa de escopos solicitados pelo aplicativo no arquivo authentication.properties .

   • ResponseMode.QUERY: O Azure AD B2C pode retornar a resposta como parâmetros de formulário em uma solicitação HTTP POST ou como parâmetros de cadeia de caracteres de consulta em uma solicitação HTTP GET.

   • Prompt.SELECT_ACCOUNT: o Azure AD B2C deve pedir ao usuário para selecionar a conta na qual pretende autenticar.

   • state: Uma variável exclusiva definida pelo aplicativo na sessão em cada solicitação de token e destruída após receber o retorno de chamada de redirecionamento do Azure AD B2C correspondente. A variável de estado garante que as solicitações do Azure AD B2C para o /auth_redirect endpoint sejam realmente de solicitações de autorização do Azure AD B2C originadas deste aplicativo e desta sessão, evitando assim ataques CSRF. Isso é feito no arquivo AADRedirectServlet.java .

   • nonce: Uma variável exclusiva definida pelo aplicativo na sessão em cada solicitação de token e destruída após receber o token correspondente. Esse nonce é transcrito para os tokens resultantes dispensados do Azure AD B2C, garantindo assim que não ocorra nenhum ataque de repetição de token.

2. O usuário recebe um prompt de entrada do Azure Ative Directory B2C. Se a tentativa de entrada for bem-sucedida, o navegador do usuário será redirecionado para o ponto de extremidade de redirecionamento do aplicativo. Uma solicitação válida para este ponto de extremidade contém um código de autorização.

3. Em ConfidentialClientApplication seguida, a instância troca esse código de autorização por um token de ID e token de acesso do Azure Ative Directory B2C, conforme mostrado no exemplo a seguir:

   final AuthorizationCodeParameters authParams = AuthorizationCodeParameters
                       .builder(authCode, new URI(REDIRECT_URI))
                       .scopes(Collections.singleton(SCOPES)).build();
   
   final ConfidentialClientApplication client = AuthHelper
           .getConfidentialClientInstance(policy);
   final Future<IAuthenticationResult> future = client.acquireToken(authParams);
   final IAuthenticationResult result = future.get();
   

   A lista a seguir descreve os recursos desse código:

   • AuthorizationCodeParameters: Parâmetros que devem ser definidos para trocar o Código de Autorização por um ID e/ou token de acesso.
   • authCode: O código de autorização que foi recebido no ponto de extremidade de redirecionamento.
   • REDIRECT_URI: O URI de redirecionamento usado na etapa anterior deve ser passado novamente.
   • SCOPES: Os escopos usados na etapa anterior devem ser passados novamente.

4. Se acquireToken for bem-sucedida, as declarações de token são extraídas e a declaração nonce é validada em relação ao nonce armazenado na sessão, conforme mostrado no exemplo a seguir:

   parseJWTClaimsSetAndStoreResultInSession(msalAuth, result, serializedTokenCache);
   validateNonce(msalAuth)
   processSuccessfulAuthentication(msalAuth);
   

5. Se o nonce for validado com êxito, o status de autenticação será colocado em uma sessão do lado do servidor, aproveitando os MsalAuthSession métodos expostos pela classe, conforme mostrado no exemplo a seguir:

   msalAuth.setAuthenticated(true);
   msalAuth.setUsername(msalAuth.getIdTokenClaims().get("name"));
   

Mais informações

• O que é o Azure Active Directory B2C?
• Tipos de aplicativos que podem ser usados no Ative Directory B2C
• Recomendações e melhores práticas para o Azure Active Directory B2C
• Sessão do Azure AD B2C
• Biblioteca de Autenticação da Microsoft (MSAL) para Java

Para obter mais informações sobre como os protocolos OAuth 2.0 funcionam neste cenário e em outros cenários, consulte Cenários de autenticação para o Microsoft Entra ID.

Próximo passo

Implementar aplicativos Java WebSphere no WebSphere Tradicional em Máquinas Virtuais do Azure