para - tipos de usuarios en linux

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

Question

¿Cómo enumero a todos los miembros de un grupo en Linux (y posiblemente otros grupos)?

Answer 1

Aquí hay un script awk muy simple que toma en cuenta todos los escollos comunes enumerados 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 & awk que cumpla con los estándares, incluyendo solaris 8+ y hpux.

Answer 2

Aquí hay una secuencia de comandos que devuelve una lista de usuarios de / etc / passwd y / etc / group que 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í (cambie 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

Answer 3

Desafortunadamente, no hay una manera buena y portátil de hacer esto que yo sepa. Si intenta analizar / etc / group, como sugieren otros, extrañará a los usuarios que tienen a ese grupo como su grupo principal y a cualquier persona que haya sido agregada a ese grupo a través de un mecanismo distinto a los archivos planos de UNIX (es decir, LDAP, NIS, pam-pgsql, etc.).

Si tuviera que hacer esto por mi cuenta, probablemente lo haría a la inversa: usar id para obtener los grupos de cada usuario en el sistema (que extraerá todas las fuentes visibles para NSS), y usar Perl o algo similar para mantener una tabla de hash para cada grupo descubierto notando la pertenencia de ese usuario.

Edición: Por supuesto, esto te deja con un problema similar: cómo obtener una lista de todos los usuarios del sistema. Como mi ubicación solo utiliza archivos sin formato y LDAP, puedo obtener una lista de ambas ubicaciones, pero eso puede o no ser cierto para su entorno.

Edit 2: Alguien que me lo pasó me recordó que getent passwd devolverá una lista de todos los usuarios del sistema, incluidos los de LDAP / NIS / etc. Pero el getent group todavía extrañará a los usuarios que son miembros solo a través de la entrada de grupo predeterminada, Eso me inspiró a escribir este truco rápido.

#!/usr/bin/perl -T
#
# Lists members of all groups, or optionally just the group
# specified on the command line
#
# 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";

my $wantedgroup = shift;

my %groupmembers;
my $usertext = `getent passwd`;

my @users = $usertext =~ /^([a-zA-Z0-9_-]+):/gm;

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

Answer 4

El siguiente comando mostrará una lista de todos los usuarios que pertenecen 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 mostrará una lista de usuarios que tienen ese grupo establecido como principal, 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

Answer 5

El siguiente comando mostrará una lista de todos los usuarios que pertenecen 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 mostrará una lista de usuarios que tienen ese grupo establecido como principal, 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

Answer 6

El siguiente script de shell se repetirá a través de todos los usuarios e imprimirá solo los nombres de usuario que pertenecen a un grupo determinado:

#!/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 de passwd y de group ). También tendrá en cuenta a los usuarios que no están agregados a un grupo pero que tienen un grupo establecido como grupo primario.

Editar: Se ha agregado una solución para situaciones poco comunes donde el usuario no pertenece al grupo con el mismo nombre.

Edición: escrito en la forma de un script de shell; agregado true para salir con 0 estados como lo sugiere @Max Chernyak aka hakunin ; stderr descartado para omitir esos groups: cannot find name for group ID xxxxxx ocasionales groups: cannot find name for group ID xxxxxx .

Answer 7

En UNIX (a diferencia de GNU / Linux), está el comando listusers. Vea la página del manual de Solaris para los usuarios de la lista

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

Answer 8

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

Descripción: Muestra los miembros de un grupo; de forma predeterminada, todos los miembros son el complemento de los grupos: mientras que los grupos muestran los grupos a los que pertenece un usuario específico, los miembros muestran los usuarios que pertenecen a un grupo específico.

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

Answer 9

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

#!/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";

Answer 10

He intentado grep ''sample-group-name'' /etc/group , que mostrará una lista de todos los miembros del grupo que especificó según el ejemplo here

Answer 11

Puedes hacerlo en una sola línea de comando:

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 nombre de grupo como su grupo primario

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

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

Answer 12

Sólo un poco grep y tr:

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

Answer 13

Use Python para enumerar a los miembros del grupo:

python -c "import grp; print grp.getgrnam (''GROUP_NAME'') [3]"

Consulte https://docs.python.org/2/library/grp.html

Answer 14

La implementación de Zed probablemente debería ampliarse para funcionar en algunos de los otros UNIX principales.

¿Alguien tiene acceso al hardware de Solaris o HP-UX ?; No probé 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, hágamelo saber; Consideré de muchas maneras, y esto es lo que se me ocurrió.

Answer 15

getent group <groupname>;

Es portátil tanto en Linux como en Solaris, y funciona con grupos locales / archivos de contraseña, NIS y configuraciones LDAP.

Answer 16

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 cat /etc/group | grep groupname .

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

3: sustituya '','' 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

Answer 17

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

Esto devuelve una lista de usuarios separados por espacios que he usado 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'')")

Answer 18

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