it-swarm.com.de

Prüfen Sie, ob der Benutzer Teil der Active Directory-Gruppe in C # + Asp.net ist

Ich brauche einen Weg, um zu sehen, ob ein Benutzer Teil einer Active Directory-Gruppe in meiner .Net 3.5 asp.net-Anwendung ist.

Ich verwende das Standard-ldap-Authentifizierungsbeispiel von msdn, sehe aber nicht wirklich, wie man mit einer Gruppe prüft.

45
mike_h

Mit 3.5 und System.DirectoryServices.AccountManagement ist dies ein bisschen sauberer:

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

Die Lösung von Nick Craver funktioniert in .NET 4.0 nicht. Ich erhalte eine Fehlermeldung über eine entladene AppDomain. Anstatt das zu verwenden, habe ich dies verwendet (wir haben nur eine Domäne). Dadurch werden Gruppen von Gruppen sowie die direkte Gruppenmitgliedschaft geprüft.

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 + "\\", ""));
    }
}
19
Dave Markle

Der folgende Code funktioniert in .net 4.0

private static string[] GetGroupNames(string userName)
{
    List<string> result = new List<string>();

    using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, "YOURDOMAIN"))
    {
        using (PrincipalSearchResult<Principal> src = UserPrincipal.FindByIdentity(pc, userName).GetGroups(pc))
        {
            src.ToList().ForEach(sr => result.Add(sr.SamAccountName));
        }
    }

    return result.ToArray();
}
15
Brandon Johnson

Einfachste Lösung

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);
10
Adam

Diese Methode kann hilfreich sein, wenn Sie feststellen möchten, ob der aktuelle authentifizierte Windows-Benutzer eine bestimmte Rolle hat.

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; }
    }
7
p.campbell

Es hängt davon ab, was Sie meinen, wenn sich ein Benutzer in einer AD-Gruppe befindet. In AD können Gruppen eine Sicherheitsgruppe oder Verteilungsgruppe sein. Selbst für Sicherheitsgruppen hängt es davon ab, ob Gruppen wie "Domänenbenutzer" oder "Benutzer" in die Mitgliedschaftsprüfung aufgenommen werden müssen.

IsUserInSecurityGroup sucht nur nach Sicherheitsgruppen und kann für Gruppen von Primärgruppen wie "Domänenbenutzer" und "Benutzer" und nicht für Verteilergruppen verwendet werden. Das Problem wird auch mit verschachtelten Gruppen gelöst. IsUserInAllGroup sucht auch nach Verteilergruppen, aber ich bin mir nicht sicher, ob Sie auf Berechtigungsprobleme stoßen würden. Verwenden Sie in diesem Fall ein Dienstkonto, das sich in WAAG befindet ( siehe MSDN ).

Der Grund, warum ich UserPrincipal.GetAuthorizedGroups () nicht verwende, liegt darin, dass es viele Probleme hat, z. B., dass das anrufende Konto in WAAG vorhanden sein muss und kein Eintrag in SidHistory ( Siehe David Thomas 'Kommentar )

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<SecurityIdentifier> 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<SecurityIdentifier>();

                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;
    }
5
Terry Tsay

Das scheint viel einfacher zu sein:

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;
}
3
Randy Gamage

Hier sind meine 2 Cent.

    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);
    }
3
Leonidius
2
BC.

Brandon Johnson, ich habe es geliebt, ich habe das benutzt, was Sie hatten, aber es hat folgende Änderung vorgenommen:

private static string[] GetGroupNames(string domainName, string userName)
{
    List<string> result = new List<string>();

    using (PrincipalContext principalContext = new PrincipalContext(ContextType.Domain, domainName))
    {
        using (PrincipalSearchResult<Principal> src = UserPrincipal.FindByIdentity(principalContext, userName).GetGroups(principalContext))
        {
            src.ToList().ForEach(sr => result.Add(sr.SamAccountName));
        }
    }

    return result.ToArray();
}
1
Bill Daugherty

Sie könnten den folgenden Code ausprobieren:

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: <br><br>" & ex.ToString)
}
1
Mick Walker

Wenn Sie die Mitgliedschaft der Benutzergruppen überprüfen möchten, einschließlich der verschachtelten Gruppen, die indirekt mit der übergeordneten Benutzergruppe verknüpft sind, können Sie die Eigenschaften "tokenGroups" wie folgt verwenden:

 Verwenden von System.DirectoryServices 

 public static bool IsMemberOfGroupsToCheck (String DomainServer, String LoginID, String LoginPassword) 
 {
 string UserDN = "CN = John.Doe-A, OU = Administratorkonten, OU = Benutzerverzeichnis, DC = ABC, DC = com" 
 Zeichenfolge ADGroupsDNToCheck = "CN = ADGroupTocheck, OU = Verwaltungsgruppen, OU = Gruppenverzeichnis, DC = ABC, DC = com"; 

 Byte [] Sid, parentSID; 
 bool check = false; 
 DirectoryEntry parentEntry; 
 DirectoryEntry basechildEntry; 
 Zeichenfolge octetSID; 

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

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

 foreach (Object GroupSid in basechildEntry.Properties ["tokenGroups"]) 
 {
 sid = (Byte []) GroupSid; 
 if (ConvertToOctetString (sid, false, false) == octetSID) 
 {
 check = true; 
 brechen;
 } 
 } 

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

 Rückkehrprüfung; 
 } 
0
AsGoodAsLight
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);
0