ASP.NET

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

Utilizzare Esplora soluzioni per rinominare WebForm1.aspx come Logon.aspx.

Aggiungere un nuovo riferimento all'assembly in System.DirectoryServices.dll. In tal modo verrà consentito l'accesso allo spazio dei nomi System.DirectoryServices contenente i tipi gestiti per facilitare le query e la manipolazione della Active Directory.

Aggiungere a Logon.aspx i controlli elencati nella tabella 1 per creare un semplice modulo di accesso.

Tabella 1: Controlli di Logon.aspx

Impostare la proprietà TextMode di txtPassword su Password.

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

Nel campo Nome digitare default.aspx, quindi fare clic su Apri.

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

Fare doppio clic su default.aspx per visualizzare il gestore eventi di caricamento della pagina.

Aggiungere il codice riportato di seguito al gestore eventi per visualizzare il nome di identità associato alla richiesta Web corrente.

Response.Write( HttpContext.Current.User.Identity.Name ); 

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 di autenticazione e impostare gli attributi loginUrl, name, timeout e path nel modo seguente:

<authentication mode="Forms"> 
  <forms loginUrl="logon.aspx" name="adAuthCookie" 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, reindirizzerà le richieste non autenticate alla pagina logon.aspx.

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

Salvare il file web.config.

Avviare lo snap-in MMC (Microsoft Management Console) di IIS.

Fare clic con il pulsante destro del mouse sulla directory virtuale dell'applicazione, quindi selezionare Proprietà.

Fare clic sulla scheda Protezione directory, quindi sul pulsante Modifica nel gruppo Controllo autenticazione e accesso anonimo.

Selezionare la casella di controllo Accesso anonimo e deselezionare la casella di controllo Abilita controllo delle password.

Poiché l'account anonimo predefinito IUSR_MACHINE non dispone dell'autorizzazione per accedere ad Active Directory, è necessario creare un nuovo account con privilegi minimi e immettere i relativi dettagli nella finestra di dialogo Metodi di autenticazione.

Fare clic su OK, quindi di nuovo su OK per chiudere la finestra di dialogo Proprietà.

Tornare a Visual Studio .NET, aggiungere un elemento <identity> sotto l'elemento <authorization> nel file web.config e impostare l'attributo <impersonate> su true. In questo modo ASP.NET rappresenterà l'account anonimo specificato in precedenza.

<identity impersonate="true" /> 

In base a tale configurazione, tutte le richieste inoltrate all'applicazione verranno eseguite nel contesto di protezione dell'account anonimo configurato. L'utente specificherà le credenziali tramite il modulo Web per eseguire l'autenticazione rispetto ad Active Directory, ma l'account utilizzato per accedere ad Active Directory sarà l'account anonimo configurato.

Aggiungere un nuovo file di classe C# denominato LdapAuthentication.cs.

Aggiungere un riferimento all'assembly System.DirectoryServices.dll.

Aggiungere le istruzioni using riportate di seguito all'inizio dell'assembly LdapAuthentication.cs.

using System.Text; 
using System.Collections; 
using System.DirectoryServices; 

Rinominare lo spazio dei nomi esistente come FormsAuthAD.

Aggiungere due stringhe private alla classe LdapAuthentication, una per il percorso LDAP ad Active Directory e l'altra per un attributo filtro utilizzato per la ricerca in Active Directory.

private string _path; 
private string _filterAttribute; 

Aggiungere un costruttore pubblico che possa essere utilizzato per inizializzare il percorso di Active Directory.

public LdapAuthentication(string path) 
{ 
  _path = path; 
} 

Aggiungere il metodo IsAuthenticated riportato di seguito, che accetta un nome di dominio, un nome utente e una password come parametri e restituisce il valore bool per indicare se all'interno di Active Directory esiste o meno l'utente con una password corrispondente. Il metodo tenta inizialmente di eseguire il binding ad Active Directory utilizzando le credenziali specificate. Se il binding viene eseguito, il metodo utilizza la classe gestita DirectorySearcher per cercare l'oggetto utente specificato. Se individuato, il membro _path viene aggiornato in modo da puntare all'oggetto utente mentre il membro _filterAttribute viene aggiornato con l'attributo del nome comune dell'oggetto utente.

public bool IsAuthenticated(string domain, string username, string pwd) 
{ 
  string domainAndUsername = domain + @"\" + username; 
  DirectoryEntry entry = new DirectoryEntry( _path,  
                                             domainAndUsername, pwd); 
  try 
  {  
    // Bind to the native AdsObject to force authentication.  
    Object obj = entry.NativeObject; 
    DirectorySearcher search = new DirectorySearcher(entry); 
    search.Filter = "(SAMAccountName=" + username + ")"; 
    search.PropertiesToLoad.Add("cn"); 
    SearchResult result = search.FindOne(); 
    if(null == result) 
    { 
      return false; 
    } 
    // Update the new path to the user in the directory 
    _path = result.Path; 
    _filterAttribute = (String)result.Properties["cn"][0]; 
  } 
  catch (Exception ex) 
  { 
    throw new Exception("Error authenticating user. " + ex.Message); 
  } 
  return true; 
} 

Aggiungere l'implementazione del metodo GetGroups riportata di seguito alla classe LdapAuthentication.

public string GetGroups() 
{ 
  DirectorySearcher search = new DirectorySearcher(_path); 
  search.Filter = "(cn=" + _filterAttribute + ")"; 
  search.PropertiesToLoad.Add("memberOf"); 
  StringBuilder groupNames = new StringBuilder(); 
  try 
  { 
    SearchResult result = search.FindOne(); 
    int propertyCount = result.Properties["memberOf"].Count; 
    String dn; 
    int equalsIndex, commaIndex; 
    for( int propertyCounter = 0; propertyCounter < propertyCount; 
         propertyCounter++) 
    { 
      dn = (String)result.Properties["memberOf"][propertyCounter]; 
      equalsIndex = dn.IndexOf("=", 1); 
      commaIndex = dn.IndexOf(",", 1); 
      if (-1 == equalsIndex) 
      { 
        return null; 
      } 
      groupNames.Append(dn.Substring((equalsIndex + 1),  
                        (commaIndex - equalsIndex) - 1)); 
      groupNames.Append("|"); 
    } 
  } 
  catch(Exception ex) 
  { 
    throw new Exception("Error obtaining group names. " + ex.Message); 
  }  
  return groupNames.ToString(); 
} 

Tornare al modulo Logon.aspx e fare doppio clic sul pulsante Accedi per creare un gestore eventi btnLogon_Click vuoto.

Aggiungere all'inizio del file la seguente istruzione using sotto le istruzioni using esistenti. In questo modo verrà abilitato l'accesso ai metodi FormsAuthentication.

using System.Web.Security; 

Aggiungere il codice per la creazione di una nuova istanza della classe LdapAuthentication inizializzata in modo da fare riferimento all'autenticazione LDAP di Active Directory, come indicato di seguito. È importante ricordarsi di modificare il percorso in modo che faccia riferimento al server Active Directory.

// Path to you LDAP directory server. 
// Contact your network administrator to obtain a valid path. 
string adPath = "LDAP://yourCompanyName.com/DC=yourCompanyName,DC=com";  
LdapAuthentication adAuth = new LdapAuthentication(adPath); 

Aggiungere il codice riportato di seguito per eseguire le seguenti operazioni:

try 
{ 
  if(true == adAuth.IsAuthenticated(txtDomainName.Text,  
                                    txtUserName.Text,  
                                    txtPassword.Text)) 
  { 
    // Retrieve the user's groups 
    string groups = adAuth.GetGroups(); 
    // Create the authetication ticket 
    FormsAuthenticationTicket authTicket =  
        new FormsAuthenticationTicket(1,  // version 
                                      txtUserName.Text, 
                                      DateTime.Now,  
                                      DateTime.Now.AddMinutes(60), 
                                      false, groups); 
    // 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); 
    // Add the cookie to the outgoing cookies collection.  
    Response.Cookies.Add(authCookie);  
    // Redirect the user to the originally requested page 
    Response.Redirect( 
              FormsAuthentication.GetRedirectUrl(txtUserName.Text,  
                                                 false)); 
  } 
  else 
  { 
    lblError.Text =  
         "Authentication failed, check username and password."; 
  } 
} 
catch(Exception ex) 
{ 
  lblError.Text = "Error authenticating. " + ex.Message; 
} 

Utilizzare Esplora soluzioni per aprire global.asax.cs.

Aggiungere all'inizio del file le istruzioni using riportate di seguito.

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

Individuare il gestore eventi Application_AuthenticateRequest e aggiungere il codice riportato di seguito. In tal modo, dalla raccolta di cookie passata con la richiesta, si ottiene il cookie con il ticket crittografato FormsAuthenticationTicket.

// 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 FormsAuthenticationTicket dal cookie e decifrarlo.

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 di gruppi 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 group names. 
String[] groups = authTicket.UserData.Split(new char[]{'|'}); 

Aggiungere il codice riportato di seguito per creare un oggetto GenericIdentity con il nome utente ottenuto dal nome del ticket e un oggetto GenericPrincipal che contenga tale identità insieme all'elenco di gruppi dell'utente.

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

Scegliere Genera soluzione dal menu Genera.

In Esplora soluzioni fare clic con il pulsante destro del mouse su default.aspx, quindi scegliere Visualizza nel browser.

Immettere un nome di dominio, un nome utente e una password validi, quindi fare clic su Accedi.

Se l'autenticazione viene eseguita correttamente, l'utente verrà reindirizzato di nuovo alla pagina default.aspx. Nel codice di questa pagina deve essere visualizzato il nome utente dell'utente autenticato.
Per visualizzare l'elenco dei gruppi a cui appartiene l'utente autenticato, aggiungere il codice riportato di seguito alla fine del gestore eventi Application_AuthenticateRequest nel file global.aspx.cs.

Response.Write("Groups: " + authTicket.UserData + "<br>");