Wie bekomme ich alle Gruppen, bei denen ein Benutzer Mitglied ist?

Einzeilig, keine Module erforderlich, verwendet aktuellen protokollierten Benutzer:

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

Qudos zu diesem Vbs/Powershell-Artikel: http://technet.Microsoft.com/en-us/library/ff730963.aspx

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

In diesem Blogpost bin ich 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, bei der ein Regex zum Entfernen der LDAP-Spalte verwendet wird und die Gruppennamen nur noch übrig bleiben:

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

Weitere Informationen zur Verwendung des Beschleunigers vom Typ [ADSISEARCHER] finden Sie im Scripting Guy-Blog: http://blogs.technet.com/b/heyscriptingguy/archive/2010/08/24/use-the-powershell-adsisearcher -type-beschleuniger-zu-suche-aktives-verzeichnis.aspx

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

Old School Weg von CMD: 

Net User mst999 /domain 

Gruppenmitgliedschaft für einen Benutzer anfordern:

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

Siehe Gruppenmitgliedschaft für einen Benutzer abrufen

Siehe auch Quest Free PowerShell-Befehle für Active Directory .

Der Befehl [Edit: Get-ADPrincipalGroupMembership ist seit v2 mit Windows 2008 R2 in Powershell enthalten. Siehe kstrauss 'Antwort unten.]

Get-Member dient nicht dazu, die Gruppenmitgliedschaft eines Benutzers zu erhalten. Wenn Sie eine Liste von Gruppen erhalten möchten, zu denen ein Benutzer auf dem lokalen System gehört, können Sie dies folgendermaßen tun:

$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 den Namen Ihres lokalen Computers oder Ihrer Domäne.

Lange Skripte sind nicht erforderlich, wenn es sich um einen einfachen Liner handelt.

QUEST-Befehl

(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 das MS AD-Cmd ist schneller, aber einige Leute mögen das Quest besser.

Steve

Get-Member ist ein Cmdlet zum Auflisten der Mitglieder einer .NET object. Dies hat nichts mit der Mitgliedschaft von Benutzern/Gruppen zu tun. Sie können die Gruppenmitgliedschaft des aktuellen Benutzers wie folgt erhalten:

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 die Gruppeninformationen beliebiger Benutzer benötigen, ist der Vorschlag von @tiagoinu, Quest AD-Cmdlets zu verwenden, der bessere Weg.

Benutzen:

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

Dies leitet die Ausgabe des Befehls in eine CSV -Datei.

Es ist nur eine Zeile:

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

ende des :)

Importieren Sie zuerst das aktivierte Verzeichnis-Modul:

import-module activedirectory

Dann gib diesen Befehl aus:

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

Dadurch werden die Mitglieder der angegebenen Gruppe angezeigt.

Das Folgende funktioniert gut:

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

Wenn Sie eine Liste von Benutzern haben:

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

Ich habe eine PowerShell-Funktion namens Get-ADPrincipalGroupMembershipRecursive geschrieben. Es akzeptiert den DSN eines Benutzers, eines 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 Gruppen. 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

Ich konnte Folgendes nicht für einen bestimmten Benutzer verwenden:

Get-ADPrincipalGroupMembership username

Es gab einen Fehler, den ich nicht zur Fehlerbehebung bereit war.

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

#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 geführt haben. +1 an euch beide.

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

Get-ADPrincipalGroupMembership USERLOGON | Name auswählen

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 entsprechend der Organisationseinheit, in der Sie die Benutzer auflisten möchten :)

Dadurch werden alle Benutzer in dieser Organisationseinheit aufgelistet und Ihnen angezeigt, in welchen Gruppen sie Mitglied sind.

Setzen Sie dieses hier für zukünftige Referenz. Ich bin mitten in einer E-Mail-Migration. Ich muss jedes Benutzerkonto und seine jeweilige Gruppenmitgliedschaft kennen und 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 ein wenig kompliziert, aber der folgende Vorgang funktioniert. Die Ausgabedateinamen enthalten den Gruppentyp. Daher sind/sollten die E-Mail-Verteilergruppen die Universal- und die Globale Verteilergruppe sein. Ich sollte die resultierenden TXT -Dateien, die ich nicht brauche, einfach löschen oder verschieben können.

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

Um es rekursiv zu erhalten, können Sie Folgendes 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 Modul ActiveDirecotry, das in den meisten Fällen möglicherweise nicht standardmäßig verfügbar ist.

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

Alle verfügbaren Gruppen auflisten

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 über das SIDs erfolgen. 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.

Wenn Sie Get-ADPrincipalGroupMembership nicht erhalten 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 *

Das Studium aller vorgestellten Kommentare gab mir einen Startpunkt (danke dafür), brachte mich jedoch zu einigen ungelösten Problemen. Als Ergebnis hier 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

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

Es gibt zwar viele hervorragende Antworten, aber es gab eine, nach der ich persönlich gesucht habe, die fehlte. Sobald ich es herausgefunden hatte, dachte ich, ich sollte es posten, falls ich es später finden möchte oder es tatsächlich jemandem helfen kann, irgendwann 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

Dadurch werden alle AD-Gruppen angezeigt, zu denen der Benutzername gehört. Außerdem werden alle Standardeigenschaften jeder Gruppe als Tabelle dargestellt.

Der entscheidende Vorteil ist, dass Sie auf einen Blick erkennen können, welche Verteilerlisten und welche Sicherheitsgruppen vorhanden sind. Sie können außerdem auf einen Blick erkennen, welche universell sind, welche DomainLocal und welche global sind.
.__ Warum interessierst du dich für das letzte Stück?

• Eine universelle Gruppe ist eine Sicherheits- oder Verteilergruppe, die Benutzer, Gruppen und Computer aus einer Domäne in ihrer Gesamtstruktur als Mitglieder enthält Mitglieder. Sie können universelle Sicherheitsgruppenrechte und Berechtigungen für Ressourcen in jeder Domäne in der Gesamtstruktur vergeben. 
• Eine globale Gruppe ist eine Gruppe, die in ihrer eigenen Domäne, auf Mitgliedsservern Und auf Arbeitsstationen der Domäne sowie in vertrauenden Domänen verwendet werden kann. An allen diesen Speicherorten können Sie globale Gruppenrechte und. .permissions und die globale Gruppe können 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 und andere lokale Domänengruppen aus ihrer eigenen Domäne sowie Konten aus allen Domänen in der Gesamtstruktur enthalten kann. Sie können Domänen-lokalen Sicherheitsgruppen Rechte und Berechtigungen für -Ressourcen erteilen, die sich nur in derselben Domäne befinden, in der sich die Domäne localgroup befindet.

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 jeden Benutzer in einer Organisationseinheit für jede Gruppe zu erhalten, in der er Benutzer ist

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

Wenn Sie nicht über die Berechtigung verfügen, andere Mitgliedergruppen zu konsultieren, Sie jedoch die Berechtigung haben, Gruppenmitglieder zu konsultieren, können Sie folgendermaßen vorgehen, um eine Karte mit dem Benutzer zu erstellen, der auf welche Gruppen Zugriff 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)
    }
}

   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.