Jak uzyskać grupy użytkowników w Active Directory? (c#, asp.net)

GetAuthorizationGroups() nie znajduje zagnieżdżonych grup. Aby naprawdę uzyskać wszystkie grupy, których dany użytkownik jest członkiem (w tym grupy zagnieżdżone), spróbuj tego:

using System.Security.Principal

private List<string> GetGroups(string userName)
{
    List<string> result = new List<string>();
    WindowsIdentity wi = new WindowsIdentity(userName);

    foreach (IdentityReference group in wi.Groups)
    {
        try
        {
            result.Add(group.Translate(typeof(NTAccount)).ToString());
        }
        catch (Exception ex) { }
    }
    result.Sort();
    return result;
}

Używam try/catch ponieważ miałem pewne wyjątki z 2 na 200 grup w bardzo dużej reklamie, ponieważ niektóre Sid nie były już dostępne. (Wywołanie Translate() wykonuje konwersję Sid -> nazwy.)

Po pierwsze, GetAuthorizationGroups() jest świetną funkcją, ale niestety ma 2 wady:

Wydajność jest słaba, szczególnie w dużych firmach z wieloma użytkownikami i grupami. Pobiera o wiele więcej danych niż faktycznie potrzebujesz i wykonuje wywołanie serwera dla każdej iteracji pętli w wyniku
1. zawiera błędy, które mogą spowodować, że aplikacja przestanie działać "pewnego dnia", gdy grupy i użytkownicy będą ewoluować. Microsoft rozpoznał problem i jest związany z niektórymi SID. Błąd, który otrzymasz, to "wystąpił błąd podczas wyliczania grup"

Dlatego napisałem małą funkcję, która zastąpi GetAuthorizationGroups () lepszą wydajnością i zabezpieczeniem przed błędami. Wykonuje tylko 1 wywołanie LDAP z zapytaniem za pomocą indeksowanych pól. Można go łatwo rozszerzyć, jeśli potrzebujesz więcej właściwości niż tylko nazwy grup (właściwość" cn").

// Usage: GetAdGroupsForUser2("domain\user") or GetAdGroupsForUser2("user","domain")
public static List<string> GetAdGroupsForUser2(string userName, string domainName = null)
{
    var result = new List<string>();

    if (userName.Contains('\\') || userName.Contains('/'))
    {
        domainName = userName.Split(new char[] { '\\', '/' })[0];
        userName = userName.Split(new char[] { '\\', '/' })[1];
    }

    using (PrincipalContext domainContext = new PrincipalContext(ContextType.Domain, domainName))
        using (UserPrincipal user = UserPrincipal.FindByIdentity(domainContext, userName))
            using (var searcher = new DirectorySearcher(new DirectoryEntry("LDAP://" + domainContext.Name)))
            {
                searcher.Filter = String.Format("(&(objectCategory=group)(member={0}))", user.DistinguishedName);
                searcher.SearchScope = SearchScope.Subtree;
                searcher.PropertiesToLoad.Add("cn");

                foreach (SearchResult entry in searcher.FindAll())
                    if (entry.Properties.Contains("cn"))
                        result.Add(entry.Properties["cn"][0].ToString());
            }

    return result;
}

W reklamie każdy użytkownik ma właściwość memberOf. To zawiera listę wszystkich grup, do których należy.

Oto mały przykład kodu:

// (replace "part_of_user_name" with some partial user name existing in your AD)
var userNameContains = "part_of_user_name";

var identity = WindowsIdentity.GetCurrent().User;
var allDomains = Forest.GetCurrentForest().Domains.Cast<Domain>();

var allSearcher = allDomains.Select(domain =>
{
    var searcher = new DirectorySearcher(new DirectoryEntry("LDAP://" + domain.Name));

    // Apply some filter to focus on only some specfic objects
    searcher.Filter = String.Format("(&(&(objectCategory=person)(objectClass=user)(name=*{0}*)))", userNameContains);
    return searcher;
});

var directoryEntriesFound = allSearcher
    .SelectMany(searcher => searcher.FindAll()
        .Cast<SearchResult>()
        .Select(result => result.GetDirectoryEntry()));

var memberOf = directoryEntriesFound.Select(entry =>
{
    using (entry)
    {
        return new
        {
            Name = entry.Name,
            GroupName = ((object[])entry.Properties["MemberOf"].Value).Select(obj => obj.ToString())
        };
    }
});

foreach (var item in memberOf)
{
    Debug.Print("Name = " + item.Name);
    Debug.Print("Member of:");

    foreach (var groupName in item.GroupName)
    {
        Debug.Print("   " + groupName);
    }

    Debug.Print(String.Empty);
}
}

W moim przypadku jedynym sposobem, w jaki mogłem używać GetGroups() bez żadnego expcetion, było dodanie użytkownika (USER_WITH_PERMISSION) do grupy, która ma uprawnienia do odczytu reklamy (Active Directory). Jest to niezwykle istotne, aby skonstruować PrincipalContext przekazując tego użytkownika i hasło.

var pc = new PrincipalContext(ContextType.Domain, domain, "USER_WITH_PERMISSION", "PASS");
var user = UserPrincipal.FindByIdentity(pc, IdentityType.SamAccountName, userName);
var groups = user.GetGroups();

Kroki, które możesz wykonać wewnątrz usługi Active Directory, aby ją uruchomić:

1. do Active Directory Utwórz grupę (lub weź jedną) i w zakładce secutiry dodaj " autoryzacja systemu Windows Grupa Dostępu "
2. Kliknij przycisk "Zaawansowane"
3. Wybierz "Windows Authorization Access Group" i kliknij "View"
4. Sprawdź "Czytaj tokenGroupsGlobalAndUniversal"
5. Znajdź żądanego użytkownika i dodaj do grupy, którą utworzyłeś (wzięłaś) od pierwszego kroku

W przypadku Translate działa lokalnie, ale nie zdalnie E.i grupy.Translate(typeof (NTAccount)

Jeśli chcesz, aby kod aplikacji był wykonywany przy użyciu tożsamości zalogowanego użytkownika, włącz podszywanie się. Podszywanie się może być włączone przez IIS lub przez dodanie następującego elementu w sieci.config .

<system.web>
<identity impersonate="true"/>

Jeśli podszywanie się jest włączone, aplikacja wykonuje przy użyciu uprawnień znalezionych na koncie użytkownika. Jeśli więc zalogowany użytkownik ma dostęp do konkretnego zasobu sieciowego, tylko wtedy będzie on w stanie uzyskać dostęp do tego zasobu za pośrednictwem aplikacji.

Dziękuję PRAGIM tech za informacje z jego starannego wideo

Uwierzytelnianie Windows w asp.net część 87:

Https://www.youtube.com/watch?v=zftmaZ3ySMc

Ale podszywanie się tworzy dużo napowietrznych na serwerze

Najlepszym rozwiązaniem pozwalającym użytkownikom pewnych grup sieci jest odmowa anonimowości w konfiguracji sieci <authorization><deny users="?"/><authentication mode="Windows"/>

I w Twoim kodzie za, najlepiej w globalnym.asax, użyj HttpContext.Aktualne.Użytkownik.Isinrol :

Sub Session_Start(ByVal sender As Object, ByVal e As EventArgs)
If HttpContext.Current.User.IsInRole("TheDomain\TheGroup") Then
//code to do when user is in group
End If

Uwaga: Grupa musi być zapisana z odwrotnym ukośnikiem \ tj. "TheDomain\Thebroup"

To działa dla mnie

public 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())
            {
                src.ToList().ForEach(sr => result.Add(sr.SamAccountName));
            }
        }

        return result.ToArray();
    }