Come ottenere tutti i gruppi di cui un utente è membro?

Il Get-ADGroupMembercmdlet di PowerShell restituisce i membri di un gruppo specifico. Esiste un cmdlet o una proprietà per ottenere tutti i gruppi di cui un determinato utente è membro?

Ho corretto l'errore: Get-Memberdovrebbe essere Get-ADGroupMember.

Get-ADPrincipalGroupMembership farà questo.

Get-ADPrincipalGroupMembership username | select name

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

Linea singola, nessun modulo necessario, utilizza l'utente attualmente registrato:

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

Qudos a questo articolo vbs / powershell: http://technet.microsoft.com/en-us/library/ff730963.aspx

Un'alternativa più concisa a quella pubblicata da Canoas, per ottenere l'appartenenza al gruppo per l'utente attualmente connesso.

Mi sono imbattuto in questo metodo in questo post del blog: http://www.travisrunyard.com/2013/03/26/auto-create-outlook-mapi-user-profiles/

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

Una versione ancora migliore che utilizza un regex per eliminare la guff LDAP e lascia solo i nomi dei gruppi:

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

Maggiori dettagli sull'uso dell'acceleratore di tipo [ADSISEARCHER] sono disponibili sul blog di scripting guy: http://blogs.technet.com/b/heyscriptingguy/archive/2010/08/24/use-the-powershell-adsisearcher-type -accelerator-to-ricerca-attiva-directory.aspx

Modo vecchia scuola da CMD:

net user mst999 /domain 

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

Se non riesci a far funzionare Get-ADPrincipalGroupMembership per te, potresti provare ad accedere come quell'utente, quindi utilizzare.

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

Ottieni l'appartenenza al gruppo per un utente:

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

Vedi Ottieni l'appartenenza al gruppo per un utente

Ma vedi anche i comandi PowerShell gratuiti di Quest per Active Directory .

[ Modifica : il comando Get-ADPrincipalGroupMembership è incluso in Powershell dalla v2 con Windows 2008 R2. Vedi la risposta di kstrauss di seguito.]

Get-Memberè un cmdlet per elencare i membri di un .NET object. Questo non ha nulla a che fare con l'appartenenza a utenti / gruppi. Puoi ottenere l'appartenenza al gruppo dell'utente corrente in questo modo:

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

Se hai bisogno di accedere a informazioni di gruppo di utenti arbitrari, il suggerimento di @tiagoinu di utilizzare i cmdlet di Quest AD è un modo migliore di procedere.

Innanzitutto, importa il modulo activedirectory:

import-module activedirectory

Quindi emettere questo comando:

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

Questo mostrerà i membri del gruppo specificato.

Non c'è bisogno di lunghi script quando si tratta di una semplice fodera ..

Comando QUEST

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

Comando MS AD

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

Trovo che il cmd di MS AD sia più veloce ma ad alcune persone piacciono quelle di Quest ..

Steve

Get-Member non è per ottenere l'appartenenza al gruppo dell'utente. Se si desidera ottenere un elenco di gruppi a cui appartiene un utente sul sistema locale, è possibile farlo:

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

Get-WMIObject -Query $query | Select Name

Nella query sopra, sostituire DemoUser1 con il nome utente desiderato e DomainName con il nome del computer locale o il nome del dominio.

Uso:

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

Questo invia l'output del comando in un file CSV .

Questo dovrebbe fornire i dettagli per l'utente corrente. Powershell non necessario.

whoami /groups

È solo una riga:

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

fine di :)

Ho scritto una funzione di PowerShell chiamata Get-ADPrincipalGroupMembershipRecursive. Accetta il DSN di un account utente, computer, gruppo o servizio. Recupera un elenco iniziale di gruppi dall'attributo memberOf dell'account, quindi controlla ricorsivamente le appartenenze a tali gruppi. Il codice abbreviato è di seguito. Il codice sorgente completo con commenti è disponibile qui .

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

Di seguito funziona bene:

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

Se hai un elenco di utenti:

$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 | seleziona il nome

Non riesco a far funzionare quanto segue per un determinato utente:

Get-ADPrincipalGroupMembership username

Ha generato un errore che non ero disposto a risolvere.

Tuttavia, ho trovato una soluzione diversa utilizzando Get-ADUser. Mi piace un po 'meglio perché se non conosci il nome dell'account, puoi ottenerlo in base a un carattere jolly sul nome effettivo dell'utente. Basta compilare PartOfUsersName e il gioco è fatto.

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

Enormi oggetti di scena per schmeckendeugler e 8DH per avermi portato a questa soluzione. +1 per entrambi.

Mentre ci sono molte risposte eccellenti qui, ce n'è una che cercavo personalmente che mancava. Una volta capito, pensavo di doverlo pubblicare nel caso in cui volessi trovarlo in un secondo momento, o riesca effettivamente ad aiutare qualcun altro a un certo punto:

Get-ADPrincipalGroupMembership username | Format-Table -auto

Un secondo approccio per presentare questo è quello di specificare le singole colonne che ti interessano ad esempio:

Get-ADPrincipalGroupMembership username | select name, GroupScope, GroupCategory

Ciò fornisce a tutti i gruppi AD a cui appartiene il nome utente, ma presenta anche tutte le proprietà predefinite di ciascun gruppo formattate come una tabella.

Il vantaggio principale che questo ti dà è che puoi vedere a colpo d'occhio quali sono le liste di distribuzione e quali sono i gruppi di sicurezza. Puoi inoltre vedere a colpo d'occhio quali sono Universal, quali DomainLocal e quali Global.
Perché dovresti preoccuparti di quest'ultima parte?

• Il gruppo universale è un gruppo di sicurezza o distribuzione che contiene come membri utenti, gruppi e computer di qualsiasi dominio nella sua foresta. È possibile assegnare ai gruppi di sicurezza universali diritti e autorizzazioni sulle risorse in qualsiasi dominio della foresta.
• Il gruppo globale è un gruppo che può essere utilizzato nel proprio dominio, nei server membri e nelle workstation del dominio e nei domini di fiducia. In tutte queste posizioni, è possibile assegnare a un gruppo globale diritti e autorizzazioni e il gruppo globale può diventare membro di gruppi locali. Tuttavia, un gruppo globale può contenere account utente che provengono solo dal proprio dominio.
• Il gruppo locale di dominio è un gruppo di sicurezza o di distribuzione che può contenere gruppi universali, gruppi globali, altri gruppi locali di dominio del proprio dominio e account di qualsiasi dominio della foresta. È possibile assegnare diritti e autorizzazioni ai gruppi di sicurezza locali del dominio su risorse che risiedono solo nello stesso dominio in cui si trova il gruppo locale del dominio.

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

Modifica il valore di -SearchBase per riflettere l'unità organizzativa di cui hai bisogno per elencare gli utenti :)

Questo elencherà tutti gli utenti in quell'unità organizzativa e ti mostrerà di quali gruppi sono membri.

Get-ADPrincipalGroupMembership USERLOGON | seleziona il nome

   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. 

Questo è il modo più semplice per ottenere solo i nomi:

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

Aggiungi un'istruzione select per tagliare la risposta o per ottenere tutti gli utenti di un'unità organizzativa in ogni gruppo di cui sono utenti:

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

Per farlo ricorsivo, puoi usare:

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

Quasi tutte le soluzioni di cui sopra hanno utilizzato il ActiveDirecotrymodulo che nella maggior parte dei casi potrebbe non essere disponibile per impostazione predefinita.

Ho usato il metodo seguente. Un po 'indiretto, ma è servito al mio scopo.

Elenca tutti i gruppi disponibili

Get-WmiObject -Class Win32_Group

E quindi elenca i gruppi a cui appartiene l'utente

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

Il confronto può quindi essere effettuato controllando tramite SIDs. Questo funziona per l'utente che ha effettuato l'accesso. Perfavore, correggimi se sbaglio. Completamente nuovo per PowerShell, ma è stato necessario farlo per un impegno lavorativo.

Con input dell'utente e formattazione di output sofisticata:

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

Metterlo qui per riferimento futuro. Sono nel mezzo di una migrazione e-mail. Ho bisogno di conoscere ogni account utente e la sua appartenenza al gruppo e ho bisogno di conoscere ogni gruppo e i suoi rispettivi membri.

Sto usando il blocco di codice qui sotto per generare un CSV per l'appartenenza al gruppo di ciascun utente.

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

Il processo di esportazione per i gruppi e i loro rispettivi membri è stato un po 'contorto, ma il seguito funziona. I nomi dei file di output includono il tipo di gruppo. Pertanto, i gruppi di distribuzione e-mail di cui ho bisogno sono / dovrebbero essere i gruppi di distribuzione universale e globale. Dovrei essere in grado di eliminare o spostare i file TXT risultanti che non mi servono.

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

Studiare tutti i commenti presentati mi ha dato un punto di partenza (grazie per questo) ma mi ha lasciato con diversi problemi irrisolti. Di conseguenza ecco la mia risposta. Lo snippet di codice fornito fa un po 'di più di quello che viene richiesto ma fornisce utili informazioni di debug.

[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

Quando non si dispone dei privilegi per consultare altri gruppi di membri ma si ha il privilegio di consultare i membri del gruppo, è possibile effettuare le seguenti operazioni per creare una mappa di quale utente ha accesso a quali gruppi.

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