Principios de usuario.GetAuthorizationGroups Se produjo un error (1301) al enumerar los grupos. Después de actualizar al Controlador de Dominio Server 2012

Experimentamos este problema cuando nuestro equipo de infraestructura puso en línea un Controlador de Dominio de 2012. También teníamos DCs pre-2012 en su lugar y por lo que experimentamos el problema de forma intermitente. Se nos ocurrió una solución que quería compartir-tiene 2 partes.

En primer lugar, instale el hotfix mencionado por Gary Hill. Esto resolverá el siguiente problema:

Se produjo un error (1301) al enumerar los grupos. El SID del grupo no podía ser resuelto.

Pensamos que estábamos en casa libre después de instalar este hotfix. Sin embargo, después de que se instaló, obtuvimos un error intermitente diferente. Ciertos grupos que estábamos interrogando tenían una propiedad null sAMAccountName. La propiedad real estaba poblada en Active Directory, pero la API la devolvía incorrectamente con un valor null. Supongo que esto es un error en algún lugar de la API de Active Directory, pero no sé más que eso.

Afortunadamente estábamos capaz de solucionar el problema cambiando a usar la propiedad group Name en lugar de la propiedad sAMAccountName. Esto funcionó para nosotros. Creo que sAMAccountName está efectivamente en desuso y solo existe por razones de compatibilidad con versiones anteriores. Siendo ese el caso, parecía un cambio razonable.

Adjunto una versión reducida de nuestro código GetRolesForUser para demostrar el cambio en su lugar.

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

Espero que eso ayude.

Aquí está mi solución. Parece funcionar consistentemente bien. Debido a que el problema ocurre cuando se itera sobre la colección, uso un enfoque diferente cuando se itera para manejar la excepción sin bloquear la iteración real:

private string[] GetUserRoles(string Username)
{    
    List<string> roles = new List<string>();
    try
    {
        string domain = Username.Contains("\\") ? Username.Substring(0, Username.IndexOf("\\")) : string.Empty;
        string username = Username.Contains("\\") ? Username.Substring(Username.LastIndexOf("\\") + 1) : Username;
        if (!string.IsNullOrEmpty(domain) && !string.IsNullOrEmpty(username))
        {
            PrincipalContext principalContext = new PrincipalContext(ContextType.Domain, domain);
            UserPrincipal user = UserPrincipal.FindByIdentity(principalContext, username);
            if (user != null)
            {
                PrincipalSearchResult<Principal> groups = user.GetAuthorizationGroups();
                int count = groups.Count();
                for (int i = 0; i < count; i++)
                {
                    IEnumerable<Principal> principalCollection = groups.Skip(i).Take(1);
                    Principal principal = null;
                    try
                    {
                        principal = principalCollection.FirstOrDefault();
                    }
                    catch (Exception e)
                    {
                        //Error handling...
                        //Known exception - sometimes AD can't query a particular group, requires server hotfix?
                        //http://support.microsoft.com/kb/2830145
                    }

                    if (principal!=null && principal is GroupPrincipal)
                    {
                        GroupPrincipal groupPrincipal = (GroupPrincipal)principal;
                        if (groupPrincipal != null && !string.IsNullOrEmpty(groupPrincipal.Name))
                        {
                            roles.Add(groupPrincipal.Name.Trim());
                        }
                    }
                }
            }
        }
    }
    catch (Exception e)
    {
        //Error handling...
    }
    return roles.ToArray();
}

Experimenté el código de error 1301 con UserPrincipal.GetAuthorizationGroups mientras usaba un nuevo dominio de desarrollo virtual que contenía 2 estaciones de trabajo y 50 usuarios/grupos (muchos de los cuales son los integrados). Estábamos ejecutando Windows Server 2012 R2 Essentials con dos estaciones de trabajo de la empresa de Windows 8,1 unidas al dominio.

Pude obtener recursivamente una lista de miembros del grupo de un usuario usando el siguiente código:

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

Estoy en un entorno con múltiples bosques de dominios y confianzas. Tengo más o menos este mismo código que se ejecuta en un formulario de sitio web utilizado para realizar búsquedas de grupos de seguridad de usuarios en los diferentes dominios.

Obtengo este error exacto en uno de los dominios muy grandes donde la membresía de grupo puede incluir más de 50 grupos diferentes. Funciona bien en otros dominios bosques.

En mi investigación encontré un hilo que parece no estar relacionado, pero en realidad tiene el mismo rastro de pila. Es para un control remoto aplicación ejecutándose en SBS. El hilo menciona que el error es causado por SID irresolubles en un grupo. Creo que estos serían lo que se conoce como "tombstoned" SIDS en active directory. Ver el hilo aquí.

El hilo sugiere que encontrar las enteries sepulcrales y eliminarlas de los grupos resuelve el problema. ¿Es posible que el error que está recibiendo se deba a que los SMSL están siendo sepultados cada 12 horas por un proceso separado no relacionado? En última instancia, creo que esto es un error en el framework, y que el método no debe bloquearse debido a los SID tombstoned/irresolubles.

¡Buena suerte!

Si alguien está interesado este es un VB.NET versión del mismo código. Pocas cosas que tienes que hacer antes de que este código pueda funcionar

1) Tiene que hacer referencia al Sistema de ensamblaje.DirectoryServices
2) Asegúrese de pasar la variable "theusername" sin el dominio, por lo que si su dominio es "GIS" y su nombre de usuario es "Hussein", Windows generalmente lo autentica como GIS\Hussein. Así que tienes que enviar solo el nombre de usuario "Hussein". Resolví las cosas sensibles a mayúsculas y minúsculas.
3) El método GetGroupsNew toma un nombre de usuario y devuelve una lista de grupos
4) El método isMemberofnew toma un nombre de usuario y un grupo y verifica que este usuario es parte de ese grupo o no, este es el que me interesaba.

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

Tuvimos un problema similar después de actualizar el controlador de dominio a 2012. De repente mi llamada al usuario.GetAuthorizationGroups() comenzó a fallar; estaba recibiendo la misma excepción que tú (error 1301). Por lo tanto, lo cambié a usuario.GetGroups(). Eso funcionó por un tiempo, luego comenzó a fallar intermitentemente en "mal nombre de usuario o contraseña". Mi última solución parece solucionarlo, al menos por el momento. En lugar de llamar a cualquiera de ellos, después de construir el objeto user, también construyo un objeto de grupo, uno para cada grupo del que quiero ver si el usuario es miembro. es decir, " usuario.IsMemberOf(grupo)". Eso parece funcionar.

try
{
using (HostingEnvironment.Impersonate())
{
    using (var principalContext = new PrincipalContext(ContextType.Domain, "MYDOMAIN"))
    {
        using (var user = UserPrincipal.FindByIdentity(principalContext, userName))
        {
            if (user == null)
            {
                Log.Debug("UserPrincipal.FindByIdentity failed for userName = " + userName + ", thus not authorized!");
                isAuthorized = false;
            }

            if (isAuthorized)
            {
                firstName = user.GivenName;
                lastName = user.Surname;

                // so this code started failing:

                // var groups = user.GetGroups();
                // adGroups.AddRange(from @group in groups where 
                // @group.Name.ToUpper().Contains("MYSEARCHSTRING") select @group.Name);

                // so the following workaround, which calls, instead, 
                // "user.IsMemberOf(group)", 
                // appears to work (for now at least).  Will monitor for issues.

                // test membership in SuperUsers
                const string superUsersGroupName = "MyApp-SuperUsers";
                using (var superUsers = GroupPrincipal.FindByIdentity(principalContext, superUsersGroupName))
                {
                    if (superUsers != null && user.IsMemberOf(superUsers))
                        // add to the list of groups this user is a member of
                        // then do something with it later
                        adGroups.Add(superUsersGroupName);                                        
                }

Tuve la misma excepción. Si alguien no quiere usar "LDAP", use este código. Porque tengo grupos anidados, estoy usando GetMembers (true) y es un poco más largo en el tiempo que GetMembers ().

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

O descarga corrección desde aquí: http://support.microsoft.com/kb/2830145

Ante el mismo problema enumerar grupos de autorización y los parches indicados en la respuesta no se aplicaban a nuestro servidor web.

Enumerar e ignorar manualmente los grupos que causan problemas está funcionando bien, sin embargo:

private static bool UserIsMember(string usr, string grp)
{
    usr = usr.ToLower();
    grp = grp.ToLower();

    using (var pc = new PrincipalContext(ContextType.Domain, "DOMAIN_NAME"))
    {
        using (var user = UserPrincipal.FindByIdentity(pc, usr))
        {
            var isMember = false;
            var authGroups = user?.GetAuthorizationGroups().GetEnumerator();

            while (authGroups?.MoveNext() ?? false)
            {
                try
                {

                    isMember = authGroups.Current.Name.ToLower().Contains(grp);
                    if (isMember) break;
                }
                catch
                {
                    // ignored
                }
            }

            authGroups?.Dispose();
            return isMember;
        }
    }
}