Esercizio - Consentire l'accesso degli utenti con MSAL

  • 5 minuti

In questo esercizio si usa Microsoft Authentication Library per Java (MSAL4J) per aggiungere l'autenticazione in un'applicazione Web Java di esempio e consentire agli utenti di accedere con gli account Microsoft Entra.

L'applicazione di esempio usata in questo esercizio è un'applicazione servlet Java che consente agli utenti di accedere e visualizza il nome utente e le informazioni di base sul profilo. Consente anche di chiamare l'API Microsoft Graph per visualizzare alcune informazioni sull'utente.

Creazione di un'applicazione Web Java

Dalla shell o della riga di comando:

  1. Creare una cartella per l'applicazione.

    mkdir ~/javawebapp

  2. Clonare l'applicazione di esempio dal repository GitHub alla nuova cartella.

    git clone https://github.com/Azure-Samples/ms-identity-java-servlet-webapp-authentication.git ~/javawebapp

  3. Passare alla cartella in cui si trova l'applicazione di esempio per questo esercizio.

    cd ~/javawebapp/ms-identity-java-servlet-webapp-authentication/2-Authorization-I/call-graph

Configurazione dell'applicazione

Per configurare il codice, aprire il progetto dell'applicazione nell'ambiente di sviluppo integrato preferito, ad esempio IntelliJ o VS Code.

  1. Aprire il file ./src/main/resources/authentication.properties.

  2. Nella proprietà aad.authority, trovare la stringa {enter-your-tenant-id-here}. Sostituire il valore esistente con il valore ID Directory (tenant), come illustrato nell'immagine seguente, perché l'app è stata registrata con all'opzione Solo account in questa directory organizzativa.

  3. Nella proprietà aad.clientId, trovare la stringa {enter-your-client-id-here} e sostituire il valore esistente con il valore ID applicazione (client), ovvero il valore clientId, dell'applicazione registrata copiata dal portale di Azure.

    Screenshot che evidenzia l'ID app di un'app registrata con Microsoft Entra ID nel portale di Azure.

  4. Nella proprietà aad.secret, trovare la stringa {enter-your-client-secret-here} e sostituire il valore esistente con il valore chiave salvato durante la creazione dell'app nel portale di Azure.

Eseguire l'applicazione

  1. Verificare che il server Tomcat sia in esecuzione e di avere i privilegi per distribuirvi un'app Web. Verificare che l'indirizzo host del server sia http://localhost:8080.

  2. Compilare e creare un pacchetto del progetto usando Maven:

    cd ~/javawebapp/2-Authorization-I/call-graph
mvn clean package

  3. Trovare il file .war risultante in ./target/msal4j-servlet-graph.war. Per eseguire la distribuzione in Tomcat, copiare questo file .war nella directory /webapps/ nella directory di installazione di Tomcat e avviare il server Tomcat.

  4. Aprire il browser e passare a http://localhost:8080/msal4j-servlet-graph/. Si viene reindirizzati all'accesso con Microsoft Entra ID. Al termine dell'accesso, verrà visualizzata una pagina simile alla seguente:

    Screenshot che mostra il nome utente visualizzato nella pagina dopo l'accesso all'applicazione di esempio.

  5. Selezionare il pulsante ID Token Details (Dettagli token ID) per visualizzare alcune delle attestazioni decodificate del token ID.

Panoramica del codice di autenticazione

La maggior parte del codice di autenticazione nell'applicazione di esempio è disponibile nella directory java/com/microsoft/azuresamples/msal4j/ del progetto. Contiene più servlet che forniscono gli endpoint di autenticazione nell'applicazione per l'accesso, la disconnessione e la gestione del callback di reindirizzamento da Microsoft Entra ID. Questi servlet usano le classi helper nella directory java/com/microsoft/azuresamples/msal4j/helpers/ per chiamare i metodi di autenticazione forniti da MSAL. Esiste un filtro servlet definito in AuthenticationFilter.java che reindirizza le richieste non autenticate alle route protette a una pagina di errore HTTP 401 Non autorizzato.

Per aggiungere l'autenticazione all'applicazione, sarà necessario includere le classi servlet nelle directory java/com/microsoft/azuresamples/msal4j/authservlets e java/com/microsoft/azuresamples/msal4j/authwebapp, le classi helper nella directory java/com/microsoft/azuresamples/msal4j/helpers/ e il filtro servlet di autenticazione AuthenticationFilter.java nei progetti. Ecco altri dettagli del codice di autenticazione MSAL.

  1. MSAL4J è disponibile in Maven. Sarà necessario aggiungere MSAL4J come dipendenza nel file pom.xml del progetto:

    <dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>msal4j</artifactId>
    <version>1.17.2</version>
</dependency>

  2. Il primo passaggio del processo di accesso prevede l'invio di una richiesta all'endpoint /authorize del tenant di Microsoft Entra. L'istanza ConfidentialClientApplication di MSAL4J viene sfruttata per costruire un URL della richiesta di autorizzazione. L'app reindirizza il browser a questo URL, dove l'utente effettua l'accesso. Il codice seguente è un estratto dell'implementazione del metodo redirectToAuthorizationEndpoint nella classe AuthHelper.

    final ConfidentialClientApplication client = getConfidentialClientInstance();
AuthorizationRequestUrlParameters parameters = AuthorizationRequestUrlParameters
                                                    .builder(Config.REDIRECT_URI, Collections.singleton(Config.SCOPES))
                                                    .responseMode(ResponseMode.QUERY).prompt(Prompt.SELECT_ACCOUNT).state(state).nonce(nonce).build();

final String authorizeUrl = client.getAuthorizationRequestUrl(parameters).toString();
contextAdapter.redirectUser(authorizeUrl);
    • AuthorizationRequestUrlParameters: Parametri che devono essere impostati per compilare un AuthorizationRequestUrl.
    • REDIRECT_URI: L'URI di reindirizzamento è l'URI a cui il provider di identità invia nuovamente i token di sicurezza. Microsoft Entra ID reindirizza il browser, con il codice di autenticazione, a questo URI dopo aver raccolto le credenziali utente. Deve corrispondere all'URI di reindirizzamento nella registrazione dell'app Microsoft Entra.
    • SCOPES: Gli ambiti sono autorizzazioni richieste dall'applicazione. In genere, i tre ambiti openid profile offline_access sono sufficienti per ricevere una risposta del token ID per un accesso utente e vengono configurati da MSAL per impostazione predefinita.

  3. L'utente riceve una richiesta di accesso da Microsoft Entra ID. Se il tentativo di accesso ha esito positivo, il browser dell'utente viene reindirizzato all'endpoint di reindirizzamento dell'app con un codice di autorizzazione valido nell'endpoint. L'istanza ConfidentialClientApplication scambia quindi questo codice di autorizzazione con un token ID e un token di accesso di Microsoft Entra ID. Il codice seguente è un estratto dell'implementazione del metodo processAADCallback nella classe AuthHelper.

    // First, validate the state, then parse any error codes in response, then extract the authCode. Then:
// build the auth code params:
final AuthorizationCodeParameters authParams = AuthorizationCodeParameters
                                                    .builder(authCode, new URI(Config.REDIRECT_URI)).scopes(Collections.singleton(Config.SCOPES)).build();

// Get a client instance and leverage it to acquire the token:
final ConfidentialClientApplication client = AuthHelper.getConfidentialClientInstance();
final IAuthenticationResult result = client.acquireToken(authParams).get();
    • AuthorizationCodeParameters: Parametri da impostare per scambiare il codice di autorizzazione con un token ID e/o di accesso.
    • authCode: Codice di autorizzazione ricevuto nell'endpoint di reindirizzamento.
    • REDIRECT_URI: L'URI di reindirizzamento usato nel passaggio precedente deve essere passato di nuovo.
    • SCOPES: Gli ambiti usati nel passaggio precedente devono essere passati di nuovo.

  4. Se acquireToken ha esito positivo, vengono estratte le attestazioni del token. Se il controllo di nonce viene superato, i risultati vengono inseriti in context, un'istanza di IdentityContextData e salvati nella sessione. L'applicazione può quindi creare un'istanza dalla sessione, tramite un'istanza di IdentityContextAdapterServlet, ogni volta che deve accedervi:

    // parse IdToken claims from the IAuthenticationResult:
// (the next step - validateNonce - requires parsed claims)
context.setIdTokenClaims(result.idToken());

// if nonce is invalid, stop immediately! this could be a token replay!
// if validation fails, throws exception and cancels auth:
validateNonce(context);

// set user to authenticated:
context.setAuthResult(result, client.tokenCache().serialize());