Condividi tramite

Proteggere le app WebLogic Java usando ruoli e attestazioni di ruolo

  • Articolo

Questo articolo illustra un'app WebLogic Java che usa OpenID Connect per consentire l'accesso agli utenti e ai ruoli applicazione di Microsoft Entra ID (ruoli dell'app) per l'autorizzazione.

Questa applicazione implementa il controllo degli accessi in base al ruolo usando i ruoli applicazione e le attestazioni dei ruoli di Microsoft Entra ID. Un altro approccio consiste nell'usare i gruppi e le attestazioni di gruppo di Microsoft Entra ID. I gruppi e i ruoli applicazione di Microsoft Entra ID non si escludono a vicenda. È possibile usarli entrambi per fornire un controllo di accesso con granularità fine.

È anche possibile usare il controllo degli accessi in base al ruolo con ruoli applicazione e attestazioni di ruolo per applicare in modo sicuro i criteri di autorizzazione.

Per un video che illustra questo scenario e questo esempio, vedere Implementare l'autorizzazione nelle applicazioni usando ruoli dell'app, gruppi di sicurezza, ambiti e ruoli della directory.

Per altre informazioni sul funzionamento dei protocolli in questo scenario e in altri scenari, vedere Autenticazione e autorizzazione.

Questa applicazione usa MSAL per Java (MSAL4J) per accedere a un utente e ottenere un token ID da Microsoft Entra ID.

Questo esempio usa innanzitutto MSAL per Java (MSAL4J) per accedere all'utente. Nella home page viene visualizzata un'opzione che consente all'utente di visualizzare le attestazioni nei token ID. Questa applicazione consente inoltre agli utenti di visualizzare una pagina di amministrazione con privilegi o una normale pagina utente, a seconda del ruolo dell'app a cui sono stati assegnati. L'idea consiste nel fornire un esempio di come, all'interno di un'applicazione, l'accesso a determinate funzionalità o pagine sia limitato a subset di utenti a seconda del ruolo a cui appartengono.

Questo tipo di autorizzazione viene implementato usando il controllo degli accessi in base al ruolo. Con il controllo degli accessi in base al ruolo, un amministratore concede le autorizzazioni ai ruoli, non ai singoli utenti o gruppi. L'amministratore può quindi assegnare ruoli a utenti e gruppi diversi per controllare chi può accedere a determinati contenuti e funzionalità.

Questa applicazione di esempio definisce i due ruoli applicazione seguenti:

  • PrivilegedAdmin: autorizzato ad accedere alle pagine Solo amministratori e Utenti normali.
  • RegularUser: autorizzato ad accedere alla pagina Utenti normali.

Questi ruoli applicazione sono definiti nel portale di Azure all'interno del manifesto di registrazione dell'applicazione. Quando un utente accede all'applicazione, Microsoft Entra ID genera un'attestazione di ruoli per ogni ruolo concesso singolarmente all'utente sotto forma di appartenenza al ruolo.

È possibile assegnare utenti e gruppi ai ruoli tramite il portale di Azure o a livello di codice usando Microsoft Graph e Microsoft Azure AD PowerShell. Questo articolo descrive entrambe le tecniche.

Nota

Le attestazioni di ruolo non sono presenti per gli utenti guest in un tenant se l'endpoint https://login.microsoftonline.com/common/ viene usato come autorità per l'accesso degli utenti. È necessario accedere a un utente a un endpoint tenant come https://login.microsoftonline.com/tenantid.

Prerequisiti

Consigli

  • Familiarità con Java /Jakarta Servlets.
  • Familiarità con il terminale Linux/OSX o Windows PowerShell.
  • jwt.ms per controllare i token.
  • Fiddler per monitorare l'attività di rete e la risoluzione dei problemi.
  • Segui il blog di Microsoft Entra ID per rimanere aggiornato 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/3-Authorization-II/roles

In alternativa, passare al repository ms-identity-msal-java-samples , quindi scaricarlo come file .zip ed estrarlo nel disco rigido.

Importante

Per evitare limitazioni di lunghezza del percorso di file in Windows, clonare o estrarre il repository in una directory vicino alla radice del disco rigido.

Registrare l'applicazione di esempio con il tenant di Microsoft Entra ID

In questo esempio è presente un progetto. Le sezioni seguenti illustrano come registrare l'app usando il portale di Azure.

Scegliere il tenant microsoft Entra ID in cui si desidera creare le applicazioni

Per scegliere il tenant, seguire questa procedura:

  1. Accedere al portale di Azure.

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

Registrare l'app (java-servlet-webapp-roles)

Prima di tutto, registrare una nuova app nel portale di Azure seguendo le istruzioni riportate in Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.

Usare quindi la procedura seguente per completare la registrazione:

  1. Passare alla pagina Registrazioni app di Microsoft Identity Platform per sviluppatori.

  2. Seleziona Nuova registrazione.

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

    • Nella sezione Nome immettere un nome di applicazione significativo da visualizzare agli utenti dell'app, java-servlet-webapp-rolesad esempio .

    • In Tipi di account supportati selezionare una delle opzioni seguenti:

      • Selezionare Account in questa directory organizzativa solo se si compila un'applicazione per l'uso solo da parte degli utenti nel tenant, ovvero un'applicazione a tenant singolo.

    • Nella sezione URI di reindirizzamento selezionare Web nella casella combinata e immettere l'URI di reindirizzamento seguente: http://localhost:8080/msal4j-servlet-roles/auth/redirect.

  4. Selezionare Registra per creare l'applicazione.

  5. Nella pagina di registrazione dell'app trovare e copiare il valore ID applicazione (client) da usare in un secondo momento. 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 delle durate disponibili: in 1 anno, in 2 anni o Mai scadute.

  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.

Definire i ruoli dell'applicazione

Per definire i ruoli dell'app, seguire questa procedura:

  1. Sempre nella stessa registrazione dell'app selezionare Ruoli app nel riquadro di spostamento.

  2. Selezionare Crea ruolo app e quindi immettere i valori seguenti:

    • Per Nome visualizzato immettere un nome appropriato, ad esempio PrivilegedAdmin.
    • In Tipi di membri consentiti scegliere Utente.
    • In Valore immettere PrivilegedAdmin.
    • Per Descrizione immettere PrivilegedAdmins che può visualizzare la pagina di amministrazione.

  3. Selezionare Crea ruolo app e quindi immettere i valori seguenti:

    • Per Nome visualizzato immettere un nome appropriato, ad esempio RegularUser.
    • In Tipi di membri consentiti scegliere Utente.
    • In Valore immettere RegularUser.
    • Per Descrizione immettere RegularUsers che può visualizzare la pagina utente.

  4. Selezionare Applica per salvare le modifiche.

Assegnare utenti ai ruoli dell'applicazione

Per aggiungere utenti al ruolo app definito in precedenza, seguire le linee guida riportate di seguito: Assegnare utenti e gruppi ai ruoli.

Configurare l'app (java-servlet-webapp-roles) per usare la registrazione dell'app

Usare la procedura seguente per configurare l'app:

Nota

Nei passaggi seguenti è ClientID uguale Application ID a o AppId.

  1. Aprire il progetto nell'IDE.

  2. Aprire il file authentication.properties .

  3. Trovare la stringa {enter-your-tenant-id-here}. Sostituire il valore esistente con l'ID tenant di Microsoft Entra ID.

  4. Trovare la stringa {enter-your-client-id-here} e sostituire il valore esistente con l'ID applicazione o clientId l'applicazione java-servlet-webapp-call-graph copiata dal portale di Azure.

  5. Trovare la stringa {enter-your-client-secret-here} e sostituire il valore esistente con il valore salvato durante la creazione dell'appjava-servlet-webapp-roles, nella portale di Azure.

  6. Trovare la app.roles proprietà e assicurarsi che il valore sia impostato su app.roles=admin PrivilegedAdmin, user RegularUsero sostituire i nomi dei ruoli specifici.

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 con estensione war che è possibile eseguire in vari server applicazioni.

Distribuire l'esempio

Queste istruzioni presuppongono l'installazione di WebLogic e la configurazione di un dominio server.

Prima di poter eseguire la distribuzione in WebLogic, seguire questa procedura per apportare alcune modifiche di configurazione nell'esempio stesso e quindi compilare o ricompilare il pacchetto:

  1. Nell'esempio trovare il file application.properties o authentication.properties in cui sono stati configurati l'ID client, il tenant, l'URL di reindirizzamento e così via.

  2. In questo file modificare i riferimenti a localhost:8080 o localhost:8443 all'URL e alla porta su cui viene eseguita WebLogic, che per impostazione predefinita deve essere localhost:7001.

  3. È anche necessario apportare la stessa modifica nella registrazione dell'app di Azure, in cui è stata impostata nella portale di Azure come valore URI di reindirizzamento nella scheda Autenticazione.

Usare la procedura seguente per distribuire l'esempio in WebLogic tramite la console Web:

  1. Avviare il server WebLogic con DOMAIN_NAME\bin\startWebLogic.cmd.

  2. Passare alla console WebLogic nel browser all'indirizzo http://localhost:7001/console.

  3. Passare a Distribuzioni struttura>di dominio, selezionare Installa, selezionare Carica i file e quindi trovare il file war compilato con Maven.

  4. Selezionare Installa questa distribuzione come applicazione, selezionare Avanti, fine e quindi selezionare Salva.

  5. La maggior parte delle impostazioni predefinite deve essere corretta, ad eccezione del fatto che è necessario assegnare un nome all'applicazione in modo che corrisponda all'URI di reindirizzamento impostato nella configurazione di esempio o nella registrazione dell'app di Azure. Ovvero, se l'URI di reindirizzamento è http://localhost:7001/msal4j-servlet-auth, è necessario assegnare all'applicazione msal4j-servlet-authil nome .

  6. Tornare a Distribuzioni della struttura>di dominio e avviare l'applicazione.

  7. Dopo l'avvio dell'applicazione, passare a http://localhost:7001/<application-name>/e si dovrebbe essere in grado di accedere all'applicazione.

Esaminare l'esempio

Per esplorare l'esempio, seguire questa procedura:

  1. Si noti lo stato di accesso o disconnesso visualizzato al centro della schermata.
  2. Selezionare il pulsante sensibile al contesto nell'angolo. Questo pulsante legge Accedi quando si esegue l'app per la prima volta.
  3. Nella pagina successiva seguire le istruzioni e accedere con un account nel tenant microsoft Entra ID.
  4. Nella schermata di consenso notare gli ambiti richiesti.
  5. Si noti che il pulsante sensibile al contesto ora indica Disconnetti e visualizza il nome utente.
  6. Selezionare ID Token Details (Dettagli token ID) per visualizzare alcune delle attestazioni decodificate del token ID.
  7. Selezionare Solo amministratori per visualizzare la /admin_only pagina. Solo gli utenti con ruolo PrivilegedAdmin app possono visualizzare questa pagina. In caso contrario, viene visualizzato un messaggio di errore di autorizzazione.
  8. Selezionare Utenti normali per visualizzare la /regular_user pagina. Solo gli utenti con ruolo RegularUser app o PrivilegedAdmin possono visualizzare questa pagina. In caso contrario, viene visualizzato un messaggio di errore di autorizzazione.
  9. Usare il pulsante nell'angolo per disconnettersi.

Informazioni sul codice

Questo esempio usa MSAL per Java (MSAL4J) per accedere a un utente e ottenere un token ID che potrebbe contenere l'attestazione dei ruoli. In base all'attestazione dei ruoli presente, l'utente connesso può accedere a nessuno, uno o entrambe le pagine Admins Only protette e Regular Users.

Per replicare il comportamento di questo esempio, è possibile copiare il file pom.xml e il contenuto delle cartelle helper e authservlets nella cartella src/main/java/com/microsoft/azuresamples/msal4j . È necessario anche il file authentication.properties . Queste classi e file contengono codice generico che è possibile usare in un'ampia gamma di applicazioni. È anche possibile copiare il resto dell'esempio, ma le altre classi e file vengono compilati in modo specifico per soddisfare l'obiettivo di questo esempio.

Contenuto

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

File/cartella Descrizione
src/main/java/com/microsoft/azuresamples/msal4j/roles/ Questa directory contiene le classi che definiscono la logica di business back-end dell'app.
src/main/java/com/microsoft/azuresamples/msal4j/authservlets/ Questa directory contiene le classi usate per l'accesso e la disconnessità degli endpoint.
____Servlet.java Tutti gli endpoint disponibili sono definiti nelle classi .java che terminano in ____Servlet.java.
src/main/java/com/microsoft/azuresamples/msal4j/helpers/ Classi helper per l'autenticazione.
AuthenticationFilter.java Reindirizza le richieste non autenticate agli endpoint protetti a una pagina 401.
src/main/resources/authentication.properties Microsoft Entra ID e configurazione del programma.
src/main/webapp/ Questa directory contiene l'interfaccia utente - Modelli JSP
CHANGELOG.md Elenco delle modifiche apportate all'esempio.
CONTRIBUTING.md Linee guida per contribuire all'esempio.
LICENZA Licenza per l'esempio.

Elaborare un'attestazione di ruoli nel token ID

L'attestazione dei ruoli del token include i nomi dei ruoli a cui è assegnato l'utente connesso, come illustrato nell'esempio seguente:

{
  ...
  "roles": [
    "Role1",
    "Role2",]
  ...
}

ConfidentialClientApplication

Viene creata un'istanza ConfidentialClientApplication nel file AuthHelper.java , come illustrato nell'esempio seguente. Questo oggetto consente di creare l'URL di autorizzazione di Microsoft Entra e consente anche di scambiare il token di autenticazione per un token di accesso.

// getConfidentialClientInstance method
IClientSecret secret = ClientCredentialFactory.createFromSecret(SECRET);
confClientInstance = ConfidentialClientApplication
                     .builder(CLIENT_ID, secret)
                     .authority(AUTHORITY)
                     .build();

Per la creazione di istanze vengono usati i parametri seguenti:

  • ID client dell'app.
  • Segreto client, che è un requisito per le applicazioni client riservate.
  • Microsoft Entra ID Authority, che include l'ID tenant di Microsoft Entra.

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

Procedura

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 per il /authorize tenant di Microsoft Entra ID. L'istanza DI MSAL4J ConfidentialClientApplication viene usata per costruire un URL della richiesta di autorizzazione. L'app reindirizza il browser a questo URL, dove l'utente accede.

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

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

    • AuthorizationRequestUrlParameters: parametri che devono essere impostati per compilare un oggetto AuthorizationRequestUrl.
    • REDIRECT_URI: dove Microsoft Entra ID reindirizza il browser, insieme al codice di autenticazione, dopo aver raccolto le credenziali utente. Deve corrispondere all'URI di reindirizzamento nella registrazione dell'app Microsoft Entra ID nel portale di Azure.
    • 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.
      • L'elenco completo degli ambiti richiesti dall'app è disponibile nel file authentication.properties . È possibile aggiungere altri ambiti, ad esempio User.Read.

  2. 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. Una richiesta valida a questo endpoint contiene un codice di autorizzazione.

  3. L'istanza ConfidentialClientApplication scambia quindi questo codice di autorizzazione per un token ID e un token di accesso da 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();

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

    • AuthorizationCodeParameters: parametri che devono essere impostati per scambiare il codice di autorizzazione per un ID e/o un token 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 nonce viene superato, i risultati vengono inseriti in context , un'istanza di IdentityContextData , e salvati nella sessione. L'applicazione può quindi creare un'istanza IdentityContextData di dalla sessione tramite un'istanza di IdentityContextAdapterServlet ogni volta che deve accedervi, come illustrato nel codice seguente:

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

Proteggere le route

Per informazioni su come l'app di esempio filtra l'accesso alle route, vedere AuthenticationFilter.java. Nel file authentication.properties la app.protect.authenticated proprietà contiene le route separate da virgole a cui possono accedere solo gli utenti autenticati, come illustrato nell'esempio seguente:

# for example, /token_details requires any user to be signed in and does not require special roles claim(s)
app.protect.authenticated=/token_details

Le route elencate nei set di regole delimitate da virgole ai app.protect.roles sensi di sono inoltre off-limits agli utenti autenticati non autenticati, come illustrato nell'esempio seguente. Tuttavia, queste route contengono anche un elenco separato da spazi di appartenenze ai ruoli dell'app: solo gli utenti che hanno almeno uno dei ruoli corrispondenti possono accedere a queste route dopo l'autenticazione.

# local short names for app roles - for example, sets admin to mean PrivilegedAdmin (useful for long rule sets defined in the next key, app.protect.roles)
app.roles=admin PrivilegedAdmin, user RegularUser

# A route and its corresponding <space-separated> role(s) that can access it; the start of the next route & its role(s) is delimited by a <comma-and-space-separator>
# this says: /admins_only can be accessed by PrivilegedAdmin, /regular_user can be accessed by PrivilegedAdmin role and the RegularUser role
app.protect.roles=/admin_only admin, /regular_user admin user

Ambiti

Gli ambiti indicano a Microsoft Entra ID il livello di accesso richiesto dall'applicazione.

In base agli ambiti richiesti, Microsoft Entra ID presenta una finestra di dialogo di consenso all'utente al momento dell'accesso. Se l'utente acconsente a uno o più ambiti e ottiene un token, gli ambiti con consenso vengono codificati nell'oggetto risultante access_token.

Per gli ambiti richiesti dall'applicazione, vedere authentication.properties. Questi tre ambiti vengono richiesti da MSAL e forniti da Microsoft Entra ID per impostazione predefinita.

Ulteriori informazioni

Passaggio successivo

Distribuire app WebLogic Java in WebLogic in Azure Macchine virtuali