Abilita l’accesso per le applicazioni Java JBoss EAP tramite MSAL4J con Azure Active Directory B2C

Questo articolo illustra un'applicazione Java JBoss EAP che autentica gli utenti tramite Azure Active Directory B2C (Azure AD B2C) utilizzando la Microsoft Authentication Library per Java (MSAL4J).

Il diagramma seguente illustra la topologia dell'app:

Diagramma che mostra la topologia dell'app.

L'app usa MSAL4J per consentire agli utenti di accedere e ottenere un ID token da Azure AD B2C. Il token di ID dimostra che l'utente è autenticato in un tenant Azure AD B2C.

Prerequisiti

• JDK versione 8 o successive
• Maven 3
• Un tenant di Azure AD B2C. Per ulteriori informazioni, vedere Esercitazione: Creare un tenant di Azure Active Directory B2C
• Un account utente nel tenant di Azure AD B2C.

• JBoss EAP
• Visual Studio Code
• Strumenti di Azure per Visual Studio Code

Consigli

• Una certa familiarità con Java / Jakarta Servlets.
• Una certa familiarità con il terminale Linux/OSX.
• jwt.ms per esaminare i tuoi token.
• Fiddler per monitorare l'attività di rete e risolvere i problemi.
• Segui il blog di Microsoft Entra per rimanere up-to-date con gli ultimi sviluppi.

Configurare l'esempio

Le sezioni seguenti illustrano come configurare l'applicazione di esempio.

Clonare o scaricare il repository di esempio

Per clonare l'esempio, aprire una finestra Bash e usare il comando seguente:

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

In alternativa, passa al repository ms-identity-msal-java-samples, quindi scaricalo come file .zip ed estrailo sul disco rigido.

Registrare l'applicazione di esempio con il tenant di Azure AD B2C

L'esempio viene fornito con un'applicazione preregistrata a scopo di test. Se si vuole usare un tenant e un'applicazione Azure AD B2C personalizzati, seguire la procedura descritta nelle sezioni seguenti per registrare e configurare l'applicazione nel portale di Azure. In caso contrario, continuare con i passaggi per Eseguire l'esempio.

Scegliere il tenant di Azure AD B2C in cui si vogliono creare le applicazioni

Per scegliere il tenant, seguire questa procedura:

1. Accedi al portale di Azure.

2. Se l'account è presente in più tenant di Azure AD B2C, selezionare il profilo nell'angolo del portale di Azure e quindi selezionare Cambia directory per modificare la sessione nel tenant di Azure AD B2C desiderato.

Creare flussi utente e criteri personalizzati

Per creare flussi utente comuni come la registrazione, l'accesso, la modifica del profilo e la reimpostazione della password, vedere Esercitazione: Creare flussi utente in Azure Active Directory B2C.

Si consiglia di valutare anche la creazione di criteri personalizzati in Azure Active Directory B2C; tuttavia, questo esula dall'ambito di questa esercitazione.

Aggiungere provider di identità esterni

Vedere Esercitazione: aggiungere provider di identità alle applicazioni in Azure Active Directory B2C.

Registrare l'app (ms-identity-b2c-java-servlet-webapp-authentication)

Per registrare l'app, seguire questa procedura:

1. Passare al portale di Azure e selezionare Azure AD B2C.

2. Selezionare Registrazioni app nel riquadro di spostamento e quindi selezionare Nuova registrazione.

3. Nella pagina Registra un'applicazione visualizzata immettere le informazioni di registrazione dell'applicazione seguenti:

   • Nella sezione Name, immetti un nome di applicazione significativo da visualizzare agli utenti dell'app - ad esempio, .
   • In Tipi di account supportati, seleziona Account in qualsiasi directory organizzativa e gli account Microsoft personali (ad esempio Skype, Xbox, Outlook.com).
   • Nella sezione URI di reindirizzamento (facoltativo), selezionare Web nella casella combinata e immettere il seguente URI di reindirizzamento: .

4. Selezionare Registra per creare l'applicazione.

5. Nella pagina di registrazione dell'app, trova e copia il valore ID applicazione (client) da utilizzare in seguito. Questo valore viene usato nel file o nei file di configurazione dell'app.

6. Seleziona Salva per salvare le modifiche.

7. Nella pagina di registrazione dell'app selezionare Certificati e segreti nel riquadro di spostamento per aprire la pagina in cui è possibile generare segreti e caricare i certificati.

8. Nella sezione Segreti client seleziona Nuovo segreto client.

9. Digitare una descrizione, ad esempio il segreto dell'app.

10. Selezionare una scadenza per il segreto o specificare una durata personalizzata. I segreti client sono limitati a una durata massima di 24 mesi e Microsoft consiglia una scadenza inferiore a 12 mesi. Per le app di produzione, preferire un certificato o credenziali di identità federate rispetto a un segreto client.

11. Selezionare Aggiungi. Viene visualizzato il valore generato.

12. Copiare e salvare il valore generato da usare nei passaggi successivi. Questo valore è necessario per i file di configurazione del codice. Questo valore non viene visualizzato di nuovo e non è possibile recuperarlo con altri mezzi. Assicurarsi quindi di salvarlo dal portale di Azure prima di passare a qualsiasi altra schermata o riquadro.

Configura l'app (ms-identity-b2c-java-servlet-webapp-authentication) per usare la registrazione della tua app

Usare la procedura seguente per configurare l'app:

1. Aprire il progetto nell'IDE.

2. Apri il file ./src/main/resources/authentication.properties.

3. Individua la proprietà e sostituisci il valore esistente con l'ID dell'applicazione o dell'applicazione nel portale di Azure.

4. Individua la proprietà e sostituisci il valore esistente con il valore salvato durante la creazione dell'applicazione nel portale di Azure.

5. Trova la proprietà e sostituisci il clientId dell'applicazione esistente con il valore inserito in al passaggio 1 di questa sezione.

6. Trova la proprietà e sostituisci la prima occorrenza di con il nome del tenant di Azure AD B2C in cui hai creato l'applicazione nel portale di Azure.

7. Individuare la proprietà e sostituire la seconda occorrenza di con il nome del tenant di Azure AD B2C in cui è stata creata l'applicazione nel portale di Azure.

8. Trova la proprietà e sostituiscila con il nome del criterio del flusso utente di registrazione/accesso che hai creato nel tenant Azure AD B2C in cui hai creato l'applicazione nel portale di Azure.

9. Individua la proprietà e sostituiscila con il nome del criterio del flusso utente per la reimpostazione della password che hai creato nel tenant Azure AD B2C in cui hai creato l'applicazione nel Portale di Azure.

10. Individua la proprietà e sostituiscila con il nome del criterio del flusso utente per la modifica del profilo che hai creato nel tenant Azure AD B2C in cui hai creato l'applicazione nel portale di Azure.

Compilare l'esempio

Per compilare l'esempio usando Maven, passare alla directory contenente il file pom.xml per l'esempio e quindi eseguire il comando seguente:

mvn clean package

Questo comando genera un file .war che puoi eseguire su vari server applicativi.

Esegui l'esempio

Please confirm webapp properties
AppName : msal4j-servlet-auth-1707220080695
ResourceGroup : msal4j-servlet-auth-1707220080695-rg
Region : centralus
PricingTier : P1v3
OS : Linux
Java Version: Java 11
Web server stack: JBosseap 7
Deploy to slot : false
Confirm (Y/N) [Y]:
[INFO] Saving configuration to pom.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  26.196 s
[INFO] Finished at: 2024-02-06T11:48:16Z
[INFO] ------------------------------------------------------------------------

<build>
    <plugins>
        <plugin>
            <groupId>com.microsoft.azure</groupId>
            <artifactId>>azure-webapp-maven-plugin</artifactId>
            <version>x.xx.x</version>
            <configuration>
                <schemaVersion>v2</schemaVersion>
                <resourceGroup>your-resourcegroup-name</resourceGroup>
                <appName>your-app-name</appName>
            ...
            </configuration>
        </plugin>
    </plugins>
</build>

az login

mvn package azure-webapp:deploy

Esaminare l'esempio

Per esplorare l'esempio, seguire questa procedura:

1. Notare lo stato di accesso o di disconnessione visualizzato al centro dello schermo.
2. Selezionare il pulsante sensibile al contesto nell'angolo. Questo pulsante mostra Accedi quando avvii l'app per la prima volta.
3. Nella pagina successiva seguire le istruzioni e accedere con un account del provider di identità scelto.
4. Si noti che il pulsante sensibile al contesto ora indica Disconnetti e visualizza il nome utente.
5. Selezionare Dettagli token ID per vedere alcune delle dichiarazioni decodificate del token ID.
6. Hai anche la possibilità di modificare il tuo profilo. Selezionare il collegamento per modificare i dettagli, ad esempio il nome visualizzato, il luogo di residenza e la professione.
7. Usare il pulsante nell'angolo per disconnettersi.
8. Dopo aver effettuato la disconnessione, vai al seguente URL della pagina dei dettagli del token: . Qui puoi osservare come l'app visualizza un errore anziché i claims del token ID.

Informazioni sul codice

Questo esempio illustra come usare MSAL4J per consentire agli utenti di accedere al tenant di Azure AD B2C.

Contenuto

La tabella seguente illustra il contenuto della cartella del progetto di esempio:

ConfidentialClientApplication

Un'istanza di viene creata nel file AuthHelper.java, come mostrato nell'esempio seguente. Questo oggetto consente di creare l'URL di autorizzazione di Azure AD B2C e consente anche di scambiare il token di autenticazione per un token di accesso.

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

Per l'istanziazione vengono utilizzati i seguenti parametri:

• ID client dell'app.
• Il segreto del client, necessario per le applicazioni client confidenziali.
• Autorità di Azure AD B2C concatenata con l'opzione appropriata UserFlowPolicy per l'iscrizione, l'accesso, la modifica del profilo o la reimpostazione della password.

In questo esempio questi valori vengono letti dal file authentication.properties usando un lettore di proprietà nel file Config.java .

Procedura dettagliata

I passaggi seguenti forniscono una procedura dettagliata delle funzionalità dell'app:

1. Il primo passaggio del processo di accesso consiste nell'inviare una richiesta all'endpoint del tenant Azure Active Directory B2C. L'istanza di MSAL4J viene utilizzata per creare un URL di richiesta di autorizzazione, e l'app reindirizza il browser a questo URL, come illustrato nell'esempio seguente:

   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);
   

   L'elenco seguente descrive le funzionalità di questo codice:

   • : parametri che devono essere impostati per costruire un AuthorizationRequestUrl.

   • : dove Azure AD B2C reindirizza il browser, insieme al codice di autorizzazione, dopo aver raccolto le credenziali dell'utente.

   • : Scopes sono le autorizzazioni richieste dall'applicazione.

     Normalmente, i tre scope sarebbero sufficienti per ricevere una risposta contenente un token ID. Tuttavia, MSAL4J richiede che tutte le risposte di Azure AD B2C contengano anche un token di accesso.

     Affinché Azure AD B2C distribuisca un token di accesso e un token ID, la richiesta deve includere un ambito di risorsa aggiuntivo. Poiché questa app non richiede effettivamente un ambito di risorsa esterna, aggiunge il proprio ID client come quarto ambito per ricevere un token di accesso.

     È possibile trovare un elenco completo degli ambiti richiesti dall'app nel file authentication.properties .

   • : Azure AD B2C può restituire la risposta come parametri del form tramite una richiesta HTTP POST o come parametri della stringa di query tramite una richiesta HTTP GET.

   • : Azure AD B2C deve chiedere all'utente di selezionare l'account con cui intende autenticarsi.

   • : Una variabile univoca impostata dall'app nella sessione per ogni richiesta di token e eliminata dopo la ricezione del callback di reindirizzamento corrispondente di Azure AD B2C. La variabile di stato garantisce che le richieste di Azure AD B2C dirette a derivino effettivamente da richieste di autorizzazione di Azure AD B2C originate da questa app e da questa sessione, impedendo così attacchi CSRF. Questa operazione viene eseguita nel file AADRedirectServlet.java .

   • : variabile univoca impostata dall'app nella sessione a ogni richiesta di token e eliminata dopo la ricezione del token corrispondente. Questo nonce viene trascritto nei token risultanti erogati da Azure AD B2C, assicurando in tal modo che non si verifichi alcun attacco di riproduzione del token.

2. L'utente riceve una richiesta di accesso da Azure Active Directory B2C. Se il tentativo di accesso ha esito positivo, il browser dell'utente viene reindirizzato all'endpoint di reindirizzamento dell'app. Una richiesta valida a questo endpoint contiene un codice di autorizzazione.

3. L'istanza scambia quindi questo codice di autorizzazione con un token ID e un token di accesso emessi da Azure Active Directory B2C, come illustrato nell'esempio seguente:

   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();
   

   L'elenco seguente descrive le funzionalità di questo codice:

   • : Parametri che devono essere impostati per scambiare il codice di autorizzazione con un token ID e/o un token di accesso.
   • : Il codice di autorizzazione ricevuto all'endpoint di reindirizzamento.
   • : l'URI di reindirizzamento utilizzato nel passaggio precedente deve essere passato di nuovo.
   • : gli scope utilizzati nel passaggio precedente devono essere passati nuovamente.

4. Se ha esito positivo, i claim del token vengono estratti e il claim nonce viene convalidato rispetto al nonce memorizzato nella sessione, come mostrato nell'esempio seguente:

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

5. Se il nonce viene convalidato correttamente, lo stato di autenticazione viene memorizzato in una sessione sul lato server, sfruttando i metodi esposti dalla classe , come illustrato nell'esempio seguente:

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

Ulteriori informazioni

• Che cos'è Azure Active Directory B2C?
• Tipi di applicazioni che è possibile usare in Active Directory B2C
• Raccomandazioni e procedure consigliate per Azure Active Directory B2C
• Sessione di Azure AD B2C
• Libreria di Autenticazione Microsoft (MSAL) per Java

Per altre informazioni su come funzionano i protocolli OAuth 2.0 in questo scenario e in altri scenari, vedere Scenari di autenticazione per Microsoft Entra ID.