c# - servidor - UserPrincipals.GetAuthorizationGroups Se produjo un error(1301) al enumerar los grupos. Después de actualizar a Server 2012 Domain Controller
error al intentar unirse al dominio windows server 2012 (9)
Investigación:
Problema similar con solución temporal, pero no solución real al problema existente
Problema similar que señala la actualización de Microsoft End Point como culpable
Los enlaces anteriores son los más adecuados para mi problema, también he visto todas las preguntas similares enumeradas por Stack Overflow al crear esta publicación, y solo las preguntas mencionadas anteriormente se ajustan a mi problema.
Fondo:
He estado utilizando UserPrincipal.GetAuthorizationGroups para obtener permisos de acceso a páginas específicas que ejecutan IIS 7.5 en Server 2008 R2 en un sitio de formularios web C # .NET 4.0 durante 2 años y medio. El 15 de mayo de 2013 eliminamos un controlador de dominio principal que ejecuta el servidor 2008 (no r2) y lo reemplazamos con un controlador de dominio del servidor 2012. Al día siguiente empezamos a recibir la excepción que se detalla a continuación.
Uso el contexto principal para la autenticación de formularios. El UserPrincipal.GetAuthorizationGroups nombre de usuario / pase se realiza correctamente y la cookie de autenticación está configurada correctamente, pero la llamada subsiguiente de contexto principal que también llama a UserPrincipal.GetAuthorizationGroups falla intermitentemente. Hemos resuelto algunos problemas de BPA que aparecieron en el controlador de dominio de Server 2012, pero esto aún tiene que resolver el problema. También instituí un cron que se ejecuta en dos servidores separados. Los dos servidores fallarán en la resolución del SID del grupo en diferentes momentos aunque estén ejecutando la misma base de código. (Un entorno de desarrollo y entorno de producción).
El problema se resuelve temporalmente al reiniciar el servidor web, y también en el servidor de desarrollo se resolverá después de 12 horas de inactividad. El servidor de producción generalmente dejará de funcionar correctamente hasta que se reinicie sin resolverse.
En este punto, estoy tratando de refinar el cron que apunta a controladores de dominio específicos en la red, así como también el nuevo DC y el uso de la consulta LDAP estándar que actualmente no produce tiempos de excepción más específicos. Hasta ahora hemos encontrado en un servidor web que no existe un patrón para los días en los que falla, pero se recuperará en aproximadamente 12 horas. Los últimos resultados muestran la falla de resolución del SID grupal entre las 8:00 a.m.-8:00 p.m., luego se recupera, varios días después fallará a las 8:00 p.m. y se recuperará a las 8 a.m., se ejecutará bien durante otras 12 horas y fallará nuevamente. Esperamos ver si se trata de un problema de comunicación del servidor específico o si se trata del conjunto completo de controladores de dominio.
Excepción:
Exception information:
Exception type: PrincipalOperationException
Exception message: An error (1301) occurred while enumerating the groups.
The group''s SID could not be resolved.
at System.DirectoryServices.AccountManagement.SidList.TranslateSids(String target, IntPtr[] pSids)
at System.DirectoryServices.AccountManagement.SidList..ctor(SID_AND_ATTR[] sidAndAttr)
at System.DirectoryServices.AccountManagement.AuthZSet..ctor(Byte[] userSid, NetCred credentials, ContextOptions contextOptions, String flatUserAuthority, StoreCtx userStoreCtx, Object userCtxBase)
at System.DirectoryServices.AccountManagement.ADStoreCtx.GetGroupsMemberOfAZ(Principal p)
at System.DirectoryServices.AccountManagement.UserPrincipal.GetAuthorizationGroups()
Pregunta:
Dada la información anterior, ¿alguien tiene alguna idea de por qué el desmantelamiento de Windows Server 2008 (no r2) y la implementación de un nuevo DC Server 2012 causaría que UserPrincipal.GetAuthorizationGroups fallara con el error de resolución 1301 SID? Las ideas sobre la eliminación de posibles causas también serían apreciadas.
Renuncia:
Esta es mi primera publicación en Stack Overflow. A menudo investigo aquí pero hasta ahora no me he unido a las discusiones. Perdóneme si debería haber publicado en otro lugar y no dude en señalar mejores pasos antes de publicar.
ACTUALIZACIÓN 13-JUN-2013:
El 12 de junio abordé la posibilidad de que los artículos no eliminados causen el problema. El marco de tiempo ha sido demasiado corto para determinar si el código ajustado ha solucionado el problema, pero continuaré actualizando a medida que trabajemos hacia una resolución tal que quizás con algo de suerte alguien aquí pueda echar una mano.
Código original
public bool isGroupMember(string userName, ArrayList groupList)
{
bool valid = false;
PrincipalContext ctx = new PrincipalContext(ContextType.Domain, domain_server + ".domain.org:636", null, ContextOptions.Negotiate | ContextOptions.SecureSocketLayer);
// find the user in the identity store
UserPrincipal user =
UserPrincipal.FindByIdentity(
ctx,
userName);
// get the groups for the user principal and
// store the results in a PrincipalSearchResult object
PrincipalSearchResult<Principal> groups =
user.GetAuthorizationGroups();
// display the names of the groups to which the
// user belongs
foreach (Principal group in groups)
{
foreach (string groupName in groupList)
{
if (group.ToString() == groupName)
{
valid = true;
}
}
}
return valid;
}
Código actualizado
public bool isGroupMember(string userName, ArrayList groupList, string domain_server)
{
bool valid = false;
try
{
using (PrincipalContext ctx = new PrincipalContext(ContextType.Domain, domain_server + ".domain.org:636", null, ContextOptions.Negotiate | ContextOptions.SecureSocketLayer))
{
// find the user in the identity store
UserPrincipal user =
UserPrincipal.FindByIdentity(
ctx,
userName);
try
{
// get the groups for the user principal and
// store the results in a PrincipalSearchResult object
using (PrincipalSearchResult<Principal> groups = user.GetAuthorizationGroups())
{
// display the names of the groups to which the
// user belongs
foreach (Principal group in groups)
{
foreach (string groupName in groupList)
{
if (group.ToString() == groupName)
{
valid = true;
}
}
group.Dispose();
}
}//end using-2
}
catch
{
log_gen("arbitrary info");
return false;
}
}//end using-1
}
catch
{
log_gen("arbitrary info");
return false;
}
return valid;
}
Aquí está mi solución. Parece que funciona bien constantemente. Como el problema ocurre al iterar sobre la colección, utilizo un enfoque diferente al iterar 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();
}
Estoy en un entorno con bosques de dominio múltiple y fideicomisos. Tengo prácticamente 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.
Me sale este error exacto en uno de los dominios muy grandes donde la membresía del grupo puede incluir más de 50 grupos diferentes. Funciona bien en otros dominios forestales.
En mi investigación encontré un hilo que parece no relacionado, pero en realidad tiene el mismo rastro de pila. Es para una aplicación remota que se ejecuta en SBS. El hilo menciona que el error es causado por SIDS irresolubles en un grupo. Creo que estos serían lo que se conoce como SIDS "Tombstoned" en el directorio activo. Mira el hilo aquí .
El hilo sugiere que encontrar las enterradas y eliminarlas de los grupos resuelve el problema. ¿Es posible que el error que está recibiendo se deba a que los SMIS se están volcando cada 12 horas por un proceso independiente no relacionado? En última instancia, creo que esto es un error en el marco, y que el método no debería colapsar debido a SIDS desmembrados / no resueltos.
¡Buena suerte!
Acabo de encontrarme con este mismo problema y la información que he logrado rastrear puede ser útil; como se muestra arriba, hemos visto este problema donde el controlador de dominio ejecuta Server 2012, primero con una implementación de cliente y luego se replica en nuestra propia red.
Después de algunos experimentos, descubrimos que nuestro código correría bien en Server 2012, pero pulsó el código de error 1301 cuando el sistema cliente ejecutaba Server 2008. Aquí se encontró la información clave sobre lo que estaba sucediendo:
La revisión a la que se hace referencia en el siguiente enlace ha solucionado el problema en nuestro sistema de prueba
SID S-1-18-1 y SID S-1-18-2 no pueden ser mapeados
Espero que esto sea útil para alguien. Como muchos han notado, este método parece bastante frágil y probablemente veamos la implementación de algún enfoque alternativo antes de abordar otros problemas.
Gary
Experimentamos este problema cuando nuestro equipo de infraestructura trajo un controlador de dominio 2012 en línea. También teníamos DC pre-2012 en funcionamiento, por lo que experimentamos el problema de forma intermitente. Se nos ocurrió una solución que quería compartir, tiene 2 partes.
Antes que nada, instale la revisión mencionada por Gary Hill. Esto resolverá el siguiente problema:
Se produjo un error (1301) al enumerar los grupos. El SID del grupo no se pudo resolver.
Pensamos que estábamos en casa gratis después de instalar este hotfix. Sin embargo, después de que se instaló, recibimos un error intermitente diferente. Ciertos grupos que estábamos interrogando tenían una propiedad nulo sAMAccountName . La propiedad real se llenó en Active Directory pero la API la devolvió incorrectamente con un valor nulo. Supongo que es un error en alguna parte de la API de Active Directory, pero no sé más que eso.
Afortunadamente, pudimos evitar el problema al cambiar para usar la propiedad del Name del grupo en lugar de la propiedad sAMAccountName . Esto funcionó para nosotros. Creo que sAMAccountName está en desuso y existe solo 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 ayude.
tuvimos un problema similar después de actualizar el controlador de dominio a 2012. De repente, mi llamada a user.GetAuthorizationGroups () comenzó a fallar; Obtuve la misma excepción que usted (error 1301). Entonces, 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 de usuario, también construyo un objeto de grupo, uno para cada grupo que quiero ver si el usuario es miembro de. es decir, "user.IsMemberOf (group)". 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);
}
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 están integrados). Estábamos ejecutando Windows Server 2012 R2 Essentials con dos estaciones de trabajo Windows 8.1 Enterprise unidas al dominio.
Pude obtener recursivamente una lista de la membresía de un grupo de usuarios 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");
}
}
Si alguien está interesado, esta es una versión de VB.NET del mismo código. Pocas cosas que tienes que hacer antes de que este código pueda funcionar
1) Debe hacer referencia al conjunto System.DirectoryServices
2) Asegúrese de pasar la variable "theuseruser" sin el dominio, por lo tanto, si su dominio es "GIS" y su nombre de usuario es "Hussein", Windows generalmente lo autenticará como GIS / Hussein. Entonces debes enviar simplemente el nombre de usuario "Hussein". Resolví las cosas sensibles a las 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 es Memberofnew toma un nombre de usuario y un grupo y verifica que este usuario es parte de ese grupo o no, este es el que estaba interesado.
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
Enfrentar el mismo problema al enumerar los grupos de autorización y los parches anotados en la respuesta no se aplicaba a nuestro servidor web.
Sin embargo, enumerar e ignorar manualmente los grupos causantes de problemas funciona bien:
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;
}
}
}
Tuve la misma excepción. Si alguien no quiere usar "LDAP", use este código. Porque tengo grupos anidados, me utilizan GetMembers (verdadero) y es un poco más largo que GetMembers ().
https://.com/a/27548271/1857271
o solución de descarga desde aquí: http://support.microsoft.com/kb/2830145