UserPrincipals.GetAuthorizationGroups Beim Auflisten der Gruppen ist ein Fehler aufgetreten (1301). Nach dem Upgrade auf Server 2012 Domain Controller

Erlebten wir dieses Problem auf, wenn unser Infrastruktur-team brachte 2012 Domain Controller online. Wir hatten auch pre-2012-DCs vorhanden und so erlebten wir das Problem zeitweise. Wir kamen mit einem Update, das wollte ich teilen - es hat 2 Teile.

Erstens, installieren Sie die hotfix erwähnt von Gary Hill. Dies beheben Sie das folgende Problem:

Einen Fehler (1301) aufgetreten, während die Aufzählung der Gruppen. Die Gruppe, die SID konnte nicht aufgelöst werden.

Dachten wir, wir waren zu Hause, frei nach der Installation dieses hotfix. Jedoch, nachdem es installiert wurde, bekamen wir ein anderes intermittierende Fehler. Bestimmte Gruppen, dass wir die Befragung hatte eine null - sAMAccountName Eigenschaft. Die eigentliche Eigenschaft war besiedelten im Active Directory, aber es war falsch zurückgegeben wird, wobei ein null-Wert von der API. Ich nehme an, dies ist ein Fehler irgendwo in den Active Directory-API, aber ich weiß nicht mehr als das.

Glücklicherweise konnten wir das Problem umgehen, durch den Wechsel zu verwenden, die Gruppe Name - Eigenschaft anstelle der sAMAccountName Eigenschaft. Dieser arbeitete für uns. Ich glaube, dass sAMAccountName ist effektiv veraltet und existiert nur zur Abwärtskompatibilität Gründen. Dieses sein der Fall, es schien eine vernünftige änderung zu stellen.

Ich lege eine abgespeckte version unserer GetRolesForUser - code zu demonstrieren, die ändern an Ort und Stelle.

using (var context = new PrincipalContext(ContextType.Domain, _domainName))
{
    try
    {
        var p = UserPrincipal.FindByIdentity(context, IdentityType.SamAccountName, username);
        if (p == null) throw new NullReferenceException(string.Format("UserPrincipal.FindByIdentity returned null for user: {0}, this can indicate a problem with one or more of the AD controllers", username));

        var groups = p.GetAuthorizationGroups();
        var domain = username.Substring(0, username.IndexOf(@"\", StringComparison.InvariantCultureIgnoreCase)).ToLower();

        foreach (GroupPrincipal group in groups)
        {
            if (!string.IsNullOrEmpty(group.Name))
            {
                var domainGroup = domain + @"\" + group.Name.ToLower();

                if (_groupsToUse.Any(x => x.Equals(domainGroup, StringComparison.InvariantCultureIgnoreCase)))
                {
                    //Go through each application role defined and check if the AD domain group is part of it
                    foreach (string role in roleKeys)
                    {
                        string[] roleMembers = new [] { "role1", "role2" };

                        foreach (string member in roleMembers)
                        {
                            //Check if the domain group is part of the role
                            if (member.ToLower().Contains(domainGroup))
                            {
                                //Cache the Application Role (NOT the AD role)
                                results.Add(role);
                            }
                        }
                    }
                }
            }

            group.Dispose();
        }
    }
    catch (Exception ex)
    {
        throw new ProviderException("Unable to query Active Directory.", ex);
    }
}

Hoffe, das hilft.

InformationsquelleAutor der Antwort

Habe ich erlebt, error code 1301 mit UserPrincipal.GetAuthorizationGroups während der Verwendung einer Marke neue virtuelle Entwicklung-Domäne, die enthalten sind 2 workstations und 50 Benutzer/Gruppen (viele von denen sind, die gebaut sind). Wir wurden mit Windows Server 2012 R2 Essentials mit zwei Windows 8.1 Enterprise-workstations der Domäne.

War ich in der Lage, rekursiv erhalten Sie eine Liste der Gruppenmitgliedschaft eines Benutzers mit dem folgenden code:

class ADGroupSearch
{
    List<String> groupNames;

    public ADGroupSearch()
    {
        this.groupNames = new List<String>();
    }

    public List<String> GetGroups()
    {
        return this.groupNames;
    }

    public void AddGroupName(String groupName)
    {
        this.groupNames.Add(groupName);
    }

    public List<String> GetListOfGroupsRecursively(String samAcctName)
    {
        PrincipalContext ctx = new PrincipalContext(ContextType.Domain, System.Environment.UserDomainName);
        Principal principal = Principal.FindByIdentity(ctx, IdentityType.SamAccountName, samAcctName);
        if (principal == null)
        {
            return GetGroups();
        }
        else
        {
            PrincipalSearchResult<Principal> searchResults = principal.GetGroups();

            if (searchResults != null)
            {
                foreach (GroupPrincipal sr in searchResults)
                {
                    if (!this.groupNames.Contains(sr.Name))
                    {
                        AddGroupName(sr.Name);
                    }
                    Principal p = Principal.FindByIdentity(ctx, IdentityType.SamAccountName, sr.SamAccountName);

                    try
                    {
                        GetMembersForGroup(p);
                    }
                    catch (Exception ex)
                    {
                        //ignore errors and continue
                    }
                }

            }
            return GetGroups();
        }

    }



    private void GetMembersForGroup(Principal group)
    {
        if (group != null && typeof(GroupPrincipal) == group.GetType())
        {
            GetListOfGroupsRecursively(group.SamAccountName);
        } 
    }

    private bool IsGroup(Principal principal)
    {
        return principal.StructuralObjectClass.ToLower().Equals("group");
    }
}

InformationsquelleAutor der Antwort TS12

Wenn jemand interessiert ist, dies ist ein VB.NET version des gleichen Codes.
Einige Dinge, die Sie tun, bevor Sie diesen code arbeiten können

1) Sie haben Verweis auf die assembly System.DirectoryServices


2) Stellen Sie sicher, dass pass "theusername" variable ohne die domain, also wenn Ihre domain "GIS" und Ihr Benutzername ist "Hussein" Windows in der Regel authentifizieren, die Sie als GIS - \ - Hussein. So haben Sie zu senden, in nur rein der username "Hussein". Ich arbeitete zu dem Fall empfindliche Sachen.


3) Die Methode GetGroupsNew nimmt einen Benutzernamen und gibt eine Liste der Gruppen


4) Die Methode isMemberofnew nimmt Sie einen Benutzernamen und ein Gruppe und überprüft, ob dieser Benutzer ist Teil dieser Gruppe ist oder nicht, das ist die, die ich interessiert war.

Private Function getGroupsNew(theusername As String) As List(Of String)
    Dim lstGroups As New List(Of String)
    Try

        Dim allDomains = Forest.GetCurrentForest().Domains.Cast(Of Domain)()

        Dim allSearcher = allDomains.[Select](Function(domain)
                                                  Dim searcher As New DirectorySearcher(New DirectoryEntry("LDAP://" + domain.Name))

                                                  searcher.Filter = [String].Format("(&(&(objectCategory=person)(objectClass=user)(userPrincipalName=*{0}*)))", theusername)

                                                  Return searcher

                                              End Function)

        Dim directoryEntriesFound = allSearcher.SelectMany(Function(searcher) searcher.FindAll().Cast(Of SearchResult)().[Select](Function(result) result.GetDirectoryEntry()))

        Dim memberOf = directoryEntriesFound.[Select](Function(entry)
                                                          Using entry
                                                              Return New With { _
                                                               Key .Name = entry.Name, _
                                                               Key .GroupName = DirectCast(entry.Properties("MemberOf").Value, Object()).[Select](Function(obj) obj.ToString()) _
                                                              }
                                                          End Using

                                                      End Function)



        For Each user As Object In memberOf
            For Each groupName As Object In user.GroupName
                lstGroups.Add(groupName)
            Next
        Next

        Return lstGroups

    Catch ex As Exception
        Throw
    End Try
End Function

Private Function isMemberofGroupNew(theusername As String, thegroupname As String) As Boolean

    Try

        Dim lstGroups As List(Of String) = getGroupsNew(theusername)

        For Each sGroup In lstGroups
            If sGroup.ToLower.Contains(thegroupname.ToLower) Then Return True
        Next

        Return False


    Catch ex As Exception
        Throw
    End Try

End Function

InformationsquelleAutor der Antwort Hussein Nasser

Hatte ich die gleiche exception. Wenn jemand nicht will, verwendet "LDAP", verwenden Sie diesen code. Ursache, die ich bin, hatte, verschachtelte Gruppen, die ich gewohnt bin GetMembers(true) und es ist etwas länger, in der Zeit, als GetMembers().

https://stackoverflow.com/a/27548271/1857271

oder download der fix von hier: http://support.microsoft.com/kb/2830145

InformationsquelleAutor der Antwort Nazar Iaremii