Veja se o usuário faz parte do grupo do Active Directory em C # + Asp.net

Eu preciso de uma maneira de ver se um usuário faz parte de um grupo de diretórios ativo do meu aplicativo .net 3.5 asp.net c #.

Eu estou usando o exemplo de autenticação ldap padrão fora do msdn, mas eu realmente não vejo como verificar contra um grupo.

Com 3.5 e System.DirectoryServices.AccountManagement isso é um pouco mais limpo:

public List GetGroupNames(string userName) { var pc = new PrincipalContext(ContextType.Domain); var src = UserPrincipal.FindByIdentity(pc, userName).GetGroups(pc); var result = new List(); src.ToList().ForEach(sr => result.Add(sr.SamAccountName)); return result; } 

A solução de Nick Craver não funciona para mim no .NET 4.0. Eu recebo um erro sobre um AppDomain descarregado. Em vez de usar isso, eu usei isso (só temos um domínio). Isto irá verificar grupos de grupos, bem como membros diretos do grupo.

 using System.DirectoryServices.AccountManagement; using System.Linq; ... using (var ctx = new PrincipalContext(ContextType.Domain, yourDomain)) { using (var grp = GroupPrincipal.FindByIdentity(ctx, IdentityType.Name, yourGroup)) { bool isInRole = grp != null && grp .GetMembers(true) .Any(m => m.SamAccountName == me.Identity.Name.Replace(yourDomain + "\\", "")); } } 

O código abaixo funcionará no .net 4.0

 private static string[] GetGroupNames(string userName) { List result = new List(); using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, "YOURDOMAIN")) { using (PrincipalSearchResult src = UserPrincipal.FindByIdentity(pc, userName).GetGroups(pc)) { src.ToList().ForEach(sr => result.Add(sr.SamAccountName)); } } return result.ToArray(); } 

Solução Simples

 PrincipalContext pc = new PrincipalContext((Environment.UserDomainName == Environment.MachineName ? ContextType.Machine : ContextType.Domain), Environment.UserDomainName); GroupPrincipal gp = GroupPrincipal.FindByIdentity(pc, "{GroupName}"); UserPrincipal up = UserPrincipal.FindByIdentity(pc, Environment.UserName); up.IsMemberOf(gp); 

Esse método pode ser útil se você estiver tentando determinar se o usuário atual autenticado do Windows está em uma function específica.

 public static bool CurrentUserIsInRole(string role) { try { return System.Web.HttpContext.Current.Request .LogonUserIdentity .Groups .Any(x => x.Translate(typeof(NTAccount)).ToString() == role); } catch (Exception) { return false; } } 

Depende do que você entende por se um usuário está em um grupo do AD. No AD, os grupos podem ser um grupo de segurança ou um grupo de distribuição. Mesmo para grupos de segurança, depende de grupos como “Usuários do domínio” ou “Usuários” precisarem ser incluídos na verificação de associação.

O IsUserInSecurityGroup só verificará grupos de segurança e funcionará para grupos de grupos como “Usuários do Domínio” e “Usuários”, e não grupos de distribuição. Também resolverá o problema com grupos nesteds. IsUserInAllGroup também verificará para grupos de distribuição, mas não tenho certeza se você teria problemas de permissão. Se você fizer isso, use uma conta de serviço que esteja no WAAG ( consulte o MSDN )

O motivo pelo qual não estou usando o UserPrincipal.GetAuthorizedGroups () é porque ele tem muitos problemas, como exigir que a conta de chamada esteja no WAAG e exigir que não haja uma input no SidHistory ( veja o comentário de David Thomas ).

 public bool IsUserInSecurityGroup(string user, string group) { return IsUserInGroup(user, group, "tokenGroups"); } public bool IsUserInAllGroup(string user, string group) { return IsUserInGroup(user, group, "tokenGroupsGlobalAndUniversal"); } private bool IsUserInGroup(string user, string group, string groupType) { var userGroups = GetUserGroupIds(user, groupType); var groupTokens = ParseDomainQualifiedName(group, "group"); using (var groupContext = new PrincipalContext(ContextType.Domain, groupTokens[0])) { using (var identity = GroupPrincipal.FindByIdentity(groupContext, IdentityType.SamAccountName, groupTokens[1])) { if (identity == null) return false; return userGroups.Contains(identity.Sid); } } } private List GetUserGroupIds(string user, string groupType) { var userTokens = ParseDomainQualifiedName(user, "user"); using (var userContext = new PrincipalContext(ContextType.Domain, userTokens[0])) { using (var identity = UserPrincipal.FindByIdentity(userContext, IdentityType.SamAccountName, userTokens[1])) { if (identity == null) return new List(); var userEntry = identity.GetUnderlyingObject() as DirectoryEntry; userEntry.RefreshCache(new[] { groupType }); return (from byte[] sid in userEntry.Properties[groupType] select new SecurityIdentifier(sid, 0)).ToList(); } } } private static string[] ParseDomainQualifiedName(string name, string parameterName) { var groupTokens = name.Split(new[] {"\\"}, StringSplitOptions.RemoveEmptyEntries); if (groupTokens.Length < 2) throw new ArgumentException(Resources.Exception_NameNotDomainQualified + name, parameterName); return groupTokens; } 

Isso parece muito mais simples:

 public bool IsInRole(string groupname) { var myIdentity = WindowsIdentity.GetCurrent(); if (myIdentity == null) return false; var myPrincipal = new WindowsPrincipal(myIdentity); var result = myPrincipal.IsInRole(groupname); return result; } 

Que tal agora

Como escrever uma consulta LDAP para testar se o usuário é membro de um grupo?

Aqui estão meus 2 centavos.

  static void CheckUserGroup(string userName, string userGroup) { var wi = new WindowsIdentity(userName); var wp = new WindowsPrincipal(wi); bool inRole = wp.IsInRole(userGroup); Console.WriteLine("User {0} {1} member of {2} AD group", userName, inRole ? "is" : "is not", userGroup); } 

Brandon Johnson, adorei, usei o que você tinha, mas fiz a seguinte alteração:

 private static string[] GetGroupNames(string domainName, string userName) { List result = new List(); using (PrincipalContext principalContext = new PrincipalContext(ContextType.Domain, domainName)) { using (PrincipalSearchResult src = UserPrincipal.FindByIdentity(principalContext, userName).GetGroups(principalContext)) { src.ToList().ForEach(sr => result.Add(sr.SamAccountName)); } } return result.ToArray(); } 

Você poderia tentar o seguinte código:

 public bool Check_If_Member_Of_AD_Group(string username, string grouptoCheck, string domain, string ADlogin, string ADpassword) {   try {       string EntryString = null;    EntryString = "LDAP://" + domain;       DirectoryEntry myDE = default(DirectoryEntry);       grouptoCheck = grouptoCheck.ToLower();          myDE = new DirectoryEntry(EntryString, ADlogin, ADpassword);       DirectorySearcher myDirectorySearcher = new DirectorySearcher(myDE);       myDirectorySearcher.Filter = "sAMAccountName=" + username;       myDirectorySearcher.PropertiesToLoad.Add("MemberOf");       SearchResult myresult = myDirectorySearcher.FindOne();       int NumberOfGroups = 0;       NumberOfGroups = myresult.Properties["memberOf"].Count - 1;       string tempString = null;       while ((NumberOfGroups >= 0)) {           tempString = myresult.Properties["MemberOf"].Item[NumberOfGroups];      tempString = tempString.Substring(0, tempString.IndexOf(",", 0));           tempString = tempString.Replace("CN=", "");           tempString = tempString.ToLower();      tempString = tempString.Trim();           if ((grouptoCheck == tempString)) {                        return true;      }                  NumberOfGroups = NumberOfGroups - 1;    }            return false;  }  catch (Exception ex) {       System.Diagnostics.Debugger.Break();  }  //HttpContext.Current.Response.Write("Error: 

" & ex.ToString) }
 var context = new PrincipalContext(ContextType.Domain, {ADDomain}, {ADContainer}); var group = GroupPrincipal.FindByIdentity(context, IdentityType.Name, {AD_GROUP_NAME}); var user = UserPrincipal.FindByIdentity(context, {login}); bool result = user.IsMemberOf(group); 

Se você deseja verificar a associação de grupos de usuários, incluindo os grupos nesteds que estão indiretamente vinculados ao grupo pai de usuários, tente usar as propriedades “tokenGroups” conforme abaixo:

 Usando System.DirectoryServices

  public static bool IsMemberOfGroupsToCheck (cadeia DomainServer, cadeia LoginID, cadeia LoginPassword)
         {
             string UserDN = "CN = John.Doe-A, OU = Contas de Administração, OU = Diretório de Usuários, DC = ABC, DC = com"
             string ADGroupsDNToCheck = "CN = ADGroupTocheck, OU = Grupos de Administração, OU = Diretório de Grupos, DC = ABC, DC = com";

             byte [] sid, parentSID;
             bool check = false;
             DirectoryEntry parentEntry;
             DirectoryEntry basechildEntry;
             string octetSID;

                 basechildEntry = new DirectoryEntry ("LDAP: //" + DomainServer + "/" + UserDN, LoginID, LoginPassword);
                 basechildEntry.RefreshCache (new String [] {"tokenGroups"});

                 parentEntry = new DirectoryEntry ("LDAP: //" + DomainServer + "/" + ADGroupsDNToCheck, LoginID, LoginPassword);
                 parentSID = (byte []) parentEntry.Properties ["objectSID"]. Valor;
                 octetSID = ConvertToOctetString (parentSID, false, false);

                 foreach (Object GroupSid em basechildEntry.Properties ["tokenGroups"])
                 {
                     sid = (byte []) GroupSid;
                     if (ConvertToOctetString (sid, falso, falso) == octetSID)
                     {
                         check = true;
                         pausa;
                     }
                 }

                 basechildEntry.Dispose ();
                 parentEntry.Dispose ();

                 cheque de retorno;
         }