Esercizio - Consentire l'accesso degli utenti con MSAL
In questo esercizio si userà 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 che verrà descritta in questo esercizio è un'applicazione servlet Java che consente agli utenti di accedere e visualizzare il nome utente e le informazioni di base del 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:
Creare una cartella per l'applicazione.
mkdir ~/javawebapp
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
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.
Apri il file
./src/main/resources/authentication.properties
.Trovare la stringa
{enter-your-tenant-id-here}
. Sostituire il valore esistente con l'ID directory (tenant) (come illustrato nell'immagine seguente), perché l'app è stata registrata con l'opzione Account solo in questa directory organizzativa.Trovare la stringa
{enter-your-client-id-here}
e sostituire il valore esistente con l'ID applicazione (client) (clientId) dell'applicazione registrata copiata dal portale di Azure.Trovare la stringa
{enter-your-client-secret-here}
e sostituire il valore esistente con la chiave salvata durante la creazione dell'app nel portale di Azure.
Eseguire l'applicazione
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
.Compilare e creare un pacchetto del progetto usando Maven:
cd ~/javawebapp/2-Authorization-I/call-graph mvn clean package
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.Aprire il browser e passare a
http://localhost:8080/msal4j-servlet-graph/
. Si verrà reindirizzati all'accesso con Microsoft Entra ID. Al termine dell'accesso, verrà visualizzata una pagina simile alla seguente: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 è disponibile nell'applicazione di esempio nella directory del java/com/microsoft/azuresamples/msal4j/
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 non autorizzata 401.
Per aggiungere l'autenticazione all'applicazione, è necessario includere le classi servlet in java/com/microsoft/azuresamples/msal4j/authservlets
e java/com/microsoft/azuresamples/msal4j/authwebapp
directory, le classi helper nella directory java/com/microsoft/azuresamples/msal4j/helpers/
e il filtro AuthenticationFilter.java
servlet di autenticazione nei progetti. Ecco altri dettagli del codice di autenticazione MSAL.
MSAL4J è disponibile in Maven. È necessario aggiungere MSAL4J come dipendenza nel file del
pom.xml
progetto:<dependency> <groupId>com.microsoft.azure</groupId> <artifactId>msal4j</artifactId> <version>1.9.1</version> </dependency>
Il primo passaggio del processo di accesso consiste nell'inviare una richiesta all'endpoint del tenant di
/authorize
Microsoft Entra. L'istanzaConfidentialClientApplication
di MSAL4J viene sfruttata per costruire un URL della richiesta di autorizzazione. L'app reindirizza il browser a questo URL, dove l'utente effettuerà l'accesso.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 da impostare per creare un elemento AuthorizationRequestUrl.
- REDIRECT_URI: l'URI di reindirizzamento è l'URI a cui il provider di identità invierà nuovamente i token di sicurezza. Microsoft Entra ID reindirizzerà 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.
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.
// 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.
Se
acquireToken
ha esito positivo, vengono estratte le attestazioni del token. Se il controllo di nonce viene superato, i risultati vengono inseriti incontext
(un'istanza diIdentityContextData
) e salvati nella sessione. L'applicazione può quindi creare un'istanza dalla sessione (tramite un'istanza diIdentityContextAdapterServlet
) 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());