¿Cómo listar a todos los usuarios en un grupo Linux?

getent group <groupname>;

Es portable a través de Linux y Solaris, y funciona con grupos locales/archivos de contraseña, NIS y configuraciones LDAP.

Use Python para listar a los miembros del grupo:

Python-c "importar grp; imprimir grp.getgrnam ('GROUP_NAME') [3] "

Véase https://docs.python.org/2/library/grp.html

lid -g groupname | cut -f1 -d'(' 

El siguiente comando listará todos los usuarios pertenecientes a <your_group_name>, pero solo aquellos administrados por la base de datos /etc/group, no LDAP, NIS, etc. También funciona solo para grupos secundarios, no listará a los usuarios que tienen ese grupo establecido como primario ya que el grupo primario se almacena como GID (ID de grupo numérico) en el archivo /etc/passwd.

grep <your_group_name> /etc/group

El siguiente comando listará todos los usuarios pertenecientes a <your_group_name>, pero solo aquellos administrados por la base de datos /etc/group, no LDAP, NIS, etc. También funciona solo para grupos secundarios, no listará a los usuarios que tienen ese grupo establecido como primario ya que el grupo primario se almacena como GID (ID de grupo numérico) en el archivo /etc/passwd.

awk -F: '/^groupname/ {print $4;}' /etc/group

El siguiente script de shell iterará a través de todos los usuarios e imprimirá solo aquellos nombres de usuario que pertenezcan a un grupo dado:

#!/usr/bin/env bash
getent passwd | while IFS=: read name trash
do
    groups $name 2>/dev/null | cut -f2 -d: | grep -i -q -w "$1" && echo $name
done
true

Ejemplo de uso:

./script 'DOMAIN+Group Name'

Nota: Esta solución comprobará NIS y LDAP para usuarios y grupos (no solo archivos passwd y group). También tendrá en cuenta a los usuarios no agregados a un grupo pero que tengan un grupo establecido como grupo primario.

Editar: Se ha añadido una corrección para el escenario raro donde el usuario no pertenece al grupo con el mismo nombre.

Editar: escrito en la forma de un script de shell; añadido true para salir con 0 estado como sugiere @Max Chernyak aka hakunin; descartado stderr con el fin de omitir los ocasionales groups: cannot find name for group ID xxxxxx.

Puede hacerlo en una sola línea de comandos:

cut -d: -f1,4 /etc/passwd | grep $(getent group <groupname> | cut -d: -f3) | cut -d: -f1

El comando anterior enumera todos los usuarios que tienen groupname como su grupo primario

Si también desea enumerar los usuarios que tienen groupname como su grupo secundario, use el siguiente comando

getent group <groupname> | cut -d: -f4 |  tr ',' '\n'

La implementación de Zed probablemente debería ser expandida para trabajar en algunos de los otros UNIX principales.

¿Alguien tiene acceso a hardware Solaris o HP-UX?; no puso a prueba esos casos.

#!/usr/bin/perl
#
# Lists members of all groups, or optionally just the group
# specified on the command line
#
# Date:         12/30/2013
# Author:       William H. McCloskey, Jr.
# Changes:      Added logic to detect host type & tailor subset of getent (OSX)
# Attribution:
#   The logic for this script was directly lifted from Zed Pobre's work.
#     See below for Copyright notice.
#   The idea to use dscl to emulate a subset of the now defunct getent on OSX
#     came from
#       http://zzamboni.org/\
#         brt/2008/01/21/how-to-emulate-unix-getent-with-macosxs-dscl/
#     with an example implementation lifted from
#       https://github.com/petere/getent-osx/blob/master/getent
#
# Copyright © 2010-2013 by Zed Pobre ([email protected] or [email protected])
#
# Permission to use, copy, modify, and/or distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#

use strict; use warnings;

$ENV{"PATH"} = "/usr/bin:/bin";

# Only run on supported $os:
my $os;
($os)=(`uname -a` =~ /^([\w-]+)/);
unless ($os =~ /(HU-UX|SunOS|Linux|Darwin)/)
    {die "\$getent or equiv. does not exist:  Cannot run on $os\n";}

my $wantedgroup = shift;

my %groupmembers;

my @users;

# Acquire the list of @users based on what is available on this OS:
if ($os =~ /(SunOS|Linux|HP-UX)/) {
    #HP-UX & Solaris assumed to be like Linux; they have not been tested.
    my $usertext = `getent passwd`;
    @users = $usertext =~ /^([a-zA-Z0-9_-]+):/gm;
};
if ($os =~ /Darwin/) {
    @users = `dscl . -ls /Users`;
    chop @users;
}

# Now just do what Zed did - thanks Zed.
foreach my $userid (@users)
{
    my $usergrouptext = `id -Gn $userid`;
    my @grouplist = split(' ',$usergrouptext);

    foreach my $group (@grouplist)
    {
        $groupmembers{$group}->{$userid} = 1;
    }
}

if($wantedgroup)
{
    print_group_members($wantedgroup);
}
else
{
    foreach my $group (sort keys %groupmembers)
    {
        print "Group ",$group," has the following members:\n";
        print_group_members($group);
        print "\n";
    }
}

sub print_group_members
{
    my ($group) = @_;
    return unless $group;

    foreach my $member (sort keys %{$groupmembers{$group}})
    {
        print $member,"\n";
    }
}

Si hay una mejor manera de compartir esta sugerencia, por favor hágamelo saber; Consideré muchas maneras, y esto es lo que se me ocurrió.

He hecho esto similar al código de perl anterior, pero reemplazé getent e id con funciones nativas de perl. Es mucho más rápido y debería funcionar en diferentes sabores *nix.

#!/usr/bin/env perl

use strict;
my $arg=shift;
my %groupMembers; # defining outside of function so that hash is only built once for multiple function calls

sub expandGroupMembers{
my $groupQuery=shift;
unless (%groupMembers){
    while (my($name,$pass,$uid,$gid,$quota,$comment,$gcos,$dir,$shell,$expire)=getpwent()) {
            my $primaryGroup=getgrgid($gid);
            $groupMembers{$primaryGroup}->{$name}=1;
    }
    while (my($gname,$gpasswd,$gid,$members)=getgrent()) {
            foreach my $member (split / /, $members){
                    $groupMembers{$gname}->{$member}=1;
            }
    }
}
my $membersConcat=join(",",sort keys %{$groupMembers{$groupQuery}});
return "$membersConcat" || "$groupQuery Does have any members";
}
print &expandGroupMembers($arg)."\n";

Solo un poco de grep y tr:

$ grep ^$GROUP /etc/group | grep -o '[^:]*$' | tr ',' '\n'
user1
user2
user3

Hay un práctico paquete de Debian y Ubuntu llamado ' miembros ' que proporciona esta funcionalidad:

Descripción: Muestra los miembros de un grupo; por defecto, todos los miembros members es el complemento de los grupos: mientras que groups muestra los grupos a los que pertenece un usuario especificado, members muestra los usuarios pertenecer a un grupo especificado.

... Puede solicitar miembros primarios, miembros secundarios, tanto en una línea, cada una en líneas separadas.

Aquí hay un script que devuelve una lista de usuarios de /etc / passwd y/etc / group no comprueba NIS o LDAP, pero muestra a los usuarios que tienen el grupo como su grupo predeterminado Probado en Debian 4.7 y solaris 9

#!/bin/bash

MYGROUP="user"

# get the group ID
MYGID=`grep $MYGROUP /etc/group | cut -d ":" -f3`
if [[ $MYGID != "" ]]
then
  # get a newline-separated list of users from /etc/group 
  MYUSERS=`grep $MYGROUP /etc/group | cut -d ":" -f4| tr "," "\n"`
  # add a newline
  MYUSERS=$MYUSERS$'\n'
  # add the users whose default group is MYGROUP from /etc/passwod 
  MYUSERS=$MYUSERS`cat /etc/passwd |grep $MYGID | cut -d ":" -f1`

  #print the result as a newline-separated list with no duplicates (ready to pass into a bash FOR loop)
  printf '%s\n' $MYUSERS  | sort | uniq
fi

O como una sola línea puede cortar y pegar directamente desde aquí (cambiar el nombre del grupo en la primera variable)

MYGROUP="user";MYGID=`grep $MYGROUP /etc/group | cut -d ":" -f3`;printf '%s\n' `grep $MYGROUP /etc/group | cut -d ":" -f4| tr "," "\n"`$'\n'`cat /etc/passwd |grep $MYGID | cut -d ":" -f1`  | sort | uniq

En UNIX (a diferencia de GNU/Linux), está el comando listusers. Vea la página man de Solaris para listusers.

Tenga en cuenta que este comando es parte del Proyecto de código abierto Heirloom. Asumo que falta en GNU/Linux porque RMS no cree en grupos y permisos. :-)

Aquí hay un script awk muy simple que tiene en cuenta todas las trampas comunes enumeradas en las otras respuestas:

getent passwd | awk -F: -v group_name="wheel" '
  BEGIN {
    "getent group " group_name | getline groupline;
    if (!groupline) exit 1;
    split(groupline, groupdef, ":");
    guid = groupdef[3];
    split(groupdef[4], users, ",");
    for (k in users) print users[k]
  }
  $4 == guid {print $1}'

Estoy usando esto con mi configuración habilitada para ldap, se ejecuta en cualquier cosa con getent y awk que cumpla con los estándares, incluidos solaris 8+ y hpux.

getent group insert_group_name_here | awk -F ':' '{print $4}' | sed 's|,| |g'

Esto devuelve una lista de usuarios separados por espacios que he utilizado en scripts para rellenar matrices.

for i in $(getent group ftp | awk -F ':' '{print $4}' | sed 's|,| |g')
    do
        userarray+=("$i")
    done

O

userarray+=("$(getent group GROUPNAME | awk -F ':' '{print $4}' | sed 's|,| |g')")

getent group groupname | awk -F: '{print $4}' | tr , '\n'

Esto tiene 3 partes:

1 - getent group groupname muestra la línea del grupo en el archivo "/etc / group". Alternativa a cat /etc/group | grep groupname.

2 - awk imprime solo los miembros en una sola línea separada con','.

3 - tr reemplace', ' con una nueva línea e imprima cada usuario en una fila.

4 - Opcional: También puede usar otra tubería con sort, si los usuarios son demasiados.

Saludos

He intentado grep 'sample-group-name' /etc/group, que enumerará todos los miembros del grupo que especificó basado en el ejemplo aquí