¿Cómo obtener todos los grupos de los que es miembro un usuario?

El Get-ADGroupMembercmdlet de PowerShell devuelve miembros de un grupo específico. ¿Existe un cmdlet o propiedad para obtener todos los grupos de los que un usuario en particular es miembro?

Arreglé mi error: Get-Memberdebería ser Get-ADGroupMember.

Get-ADPrincipalGroupMembership lo hará.

Get-ADPrincipalGroupMembership username | select name

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

Una sola línea, sin módulos necesarios, utiliza el usuario registrado actual:

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

Qudos a este artículo de vbs / powershell: http://technet.microsoft.com/en-us/library/ff730963.aspx

Una alternativa más concisa a la publicada por Canoas, para obtener la membresía de grupo para el usuario actualmente conectado.

Encontré este método en esta publicación de blog: http://www.travisrunyard.com/2013/03/26/auto-create-outlook-mapi-user-profiles/

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

Una versión aún mejor que usa una expresión regular para quitar el guff LDAP y deja solo los nombres de los grupos:

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

Puede encontrar más detalles sobre el uso del acelerador de tipo [ADSISEARCHER] en el 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

Camino de la vieja escuela de CMD:

net user mst999 /domain 

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

Si no puede hacer que Get-ADPrincipalGroupMembership funcione, puede intentar iniciar sesión como ese usuario y luego usarlo.

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

Obtener membresía de grupo para un usuario:

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

Consulte Obtener membresía de grupo para un usuario

Pero también vea los Comandos gratuitos de PowerShell de Quest para Active Directory .

[ Editar : el comando Get-ADPrincipalGroupMembership está incluido en Powershell desde v2 con Windows 2008 R2. Ver la respuesta de kstrauss a continuación.]

Get-Memberes un cmdlet para enumerar los miembros de un .NET object. Esto no tiene nada que ver con la membresía de usuario / grupo. Puede obtener la membresía de grupo del usuario actual de la siguiente manera:

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 necesita acceso a información de grupo de usuarios arbitrarios, entonces la sugerencia de @tiagoinu de usar los cmdlets de Quest AD es una mejor manera de hacerlo.

Primero, importe el módulo activedirectory:

import-module activedirectory

Luego emita este comando:

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

Esto mostrará los miembros del grupo especificado.

No hay necesidad de guiones largos cuando se trata de un simple revestimiento.

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

Me parece que el cmd de MS AD es más rápido, pero a algunas personas les gustan más los Quest.

Steve

Get-Member no es para obtener la membresía de grupo del usuario. Si desea obtener una lista de grupos a los que pertenece un usuario en el sistema local, puede hacerlo de la siguiente manera:

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

Get-WMIObject -Query $query | Select Name

En la consulta anterior, reemplace DemoUser1 con el nombre de usuario que desee y el DomainName con el nombre de su computadora local o el nombre de dominio.

Utilizar:

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

Esto canaliza la salida del comando en un archivo CSV .

Esto debería proporcionarle los detalles para el usuario actual. Powershell no es necesario.

whoami /groups

Es solo una línea:

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

final de :)

Escribí una función de PowerShell llamada Get-ADPrincipalGroupMembershipRecursive. Acepta el DSN de una cuenta de usuario, computadora, grupo o servicio. Recupera una lista inicial de grupos del atributo memberOf de la cuenta, luego verifica recursivamente las membresías de esos grupos. El código abreviado está debajo. El código fuente completo con comentarios se puede encontrar aquí .

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

Lo siguiente funciona bien:

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

Si tiene una lista de usuarios:

$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 | seleccione nombre

No pude hacer que lo siguiente funcione para un usuario en particular:

Get-ADPrincipalGroupMembership username

Lanzó un error que no estaba dispuesto a solucionar.

Sin embargo, encontré una solución diferente usando Get-ADUser. Me gusta un poco mejor porque si no conoce el nombre de la cuenta, puede obtenerlo basándose en un comodín en el nombre real del usuario. Simplemente complete PartOfUsersName y listo .

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

Enormes apoyos para schmeckendeugler y 8DH por llevarme a esta solución. +1 a los dos.

Si bien hay muchas respuestas excelentes aquí, hay una que estaba buscando personalmente que faltaba. Una vez que lo descubrí, pensé que debería publicarlo en caso de que quiera encontrarlo más tarde, o de hecho se las arregla para ayudar a alguien más en algún momento:

Get-ADPrincipalGroupMembership username | Format-Table -auto

Un segundo enfoque para presentar esto es especificar las columnas individuales que le interesan, por ejemplo:

Get-ADPrincipalGroupMembership username | select name, GroupScope, GroupCategory

Esto proporciona a todos los grupos de AD a los que pertenece el nombre de usuario, pero también presenta todas las propiedades predeterminadas de cada grupo formateadas como una tabla.

El beneficio clave que esto le brinda es que puede ver de un vistazo cuáles son las listas de distribución y cuáles son los grupos de Seguridad. Puede ver más de un vistazo cuáles son universales, cuáles son DomainLocal y cuáles son globales.
¿Por qué te importaría esta última parte?

• El grupo universal es un grupo de seguridad o distribución que contiene usuarios, grupos y computadoras de cualquier dominio en su bosque como miembros. Puede otorgar derechos y permisos a grupos de seguridad universal sobre recursos en cualquier dominio del bosque.
• El grupo global es un grupo que se puede utilizar en su propio dominio, en servidores miembros y en estaciones de trabajo del dominio, y en dominios de confianza. En todas esas ubicaciones, puede otorgar derechos y permisos a un grupo global y el grupo global puede convertirse en miembro de grupos locales. Sin embargo, un grupo global puede contener cuentas de usuario que son solo de su propio dominio.
• El grupo local de dominio es un grupo de seguridad o distribución que puede contener grupos universales, grupos globales, otros grupos locales de dominio de su propio dominio y cuentas de cualquier dominio en el bosque. Puede otorgar derechos y permisos a grupos de seguridad local de dominio sobre recursos que residen solo en el mismo dominio donde se encuentra el grupo local de 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
    }
}

Cambie el valor de -SearchBase para reflejar la unidad organizativa de la que necesita enumerar los usuarios :)

Esto mostrará una lista de todos los usuarios en esa unidad organizativa y le mostrará de qué grupos son miembros.

Get-ADPrincipalGroupMembership USERLOGON | seleccione nombre

   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. 

Esta es la forma más simple de obtener los nombres:

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

Agregue una instrucción select para recortar la respuesta o para que cada usuario de una unidad organizativa cada grupo del que sea usuario:

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

Para hacerlo recursivo, puede usar:

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

Casi todas las soluciones anteriores utilizaron el ActiveDirecotrymódulo que podría no estar disponible por defecto en la mayoría de los casos.

Usé el siguiente método. Un poco indirecto, pero cumplió mi propósito.

Listar todos los grupos disponibles

Get-WmiObject -Class Win32_Group

Y luego enumere los grupos a los que pertenece el usuario

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

La comparación se puede hacer mediante la comprobación a través de SIDs. Esto funciona para el usuario conectado. Por favor, corríjame si estoy equivocado. Completamente nuevo en PowerShell, pero tuve que hacerlo para un compromiso de trabajo.

Con entrada de usuario y formato de salida elegante:

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

Poniendo esto aquí para referencia futura. Estoy en medio de una migración de correo electrónico. Necesito conocer cada cuenta de usuario y su respectiva membresía de grupo, y también necesito conocer cada grupo y sus respectivos miembros.

Estoy usando el bloque de código a continuación para generar un CSV para la membresía de grupo de cada usuario.

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

El proceso de exportación para los grupos y sus respectivos miembros fue un poco complicado, pero a continuación funciona. Los nombres de los archivos de salida incluyen el tipo de grupo. Por lo tanto, los grupos de distribución de correo electrónico que necesito son / deberían ser los grupos de Distribución Universal y Global. Debería poder simplemente eliminar o mover los archivos TXT resultantes que no necesito.

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

Estudiar todos los comentarios presentados me dio un punto de partida (gracias por eso) pero me dejó con varios problemas sin resolver. Como resultado aquí está mi respuesta. El fragmento de código proporcionado hace un poco más de lo que se solicita, pero proporciona información útil de depuración.

[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

Cuando no tiene privilegios para consultar a otros grupos de miembros pero sí tiene el privilegio de consultar a los miembros del grupo, puede hacer lo siguiente para crear un mapa de qué usuario tiene acceso a qué grupos.

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