Grep /etc/passwd et /etc/group pour la liste de tous les utilisateurs et chaque groupe auquel appartient l'utilisateur

Même en ignorant la possibilité d'un réseau de bases de données pour vos fichiers, vous ne pouvez pas vraiment utiliser grep pour ce travail, au moins, pas si vous allez le faire vraiment à fond. Vous devriez probablement utiliser Perl ou Python ou un autre langage de script de votre choix.

Notez qu'il existe un groupe spécifié par le numéro de l'utilisateur dans le /etc/passwd fichier. Il peut y avoir un nombre arbitraire d'autres groupes énumérés dans /etc/group pour le même utilisateur. Supposons que les utilisateurs primaires GID' est 23 dans /etc/passwd. Il n'y a aucune garantie que l'entrée pour le groupe des 23 en /etc/group donnera la liste de l'utilisateur.

Notez que vous pouvez avoir toutes sortes de weirdnesses dans le fichier de groupe.

• Plusieurs noms pour le même GID.
• Plusieurs lignes pour le même nom de groupe avec les différents GID valeurs.
• GID valeurs indiquées dans /etc/passwd qui ne sont pas répertoriés dans /etc/group.
• Plusieurs noms avec le même UID dans le /etc/passwd fichier (souvent pour permettre à différentes personnes de se connecter avec leurs propres informations d'identification — nom et mot de passe, mais à tous les exécuter en tant qu'UID 0, aka root).

Affaire avec tous ces est un cauchemar — et oui, la quasi-totalité de ces se produire sur les systèmes sur lesquels je travaille, mais ne pas administrer.

Quelque part, j'ai le code pour aider à cette analyse; c'est du Perl, et utilise getpwent() et getgrent() pour récupérer les informations (à partir de fichiers ou d'un réseau configuré par les admins). Il n'est pas assez.

---

Pour un exercice à faire en classe d'analyse, vous avez probablement besoin d':

De /etc/passwd:

• nom d'utilisateur
• ID utilisateur (UID)
• primaire de l'IDENTIFIANT de groupe (GID)

De /etc/group:

• Nom pour le primaire GID.
• Autres entrées de cette liste le nom d'utilisateur.

C'est beaucoup plus simple, il suffit de canard et d'utiliser le id commande pour le faire la plupart du travail pour vous. Chalut par /etc/passwd avec grep pour obtenir les noms d'utilisateur, puis utilisez id pour spécifier les groupes auxquels l'utilisateur appartient. Voir la réponse par gvalkov pour une réponse qui est susceptible d'être suffisant pour sane systèmes.

grep -o '^[^:]*' /etc/passwd |
xargs -L1 id

Cela vous donne des noms et des numéros; jouer avec les options de id fonction de vos besoins. C'est à l'aide de GNU grep; la -o option est pratique mais pas portable. Heureusement, les noms d'utilisateur Unix ne pas contenir des sauts de ligne (ou des deux-points), ce qui simplifie l'utilisation de xargs.

---

Groupe D'Utilisateurs De La Carte

243 lignes ou Perl, certains de il commentaire. Regarder la ligne shebang; le code est de trois ans et que j'ai pris à l'aide de #!/usr/bin/env perl depuis que ceci a été écrit; j'ai ensuite use warnings; à la partie supérieure du corps de code.

#!/bin/perl -w
#
# @(#)$Id: usergroupmap.pl,v 1.6 2009/06/08 02:30:19 jleffler Exp $
#
# Create a map of groups associated with users
use strict;
use constant debug => 0;
$| = 1;
my $group_entries = 0;  # Number of rows returned by getgrent()
my %usr_hash = ();      # List of lists of GID values keyed by user name
my %gid_hash = ();      # List of GID values count definitions
my %grp_hash = ();      # List of group name values and corresponding GID value
my %grp_count = ();     # List of count of entries with given group name
my %gid_name  = ();     # List of first occurring name for group, indexed by GID
{
while (my ($name, $password, $gid, $userlist) = getgrent())
{
print "# $gid ($name) $userlist\n" if debug > 1;
$group_entries++                                            ;# if debug > 0;
$grp_hash{$name}  = $gid  unless defined $grp_hash{$name}   ;# if debug > 0;
$grp_count{$name} = 0     unless defined $grp_count{$name}  ;# if debug > 0;
$grp_count{$name}++                                         ;# if debug > 0;
$gid_hash{$gid}   = 0     unless defined $grp_hash{$gid}    ;# if debug > 0;
$gid_hash{$gid}++                                           ;# if debug > 0;
$gid_name{$gid}   = $name unless defined $gid_name{$gid};
foreach my $user (split /[, ]/, $userlist)
{
print ". $user\n" if debug > 1;
$usr_hash{$user} = { } unless defined $usr_hash{$user};
$usr_hash{$user}->{$gid} = 1;
}
printf "-- Group %-8s reappears with GID %5d (previously %5d)\n",
$name, $gid, $grp_hash{$name} if $grp_hash{$name} != $gid;
printf "-- GID   %-8d reappears with name %-8s (previously %-8s)\n",
$gid, $name, $gid_name{$gid} if $name ne $gid_name{$gid};
}
}
printf "Number of group entries: %5d\n", $group_entries         ;# if debug > 0;
printf "Number of group   names: %5d\n", scalar(keys %grp_hash) ;# if debug > 0;
printf "Number of group numbers: %5d\n", scalar(keys %gid_hash) ;# if debug > 0;
printf "Number of user    names: %5d\n", scalar(keys %usr_hash) ;# if debug > 0;
{
foreach my $gid (sort keys %gid_hash)
{
printf "    Group ID %5d (%-8s) appears %2d times\n",
$gid, $gid_name{$gid}, $gid_hash{$gid} if $gid_hash{$gid} > 1;
}
}
# Nominally, this should print nothing.
# However, when the local /etc/group file and the NIS+ group file disagree, it does.
foreach my $name (sort keys %grp_count)
{
printf "    Group name %-8s (%-5d) appears %2d times\n",
$name, $grp_hash{$name}, $grp_count{$name} if $grp_count{$name} > 1;
}
# Determining canonical name for a group turns out to be tricky!
# On Solaris, it appears that:
# --- When groups are listed in /etc/group, the first name for a given GID is used
# -1-   Add to /etc/group:
#       a123::54876:username
#       a12::54876:username
#       a1::54876:username
#       a::54876:username
# ---   With these entries present, first one listed in /etc/group is 'name of group'
# ---   Demonstrated with multiple permutations of 4 entries.
#
# --- When groups are listed via NIS+, the shortest name for a given GID is used
# -1-   In NIS+ data,
#       -- GID   1360     reappears with name rand8    (previously rand4   )
#       -- GID   1360     reappears with name rand3    (previously rand4   )
#       -- GID   1360     reappears with name rand     (previously rand4   )
#       -- GID   1360     reappears with name rand9    (previously rand4   )
#       -- GID   1360     reappears with name rand1    (previously rand4   )
#       -- GID   1360     reappears with name rand2    (previously rand4   )
#       -- GID   1360     reappears with name rand10   (previously rand4   )
#       -- GID   1360     reappears with name rand5    (previously rand4   )
#       -- GID   1360     reappears with name rand7    (previously rand4   )
#       -- GID   1360     reappears with name rand11   (previously rand4   )
#       -- GID   1360     reappears with name rand12   (previously rand4   )
#       -- GID   1360     reappears with name rand6    (previously rand4   )
# ---   With these entries present, shortest name (rand) is listed by 'ls'.
# -2-   In NIS+ data,
#       -- GID   1240     reappears with name pd       (previously rd      )
# ---   With these entries present, first name with shortest length (rd) is listed by 'ls'.
# -3-   In NIS+ data,
#       -- GID   8714     reappears with name vcs-vsnet (previously vcs-mgr2)
#       -- GID   8714     reappears with name vcs  (previously vcs-mgr2)
#       -- GID   8714     reappears with name vcs-tech (previously vcs-mgr2)
#       -- GID   8714     reappears with name vcs-tech1 (previously vcs-mgr2)
#       -- GID   8714     reappears with name vcs-sys2 (previously vcs-mgr2)
#       -- GID   8714     reappears with name vcs-mgr1 (previously vcs-mgr2)
#       -- GID   8714     reappears with name vcs-other (previously vcs-mgr2)
#       -- GID   8714     reappears with name vcs-sys1 (previously vcs-mgr2)
#       -- GID   8714     reappears with name vcs-mgr (previously vcs-mgr2)
#       -- GID   8714     reappears with name vcs-mgr3 (previously vcs-mgr2)
#       -- GID   8714     reappears with name vcs-sys (previously vcs-mgr2)
# ---   With these entries present, shortest name (vcs) is listed by 'ls'.
# ---   Could be first name without punctuation?
# -4-   In NIS+ data + /etc/group data (other::1:root in /etc/group)
#       -- Group other    reappears with GID    20 (previously     1)
# ---   With these entries present, 'chgrp  1 x; ls -l x' lists group as other.
# ---   With these entries present, 'chgrp 20 x; ls -l x' lists group as other.
# ---   Hence, 'ls' must use getgrgid() to determine group name.
# -5-   In NIS+ data
#       -- GID   7777     reappears with name xgrp      (previously pdxgrp  )
# ---   With these entries present, 'chgrp pdxgrp x; ls -l x' lists xgrp as group.
# ---   Hence, as expected, chgrp uses getgrnam() to determine GID, and ls uses getgrgid().
# -6-   Add entry 'ccc::8714:' to /etc/group.
#       With this entry present, 'chgrp 8714 x; ls -l x' lists ccc as group.
# NB: /etc/nsswitch.conf lists 'group: files nis' (and 'passwd: files').
#
# ---   NB: No definitive test with same group name listed in both /etc/group and NIS+.
# ---   NB: No definitive info on why rand.
# ---   NB: No definitive info on why vcs.
# Hence: most reliable way to determine canonical name for a given GID is via getgrgid().
# Determining it from the results of getgrent() is unreliable.
my $max_groups = 0;
my $max_user = "";
my $tot_usrgrp = 0;
my %grp_lists = ();
foreach my $user (sort keys %usr_hash)
{
my $groups = $usr_hash{$user};
my $numgrps = scalar(keys %{$groups});
$tot_usrgrp += $numgrps;
if ($numgrps > $max_groups)
{
$max_groups = $numgrps;
$max_user = $user;
}
my $grplst = "";
foreach my $group (sort keys %{$groups})
{
$grplst .= " $group";
}
$grp_lists{$grplst} = 1;
print "$user: $grplst\n" if debug;
}
printf "Maximum number of groups for one user (%s): %5d\n", $max_user, $max_groups;
printf "Total number of groups listed for all users: %5d\n", $tot_usrgrp;
printf "Total number of distinct group lists: %5d\n", scalar(keys %grp_lists);
my %name_hash = (); # List of distinct names - group names and user names
foreach my $user (keys %usr_hash)
{
$name_hash{$user} = 1;
}
foreach my $group (keys %grp_hash)
{
$name_hash{$group} = 1;
}
my $name_offset = 0;
foreach my $name (keys %name_hash)
{
$name_hash{$name} = $name_offset;
$name_offset += length($name) + 1;
}
printf "Total space needed for names = %5d\n", $name_offset;
# Add gid to group list if not already present
# If input is sorted, add condition: last if $grpnum > $gid;
sub add_gid
{
my($gid, @groups) = @_;
foreach my $grpnum (@groups)
{
return(@groups) if ($grpnum == $gid);
}
return sort { $a <=> $b } $gid, @groups;
}
# Get group set for given user name
sub getgrsetnam
{
my($user) = @_;
my(@groups) = ();
my($usrref) = $usr_hash{$user};
print "getgrsetnam(): name = $user\n" if debug > 0;
push(@groups, sort { $a <=> $b } keys %$usrref) if defined $usrref;
print "getgrsetnam(): groups = @groups\n" if debug > 0;
my($name, $pass, $pw_uid, $gid) = getpwnam($user);
# Not all users listed in groups appear in password
if (defined $name)
{
print "getgrsetnam(): user = $name, $pw_uid, $gid\n" if debug > 0;
@groups = add_gid($gid, @groups);
}
return(@groups);
}
# Get set of group IDs for given user number
sub getgrsetuid
{
my($uid) = @_;
print "getgrsetuid(): $uid\n" if debug > 0;
my($name, $pass, $pw_uid, $gid) = getpwuid($uid);
print "getgrsetuid(): $name, $pw_uid, $gid\n" if debug > 0;
my(@groups) = ();
# Not all UID values have a user name
if (defined $name)
{
print "getgrsetuid(): name = $name\n" if debug > 0;
@groups = getgrsetnam($name);
@groups = add_gid($gid, @groups);
}
return(@groups);
}
{
foreach my $user (sort keys %usr_hash)
{
print "user = $user\n" if debug > 0;
my(@groups) = getgrsetnam($user);
printf "%-9s @groups\n", "$user:";
}
}
{
foreach my $uid (0..65535)
{
my($name, $pass, $pw_uid, $gid) = getpwuid($uid);
if (defined $name)
{
print "uid = $uid\n" if debug > 0;
my(@groups) = getgrsetuid($uid);
printf "%-9s (uid = %6d) @groups\n", "$name:", $uid;
}
}
}
__END__

Certains de la sortie de synthèse:

...
-- Group nobody   reappears with GID 60001 (previously    99)
...
Number of group entries:   225
Number of group   names:   221
Number of group numbers:   148
Number of user    names:  1072
Group name xxxxxxx1 (297  ) appears  2 times
Group name xxxxxxx2 (296  ) appears  2 times
Group name xxxxxxx3 (102  ) appears  2 times
Group name nobody   (99   ) appears  2 times
Maximum number of groups for one user (xxxxxxxx):    32
Total number of groups listed for all users:  2275
Total number of distinct group lists:   108
Total space needed for names =  9562

Les chaînes de x sont distincts des noms que j'ai masqué.

J'ai juste besoin moi-même aujourd'hui et est venu avec les suivants en environ 2 minutes de jongler avec des pages man:

for i in $(cat /etc/passwd | awk --field-separator=":" '{print $1}'); do id $i; done

Peut également être réduit légèrement avec:

for i in $(cat /etc/passwd | cut -d: -f1); do id $i; done

Ressemble la sortie de plusieurs id commandes en ligne:

uid=34(backup) gid=34(backup) groups=34(backup)
uid=1000(bobby) gid=1000(bobby) groups=1000(bobby),27(sudo)
...

Le résultat n'est pas le plus lisible, mais il est assez simple et facile à retenir. @gvalkov réponse est beaucoup plus clair dans cet aspect.