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

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.

Get-ADPrincipalGroupMembership wird dies tun.

Get-ADPrincipalGroupMembership username | select name

name
----
Domain Users
Domain Computers
Workstation Admins
Company Users
Company Developers
AutomatedProcessingTeam

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

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

Old School Weg von CMD:

net user mst999 /domain 

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

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 *

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.]

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.

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.

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

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.

Verwenden:

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

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

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

whoami /groups

Es ist nur eine Zeile:

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

Ende des :)

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

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=$_;}} `
    }

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

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.

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.

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.

Get-ADPrincipalGroupMembership USERLOGON | Name auswählen

   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. 

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}

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

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.

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

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=""; `
  }

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

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