PowerShell - Get-ADGroupMember

Hi,
weiß jemand, ob man Get-ADGroupMember dazu bewegen kann, bei Angabe von -Recursive nicht nur die einzelnen Benutzer zu liefern, sondern auch die zwischendurch aufgelösten Gruppen?

Bsp.
Domänenlokale Gruppe "DL1"
Globale Gruppe "G1"
Globale Gruppe "G2"
Globale Gruppe "G3"
Benutzer "B1"
Benutzer "B2"

Verschachtelung ist
B1 --> G1 --> DL1
B2 --> G1 --> DL1
B3 --> G3 --> G2 --> DL1

Wenn man jetzt abfragt

1
Get-AdGroupMember DL1 -Recursive

dann liefert er nur B1 und B2, aber nicht G1, G2 oder G3

E.

Bitte markiere auch die Kommentare, die zur Lösung des Beitrags beigetragen haben

Content-ID: 586548

Url: https://administrator.de/forum/powershell-get-adgroupmember-586548.html

Ausgedruckt am: 13.04.2025 um 06:04 Uhr

7 Kommentare

Neuester Kommentar

Hallo Emeriks,

meinst du vielleicht so etwas hier:

1
Get-ADGroup -Filter "GroupScope -eq 'DomainLocal'" | Get-ADGroupMember -Recursive | where {$_.ObjectClass -eq "user"}  

Quelle: Windowspro

Zitat von @NixVerstehen:
meinst du vielleicht so etwas hier:

Nein.

Habe das jetzt erstmal über eine Function gelöst.
Diese funktioniert aber auch nur bei einem Ein-Domänen-Modell. Für mehr habe ich jetzt keine Zeit.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Function GetNestedGroups {
  param([string]$GroupName)

  $ReturnValue = @()

    ForEach($O in (Get-ADGroupMember $GroupName )) { # KEIN -recursive !
      If($O.objectClass) {
        If($O.objectClass.Contains("group")) {  
          $ReturnValue += $O.SamAccountName
          $ReturnValue += (GetNestedGroups $O.SamAccountName)
        }
      }
    }  

  return ($ReturnValue | Get-Unique)
}

Zitat von @emeriks:

Habe das jetzt erstmal über eine Function gelöst.
Diese funktioniert aber auch nur bei einem Ein-Domänen-Modell. Für mehr habe ich jetzt keine Zeit.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
> Function GetNestedGroups {
>   param([string]$GroupName)
> 
>   $ReturnValue = @()
> 
>     ForEach($O in (Get-ADGroupMember $GroupName )) { # KEIN -recursive !
>       If($O.objectClass) {
>         If($O.objectClass.Contains("group")) {  
>           $ReturnValue += $O.SamAccountName
>           $ReturnValue += (GetNestedGroups $O.SamAccountName)
>         }
>       }
>     }  
> 
>   return ($ReturnValue | Get-Unique)
> }
> 

Yip kann man aber auch ohne das zeitfressende Erweitern von Arrays mit += machen

1
2
3
4
5
6
7
8
9
function Get-NestedGroups ($group,$result = (New-Object System.Collections.ArrayList)){
    Get-ADGroupMember $group | ?{$_.objectClass -eq 'group' -and !$result.Contains($_.SamAccountName)} | %{  
        $result.Add($_.SamAccountName) | out-null
        $result.AddRange(@(Get-NestedGroups $_.SamAccountName $result)) | out-null
    }
    return ($result | select -Unique)
}

Get-NestedGroups Testgruppe

Zitat von @144705:
Yip kann man aber auch ohne das zeitfressende Erweitern von Arrays mit += machen

OK. Und wo würdest Du da innerhalb der Function das Get-Unique einbauen?

Moin,

sowas habe ich hier doch rumliegen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
# Skript zur Dokumentation der Gruppenmitgliedschaften
#Requires -Version 5
#Requires -Modules activedirectory
#Requires -RunAsAdministrator

param (

    $group_praefix = "l_", # hier kann auch ein konkreter Gruppenname angegeben werden  
    $outpath = "grouplist.xml",  
    $acl_path = "X:\Pfad\",  
    $depth = 3 # Suchtiefe für die Ausgabe der Ordner

)

$acls = $(Get-ChildItem $acl_path -depth $depth -Directory | get-acl)

$outfile = [xml]"<?xml version='1.0' encoding='utf-8'?>`n<?xml-stylesheet type='text/css' href='stylesheet.css'?>`n<groups name='Gruppenliste' />"  
$outfile.save($outpath)

function get-childgroup {

    param ( $parent_group, $parent_element )
    $children = Get-ADGroupMember $parent_group -ErrorAction Ignore
    if($children) {

        foreach($child in $children) {

            $newchild = $outfile.CreateElement("member")  
            $newchild.set_InnerText($child.name)
            $newchildattribute = $outfile.CreateAttribute("class")  
            $newchildattribute.set_Value($child.objectClass)
            $newchild.SetAttributeNode($newchildattribute)
            if($child.objectClass -eq "group") {  

                get-childgroup -parent_group $child.name -parent_element $newchild

            }
            $parent_element.AppendChild($newchild)

        }


    }
}



$base_groups = Get-ADGroup -filter "name -like '$group_praefix*'"  
foreach($group in $base_groups) {

    $newgroup = $outfile.CreateElement("group")  
    $newgroup.set_InnerText($group.name)
    $groupname=$group.name

    $given_acl = $($acls | Where-Object { $_.AccessToString -like "*$groupname*" })  
    foreach($acl in $given_acl) {
        $newacl = $outfile.CreateElement("access")  
        $arr_path_only = $acl.path.split(":")  
        $path_only = $arr_path_only[2]+":"+$arr_path_only[3]  
        $newacl.set_InnerText("$path_only")  
        $newgroup.AppendChild($newacl)
    }

    $members = get-adgroupmember $group

    foreach($member in $members) {

        $newmember = $outfile.CreateElement("member")  
        $newmember.set_InnerText($member.name)
        $newattribute = $outfile.CreateAttribute("class")  
        $newattribute.set_value($member.objectClass)
        $newmember.SetAttributeNode($newattribute)
        get-childgroup -parent_group $member.name -parent_element $newmember
        $newgroup.AppendChild($newmember)


    }
    $outfile.groups.appendchild($newgroup)
}

$outfile.save($outpath)

Was dabei rauskommt ist sowas hier als xml (eine Gruppe):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
l_rw_gruppe
    x:\path\Ordner
    O:\path\Ordner\Unterordner
        g_global1
            User_1
            User_2
            User_3
        g_global2
            User_4
            User_1
        g_verwaltung
            Verwaltung_1
            Verwaltung_2
                g_leitung
                    chef_1
                    chef_2

Wenn man jetzt noch alle lokalen mit z. B. l_ und alle globalen mit z. B. g_ anfangen lässt, kann man auch komplette Strukturen ausgeben lassen.

hth

Erik