ASP.NET

Avviare Visual Studio .NET e creare una nuova applicazione Web ASP.NET Visual C# denominata GenericPrincipalApp.

Rinominare WebForm1.aspx come Logon.aspx.

Aggiungere i controlli riportati di seguito a Logon.aspx per creare un modulo di accesso.

Tabella 1: Controlli di Logon.aspx

Impostare la proprietà TextMode del controllo Casella di testo della password su Password.

In Esplora soluzioni fare clic con il pulsante destro del mouse su GenericPrincipalApp, selezionare Aggiungi, quindi fare clic su Aggiungi Web Form.

Immettere default.aspx come nome del nuovo modulo, quindi fare clic su Apri.

Utilizzare Esplora soluzioni per aprire il file web.config.

Individuare l'elemento <authentication> e modificare l'attributo mode impostandolo su Forms.

Aggiungere l'elemento <forms> che segue come figlio dell'elemento <authentication> e impostare gli attributi loginUrl, name, timeout e path nel modo seguente:

<authentication mode="Forms"> 
  <forms loginUrl="logon.aspx" name="AuthCookie" timeout="60" path="/"> 
  </forms> 
</authentication> 

Aggiungere l'elemento <authorization> riportato di seguito sotto l'elemento <authentication>. In questo modo, l'accesso all'applicazione verrà consentito solo agli utenti autenticati. L'attributo loginUrl dell'elemento <authentication>, definito in precedenza, reindirizza le richieste non autenticate alla pagina Logon.aspx.

<authorization>  
  <deny users="?" /> 
  <allow users="*" /> 
</authorization> 

Aprire il file Logon.aspx.cs e aggiungere l'istruzione using riportata di seguito all'inizio del file, sotto le istruzioni using esistenti.

using System.Web.Security; 

Aggiungere il metodo dell'helper privato riportato di seguito alla classe WebForm1 denominata IsAuthenticated, utilizzata per convalidare i nomi utente e le password durante l'autenticazione degli utenti. Per questo codice viene presupposto che siano valide tutte le combinazioni di nome utente e password.

private bool IsAuthenticated( string username, string password ) 
{ 
  // Lookup code omitted for clarity 
  // This code would typically validate the user name and password 
  // combination against a SQL database or Active Directory 
  // Simulate an authenticated user 
  return true; 
} 

Aggiungere il metodo dell'helper privato denominato GetRoles riportato di seguito, utilizzato per ottenere l'insieme dei ruoli dell'utente.

private string GetRoles( string username, string password ) 
{ 
  // Lookup code omitted for clarity 
  // This code would typically look up the role list from a  
  database table. 
  // If the user was being authenticated against Active Directory, the 
  // Security groups and/or distribution lists that the user  
  belongs to may be  
  // used instead 
  // This GetRoles method returns a pipe delimited string containing  
  roles 
  // rather than returning an array, because the string format is  
  convenient  
  // for storing in the authentication ticket / cookie, as user data 
  return "Senior Manager|Manager|Employee"; 
} 

Visualizzare il modulo Logon.aspx in modalità progettazione, quindi fare doppio clic sul pulsante Accedi per creare un gestore eventi Click.

Aggiungere una chiamata al metodo IsAuthenticated, specificando il nome utente e la password acquisiti tramite il modulo di accesso. Assegnare il valore restituito a una variabile di tipo bool, che indica se l'utente è autenticato o meno.

bool isAuthenticated = IsAuthenticated( txtUserName.Text,  
                                        txtPassword.Text ); 

Se l'utente è autenticato, aggiungere una chiamata al metodo GetRoles per ottenere l'elenco dei ruoli dell'utente.

if (isAuthenticated == true ) 
{ 
  string roles = GetRoles( txtUserName.Text, txtPassword.Text ); 

Creare un nuovo ticket di autenticazione basata su moduli contenente il nome utente, la data di scadenza e l'elenco dei ruoli dell'utente. Si noti che la proprietà User data del ticket di autenticazione viene utilizzata per archiviare l'elenco dei ruoli dell'utente. Osservare inoltre che il codice riportato di seguito consente di creare un ticket non permanente, anche se il fatto che il ticket o cookie sia permanente o meno dipende dallo scenario dell'applicazione specifica.

  // Create the authentication ticket 
  FormsAuthenticationTicket authTicket = new  
       FormsAuthenticationTicket(1,                          // version 
                                 txtUserName.Text,           // user name 
                                 DateTime.Now,               // creation 
                                 DateTime.Now.AddMinutes(60),// Expiration 
                                 false,                      // Persistent 
                                 roles );                    // User data 

Aggiungere il codice per creare una rappresentazione del ticket in formato di stringa crittografata e archiviarla come dati all'interno di un oggetto HttpCookie .

  // Now encrypt the ticket. 
  string encryptedTicket = FormsAuthentication.Encrypt(authTicket); 
  // Create a cookie and add the encrypted ticket to the  
  // cookie as data. 
  HttpCookie authCookie =  
               new HttpCookie(FormsAuthentication.FormsCookieName, 
                              encryptedTicket); 

Aggiungere il cookie all'insieme di cookie restituito al browser dell'utente.

  // Add the cookie to the outgoing cookies collection.  
  Response.Cookies.Add(authCookie);  

Reindirizzare l'utente alla pagina richiesta in origine.

  // Redirect the user to the originally requested page 
  Response.Redirect( FormsAuthentication.GetRedirectUrl( 
                                                txtUserName.Text,  
                                                false )); 
} 

Da Esplora soluzioni aprire global.asax.

Passare alla visualizzazione del codice e aggiungere all'inizio del file le seguenti istruzioni using:

using System.Web.Security; 
using System.Security.Principal; 

Individuare il gestore eventi Application_AuthenticateRequest e aggiungere il codice riportato di seguito per ottenere il cookie di autenticazione basata su moduli dall'insieme di cookie passato con la richiesta.

// Extract the forms authentication cookie 
string cookieName = FormsAuthentication.FormsCookieName; 
HttpCookie authCookie = Context.Request.Cookies[cookieName]; 
if(null == authCookie) 
{ 
  // There is no authentication cookie. 
  return; 
}  

Aggiungere il codice riportato di seguito per estrarre il ticket di autenticazione dal cookie di autenticazione basata su moduli e decrittografarlo.

FormsAuthenticationTicket authTicket = null; 
try 
{ 
  authTicket = FormsAuthentication.Decrypt(authCookie.Value); 
} 
catch(Exception ex) 
{ 
  // Log exception details (omitted for simplicity) 
  return; 
} 
if (null == authTicket) 
{ 
  // Cookie failed to decrypt. 
  return;  
}  

Aggiungere il codice riportato di seguito per analizzare l'elenco dei nomi dei ruoli separati da barre verticali associato al ticket quando l'utente è stato autenticato in origine.

// When the ticket was created, the UserData property was assigned a 
// pipe delimited string of role names. 
string[] roles = authTicket.UserData.Split(new char[]{'|'}); 

Aggiungere il codice riportato di seguito per creare un oggetto FormsIdentity con il nome utente ottenuto dal nome del ticket e un oggetto GenericPrincipal contenente l'identità stessa e il relativo elenco dei ruoli utente.

// Create an Identity object 
FormsIdentity id = new FormsIdentity( authTicket );  
// This principal will flow throughout the request. 
GenericPrincipal principal = new GenericPrincipal(id, roles); 
// Attach the new principal object to the current HttpContext object 
Context.User = principal; 

In Esplora soluzioni fare doppio clic su default.aspx.

Fare doppio clic sul modulo Web default.aspx per visualizzare il gestore eventi di caricamento della pagina.

Scorrere verso l'inizio del file e aggiungere l'istruzione using riportata di seguito sotto le istruzioni using esistenti.

using System.Security.Principal; 

Tornare al gestore eventi di caricamento della pagina e aggiungere il codice riportato di seguito per visualizzare il nome di identità correlato all'oggetto GenericPrincipal associato alla richiesta Web corrente.

IPrincipal p = HttpContext.Current.User; 
Response.Write( "Authenticated Identity is: " +   
                p.Identity.Name ); 
Response.Write( "<p>" ); 

Aggiungere il codice riportato di seguito per verificare l'appartenenza ai ruoli dell'identità autenticata corrente.

if ( p.IsInRole("Senior Manager") ) 
  Response.Write( "User is in Senior Manager role<p>" ); 
else 
  Response.Write( "User is not in Senior Manager role<p>" ); 
if ( p.IsInRole("Manager") ) 
  Response.Write( "User is in Manager role<p>" ); 
else 
  Response.Write( "User is not in Manager role<p>" ); 
if ( p.IsInRole("Employee") ) 
  Response.Write( "User is in Employee role<p>" ); 
else 
  Response.Write( "User is not in Employee role<p>" ); 
if ( p.IsInRole("Sales") ) 
  Response.Write( "User is in Sales role<p>" ); 
else 
  Response.Write( "User is not in Sales role<p>" ); 

In Esplora soluzioni fare clic con il pulsante destro del mouse su default.aspx, quindi fare clic su Imposta come pagina iniziale.

Scegliere Genera soluzione dal menu Genera. Eliminare eventuali errori di generazione.

Premere Ctrl+F5 per eseguire l'applicazione. Poiché default.aspx è configurata come pagina iniziale, questa è la pagina richiesta inizialmente.

Quando si viene reindirizzati alla pagina di accesso poiché inizialmente non si dispone di un ticket di autenticazione, immettere un nome utente e una password qualsiasi, quindi fare clic su Accedi.

Verificare che l'utente venga reindirizzato alla pagina default.aspx e che vengano visualizzati l'identità dell'utente e i dettagli corretti relativi ai ruoli. L'utente deve risultare un membro dei ruoli Senior Manager, Manager ed Employee ma non del ruolo Sales.