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


135

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.


La pregunta no es clara. ¿Puedes replantearlo o agregar un ejemplo?
Mohit Chakraborty

1
Consulte stackoverflow.com/questions/668321/… y technet.microsoft.com/en-us/library/dd315351.aspx . ¿Estás seguro de que Get-Member hace lo que crees que hace?
tiago2014

@Mohit Chakraborty ¿Ahora está más claro?
Primoz

1
puede usar rápidamente net user /domain username, verifique también otros métodos en Obtener grupos en los que un usuario es miembro Uso de PowerShell
Mohamed

Respuestas:


282

Get-ADPrincipalGroupMembership lo hará.

Get-ADPrincipalGroupMembership username | select name

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

1
Esto me salvó de usar el método más complicado y largo de encontrar esto. Sabía que PowerShell tendría algo como esto, pero no podría encontrarlo en ningún lado. +1
Tim Alexander

77
Tenga en cuenta que esto depende de que el módulo ActiveDirectory esté disponible. Eso no necesariamente funcionará en una máquina cliente donde esté ejecutando un script de PowerShell, o en clientes de nivel inferior. Si quieres hacer eso, usa esta solución .
Daniel.S

55
Lo anterior me estaba dando errores ("El servidor no pudo procesar la solicitud debido a un error interno" - presumiblemente la funcionalidad no está disponible en el servidor). get-aduser $username -Properties memberof | select -expand memberoffuncionó bien sin embargo.
JohnLBevan

55
Si está en una estación de trabajo con Windows 10 en lugar de un servidor, instale RSAT desde aquí , luego escriba import-module activedirectoryen la línea de comandos de powershell, entonces esto debería ejecutarse.
James Toomey

3
Si el módulo no está instalado: Install-WindowsFeature RSAT-AD-PowerShell
Preben Huybrechts

81

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


55
Gracias, aprecio esta versión sin módulos. Simplemente cambié la variable de $env:usernamea $usernamey configuré $username = "testuser"para hacer fácilmente la sustitución de variables para otras búsquedas de usuarios.
projectdp

¡Simplemente busqué en Google mi camino de regreso aquí de nuevo! Sigue siendo útil en situaciones aleatorias donde las herramientas de AD no están disponibles.
Nathan

43

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


1
Ambos me dan el error: Excepción llamando a "FindOne" con argumento "0": "El filtro samaccountname = search no es válido".
Dallas

Extraño ... Acabo de probarlo de nuevo, pero en Windows 7 en un entorno completamente diferente, y también funciona bien aquí.
Daniel.S

Lo intenté nuevamente ahora, todavía en Win 7, y funciona bien. Quizás tuve un error tipográfico cuando probé esto por primera vez. Gracias por agregar el reemplazo para quitar el bosque "guff".
Dallas

2
Funciona muy bien, agregue | Sort-Objectpara hacerlo aún más legible.
Martin Hollingsworth

31

Camino de la vieja escuela de CMD:

net user mst999 /domain 

1
también funciona en máquinas cliente sin herramientas AD adicionales
Rast

44
Desafortunadamente, si los nombres de sus grupos son largos (es decir,> 21 caracteres), los truncará ...
kiltannen

¡ese supera a todos los demás! Bravo
StayCool

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

¡Gracias! Esto funcionó. El único inconveniente es que el valor devuelto es una cadena.
shaiss

3
El | get-adgroup generará los objetos del grupo. ¡Brillante!
8DH

1
o use $ env: USERNAME en su lugar para obtener el nombre de usuario del usuario actualmente conectado
Dave Lucre, el

6

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 *

No necesita iniciar sesión como usuario tampoco si usa algo como$id = [Security.Principal.WindowsIdentity]("username")
Bitcoin Murderous Maniac

1
Esto acorta muy bien a la frase [System.Security.Principal.WindowsIdentity]::GetCurrent().Groups | % {$_.Translate([Security.Principal.NTAccount])}.
alx9r

5

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


2
En realidad, hay una manera más fácil con los cmdlets de Quest: Get-QADGroup -Contains Primoz
fenster

18
Esta ya no es la mejor respuesta, ya que Get-ADPrincipalGroupMembership ahora está integrado en PowerShell
Rob Cannon

1
Votado abajo porque sería mucho mejor usar Get-ADPrincipalGroupMembership. Me gustaría deshacer este voto negativo, pero no puedo. Editaré la respuesta para señalar que la opción integrada ahora existe.
Abraham

4

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.


4

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.


El OP pide lo contrario. Obtenga todos los grupos de los que es miembro un usuario especificado.
8DH

4

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


4

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.


Esta consulta lleva mucho tiempo y responde muy lentamente cuando hay varios usuarios y grupos en el entorno
randeepsp

Quien esté editando la respuesta, asegúrese de editarla de la manera correcta. Estaba sugiriendo que el OP reemplazara DemoUser1 con el nombre de usuario que quiera. Y, cambiaste completamente ese significado.
ravikanth

4

Utilizar:

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

Esto canaliza la salida del comando en un archivo CSV .


4

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

whoami /groups


3

Es solo una línea:

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

final de :)


Si se conecta eso a a select -expandproperty memberof, la salida será un poco más legible / útil.
Ben Thul

2

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

2

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

1

Get-QADUser -SamAccountName LoginID | % {$ _. MemberOf} | Get-QADGroup | seleccione nombre


1

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.


1

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.

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



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

0

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}


0

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

0

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.


Si está comprobando un usuario que ya es miembro del grupo Administrador, asegúrese de iniciar PowerShell con "Ejecutar como administrador", de lo contrario, los grupos no se enumerarán correctamente para el segundo comando ... tardó bastante en darse cuenta esto fuera ... ventanas ...
Ruifeng Ma

0

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

0

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

0

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

Lo siento, olvidé aclararlo. Haga esto primero: $ aduserDistinguishedName = "CN = name, OU = ..." $ aduser = Get-ADUser -Identity $ aduserDistinguishedName -Properties *
ES44AC SD70MAC

0

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)
    }
}
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.