Como: Usar a autenticação baseada em formulário com o Active Directory

Inicie o Visual Studio .NET e crie um novo aplicativo Visual C# ASP.NET da Web denominado FormsAuthAD.

Use o Solution Explorer para renomear o arquivo WebForm1.aspx como Logon.aspx.

Adicione uma nova referência ao conjunto de módulos (assembly) no System.DirectoryServices.dll. Isso proporciona acesso ao espaço para nome System.DirectoryServices que contém tipos gerenciados para ajudar na consulta e manipulação do Active Directory.

Adicione os controles listados na Tabela 1 a Logon.aspx para criar um formulário simples de logon.

Tabela 1: Controles de Logon.aspx

Defina a propriedade TextMode de txtPassword como Password.

No Solution Explorer, clique com o botão direito do mouse em FormsAuthAd, aponte para Add e clique em Add Web Form.

No campo Name, digite default.aspx e clique em Open.

No Solution Explorer, clique com o botão direito do mouse em default.aspx e depois em Set As Start Page.

Clique duas vezes sobre default.aspx para exibir o manipulador de eventos de carga de páginas.

Adicione o código a seguir ao manipulador de eventos para exibir o nome da identidade associado à solicitação da Web atual.

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

Use o Solution Explorer para abrir o arquivo Web.config.

Localize o elemento <authentication> e altere o atributo mode para Forms.

Adicione o seguinte elemento <forms> como um filho do elemento authentication e defina os atributos loginUrl, name, timeout e path conforme demonstrado a seguir:

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

Adicione o seguinte elemento <authorization> abaixo do elemento <authentication>. Isto permitirá que apenas usuários autenticados acessem o aplicativo. O atributo loginUrl do elemento <authentication>, definido anteriormente, redirecionará solicitações não autenticadas para a página logon.aspx.

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

Salve o arquivo Web.config.

Inicie o snap-in MMC (Console de Gerenciamento Microsoft) do IIS.

Clique com o botão direito do mouse no diretório virtual do aplicativo. Em seguida, clique em Propriedades.

Clique na guia Segurança da pasta e no botão Editar no grupo Controle de acesso anônimo e autenticação.

Marque a caixa de seleção Acesso anônimo e desmarque a caixa de seleção Permitir que o IIS controle a senha.

Como a conta anônima padrão IUSR_MACHINE não possui permissão para acessar o Active Directory, crie uma nova conta menos privilegiada e digite os detalhes da conta na caixa de diálogo Métodos de Autenticação.

Clique em OK e clique em OK novamente para fechar a caixa de diálogo Propriedades.

Retorne ao Visual Studio .NET e adicione um elemento <identity> abaixo do elemento <authorization> em Web.config. Defina o atributo de representação como true. Dessa forma, ASP.NET representará a conta anônima especificada anteriormente.

<identity impersonate="true" /> 

Como resultado dessa configuração, todos as solicitações feitas ao aplicativo serão executadas no contexto de segurança da conta anônima configurada. O usuário fornecerá as credenciais por meio do formulário da Web para fins de autenticação no Active Directory, mas a conta usada para acessar o Active Directory será a conta anônima configurada.

Adicione um novo arquivo de classe C# denominado LdapAuthentication.cs.

Adicione uma referência ao conjunto de módulos (assembly) de System.DirectoryServices.dll.

Adicione as instruções using a seguir no início de LdapAuthentication.cs.

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

Renomeie o espaço para nome existente como FormsAuthAD.

Adicione duas seqüências privadas à classe LdapAuthentication; uma para manter o caminho LDAP para o Active Directory e a outra para manter um atributo filter usado para pesquisar no Active Directory.

private string _path; 
private string _filterAttribute; 

Adicione um construtor público que possa ser usado para inicializar o caminho do Active Directory.

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

Adicione o método IsAuthenticated a seguir, que aceita um nome de domínio, um nome de usuário e uma senha, como parâmetros e retorna bool para indicar se existe ou não o usuário com a senha correspondente no Active Directory. O método inicialmente tenta estabelecer uma ligação com o Active Directory usando as credenciais fornecidas. Se esse procedimento for bem-sucedido, o método usará a classe gerenciada DirectorySearcher para pesquisar o objeto do usuário especificado. Se o membro _path for localizado, ele será atualizado para apontar para o objeto de usuário. O membro _filterAttribute será atualizado com o atributo de nome comum do objeto de usuário.

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

Adicione a implementação a seguir do método GetGroups à 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(); 
} 

Retorne ao formulário Logon.aspx e clique duas vezes sobre o botão Log On para criar um manipulador de eventos btnLogon_Click vazio.

No início do arquivo, adicione a instrução using a seguir abaixo das instruções using existentes. Esse procedimento permite o acesso aos métodos FormsAuthentication.

using System.Web.Security; 

Adicione o código para criar uma nova instância da classe LdapAuthentication inicializada para apontar para o Active Directory do LDAP, conforme demonstrado no código a seguir. Lembre-se de alterar o caminho para apontar para o servidor 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); 

Adicione o código a seguir para executar estas etapas:

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

Use o Solution Explorer para abrir o arquivo global.asax.cs.

Adicione as instruções using a seguir ao início do arquivo.

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

Localize o manipulador de eventos Application_AuthenticateRequest e adicione o código a seguir para obter o cookie que contém a FormsAuthenticationTicket criptografada, a partir do conjunto de cookies passado com a solicitação.

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

Adicione o código a seguir para extrair e descriptografar a FormsAuthenticationTicket do cookie.

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

Adicione o código a seguir para analisar a lista separada de pipes de nomes de grupos anexada à permissão quando o usuário foi originalmente autenticado.

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

Adicione o código a seguir para criar um objeto GenericIdentity com o nome do usuário obtido do nome da permissão e um objeto GenericPrincipal que contém essa identidade, junto com a lista de grupos do usuário.

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

No menu Build, clique em Build Solution.

No Solution Explorer, clique com o botão direito do mouse em default.aspx e depois clique em View in Browser.

Digite um nome de domínio, um nome de usuário e uma senha válidos. Em seguida, clique em Log On.

Se sua autenticação for bem-sucedida, você deverá ser redirecionado para default.aspx. O código nesta página deve exibir o nome do usuário autenticado.
Para ver a lista de grupos da qual o usuário autenticado é membro, adicione o código a seguir ao final do manipulador de eventos Application_AuthenticateRequest no arquivo global.aspx.cs.

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