Procedura: Implementare il Controllo di accesso basato sui ruoli in un'applicazione con riconoscimento delle attestazioni ASP.NET tramite WIF e ACS

Aggiornamento: 19 giugno 2015

Si applica a: Azure

Si applica a

• Microsoft Azure Active Directory Access Control (anche noto come Servizio di controllo di accesso o ACS)

• Windows® Identity Foundation (WIF)

• ASP.NET

Riepilogo

Questo argomento illustra come implementare l'autorizzazione basata su Controllo di accesso ruoli (RBAC) in applicazioni Web con riconoscimento delle attestazioni ASP.NET tramite WIF e ACS.

Contenuto

• Obiettivi

• Panoramica

• Riepilogo dei passaggi

• Passaggio 1 - Creare una semplice applicazione Web ASP.NET in grado di riconoscere attestazioni

• Passaggio 2 - Configurare le attestazioni dei ruoli in ACS

• Passaggio 3 - Implementare i controlli dei ruoli in un'applicazione Web ASP.NET

• Passaggio 4 - Implementare una trasformazione delle attestazioni mediante un componente ClaimsAuthenticationManager personalizzato

• Passaggio 5: Verificare il lavoro eseguito

• Elementi correlati

Obiettivi

• Configurare le attestazioni di ruolo usando ACS.

• Trasformare le attestazioni dei ruoli usando il componente ClaimsAuthenticationManager.

• Implementare controlli di controllo degli accessi in base al ruolo usando il metodo IsInRole e gli attributi PrinciaplPermission.

Panoramica

Il controllo di accesso basato sui ruoli (RBAC) è un approccio largamente adottato per limitare l'accesso nelle applicazioni. In ASP.NET applicazioni Web questo approccio viene implementato usando il metodo IsInRole, l'attributo PrincipalPermission o le richieste, disponibili a partire da ASP.NET 1.0. È possibile usare le attestazioni per l'autorizzazione, preservando in tal modo le procedure consolidate usando nuove tecnologie, ad esempio WIF e ACS. Il runtime e l'SDK WIF sono disponibili per il download ai seguenti indirizzi:

• Windows Identity Foundation Runtime

• Windows Identity Foundation SDK

Riepilogo dei passaggi

• Passaggio 1 - Creare una semplice applicazione Web ASP.NET in grado di riconoscere attestazioni

• Passaggio 2 - Configurare le attestazioni dei ruoli in ACS

• Passaggio 3 - Implementare i controlli dei ruoli in un'applicazione Web ASP.NET

• Passaggio 4 - Implementare una trasformazione delle attestazioni mediante un componente ClaimsAuthenticationManager personalizzato

• Passaggio 5: Verificare il lavoro eseguito

Passaggio 1 - Creare una semplice applicazione Web ASP.NET in grado di riconoscere attestazioni

Questo passaggio consente di creare un'applicazione Web ASP.NET non particolarmente complessa da usare come base per l'implementazione del controllo di accesso basato sui ruoli.

Per creare una semplice applicazione Web ASP.NET

1. Avviare Visual Studio usando l'opzione "Esegui come amministratore". Questo passaggio è obbligatorio per WIF.

2. Creare una nuova applicazione Web ASP.NET vuota.

3. Aggiungere il Web Form aspx e assegnargli un nome, ad esempio default.aspx.

Passaggio 2 - Configurare le attestazioni dei ruoli in ACS

Questo passaggio illustra come configurare le attestazioni di ruolo nel portale di gestione ACS usando i gruppi di regole. Per una procedura dettagliata completa, vedere Procedura: Implementare la logica di trasformazione dei token usando le regole .

Per configurare le attestazioni dei ruoli nel portale di gestione ACS

1. Nella pagina Edit Relying Party Application scorrere verso il basso fino alla sezione Rule Groups, quindi fare clic sul collegamento relativo al gruppo desiderato. Accertarsi che sia selezionato.

2. Nella pagina Edit Rule Group scorrere verso il basso fino alla sezione Rule, quindi fare clic sul collegamento Add Rule.

3. Nella pagina Add Claim Rule scorrere verso il basso fino alla sezione Output claim type, selezionare il pulsante di opzione Select type, quindi scegliere il seguente tipo di attestazione.

   https://schemas.microsoft.com/ws/2008/06/identity/claims/role
   

4. Nella sezione Output claim value fare clic su Enter value, quindi nella casella di testo immettere come valore il seguente testo:
   Utente

5. Facoltativamente, (operazione consigliata) aggiungere una descrizione, quindi fare clic su Save.

L'attestazione del ruolo utente (user) è stata così configurata e può essere aggiunta a qualsiasi token. Lo scenario potrebbe variare in base ai propri requisiti. Per altre informazioni sulla configurazione di regole più complesse, vedere Procedura: Implementare la logica di trasformazione del token tramite regole.

Passaggio 3 - Implementare i controlli dei ruoli in un'applicazione Web ASP.NET

Questo passaggio consente di implementare il controllo di accesso basato sui ruoli.

Per implementare il controllo di accesso basato sui ruoli in una pagina Web ASP.NET

1. Aggiungere un riferimento all'assembly Microsoft.IdentityModel.

2. Accedere al codice associato a default.aspx.cs.

3. Aggiungere quanto segue usando dichiarazioni.

   using System.Security.Permissions;
   using System.Threading;
   using Microsoft.IdentityModel.Claims;
   using System.Security;
   

4. Decorare il gestore dell'evento Page_Load con la seguente richiesta di sicurezza. Questo attributo verificherà se l'utente corrente è incluso nel ruolo utente. In caso negativo, verrà generata un'eccezione.

   [PrincipalPermission(SecurityAction.Demand, Role = "User")]
   

5. Aggiungere il seguente codice al corpo del gestore dell'evento Page_Load. Corrisponde esattamente alla richiesta espressa nel codice.

   PrincipalPermission p = new PrincipalPermission(null, "User");
      p.Demand();
   

6. Aggiungere il seguente codice al corpo dell'evento Page_Load. A differenza del codice precedente, questo codice non genera un'eccezione. IsInRole invece restituisce un valore booleano che indica se l'utente corrente dispone del ruolo specificato.

   if (!User.IsInRole("User"))
                   throw new SecurityException("Access is denied.");
   

7. Il codice completato dovrebbe risultare simile a quello riportato di seguito.

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Web;
   using System.Web.UI;
   using System.Web.UI.WebControls;
   
   using System.Security.Permissions;
   using System.Threading;
   using Microsoft.IdentityModel.Claims;
   using System.Security;
   
   namespace WebIsInRoleACS
   {
       public partial class _default : System.Web.UI.Page
       {
           //THIS SHOULD THROW AN EXCEPTION
           [PrincipalPermission(SecurityAction.Demand, Role = "User")]
           protected void Page_Load(object sender, EventArgs e)
           {
   
               //THIS SHOULD THROW AN EXCEPTION
               PrincipalPermission p = new PrincipalPermission(null, "User");
               p.Demand();
   
               //THIS RETURNS BOOL
               if (!User.IsInRole("User"))
                   throw new SecurityException("Access is denied.");
           }
       }
   }
   

Passaggio 4 - Implementare una trasformazione delle attestazioni mediante un componente ClaimsAuthenticationManager personalizzato

Si tratta di un passaggio facoltativo. Questo passaggio illustra come trasformare le attestazioni usando ClaimsAuthenticationManager, che fa parte della pipeline WIF eseguita all'interno del contesto dell'applicazione ASP.NET, invece delle regole di trasformazione delle attestazioni eseguite in ACS, come descritto nel passaggio 2: Configurare attestazioni ruolo in ACS.

Per implementare la trasformazione delle attestazioni usando un componente ClaimsAuthenticationManager personalizzato

1. Aggiungere il progetto Libreria di classi alla soluzione di Visual Studio e assegnargli un nome, ad esempio MyClaimsTransformationModule.

2. Aggiungere un riferimento all'assembly Microsoft.IdentityModel.

3. Aggiungere un riferimento all'assembly System.IdentityModel.

4. Creare una nuova classe e assegnarle un nome, ad esempio ClaimsTransformationModule.

5. Aggiungere alla classe le seguenti dichiarazioni.

   using Microsoft.IdentityModel.Claims;
   using System.Security.Principal;
   

6. Derivare la classe dal tipo ClaimsAuthenticationManager.

7. Ignorare il relativo metodo Authenticate (dove verrà eseguita la trasformazione delle attestazioni). Il proprio codice per il metodo Authenticate può essere basato su quanto segue.

   if (incomingPrincipal != null && incomingPrincipal.Identity.IsAuthenticated == true)
   {
       //DECIDE ON SOME CRITERIA IF CURRENT USER DESERVES THE ROLE
       //IClaimsIdentity identity = (IClaimsIdentity)incomingPrincipal.Identity;
       ((IClaimsIdentity)incomingPrincipal.Identity).Claims.Add(
           new Claim(ClaimTypes.Role, "Admin"));
   }
   return incomingPrincipal;
   

8. Passare all'applicazione ASP.NET e configurare il componente ClaimsAuthenticationManager personalizzato nel relativo file web.config.

     <microsoft.identityModel>
       <service>
         <claimsAuthenticationManager type="MyClaimsTransformationModule.ClaimsTransformationModule, MyClaimsTransformationModule" />
   

9. Accertarsi che il nuovo assembly creato possa essere trovato dall'applicazione. Il modo più semplice è quello di inserirlo nella cartella bin dell'applicazione.

Passaggio 5: Verificare il lavoro eseguito

Questo passaggio consente di verificare che la soluzione funzioni. Per eseguire il test della soluzione, premere F5. L'applicazione Web ASP.NET dovrebbe essere eseguita in modalità di debug. È possibile aggiungere punti di interruzione per verificare l'esecuzione del codice in Visual Studio. Si dovrebbe innanzitutto essere reindirizzati alla pagina di autenticazione del provider di identità configurato per la federazione. Al termine dell'autenticazione, si dovrebbe essere reindirizzati di nuovo alla pagina Default.aspx senza che venga generata un'eccezione. Questo significa che tutte le richieste di sicurezza relative al ruolo utente sono state soddisfatte.

Elementi correlati

• Procedura: Implementare l'autorizzazione delle attestazioni in un'applicazione ASP.NET con riconoscimento delle attestazioni tramite WIF e ACS