Comment obtenir tous les groupes dont un utilisateur est membre?

L' Get-ADGroupMemberapplet de commande de PowerShell renvoie les membres d'un groupe spécifique. Existe-t-il une applet de commande ou une propriété pour obtenir tous les groupes dont un utilisateur particulier est membre?

J'ai corrigé mon erreur: Get-Memberdevrait être Get-ADGroupMember.

Get-ADPrincipalGroupMembership le fera.

Get-ADPrincipalGroupMembership username | select name

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

Une seule ligne, aucun module nécessaire, utilise l'utilisateur actuellement connecté:

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

Qudos à cet article vbs / powershell: http://technet.microsoft.com/en-us/library/ff730963.aspx

Une alternative plus concise à celle publiée par Canoas, pour obtenir l'adhésion au groupe pour l'utilisateur actuellement connecté.

Je suis tombé sur cette méthode dans ce billet de blog: http://www.travisrunyard.com/2013/03/26/auto-create-outlook-mapi-user-profiles/

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

Une version encore meilleure qui utilise une regex pour supprimer le guff LDAP et ne laisse que les noms de groupe:

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

Plus de détails sur l'utilisation de l'accélérateur de type [ADSISEARCHER] peuvent être trouvés sur le blog de scripting guy: http://blogs.technet.com/b/heyscriptingguy/archive/2010/08/24/use-the-powershell-adsisearcher-type -accelerator-to-search-active-directory.aspx

Vieille école de CMD:

net user mst999 /domain 

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

Si vous ne parvenez pas à faire fonctionner Get-ADPrincipalGroupMembership, vous pouvez essayer de vous connecter en tant qu'utilisateur, puis utiliser.

$id = [Security.Principal.WindowsIdentity]::GetCurrent()
$groups = $id.Groups | foreach-object {$_.Translate([Security.Principal.NTAccount])}
$groups | select *

Obtenez l'appartenance à un groupe pour un utilisateur:

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

Voir Obtenir l'adhésion à un groupe pour un utilisateur

Mais consultez également les commandes PowerShell gratuites de Quest pour Active Directory .

[ Modifier : la commande Get-ADPrincipalGroupMembership est incluse dans Powershell depuis la v2 avec Windows 2008 R2. Voir la réponse de kstrauss ci-dessous.]

Get-Memberest une applet de commande pour répertorier les membres d'un .NET object. Cela n'a rien à voir avec l'appartenance à un utilisateur / groupe. Vous pouvez obtenir l'appartenance au groupe de l'utilisateur actuel comme suit:

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

Si vous avez besoin d'accéder à des informations de groupe d'utilisateurs arbitraires, la suggestion de @tiagoinu d'utiliser les applets de commande Quest AD est une meilleure solution.

Tout d'abord, importez le module activedirectory:

import-module activedirectory

Puis émettez cette commande:

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

Cela affichera les membres du groupe spécifié.

Pas besoin de longs scripts quand il s'agit d'une simple ligne unique.

Commande QUEST

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

Commande MS AD

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

Je trouve que le cmd MS AD est plus rapide, mais certaines personnes préfèrent les Quest.

Steve

Get-Member n'est pas pour obtenir l'adhésion au groupe de l'utilisateur. Si vous souhaitez obtenir une liste des groupes auxquels appartient un utilisateur sur le système local, vous pouvez le faire en:

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

Get-WMIObject -Query $query | Select Name

Dans la requête ci-dessus, remplacez DemoUser1 par le nom d'utilisateur souhaité et le DomainName par le nom de votre ordinateur local ou le nom de domaine.

Utilisation:

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

Cela transfère la sortie de la commande dans un fichier CSV .

Cela devrait vous fournir les détails de l'utilisateur actuel. Powershell pas nécessaire.

whoami /groups

C'est juste une ligne:

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

Fin de :)

J'ai écrit une fonction PowerShell appelée Get-ADPrincipalGroupMembershipRecursive. Il accepte le DSN d'un utilisateur, d'un ordinateur, d'un groupe ou d'un compte de service. Il récupère une liste initiale de groupes à partir de l'attribut memberOf du compte, puis vérifie de manière récursive les appartenances à ces groupes. Le code abrégé est ci-dessous. Le code source complet avec des commentaires peut être trouvé ici .

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

Le ci-dessous fonctionne bien:

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

Si vous avez une liste d'utilisateurs:

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

Get-QADUser -SamAccountName ID de connexion | % {$ _. MemberOf} | Get-QADGroup | sélectionner un nom

Je n'ai pas pu faire fonctionner les éléments suivants pour un utilisateur particulier:

Get-ADPrincipalGroupMembership username

Il a jeté une erreur que je n'étais pas disposé à résoudre.

J'ai cependant proposé une solution différente en utilisant Get-ADUser. Je l'aime un peu mieux car si vous ne connaissez pas le nom du compte, vous pouvez l'obtenir en fonction d'un caractère générique sur le nom réel de l'utilisateur. Remplissez simplement PartOfUsersName et c'est parti.

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

D'énormes accessoires à schmeckendeugler et 8DH pour m'avoir amené à cette solution. +1 à vous deux.

Bien qu'il y ait beaucoup d'excellentes réponses ici, il y en a une que je cherchais personnellement et qui manquait. Une fois que je l'ai compris - j'ai pensé que je devrais le publier au cas où je voudrais le retrouver plus tard, ou il parvient en fait à aider quelqu'un d'autre à un moment donné:

Get-ADPrincipalGroupMembership username | Format-Table -auto

Une deuxième approche pour présenter ceci est de spécifier les colonnes individuelles qui vous intéressent, par exemple:

Get-ADPrincipalGroupMembership username | select name, GroupScope, GroupCategory

Cela donne tous les groupes AD auxquels le nom d'utilisateur appartient - mais présente également toutes les propriétés par défaut de chaque groupe bien formatées sous forme de tableau.

Le principal avantage que cela vous donne est que vous pouvez voir en un coup d'œil quelles sont les listes de distribution et quels sont les groupes de sécurité. Vous pouvez en outre voir en un coup d'œil quels sont Universal, qui sont DomainLocal et qui sont Global.
Pourquoi vous souciez-vous de ce dernier morceau?

• Un groupe universel est un groupe de sécurité ou de distribution qui contient des utilisateurs, des groupes et des ordinateurs de n'importe quel domaine de sa forêt en tant que membres. Vous pouvez attribuer des droits et autorisations aux groupes de sécurité universels sur les ressources de n'importe quel domaine de la forêt.
• Le groupe global est un groupe qui peut être utilisé dans son propre domaine, dans les serveurs membres et dans les postes de travail du domaine, et dans les domaines d'approbation. Dans tous ces emplacements, vous pouvez attribuer des droits et autorisations à un groupe global et le groupe global peut devenir membre de groupes locaux. Cependant, un groupe global peut contenir des comptes d'utilisateurs provenant uniquement de son propre domaine.
• Le groupe local de domaine est un groupe de sécurité ou de distribution qui peut contenir des groupes universels, des groupes globaux, d'autres groupes locaux de domaine de son propre domaine et des comptes de n'importe quel domaine de la forêt. Vous pouvez accorder des droits et des autorisations aux groupes de sécurité locaux de domaine sur les ressources qui résident uniquement dans le même domaine où se trouve le groupe local de domaine.

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

Modifiez la valeur de -SearchBase pour refléter l'unité d'organisation dont vous avez besoin pour répertorier les utilisateurs :)

Cela listera tous les utilisateurs de cette UO et vous montrera de quels groupes ils sont membres.

Get-ADPrincipalGroupMembership USERLOGON | sélectionner un nom

   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. 

C'est le moyen le plus simple d'obtenir simplement les noms:

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

Ajoutez une instruction de sélection pour réduire la réponse ou pour obtenir chaque utilisateur d'une UO chaque groupe dont il est utilisateur:

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

Pour l'obtenir récursif, vous pouvez utiliser:

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

Presque toutes les solutions ci-dessus utilisaient le ActiveDirecotrymodule qui pourrait ne pas être disponible par défaut dans la plupart des cas.

J'ai utilisé la méthode ci-dessous. Un peu indirect, mais a servi mon objectif.

Lister tous les groupes disponibles

Get-WmiObject -Class Win32_Group

Et puis listez les groupes auxquels appartient l'utilisateur

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

La comparaison peut ensuite être effectuée en vérifiant via le fichier SIDs. Cela fonctionne pour l'utilisateur connecté. S'il vous plait corrigez moi si je me trompe. Complètement nouveau dans PowerShell, mais a dû le faire pour un engagement de travail.

Avec entrée utilisateur et formatage de sortie sophistiqué:

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

Mettre ceci ici pour référence future. Je suis au milieu d'une migration de messagerie. J'ai besoin de connaître chaque compte d'utilisateur et son appartenance à un groupe respectif, et j'ai également besoin de connaître chaque groupe et ses membres respectifs.

J'utilise le bloc de code ci-dessous pour générer un CSV pour l'appartenance au groupe de chaque utilisateur.

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

Le processus d'exportation pour les groupes et leurs membres respectifs était un peu compliqué, mais ce qui suit fonctionne. Les noms de fichiers de sortie incluent le type de groupe. Par conséquent, les groupes de distribution de courrier électronique dont j'ai besoin sont / doivent être les groupes de distribution universelle et globale. Je devrais pouvoir simplement supprimer ou déplacer les fichiers TXT résultants dont je n'ai pas besoin.

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

L'étude de tous les commentaires présentés m'a donné un point de départ (merci pour cela) mais m'a laissé avec plusieurs problèmes non résolus. En conséquence, voici ma réponse. L'extrait de code fourni fait un peu plus que ce qui est demandé, mais il fournit des informations de débogage utiles.

[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

Lorsque vous ne disposez pas des privilèges pour consulter d'autres groupes de membres, mais que vous avez le privilège de consulter les membres du groupe, vous pouvez effectuer les opérations suivantes pour créer une carte indiquant quels utilisateurs ont accès à quels groupes.

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