Linux-User anzeigen: alle Benutzer, Gruppen und wer gerade eingeloggt ist

Kurz gesagt: Alle Linux-User zeigst du mit getent passwd | cut -d: -f1 an. Der Befehl gibt jedes Konto aus, das das System kennt, einen Namen pro Zeile. Die meisten davon sind Systemkonten, unter denen Dienste laufen. Die echten Benutzerkonten, hinter denen Menschen stehen, haben eine Benutzer-ID (UID) ab 1000, und awk filtert genau diese aus /etc/passwd heraus:

# alle Konten
getent passwd | cut -d: -f1

# nur Konten für Menschen (UID ab 1000, ohne "nobody")
awk -F: '$3>=1000 && $3<65534 {print $1}' /etc/passwd

# Gruppen, und die Gruppen eines Benutzers
getent group | cut -d: -f1
id alice

# wer gerade eingeloggt ist
who

Das funktioniert auf Ubuntu, Debian, Rocky Linux und Alma gleich. Die Abschnitte unten erklären, was die Felder bedeuten, wie du siehst, wer sich wirklich einloggen kann, wer sudo-Rechte hat und wer sich zuletzt angemeldet hat, und wie du einen Server auf Konten prüfst, die dort nicht sein sollten.

Was bedeuten die sieben Felder in /etc/passwd?

Jede Zeile in /etc/passwd ist ein Konto, mit sieben Feldern, getrennt durch Doppelpunkte:

alice:x:1000:1000:Alice Example,,,:/home/alice:/bin/bash

• alice: der Login-Name.
• x: das Passwortfeld. x bedeutet, dass der Passwort-Hash in /etc/shadow liegt, das nur root lesen kann. Die passwd-Datei selbst ist für alle lesbar, und das seit Jahrzehnten.
• 1000: die UID, die Zahl, mit der der Kernel tatsächlich arbeitet. UID 0 ist root, egal welcher Name dasteht.
• 1000: die GID der primären Gruppe.
• Alice Example,,,: das Kommentarfeld (GECOS) mit vollem Namen und optionalen Kontaktdaten.
• /home/alice: das Home-Verzeichnis.
• /bin/bash: die Login-Shell. /usr/sbin/nologin oder /bin/false bedeutet, dass das Konto keine Shell bekommen kann.

getent passwd liest dieselben Daten, dazu Konten aus LDAP oder Active Directory, wenn der Server an ein solches Verzeichnis angebunden ist. cat /etc/passwd zeigt nur die lokalen Konten. Auf einem alleinstehenden VPS geben beide dieselbe Liste aus.

Welche Konten sind Systemkonten und welche gehören Menschen?

Unterscheiden lassen sie sich an der UID. Debian, Ubuntu, Rocky und Alma reservieren die niedrigen Nummern für das System und lassen Benutzerkonten bei 1000 beginnen:

• 0: root.
• 1 bis 999: Systemkonten wie daemon, www-data (bzw. nginx und apache auf Rocky), mysql, sshd und was Pakete sonst anlegen. Dienste laufen unter ihnen; niemand loggt sich damit ein.
• 1000 und höher: Konten, die mit adduser oder useradd für Menschen angelegt wurden.
• 65534: nobody, ein Platzhalter ohne Rechte, deshalb hört der Filter oben knapp darunter auf.

Die Grenzen stehen in /etc/login.defs als UID_MIN und UID_MAX. Hat jemand sie geändert, lies den Wert aus, statt von 1000 auszugehen:

awk -F: -v min="$(awk '/^UID_MIN/ {print $2}' /etc/login.defs)" \
  '$3>=min && $3<65534 {print $1, $3, $6}' /etc/passwd

Welche Benutzer können sich wirklich einloggen?

Ein Konto kann eine Shell öffnen, wenn seine Shell eine echte ist, also nicht nologin oder false. Das listet diese Konten mit ihrer Shell auf:

getent passwd | awk -F: '$7 !~ /(nologin|false)$/ {print $1, $7}'

Auf Debian und Ubuntu taucht sync mit /bin/sync als Shell auf. Das ist normal: Diese „Shell“ schreibt nur die Puffer auf die Platten und beendet sich. Alles andere auf der Liste verdient einen zweiten Blick.

Die Shell ist nur die halbe Wahrheit. Ob sich jemand mit Passwort einloggen kann, hängt vom Passwortstatus ab, und SSH-Schlüssel umgehen das Passwort komplett:

sudo passwd -S -a     # P = nutzbares Passwort, L = gesperrt, NP = kein Passwort
sudo passwd -S alice  # ein einzelnes Konto; geht auch auf Rocky und Alma

Ein gesperrtes Passwort (L) verhindert Passwort-Logins. Es verhindert nicht unbedingt einen Login per SSH-Schlüssel, prüf also auch die Schlüssel, wie weiter unten beschrieben.

Wie zeige ich Gruppen und ihre Mitglieder an?

getent group                     # jede Gruppe: Name:x:GID:Mitglieder
getent group sudo                # eine Gruppe und ihre Mitglieder
id alice                         # UID, primäre Gruppe und alle weiteren Gruppen von alice
groups alice                     # nur die Gruppennamen

# nur Gruppen, die Mitglieder aufführen
getent group | awk -F: '$4 != "" {print $1": "$4}'

Über ein Detail stolpern viele. Die Mitgliederliste in /etc/group enthält nur Benutzer, die einer Gruppe hinzugefügt wurden. Die primäre Gruppe eines Benutzers, die GID in /etc/passwd, wird dort nicht wiederholt. Deshalb zeigt getent group alice meist keine Mitglieder, obwohl alice Mitglied ist. id alice zeigt immer die vollständige Liste, inklusive primärer Gruppe.

Wer hat sudo-Rechte auf diesem Server?

Auf Debian und Ubuntu kommen sudo-Rechte normalerweise über die Mitgliedschaft in der Gruppe sudo; auf Rocky und Alma ist es die Gruppe wheel. Regeln können aber auch direkt in /etc/sudoers oder in einer Datei unter /etc/sudoers.d/ stehen, prüf also beides:

getent group sudo                      # Debian, Ubuntu
getent group wheel                     # Rocky, Alma
sudo grep -rE '^[^#[:space:]]' /etc/sudoers /etc/sudoers.d/   # jede aktive Regel
sudo -l -U alice                       # was alice ausführen darf, aus Sicht von sudo

Eine Zeile wie %sudo ALL=(ALL:ALL) ALL gibt der ganzen Gruppe volle Rechte; eine Zeile, die mit einem Benutzernamen beginnt, gibt nur diesem Benutzer Rechte, und NOPASSWD heißt: ohne Passwortabfrage. Defaults-Zeilen sind Einstellungen, keine Rechte, und die Zeile root ALL=(ALL:ALL) ALL gehört zur mitgelieferten Datei. Wie du einem Konto sauber sudo-Rechte gibst, steht in der Anleitung sudo-Benutzer anlegen (engl.). Fehlt auf dem Server sogar der Befehl selbst, fang mit sudo: command not found (engl.) an.

Wer ist gerade eingeloggt?

who        # wer eingeloggt ist, an welchem Terminal, von welcher IP
w          # dasselbe plus Leerlaufzeit und was jede Sitzung gerade ausführt
users      # nur die Namen, in einer Zeile
loginctl list-sessions   # die Sicht von systemd, auch Sitzungen ohne Terminal

Eine entfernte Sitzung zeigt in who die IP-Adresse des Clients in Klammern, in w in der Spalte FROM. Siehst du eine Adresse, die du nicht kennst, notier sie dir, bevor du irgendetwas anderes tust.

Wer hat sich zuletzt angemeldet?

last -n 20              # die letzten 20 Logins, mit Quell-IP und Dauer
last alice              # die Logins eines Benutzers
last reboot             # wann der Server neu gestartet wurde
sudo lastb -n 20        # fehlgeschlagene Login-Versuche (nur root)
lastlog                 # der letzte Login jedes Kontos
lastlog -u alice

last liest /var/log/wtmp, lastb liest /var/log/btmp und lastlog liest /var/log/lastlog. In der Ausgabe von lastlog ist **Never logged in** neben einem Systemkonto genau das, was du sehen willst.

# die Unit heißt ssh auf Debian und Ubuntu, sshd auf Rocky und Alma
sudo journalctl -u ssh -u sshd --since "7 days ago" | grep -E 'Accepted|Failed password|Invalid user'

Accepted publickey for alice from 198.51.100.7 ist ein erfolgreicher Login per Schlüssel. Hunderte Zeilen mit Invalid user von Adressen, die du nicht kennst, sind Bots, die Passwörter durchprobieren, und die sieht jeder Server im Internet; wichtig werden sie nur, wenn auf eine davon ein Accepted folgt.

Welche Konten können sich per SSH-Schlüssel einloggen?

Jeder Schlüssel in der ~/.ssh/authorized_keys eines Kontos ist ein Zugang, den keine Passwortänderung schließt. Diese Schleife listet die Schlüssel aller Konten auf, root eingeschlossen, mit dem Kommentar am Ende jeder Schlüsselzeile, der oft den Namen oder den Rechner des Besitzers nennt:

sudo sh -c 'getent passwd | while IFS=: read -r user _ _ _ _ home _; do
  for f in "$home/.ssh/authorized_keys" "$home/.ssh/authorized_keys2"; do
    [ -f "$f" ] && echo "== $user: $f" && cat "$f"
  done
done'

# wo sshd tatsächlich sucht (das lässt sich umkonfigurieren)
sudo sshd -T | grep -i authorizedkeysfile

Jeder Schlüssel, den du keiner Person und keinem Deployment-Werkzeug zuordnen kannst, sollte weg. Wie du SSH nur mit Schlüsseln betreibst und einschränkst, wer sich überhaupt einloggen darf, steht in SSH-Zugriff absichern (engl.).

Wie erkenne ich ein Konto, das nicht da sein sollte?

Nach einem Einbruch hinterlassen Angreifer gern einen Weg zurück: ein neues Konto, ein zweites Konto mit UID 0 oder einen Schlüssel bei root. Diese Prüfungen dauern eine Minute:

# jedes Konto mit UID 0 außer root ist eine Hintertür
awk -F: '$3==0 {print $1}' /etc/passwd

# Konten mit leerem Passwortfeld
sudo awk -F: '$2=="" {print $1}' /etc/shadow

# Benutzerkonten und ihre Shells
awk -F: '$3>=1000 && $3<65534 {print $1, $7}' /etc/passwd

# wann sich die Kontendateien zuletzt geändert haben
ls -l --time-style=long-iso /etc/passwd /etc/shadow /etc/group /etc/sudoers

# kürzlich angelegte oder geänderte Konten, wenn das Journal weit genug zurückreicht
sudo journalctl -t useradd -t usermod -t groupadd --since "30 days ago"

Was als unerwartet gilt, hängt davon ab, womit der Server angefangen hat. Speichere die Liste deshalb auf einem neuen Server (getent passwd > ~/accounts-day1.txt) und vergleiche sie später mit diff. Jedes Benutzerkonto, das du nicht selbst angelegt hast, verdient einen genaueren Blick. Ein unbekanntes Konto kommt oft zusammen mit einem Prozess, den du nicht kennst und der die CPU auffrisst; der Abschnitt zu Kryptominern (engl.) in unserer Anleitung zu hoher CPU-Last zeigt, worauf du achten musst und warum ein Neuaufsetzen besser ist als Aufräumen.

Geht es in bash auch kürzer?

Ja. compgen ist ein eingebauter bash-Befehl für die Vervollständigung von Namen, und er kann Benutzer und Gruppen direkt auflisten. Für einen schnellen Blick ist er praktisch, er gibt aber nur Namen aus und existiert weder in sh noch in zsh:

compgen -u    # alle Benutzer
compgen -g    # alle Gruppen
getent passwd | wc -l   # wie viele Konten es gibt

Wie zeige ich die Benutzer unter Windows Server an?

Windows verwaltet lokale Konten in einer eigenen Datenbank, und die passenden Befehle sind kurz:

net user                                   # alle lokalen Konten
net user alice                             # Details, letzte Anmeldung, Gruppenmitgliedschaften
net localgroup administrators              # wer Administratorrechte hat
net localgroup "Remote Desktop Users"      # wer sich per RDP anmelden darf
quser                                      # wer gerade eingeloggt ist

Get-LocalUser | Format-Table Name, Enabled, LastLogon
Get-LocalGroupMember -Group Administrators

Auf einem deutschsprachigen Windows heißen die Gruppen „Administratoren“ und „Remotedesktopbenutzer“, dort lauten die Befehle also net localgroup Administratoren und net localgroup Remotedesktopbenutzer (in PowerShell entsprechend Get-LocalGroupMember -Group Administratoren). Räumst du nach einem verdächtigen Login auf, schau dir zuerst die aktivierten Konten in diesen beiden Gruppen an; das sind die, die einen Desktop auf dem Server bekommen können.

Jeder Befehl auf dieser Seite funktioniert auf jedem Linux-VPS mit Root-Zugriff, von der Testkiste zum Wegwerfen bis zum Standard-KVM-Tarif, den du über Jahre betreibst.

Häufige Fragen