Voir si l'utilisateur fait partie du groupe Active Directory en C# + Asp.net

Nick Craver la solution ne fonctionne pas pour moi .NET 4.0. J'obtiens une erreur à propos d'un déchargé domaine d'application. Au lieu de l'utiliser, j'ai utilisé cette (nous n'avons qu'un seul domaine). Il s'agira de vérifier des groupes de groupes, ainsi que l'appartenance à un groupe.

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

Solution La Plus Simple

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

Cela dépend de ce que tu veux dire par la que si un utilisateur est dans un groupe d'ANNONCES. Dans la ma, les groupes peuvent être un groupe de Sécurité ou d'un groupe de Distribution. Même pour des groupes de sécurité, cela dépend si des groupes comme "Utilisateurs du Domaine" ou "Utilisateurs" ont besoin d'être inclus dans l'adhésion à vérifier.

IsUserInSecurityGroup seulement pour les groupes de sécurité et de travail pour le Groupe Principal genre de groupes comme "Utilisateurs du Domaine" et "Utilisateurs", et non pas des groupes de distribution. Il permettra également de résoudre le problème avec les groupes imbriqués.
IsUserInAllGroup vérifiera également pour les groupes de Distribution, mais je ne suis pas sûr que si vous exécutez dans les problèmes d'autorisation. Si vous le faites, l'utilisation d'un compte de service qui est en WAAG (Voir MSDN)

La raison pour laquelle je ne suis pas à l'aide de UserPrincipal.GetAuthorizedGroups (), c'est parce qu'il a beaucoup de questions, telles que l'obligation de l'appelant en compte dans la WAAG et nécessitant il n'y a pas une entrée dans SidHistory (Voir David Thomas commentaire)

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

Cela semble beaucoup plus simple:

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

Brandon Johnson, adoré, j'ai utilisé ce que vous avez eu, mais apporté la modification suivante:

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

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