Wie erhalte ich alle Gruppen, in denen ein Benutzer Mitglied ist?

135

Das Get-ADGroupMemberCmdlet von PowerShell gibt Mitglieder einer bestimmten Gruppe zurück. Gibt es ein Cmdlet oder eine Eigenschaft, um alle Gruppen abzurufen, zu denen ein bestimmter Benutzer gehört?


Ich habe meinen Fehler behoben: Get-Membersollte sein Get-ADGroupMember.

Primoz
quelle
Die Frage ist nicht klar. Können Sie es neu gestalten oder ein Beispiel hinzufügen?
Mohit Chakraborty
1
Siehe stackoverflow.com/questions/668321/… und technet.microsoft.com/en-us/library/dd315351.aspx . Sind Sie sicher, dass Get-Member das tut, was Sie denken?
tiago2014
@Mohit Chakraborty Ist jetzt klarer?
Primoz
1
Überprüfen Sie schnell net user /domain usernameauch andere Methoden unter Get Groups, bei denen ein Benutzer Mitglied ist. Verwenden von PowerShell
Mohamed

Antworten:

282

Get-ADPrincipalGroupMembership wird dies tun.

Get-ADPrincipalGroupMembership username | select name

name
----
Domain Users
Domain Computers
Workstation Admins
Company Users
Company Developers
AutomatedProcessingTeam
kstrauss
quelle
1
Dies hat mich nur davor bewahrt, die komplizierteste und langwierigste Methode zu verwenden, um dies zu finden. Ich wusste, dass Powershell so etwas haben würde, konnte es aber nirgendwo finden. +1
Tim Alexander
7
Beachten Sie, dass dies vom verfügbaren ActiveDirectory-Modul abhängt. Dies funktioniert nicht unbedingt auf einem Clientcomputer, auf dem Sie ein PowerShell-Skript ausführen, oder auf Clients auf niedriger Ebene. Wenn Sie dies tun möchten, verwenden Sie diese Lösung .
Daniel.S
5
Das oben Gesagte gab mir Fehler ("Der Server konnte die Anforderung aufgrund eines internen Fehlers nicht verarbeiten" - vermutlich keine auf dem Server verfügbare Funktionalität). get-aduser $username -Properties memberof | select -expand memberofhat aber gut funktioniert.
JohnLBevan
5
Wenn Sie sich auf einer Windows 10-Workstation und nicht auf einem Server befinden, installieren Sie RSAT von hier aus und geben Sie die import-module activedirectoryPowershell-Befehlszeile ein. Diese sollte dann ausgeführt werden.
James Toomey
3
Wenn das Modul nicht installiert ist: Install-WindowsFeature RSAT-AD-PowerShell
Preben Huybrechts
81

Einzeilig, keine Module erforderlich, verwendet den aktuell angemeldeten Benutzer:

(New-Object System.DirectoryServices.DirectorySearcher("(&(objectCategory=User)(samAccountName=$($env:username)))")).FindOne().GetDirectoryEntry().memberOf

Fragen zu diesem vbs / Powershell-Artikel: http://technet.microsoft.com/en-us/library/ff730963.aspx

Canoas
quelle
5
Vielen Dank, ich schätze diese Version ohne Module. Ich habe einfach die Variable von $env:usernameauf geändert $usernameund festgelegt $username = "testuser", um andere Benutzersuchen einfach durch Variablen zu ersetzen.
Projektdp
Ich habe gerade wieder hierher gegoogelt! Immer noch nützlich in zufälligen Situationen, in denen AD-Tools nicht verfügbar sind.
Nathan
43

Eine prägnantere Alternative zu der von Canoas veröffentlichten, um eine Gruppenmitgliedschaft für den aktuell angemeldeten Benutzer zu erhalten.

Ich bin in diesem Blog-Beitrag auf diese Methode gestoßen: http://www.travisrunyard.com/2013/03/26/auto-create-outlook-mapi-user-profiles/

([ADSISEARCHER]"samaccountname=$($env:USERNAME)").Findone().Properties.memberof

Eine noch bessere Version, die einen regulären Ausdruck verwendet, um den LDAP-Guff zu entfernen und nur die Gruppennamen belässt:

([ADSISEARCHER]"samaccountname=$($env:USERNAME)").Findone().Properties.memberof -replace '^CN=([^,]+).+$','$1'

Weitere Informationen zur Verwendung des Beschleunigers vom Typ [ADSISEARCHER] finden Sie im Blog des Scripting Guy: http://blogs.technet.com/b/heyscriptingguy/archive/2010/08/24/use-the-powershell-adsisearcher-type -accelerator-to-search-active-directory.aspx

Daniel.S
quelle
1
Beides gibt mir den Fehler: Ausnahme beim Aufrufen von "FindOne" mit "0" -Argumenten: "Der Suchfilter samaccountname = ist ungültig."
Dallas
Seltsam ... Ich habe es gerade noch einmal getestet, aber unter Windows 7 in einer völlig anderen Umgebung, und es funktioniert auch hier einwandfrei.
Daniel.S
Ich habe es gerade noch einmal versucht, immer noch unter Win 7, und es funktioniert einwandfrei. Vielleicht hatte ich Tippfehler, als ich das zum ersten Mal ausprobierte. Vielen Dank für das Hinzufügen des Ersatzes, um den Wald "Guff" zu entfernen.
Dallas
2
Funktioniert hervorragend, fügen Sie es hinzu | Sort-Object, um es noch besser lesbar zu machen.
Martin Hollingsworth
31

Old School Weg von CMD:

net user mst999 /domain 
user4511672
quelle
1
Es funktioniert auch auf Client-Computern ohne zusätzliche AD-Tools
Rast
4
Leider - wenn Ihre Gruppennamen lang sind (dh> 21 Zeichen), werden sie abgeschnitten ...
Kiltannen
das schlägt man anders! Bravo
StayCool
24
(GET-ADUSER Identity USERNAME Properties MemberOf | Select-Object MemberOf).MemberOf
schmeckendeugler
quelle
Vielen Dank! das hat funktioniert. Der einzige Nachteil ist, dass der zurückgegebene Wert eine Zeichenfolge ist.
Shaiss
3
| get-adgroup gibt die Gruppenobjekte aus. Brillant!
8DH
1
oder verwenden Sie stattdessen $ env: USERNAME, um den Benutzernamen des aktuell angemeldeten Benutzers
abzurufen
6

Wenn Sie Get-ADPrincipalGroupMembership nicht zum Laufen bringen können, können Sie versuchen, sich als dieser Benutzer anzumelden, und dann verwenden.

$id = [Security.Principal.WindowsIdentity]::GetCurrent()
$groups = $id.Groups | foreach-object {$_.Translate([Security.Principal.NTAccount])}
$groups | select *
Andrew Pate
quelle
Sie müssen sich auch nicht als Benutzer anmelden, wenn Sie etwas wie$id = [Security.Principal.WindowsIdentity]("username")
Bitcoin Murderous Maniac
1
Dies verkürzt sich gut zum Einzeiler [System.Security.Principal.WindowsIdentity]::GetCurrent().Groups | % {$_.Translate([Security.Principal.NTAccount])}.
alx9r
5

Erhalten Sie eine Gruppenmitgliedschaft für einen Benutzer:

$strUserName = "Primoz"
$strUser = get-qaduser -SamAccountName $strUserName
$strUser.memberof

Siehe Gruppenmitgliedschaft für einen Benutzer abrufen

Siehe aber auch die kostenlosen PowerShell-Befehle von Quest für Active Directory .

[ Bearbeiten : Der Befehl Get-ADPrincipalGroupMembership ist seit Version 2 mit Windows 2008 R2 in Powershell enthalten. Siehe die Antwort von kstrauss unten.]

tiago2014
quelle
2
Eigentlich ist es ein einfacher Weg mit Quest - Cmdlets: Get-QADGroup -Enthält Primoz
fenster
18
Dies ist nicht mehr die beste Antwort, da Get-ADPrincipalGroupMembership jetzt in PowerShell
Rob Cannon
1
Abgestimmt, weil es viel besser wäre, Get-ADPrincipalGroupMembership zu verwenden. Ich möchte diese Ablehnung rückgängig machen, kann es aber nicht. Ich werde die Antwort bearbeiten, um darauf hinzuweisen, dass die integrierte Option jetzt vorhanden ist.
Abraham
4

Get-Memberist ein Cmdlet zum Auflisten der Mitglieder eines .NET object. Dies hat nichts mit der Benutzer- / Gruppenmitgliedschaft zu tun. Sie können die Gruppenmitgliedschaft des aktuellen Benutzers folgendermaßen abrufen:

PS> [System.Security.Principal.WindowsIdentity]::GetCurrent().Groups | 
         Format-Table -auto

BinaryLength AccountDomainSid    Value
------------ ----------------    -----
          28 S-1-5-21-...        S-1-5-21-2229937839-1383249143-3977914998-513
          12                     S-1-1-0
          28 S-1-5-21-...        S-1-5-21-2229937839-1383249143-3977914998-1010
          28 S-1-5-21-...        S-1-5-21-2229937839-1383249143-3977914998-1003
          16                     S-1-5-32-545
...

Wenn Sie Zugriff auf Gruppeninformationen beliebiger Benutzer benötigen, ist der Vorschlag von @tiagoinu, die Quest AD-Cmdlets zu verwenden, der bessere Weg.

Keith Hill
quelle
4

Importieren Sie zunächst das Modul activedirectory:

import-module activedirectory

Geben Sie dann diesen Befehl ein:

Get-ADGroupMember -Identity $group | foreach-object {
    Write-Host $_.SamAccountName
}

Dadurch werden die Mitglieder der angegebenen Gruppe angezeigt.

Jonathan Rioux
quelle
Das OP fragt nach dem Gegenteil. Alle Gruppen abrufen, zu denen ein bestimmter Benutzer gehört.
8DH
4

Keine Notwendigkeit für lange Skripte, wenn es sich um einen einfachen Einzeiler handelt.

Befehl QUEST

(Get-QADUser -Identity john -IncludedProperties MemberOf | Select-Object MemberOf).MemberOf

MS AD-Befehl

(GET-ADUSER Identity john Properties MemberOf | Select-Object MemberOf).MemberOf

Ich finde, dass der MS AD cmd schneller ist, aber einige Leute mögen die Quest besser.

Steve

Steve Adkin
quelle
4

Get-Member dient nicht zum Abrufen der Gruppenmitgliedschaft des Benutzers. Wenn Sie eine Liste der Gruppen erhalten möchten, zu denen ein Benutzer auf dem lokalen System gehört, können Sie dies tun, indem Sie:

$query = "ASSOCIATORS OF {Win32_Account.Name='DemoUser1',Domain='DomainName'} WHERE ResultRole=GroupComponent ResultClass=Win32_Account"

Get-WMIObject -Query $query | Select Name

Ersetzen Sie in der obigen Abfrage DemoUser1 durch den gewünschten Benutzernamen und den Domänennamen durch Ihren lokalen Computernamen oder Domänennamen.

Ravikanth
quelle
Diese Abfrage ist sehr zeitaufwändig und reagiert sehr langsam, wenn sich mehrere Benutzer und Gruppen in der Umgebung befinden
randeepsp
Wer auch immer die Antwort bearbeitet, stellt sicher, dass Sie sie richtig bearbeiten. Ich schlug dem OP vor, DemoUser1 durch einen beliebigen Benutzernamen zu ersetzen. Und Sie haben diese Bedeutung komplett geändert.
Ravikanth
4

Verwenden:

Get-ADPrincipalGroupMembership username | select name | export-CSV username.csv

Dadurch wird die Ausgabe des Befehls in eine CSV- Datei geleitet.

Dee
quelle
4

Dies sollte Ihnen die Details für den aktuellen Benutzer liefern. Powershell nicht benötigt.

whoami /groups

Nayan
quelle
3

Es ist nur eine Zeile:

(get-aduser joe.bloggs -properties *).memberof

Ende des :)

user4931356
quelle
Wenn Sie dies an a weiterleiten, select -expandproperty memberofwird die Ausgabe ein wenig lesbarer / nützlicher.
Ben Thul
2

Ich habe eine PowerShell-Funktion namens Get-ADPrincipalGroupMembershipRecursive geschrieben. Es akzeptiert den DSN eines Benutzers, Computers, einer Gruppe oder eines Dienstkontos. Es ruft eine erste Liste von Gruppen aus dem memberOf-Attribut des Kontos ab und überprüft dann rekursiv die Mitgliedschaften dieser Gruppe. Der abgekürzte Code ist unten. Den vollständigen Quellcode mit Kommentaren finden Sie hier .

function Get-ADPrincipalGroupMembershipRecursive( ) {

    Param(
        [string] $dsn,
        [array]$groups = @()
    )

    $obj = Get-ADObject $dsn -Properties memberOf

    foreach( $groupDsn in $obj.memberOf ) {

        $tmpGrp = Get-ADObject $groupDsn -Properties memberOf

        if( ($groups | where { $_.DistinguishedName -eq $groupDsn }).Count -eq 0 ) {
            $groups +=  $tmpGrp           
            $groups = Get-ADPrincipalGroupMembershipRecursive $groupDsn $groups
        }
    }

    return $groups
}

# Simple Example of how to use the function
$username = Read-Host -Prompt "Enter a username"
$groups   = Get-ADPrincipalGroupMembershipRecursive (Get-ADUser $username).DistinguishedName
$groups | Sort-Object -Property name | Format-Table
Brian Reich
quelle
2

Das Folgende funktioniert gut:

get-aduser $username -Properties memberof | select -expand memberof

Wenn Sie eine Benutzerliste haben:

$list = 'administrator','testuser1','testuser2'
$list | `
    %{  
        $user = $_; 
        get-aduser $user -Properties memberof | `
        select -expand memberof | `
        %{new-object PSObject -property @{User=$user;Group=$_;}} `
    }
JohnLBevan
quelle
1

Get-QADUser -SamAccountName LoginID | % {$ _. MemberOf} | Get-QADGroup | Name auswählen

Sathish
quelle
1

Ich konnte Folgendes für einen bestimmten Benutzer nicht zum Laufen bringen:

Get-ADPrincipalGroupMembership username

Es gab einen Fehler, den ich nicht beheben wollte.

Ich habe jedoch mit Get-ADUser eine andere Lösung gefunden. Ich mag es ein bisschen besser, denn wenn Sie den Kontonamen nicht kennen, können Sie ihn anhand eines Platzhalters auf dem tatsächlichen Namen des Benutzers abrufen. Füllen Sie einfach PartOfUsersName aus und los geht's.

#Get the groups that list of users are the member of using a wildcard search

[string]$UserNameLike = "*PartOfUsersName*" #Use * for wildcards here
[array]$AccountNames = $(Get-ADUser -Filter {Name -like $UserNameLike}).SamAccountName

ForEach ($AccountName In $AccountNames) {
Write-Host "`nGETTING GROUPS FOR" $AccountName.ToUpper() ":"
(Get-ADUser -Identity $AccountName -Properties MemberOf|select MemberOf).MemberOf|
    Get-ADGroup|select Name|sort name
    }

Riesige Requisiten an schmeckendeugler und 8DH, die mich zu dieser Lösung gebracht haben. +1 an euch beide.

Adam
quelle
1

Während es hier viele ausgezeichnete Antworten gibt, fehlt eine, nach der ich persönlich gesucht habe. Nachdem ich es herausgefunden hatte, dachte ich, ich sollte es posten, falls ich es später finden möchte, oder es schafft es tatsächlich, irgendwann jemand anderem zu helfen:

Get-ADPrincipalGroupMembership username | Format-Table -auto

Ein zweiter Ansatz, um dies darzustellen, besteht darin, die einzelnen Spalten anzugeben, an denen Sie interessiert sind, z.

Get-ADPrincipalGroupMembership username | select name, GroupScope, GroupCategory

Dies gibt alle AD-Gruppen an, zu denen der Benutzername gehört - zeigt aber auch alle Standardeigenschaften jeder Gruppe an, die gut als Tabelle formatiert sind.

Der Hauptvorteil besteht darin, dass Sie auf einen Blick sehen können, welche Verteilerlisten und welche Sicherheitsgruppen sind. Sie können auf einen Blick sehen, welche universell, welche domänenlokal und welche global sind.
Warum interessiert dich dieses letzte Stück?

  • Die universelle Gruppe ist eine Sicherheits- oder Verteilergruppe, die Benutzer, Gruppen und Computer aus einer beliebigen Domäne in ihrer Gesamtstruktur als Mitglieder enthält. Sie können universellen Sicherheitsgruppen Rechte und Berechtigungen für Ressourcen in jeder Domäne in der Gesamtstruktur erteilen.
  • Globale Gruppe ist eine Gruppe, die in ihrer eigenen Domäne, auf Mitgliedsservern und auf Arbeitsstationen der Domäne sowie in vertrauenswürdigen Domänen verwendet werden kann. An all diesen Standorten können Sie einer globalen Gruppe Rechte und Berechtigungen erteilen, und die globale Gruppe kann Mitglied lokaler Gruppen werden. Eine globale Gruppe kann jedoch Benutzerkonten enthalten, die nur aus ihrer eigenen Domäne stammen.
  • Die lokale Domänengruppe ist eine Sicherheits- oder Verteilergruppe, die universelle Gruppen, globale Gruppen, andere lokale Domänengruppen aus ihrer eigenen Domäne und Konten aus einer beliebigen Domäne in der Gesamtstruktur enthalten kann. Sie können lokalen Sicherheitsgruppen für Domänen Rechte und Berechtigungen für Ressourcen erteilen, die sich nur in derselben Domäne befinden, in der sich die lokale Domänengruppe befindet.
kiltannen
quelle
0
Import-Module ActiveDirectory
Get-ADUser -SearchBase "OU=Users,DC=domain,DC=local" -Filter * | foreach-object {
write-host "User:" $_.Name -foreground green
    Get-ADPrincipalGroupMembership $_.SamAccountName | foreach-object {
        write-host "Member Of:" $_.name
    }
}

Ändern Sie den Wert von -SearchBase, um die Organisationseinheit wiederzugeben, aus der Sie die Benutzer auflisten möchten :)

Dadurch werden alle Benutzer in dieser Organisationseinheit aufgelistet und angezeigt, zu welchen Gruppen sie gehören.

Stephen Galvin
quelle
0

Get-ADPrincipalGroupMembership USERLOGON | Name auswählen

Jacob Fischlein
quelle
0
   Get-ADUser -Filter { memberOf -RecursiveMatch "CN=Administrators,CN=Builtin,DC=Fabrikam,DC=com" } -SearchBase "CN=Administrator,CN=Users,DC=Fabrikam,DC=com"  -SearchScope Base
                  ## NOTE: The above command will return the user object (Administrator in this case) if it finds a match recursively in memberOf attribute. 
Sunil Aher
quelle
0

Dies ist der einfachste Weg, um nur die Namen zu erhalten:

Get-ADPrincipalGroupMembership "YourUserName"

# Returns distinguishedName : CN=users,OU=test,DC=SomeWhere GroupCategory : Security GroupScope : Global name : testGroup objectClass : group objectGUID : 2130ed49-24c4-4a17-88e6-dd4477d15a4c SamAccountName : testGroup SID : S-1-5-21-2114067515-1964795913-1973001494-71628

Fügen Sie eine select-Anweisung hinzu, um die Antwort zu kürzen oder um jedem Benutzer in einer Organisationseinheit jede Gruppe zuzuweisen, deren Benutzer er ist:

foreach ($user in (get-aduser -SearchScope Subtree -SearchBase $oupath -filter * -Properties samaccountName, MemberOf | select samaccountName)){ Get-ADPrincipalGroupMembership $user.samaccountName | select name}

Stuart
quelle
0

Um es rekursiv zu machen, können Sie verwenden:

<# 
    .SYNOPSIS   
        Get all the groups that a user is MemberOf.

    .DESCRIPTION
        This script retrieves all the groups that a user is MemberOf in a recursive way.

    .PARAMETER SamAccountName
        The name of the user you want to check #>

Param (
    [String]$SamAccountName = 'test',
    $DomainUsersGroup = 'CN=Domain Users,CN=Users,DC=domain,DC=net'
)


Function Get-ADMemberOf {
    Param (
        [Parameter(ValueFromPipeline)]
        [PSObject[]]$Group,
        [String]$DomainUsersGroup = 'CN=Domain Users,CN=Users,DC=grouphc,DC=net'
    )
    Process {
        foreach ($G in $Group) {
            $G | Get-ADGroup | Select -ExpandProperty Name
            Get-ADGroup $G -Properties MemberOf| Select-Object Memberof | ForEach-Object {
                Get-ADMemberOf $_.Memberof
            }
        }
    }
}


$Groups = Get-ADUser $SamAccountName -Properties MemberOf | Select-Object -ExpandProperty MemberOf
$Groups += $DomainUsersGroup
$Groups | Get-ADMemberOf | Select -Unique | Sort-Object
DarkLite1
quelle
0

Fast alle oben genannten Lösungen verwendeten das ActiveDirecotryModul, das in den meisten Fällen möglicherweise nicht standardmäßig verfügbar ist.

Ich habe die folgende Methode verwendet. Ein bisschen indirekt, hat aber meinen Zweck erfüllt.

Listen Sie alle verfügbaren Gruppen auf

Get-WmiObject -Class Win32_Group

Listen Sie dann die Gruppen auf, zu denen der Benutzer gehört

[System.Security.Principal.WindowsIdentity]::GetCurrent().Groups

Der Vergleich kann dann durch Überprüfen durch die durchgeführt werden SIDs. Dies funktioniert für den angemeldeten Benutzer. Bitte korrigieren Sie mich, wenn ich falsch liege. Völlig neu in PowerShell, musste dies jedoch für eine Arbeitsverpflichtung erledigen.

Ruifeng Ma
quelle
Wenn Sie einen Benutzer überprüfen, der bereits Mitglied der Administratorgruppe ist, stellen Sie sicher, dass PowerShell über "Als Administrator ausführen" gestartet wird. Andernfalls werden die Gruppen für den zweiten Befehl nicht korrekt aufgelistet dies aus ... Fenster ...
Ruifeng Ma
0

Mit Benutzereingabe und ausgefallener Ausgabeformatierung:

[CmdletBinding(SupportsShouldProcess=$True)] 
Param( 
    [Parameter(Mandatory = $True)] 
    [String]$UserName 
) 
Import-Module ActiveDirectory 
If ($UserName) { 
    $UserName = $UserName.ToUpper().Trim() 
    $Res = (Get-ADPrincipalGroupMembership $UserName | Measure-Object).Count 
    If ($Res -GT 0) { 
        Write-Output "`n" 
        Write-Output "$UserName AD Group Membership:" 
        Write-Output "===========================================================" 
        Get-ADPrincipalGroupMembership $UserName | Select-Object -Property Name, GroupScope, GroupCategory | Sort-Object -Property Name | FT -A 
    } 
}
Coinbird
quelle
0

Setzen Sie dies hier als zukünftige Referenz. Ich bin mitten in einer E-Mail-Migration. Ich muss jedes Benutzerkonto und seine jeweilige Gruppenmitgliedschaft kennen, und ich muss auch jede Gruppe und ihre jeweiligen Mitglieder kennen.

Ich verwende den folgenden Codeblock, um eine CSV für die Gruppenmitgliedschaft jedes Benutzers auszugeben.

Get-ADUser -Filter * |`
  ForEach-Object { `
    $FileName = $_.SamAccountName + ".csv" ; `
    $FileName ; `
    Get-ADPrincipalGroupMembership $_ | `
      Select-Object -Property SamAccountName, name, GroupScope, GroupCategory | `
        Sort-Object -Property SamAccountName | `
          Export-Csv -Path $FileName -Encoding ASCII ; `
  }

Der Exportprozess für die Gruppen und ihre jeweiligen Mitglieder war etwas kompliziert, aber das Folgende funktioniert. Die Ausgabedateinamen enthalten den Gruppentyp. Daher sind / sollten die E-Mail-Verteilergruppen, die ich benötige, die universellen und globalen Verteilergruppen. Ich sollte in der Lage sein, die resultierenden TXT-Dateien, die ich nicht benötige, einfach zu löschen oder zu verschieben.

Get-ADGroup -Filter * | `
 Select-Object -Property Name, DistinguishedName, GroupScope, GroupCategory | `
  Sort-Object -Property GroupScope, GroupCategory, Name | `
   Export-Csv -Path ADGroupsNew.csv -Encoding ASCII

$MyCSV = Import-Csv -Path .\ADGroupsNew.csv -Encoding ASCII

$MyCSV | `
 ForEach-Object { `
  $FN = $_.GroupScope + ", " + $_.GroupCategory + ", " + $_.Name + ".txt" ; `
  $FN ; `
  Get-ADGroupMember -Identity $_.DistinguishedName | `
   Out-File -FilePath $FN -Encoding ASCII ; $FN=""; `
  }
user208145
quelle
0

Das Studium aller vorgelegten Kommentare gab mir einen Ausgangspunkt (danke dafür), ließ mich aber mit einigen ungelösten Problemen zurück. Als Ergebnis hier ist meine Antwort. Das bereitgestellte Code-Snippet bietet etwas mehr als das, was verlangt wird, bietet jedoch hilfreiche Debugging-Informationen.

[array] $script:groupsdns = @()
function Get-ADPrincipalGroupMembershipRecursive() 
{
  Param( [string] $dn, [int] $level = 0, [array] $groups = @() )

  #if(($groupsdns | where { $_.DistinguishedName -eq $dn }).Count -ne 0 ) { return $groups } # dependency on next statement
  #$groupsdns += (Get-ADObject $dn -Properties MemberOf) # Get-ADObject cannot find an object with identity
  if ($script:groupsdns.Contains($dn)) { return $groups }
  $script:groupsdns += $dn
  $mo = $Null
  $mo = Get-ADObject $dn -Properties MemberOf # Get-ADObject cannot find an object with identity
  $group = ($dn + " (" + $level.ToString())
  if ($mo -eq $Null) { $group += "!" }
  $group += ")"
  $groups += $group
  foreach( $groupdn in $mo.MemberOf )
  {
    $groups = Get-ADPrincipalGroupMembershipRecursive -dn $groupdn -level ($level+1) -groups $groups
  }
  if ($level -le 0) 
  { 
    $primarygroupdn = (Get-ADUser -Identity $dn -Properties PrimaryGroup).PrimaryGroup 
    $groups = Get-ADPrincipalGroupMembershipRecursive -dn $primarygroupdn -level ($level+1) -groups $groups
  }
  return $groups
}
$adusergroups = Get-ADPrincipalGroupMembershipRecursive -dn $aduser.DistinguishedName
$adusergroups | ft -AutoSize | `
              Out-File -Width 512 Get-ADPrincipalGroupMembershipRecursive.txt #-Append #-Wrap # | Sort-Object -Property Name
ES44AC SD70MAC
quelle
Entschuldigung, ich habe vergessen zu klären. Tun Sie dies zuerst: $ aduserDistinguishedName = "CN = name, OU = ..." $ aduser = Get-ADUser -Identity $ aduserDistinguishedName -Properties *
ES44AC SD70MAC
0

Wenn Sie nicht berechtigt sind, andere Mitgliedergruppen zu konsultieren, aber die Berechtigung haben, Gruppenmitglieder zu konsultieren, können Sie Folgendes tun, um eine Karte zu erstellen, welcher Benutzer Zugriff auf welche Gruppen hat.

$groups = get-adgroup -Filter * | sort name | select Name
$users = @{}
foreach($group in $groups) {
    $groupUsers = @()
    $groupUsers = Get-ADGroupMember -Identity $group.Name | Select-Object SamAccountName
    $groupUsers | % {
        if(!$users.ContainsKey($_.SamAccountName)){
            $users[$_.SamAccountName] = @()
        }
        ($users[$_.SamAccountName]) += ($group.Name)
    }
}
Nadzzz
quelle