programing

사용자가 C# + As에서 Active Directory 그룹에 속해 있는지 확인합니다.그물

firstcheck 2023. 8. 1. 21:06
반응형

사용자가 C# + As에서 Active Directory 그룹에 속해 있는지 확인합니다.그물

사용자가 의 활성 디렉토리 그룹에 속해 있는지 확인할 수 있는 방법이 필요합니다.Net 3.5 asp.net c# 응용 프로그램.

msdn에서 표준 LDAP 인증 예제를 사용하고 있지만 그룹에 대해 확인하는 방법을 잘 모르겠습니다.

3.5 및 시스템 포함.디렉터리 서비스.계정 관리 이것은 조금 더 깨끗합니다.

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

닉 크레이버의 해결책은 제게 도움이 되지 않습니다.NET 4.0.언로드된 AppDomain에 대한 오류가 발생했습니다.저는 그것을 사용하는 대신 이것을 사용했습니다(우리는 도메인이 하나뿐입니다).이렇게 하면 그룹 그룹과 직접 그룹 구성원 자격이 확인됩니다.

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

아래 코드는 .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();
}

가장 간단한 해결책

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

이 방법은 Windows 인증 현재 사용자가 특정 역할에 속해 있는지 확인하려는 경우 유용할 수 있습니다.

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

사용자가 AD 그룹에 속해 있는지 여부는 사용자가 의미하는 바에 따라 달라집니다.AD에서 그룹은 Security Group 또는 Distribution Group일 수 있습니다.보안 그룹의 경우에도 "도메인 사용자" 또는 "사용자"와 같은 그룹이 구성원 자격 검사에 포함되어야 하는지 여부에 따라 다릅니다.

IsUserInSecurityGroup은 Security Group만 확인하고 배포 그룹이 아닌 "도메인 사용자" 및 "사용자"와 같은 기본 그룹 종류의 그룹에 대해 작동합니다.또한 중첩된 그룹의 문제도 해결합니다.IsUserInAllGroup도 배포 그룹을 확인하지만 권한 문제가 발생할지 모르겠습니다.사용하는 경우 WAAG에 있는 서비스 계정을 사용합니다(MSDN 참조).

UserPrincipal을 사용하지 않는 이유입니다.GetAuthorizedGroups()는 호출 계정이 WAG에 있어야 하고 SidHistory에 항목이 없어야 하는 등 많은 문제가 있기 때문입니다(David Thomas의 의견 참조).

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

여기 제 2센트입니다.

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

이 방법은 훨씬 단순해 보입니다.

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

이것은 어떻습니까?

사용자가 그룹의 구성원인지 테스트하기 위해 LDAP 쿼리를 작성하는 방법은 무엇입니까?

다음 코드를 시도할 수 있습니다.

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

Brandon Johnson씨, 저는 당신이 가지고 있는 것을 사용했지만, 다음과 같은 변경을 했습니다.

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

사용자 상위 그룹에 간접적으로 연결된 중첩 그룹을 포함한 사용자 그룹 구성원 자격을 확인하려면 다음과 같이 "tokenGroups" 속성을 사용할 수 있습니다.

시스템 사용.디렉터리 서비스
public static bool IsMemberOfGroupsToCheck(문자열 도메인 서버, 문자열 로그인)ID, 문자열 로그인 암호){string UserDN = "CN=John.Doe-A,OU=관리 계정,OU= 사용자 디렉토리,DC=CJB,DC=com"문자열 ADGroupsDNTToCheck = "CN=ADGroup확인하려면,OU=관리 그룹,OU=그룹 디렉터리,DC=CJB,DC=com";
바이트[] sid, 상위SID;bool check = false;디렉터리 항목 상위 항목;디렉터리 항목 기본 하위 항목;현악 옥텟SID;
basechildEntry = 새 디렉터리 항목("LDAP://" + 도메인 서버 + "/" + 사용자DN, 로그인ID, 로그인 비밀번호);basechildEntry.캐시 새로 고침(새 문자열[] {"tokenGroups"});
parentEntry = new DirectoryEntry("LDAP://" + 도메인 서버 + "/" + AD GroupsDNT to Check, LoginID, 로그인 비밀번호);부모SID = (byte[]) parentEntry.속성["개체SID").값;옥텟SID = ConvertToOctetString(상위 문자열)SID, 거짓, 거짓);
각(기본 자식 항목의 ObjectGroupSid).속성["tokenGroups"]){sid = (바이트[])GroupSid;if (ConvertToOctetString(sid, false, false) == 옥텟SID){확인 = 참;브레이크;}}
basechildEntry.폐기();parentEntry.폐기();
반품수표;}

사용자가 AD 멤버 및 특정 AD 그룹 멤버에 있는지 확인하는 방법

//This Reference and DLL must be attach in your project         
//using System.DirectoryServices.AccountManagement;        


         public bool IsAuthenticated(string username, string pwd)
        {

            using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, "xxx.com"))   // Your Domain Name
            {
                if (pc.ValidateCredentials(username, password))  //User and Password is OK for Active Directory 
                {
                    UserPrincipal user = UserPrincipal.FindByIdentity(pc, username);  //Get User Active Directory Information Details
                    if (user != null)
                    {

                        var groups = user.GetAuthorizationGroups();   // Get User Authorized Active Directory Groups
                        foreach (GroupPrincipal group in groups)
                        {
                            if (group.Name.Equals("SpecificActiveDirectoryGroupName"))  //Check if user specific group members
                            { 
                                return true;
                            }

                        }
                    }
                }
            }
            return false;
        }

에서 사용할 수 있습니다.NET 3.5+

// using System.DirectoryServices.AccountManagement;
public static bool IsUserMemberOfGroup(string username, string group)
{
    using (var ctx = new PrincipalContext(ContextType.Domain))
    using (var usr = UserPrincipal.FindByIdentity(ctx, username))
        return usr.IsMemberOf(ctx, IdentityType.Name, group);
}

이는 많은 답변과 유사하지만 다음과 같습니다.

  • 사용자만 찾은 다음 이름만 사용하여 사용자가 그룹의 구성원인지 확인합니다(사용자/그룹에 대한 그룹 또는 반복을 찾을 필요 없음).
  • Dispose 체사(으)로 사용)using

언급URL : https://stackoverflow.com/questions/2188954/see-if-user-is-part-of-active-directory-group-in-c-sharp-asp-net

반응형